cc-session-control 0.6.4__tar.gz → 0.6.5__tar.gz

{cc_session_control-0.6.4/src/cc_session_control.egg-info → cc_session_control-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-control
-Version: 0.6.4
+Version: 0.6.5
 Summary: TUI manager for Claude Code sessions and Remote Control
 Author: dzshzx
 License-Expression: MIT

{cc_session_control-0.6.4 → cc_session_control-0.6.5}/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.4"
+__version__ = "0.6.5"

{cc_session_control-0.6.4 → cc_session_control-0.6.5}/src/cc_session_control/actions/agent_ops.py

@@ -25,7 +25,7 @@ import os
 import shlex
 
 from ..config import cfg
-from ..data import cleanup, liveness, proc, rc, registry
+from ..data import cleanup, liveness, proc, registry, tmux
 from ..models import AgentJob, Session
 from . import session_ops
 
@@ -71,12 +71,12 @@ def respawn(job: AgentJob) -> str:
     """Relaunch a background agent in tmux; returns the exact command string.
 
     Runs `respawn_cmd(job)` in the job's per-project tmux session
-    (`rc.session_name_for(job.cwd)`) so it outlives the terminal — it does NOT
+    (`tmux.session_name_for(job.cwd)`) so it outlives the terminal — it does NOT
     os.exec/replace the csctl process. The returned string also feeds the
     clipboard `y`-style key.
     """
     cmd = respawn_cmd(job)
-    rc.run_in_tmux(rc.session_name_for(job.cwd), _job_window(job), cmd)
+    tmux.run_in_tmux(tmux.session_name_for(job.cwd), _job_window(job), cmd)
     return cmd
 
 
@@ -94,15 +94,7 @@ def remove_job(job: AgentJob) -> bool:
     _, alive = job_host(job)
     if alive:
         return False
-    job_dir = os.path.join(str(cfg.jobs_dir), job.short)
-    removed = cleanup._remove_path(job_dir)
-    # Reuse cleanup's artifact-path helper / remover: it returns the sid-keyed
-    # dirs (session-env/file-history/tasks/uploads) plus jobs/<sid[:8]> (which
-    # usually equals job_dir — a second remove is a harmless no-op), so the job's
-    # session leaves no orphan artifacts behind.
-    for path in cleanup._session_artifact_paths(job.sid):
-        cleanup._remove_path(path)
-    return removed
+    return cleanup.remove_agent_artifacts(job.short, job.sid)
 
 
 # --- watch (read-only) --------------------------------------------------------

{cc_session_control-0.6.4 → cc_session_control-0.6.5}/src/cc_session_control/actions/session_ops.py

@@ -10,7 +10,7 @@ from dataclasses import dataclass
 from typing import Literal
 
 from .. import clipboard
-from ..data import proc, rc
+from ..data import proc, tmux
 from ..data.liveness import invalidate_cache
 from ..models import Session
 
@@ -151,7 +151,7 @@ def _spawn_in_tmux(s: Session, cmd: str, fork: bool = False) -> str | None:
     _, _, should_kill = _resume_plan(s, fork)
     if should_kill and s.pid and take_over(s.pid, s.proc_start) == "refused":
         return None
-    return rc.run_in_tmux(rc.session_name_for(s.cwd), s.sid[:8], cmd)
+    return tmux.run_in_tmux(tmux.session_name_for(s.cwd), s.sid[:8], cmd)
 
 
 def relaunch_in_tmux(s: Session, fork: bool = False) -> bool:
@@ -173,7 +173,7 @@ def attach_target(s: Session) -> str | None:
     a bare terminal (those need `do_tmux_resume`)."""
     if not s.alive or not s.pid:
         return None
-    return rc.find_session_window([s.pid])
+    return tmux.find_session_window([s.pid])
 
 
 def tmux_foreground_cmd(s: Session) -> str:
@@ -205,7 +205,7 @@ def do_tmux_new(directory: str) -> str | None:
     either: the user lands inside the window, so claude's own trust dialog
     shows interactively."""
     cmd = f"cd {shlex.quote(directory)} && claude"
-    return rc.run_in_tmux(rc.session_name_for(directory), "claude", cmd)
+    return tmux.run_in_tmux(tmux.session_name_for(directory), "claude", cmd)
 
 
 # --- exit intents (the payload crossing the exit-then-exec seam) ------------
@@ -282,10 +282,10 @@ def enter_window(target: str) -> bool:
     return so the caller exits csctl normally — both paths end csctl, keeping
     "接回 = 离开 csctl" uniform. select-window failure is non-fatal (the user
     lands in the session and can pick the window by hand)."""
-    rc.select_window(target)
+    tmux.select_window(target)
     session = target.split(":", 1)[0]
     if os.environ.get("TMUX"):
-        return rc.switch_client(target)
+        return tmux.switch_client(target)
     try:
         os.execvp("tmux", ["tmux", "attach-session", "-t", session])
     except OSError:

{cc_session_control-0.6.4 → cc_session_control-0.6.5}/src/cc_session_control/cli.py

@@ -136,21 +136,31 @@ def _cmd_rc(args: argparse.Namespace) -> None:
 
 
 def _cmd_prune(args: argparse.Namespace) -> None:
+    from .data import liveness
     from .data.cleanup import (
-        cleanup_stats,
+        build_plan,
         execute_orphan_removals,
         execute_session_removals,
-        list_orphan_dirs,
         prune_sessions,
     )
     from .data.sessions import scan
 
     sessions = scan()
-    stats = cleanup_stats(sessions)
-    print(f"Total: {stats['total']}  Empty: {stats['empty']}  Short(<=2): {stats['short']}  Orphans: {stats['orphans']}")
+    # One shared fetch feeds the frozen plan — the SAME assembly build_plan's
+    # other callers (the Sessions view, build_world_snapshot) use, so the CLI
+    # header and any future TUI parity stay derived from one source (删除 ⊆ 预览
+    # still holds: execute_* revalidate against fresh data at apply time).
+    procs, cur, jobs, agents = liveness.liveness_inputs()
+    plan = build_plan(sessions, procs, cur, jobs, agents)
+    counts = plan.counts()
+    print(
+        f"Total: {len(sessions)}  Prunable empty: {counts['empty']}  "
+        f"short(<=2): {counts['short']}  Orphan dirs: {counts['orphan_dirs']}  "
+        f"Zombie files: {counts['zombie_procs']}  Aged: {counts['aged_entries']}"
+    )
 
     if args.sweep_orphans:
-        orphans = list_orphan_dirs(sessions)
+        orphans = plan.orphan_entries
         print(f"Would sweep {len(orphans)} orphan artifact dir(s)")
         if not args.apply:
             print("Dry run. Add --apply to execute.")

{cc_session_control-0.6.4 → cc_session_control-0.6.5}/src/cc_session_control/data/cleanup.py

@@ -80,9 +80,10 @@ def _session_artifact_paths(sid: str) -> list[str]:
     """All on-disk artifact paths owned by one session id (cfg-derived).
 
     Covers the sid-keyed dirs plus the 8-char-prefixed `jobs/<short>` dir for
-    this session. Used by `agent_ops.remove_job` (which has already alive-gated
-    the job). `remove_session` does NOT use this — it guards the `jobs/<short>`
-    path separately so a LIVE agent worker's jobs dir is never deleted (M3).
+    this session. Used by `remove_agent_artifacts` (whose caller,
+    `agent_ops.remove_job`, has already alive-gated the job). `remove_session`
+    does NOT use this — it guards the `jobs/<short>` path separately so a LIVE
+    agent worker's jobs dir is never deleted (M3).
     """
     return _sid_keyed_paths(sid) + [_jobs_path(sid)]
 
@@ -101,6 +102,26 @@ def _remove_path(path: str) -> bool:
     return False
 
 
+def remove_agent_artifacts(short: str, sid: str) -> bool:
+    """Delete a settled background agent's `jobs/<short>` dir + sid artifacts.
+
+    Removes `jobs/<short>` first (the return value is True iff THAT removal
+    happened), then every path in `_session_artifact_paths(sid)` (the sid-keyed
+    dirs plus `jobs/<sid[:8]>` — a second remove of the same job dir when
+    `short == sid[:8]` is a harmless no-op).
+
+    The CALLER owns the gates: this function assumes the job has already been
+    alive-gated (a LIVE worker must never reach here) and that
+    `proc.current_determinable()` (R10) has already been checked — it only
+    deletes.
+    """
+    job_dir = os.path.join(str(cfg.jobs_dir), short)
+    removed = _remove_path(job_dir)
+    for path in _session_artifact_paths(sid):
+        _remove_path(path)
+    return removed
+
+
 # --- Strategy A: sid-keyed orphan dirs (H1 protected-sid set) --------------
 
 def known_sids(
@@ -141,6 +162,33 @@ def known_sids(
     return known
 
 
+def _fill_liveness_inputs(
+    session_procs: list[SessionProc] | None,
+    agent_jobs: list[AgentJob] | None,
+    agents_map: dict[str, int | None] | None,
+    cur: set[int] | None,
+) -> tuple[list[SessionProc], list[AgentJob], dict[str, int | None], set[int]]:
+    """Fill any None input from `liveness.liveness_inputs()` (the ONE assembly).
+
+    Snapshot/view callers inject the shared world data (R11) and pay no IO
+    here; CLI / no-snapshot callers pass None and get the same assembly
+    `build_world_snapshot` uses (which swallows each source's errors → safe
+    empties). A caller that doesn't consume a source passes `[]`/`{}` — not
+    None — so an unused gap never triggers the fetch on its own.
+    """
+    if session_procs is None or agent_jobs is None or agents_map is None or cur is None:
+        d_procs, d_cur, d_jobs, d_agents = liveness.liveness_inputs()
+        if session_procs is None:
+            session_procs = d_procs
+        if agent_jobs is None:
+            agent_jobs = d_jobs
+        if agents_map is None:
+            agents_map = d_agents
+        if cur is None:
+            cur = d_cur
+    return session_procs, agent_jobs, agents_map, cur
+
+
 def _gather_known(
     sessions: list[Session],
     session_procs: list[SessionProc] | None = None,
@@ -148,26 +196,10 @@ def _gather_known(
     agents_map: dict[str, int | None] | None = None,
     cur: set[int] | None = None,
 ) -> set[str]:
-    """Resolve the protected-sid set, self-fetching any omitted source.
-
-    Snapshot/view callers inject the shared world data (R11); CLI / no-snapshot
-    callers pass nothing and we read the (TTL-cached) registry + `alive_map`. Each
-    self-read swallows its own errors → safe empties.
-    """
-    if session_procs is None:
-        session_procs = liveness.live_session_procs()
-    if agent_jobs is None:
-        try:
-            agent_jobs = registry.read_agent_jobs()
-        except Exception:
-            agent_jobs = []
-    if agents_map is None:
-        try:
-            agents_map = liveness.alive_map()
-        except Exception:
-            agents_map = {}
-    if cur is None:
-        cur = proc.ancestor_pids()
+    """Resolve the protected-sid set, self-fetching any omitted source
+    (`_fill_liveness_inputs`)."""
+    session_procs, agent_jobs, agents_map, cur = _fill_liveness_inputs(
+        session_procs, agent_jobs, agents_map, cur)
     return known_sids(sessions, session_procs, agent_jobs, agents_map, cur)
 
 
@@ -399,18 +431,10 @@ def execute_session_removals(
     """
     if not proc.current_determinable():
         return 0
-    # This self-fetch mirrors snapshot.liveness_inputs()'s assembly — cleanup
-    # sits BELOW snapshot in the data DAG and cannot import it; keep the two
-    # in sync when the liveness sources change.
-    if session_procs is None:
-        session_procs = liveness.live_session_procs()
-    if agents_map is None:
-        try:
-            agents_map = liveness.alive_map()
-        except Exception:
-            agents_map = {}
-    if cur is None:
-        cur = proc.ancestor_pids()
+    # agent_jobs is unused here: pass [] (not None) so an omitted-but-unused
+    # source never triggers the fetch on its own (see _fill_liveness_inputs).
+    session_procs, _, agents_map, cur = _fill_liveness_inputs(
+        session_procs, [], agents_map, cur)
     fresh_alive = {sp.sid for sp in session_procs if sp.proc_alive}
     fresh_alive |= {sid for sid, pid in agents_map.items() if pid}
     count = 0
@@ -470,39 +494,3 @@ def build_plan(
         zombie_pids=select_zombie_pids(session_procs, cur),
         aged_entries=list_aged_entries(now),
     )
-
-
-# --- Classified counts -----------------------------------------------------
-
-def cleanup_stats(sessions: list[Session]) -> dict[str, int]:
-    """Summary counts for the Sessions cleanup submenu (view-facing contract).
-
-    Keeps the established 4-key shape (`total/empty/short/orphans`) that the
-    view reads; `orphans` is the sid-keyed orphan count (Strategy A).
-    """
-    return {
-        "total": len(sessions),
-        "empty": sum(1 for s in sessions if s.prompts == 0),
-        "short": sum(1 for s in sessions if 0 < s.prompts <= 2),
-        "orphans": len(list_orphan_dirs(sessions)),
-    }
-
-
-def cleanup_classified(
-    sessions: list[Session],
-    session_procs: list[SessionProc],
-    cur: set[int],
-    agent_jobs: list[AgentJob] | None = None,
-    agents_map: dict[str, int | None] | None = None,
-    now: float | None = None,
-) -> dict[str, int]:
-    """Per-category cleanup counts (D6) — a thin view over `build_plan`.
-
-    Deriving the counts FROM the plan keeps them equal to what a preview would
-    show: `empty`/`short` count *prunable* sessions (not alive/current/recent),
-    matching the preview list instead of the raw prompt tally.
-    """
-    return build_plan(
-        sessions, session_procs, cur,
-        agent_jobs=agent_jobs, agents_map=agents_map, now=now,
-    ).counts()

{cc_session_control-0.6.4 → cc_session_control-0.6.5}/src/cc_session_control/data/liveness.py

@@ -20,6 +20,30 @@ _cache: dict[str, int | None] | None = None
 _cache_time: float = 0.0
 
 
+def liveness_inputs() -> tuple[
+    list[SessionProc], set[int], list[AgentJob], dict[str, int | None]
+]:
+    """The shared liveness inputs — `(session_procs, cur, agent_jobs,
+    agents_map)` — fetched ONCE, jobs already host-enriched.
+
+    `build_world_snapshot`, the Sessions view's `fetch_pending(None)`
+    self-fetch, and `cleanup`'s protection-set assembly all consume this, so
+    the degraded/self-fetch paths are the same assembly instead of a
+    hand-kept mirror that can drift. Each read swallows its own errors → safe
+    empties.
+    """
+    session_procs = live_session_procs()
+    try:
+        agent_jobs = enrich_jobs(registry.read_agent_jobs(), session_procs)
+    except Exception:
+        agent_jobs = []
+    try:
+        agents_map = alive_map()
+    except Exception:
+        agents_map = {}
+    return session_procs, proc.ancestor_pids(), agent_jobs, agents_map
+
+
 def _scrub_dead_pids(
     mapping: dict[str, int | None],
     exists: Callable[[int | None], bool],

{cc_session_control-0.6.4 → cc_session_control-0.6.5}/src/cc_session_control/data/rc.py

@@ -6,12 +6,11 @@ import json
 import os
 import re
 import shlex
-import subprocess
 import time
 
 from ..config import cfg
 from ..models import EnvRecord, RCProject, RCServer, split_env_id
-from . import environments, proc
+from . import environments, proc, tmux
 
 # Cloud bridge env id printed to a managed server's pane (`environment=env_…`).
 _ENV_ID_RE = re.compile(r"env_[A-Za-z0-9]+")
@@ -102,199 +101,33 @@ def is_trusted(proj: str) -> bool:
         return False
 
 
-# --- tmux adapter ---------------------------------------------------------
-# Single seam over the tmux CLI. Only `_tmux_run` touches `subprocess`; every
-# other tmux call routes through a verb wrapper. Each wrapper keeps the
-# swallow-errors contract (return empty/False/None on any failure).
+# --- RC-scoped thin delegates over data/tmux.py ---------------------------
+# Bound to `cfg.rc_session`. The generic tmux adapter lives in `data/tmux.py`
+# (the single seam — only its `_tmux_run` touches `subprocess`); these four
+# stay here (rather than inlined at call sites) because `scan`/`scan_servers`
+# and their tests poke these exact RC-scoped names.
 
 
-def _tmux_run(args: list[str]) -> subprocess.CompletedProcess | None:
-    """Run one `tmux <args>` command; return the result, or None on failure."""
-    try:
-        return subprocess.run(
-            ["tmux", *args],
-            capture_output=True, text=True, timeout=5,
-        )
-    except Exception:
-        return None
+def _tmux_windows() -> list[str]:
+    return tmux.list_windows(cfg.rc_session)
 
 
-def _tmux_list_windows() -> list[str]:
-    cp = _tmux_run(["list-windows", "-t", cfg.rc_session, "-F", "#W"])
-    if cp is None:
-        return []
-    return [line.strip() for line in cp.stdout.splitlines() if line.strip()]
+def _tmux_window_pids() -> dict[str, int]:
+    return tmux.window_pids(cfg.rc_session)
 
 
 def _tmux_pane_alive(target: str) -> bool:
-    cp = _tmux_run(["list-panes", "-t", target, "-F", "#{pane_dead}"])
-    if cp is None:
-        return False
-    return cp.stdout.strip().split("\n")[0] == "0"
-
-
-def _tmux_window_pids() -> dict[str, int]:
-    """{window_name: pane_pid} for the rc session; {} on failure.
-
-    The pane pid IS the RC server pid because `start_one` runs `exec claude …`
-    (the shell is replaced). Used to classify /proc-discovered servers as
-    managed (pid in this set) vs external.
-    """
-    cp = _tmux_run(
-        ["list-windows", "-t", cfg.rc_session, "-F", "#W\t#{pane_pid}"]
-    )
-    if cp is None:
-        return {}
-    out: dict[str, int] = {}
-    for line in cp.stdout.splitlines():
-        name, _, pid_s = line.partition("\t")
-        name = name.strip()
-        try:
-            pid = int(pid_s.strip())
-        except ValueError:
-            continue
-        if name:
-            out[name] = pid
-    return out
+    return tmux.pane_alive(target)
 
 
 def _tmux_capture_pane(target: str) -> str:
-    """Full scrollback of a tmux pane as text; "" on failure.
-
-    Captures from the start of history (`-S -`) so an `env_*` id printed at
-    server startup is still grep-able after it scrolls off the visible region.
-    """
-    cp = _tmux_run(["capture-pane", "-p", "-S", "-", "-t", target])
-    if cp is None:
-        return ""
-    return cp.stdout
-
-
-def _tmux_has_session(session: str) -> bool:
-    cp = _tmux_run(["has-session", "-t", session])
-    return cp is not None and cp.returncode == 0
-
-
-# -P -F makes tmux print the exact target of the window it just created, so
-# callers enter THAT window even when names collide (no select-by-name guess).
-_TARGET_FMT = "#{session_name}:#{window_index}"
-
-
-def _spawned_target(cp: subprocess.CompletedProcess | None) -> str | None:
-    if cp is None or cp.returncode != 0:
-        return None
-    return cp.stdout.strip() or None
-
-
-def _tmux_new_window(session: str, name: str, cmd: str) -> str | None:
-    """Create a window; return its exact "session:index" target, or None."""
-    cp = _tmux_run(["new-window", "-P", "-F", _TARGET_FMT, "-t", session, "-n", name, cmd])
-    return _spawned_target(cp)
-
-
-def _tmux_new_session(session: str, name: str, cmd: str) -> str | None:
-    """Create a detached session; return its window's target, or None."""
-    cp = _tmux_run(["new-session", "-d", "-P", "-F", _TARGET_FMT, "-s", session, "-n", name, cmd])
-    return _spawned_target(cp)
-
-
-def _tmux_kill_window(target: str) -> bool:
-    cp = _tmux_run(["kill-window", "-t", target])
-    return cp is not None and cp.returncode == 0
-
-
-def _tmux_kill_session(session: str) -> bool:
-    cp = _tmux_run(["kill-session", "-t", session])
-    return cp is not None and cp.returncode == 0
-
-
-def _tmux_windows() -> list[str]:
-    return _tmux_list_windows()
+    return tmux.capture_pane(target)
 
 
 def _is_alive(proj: str) -> bool:
     return _tmux_pane_alive(f"{cfg.rc_session}:{proj}")
 
 
-def session_name_for(cwd: str) -> str:
-    """tmux session name for a project directory: its basename, with the tmux
-    target separators `.`/`:` (illegal in session names) replaced by `-`.
-
-    One session per project — the grouping rule shared by every claude spawn
-    (t 新建 / t 接回 / R 转入后台 / agents respawn). Empty cwd → "claude"."""
-    base = cwd.rstrip("/").rsplit("/", 1)[-1] if cwd else ""
-    name = base.replace(".", "-").replace(":", "-").strip()
-    return name or "claude"
-
-
-def run_in_tmux(session: str, window: str, cmd: str) -> str | None:
-    """Run `cmd` in a tmux `window` under `session`, creating the session if
-    it doesn't exist yet. Returns the exact "session:window_index" target of
-    the new window (None on failure) so callers can enter it unambiguously.
-    Public seam for relaunching a session outside the managed RC server
-    machinery."""
-    if _tmux_has_session(session):
-        return _tmux_new_window(session, window, cmd)
-    return _tmux_new_session(session, window, cmd)
-
-
-def _tmux_list_all_panes() -> list[tuple[str, int]]:
-    """[(\"session:window_index\", pane_pid)] across ALL tmux sessions; [] on failure."""
-    cp = _tmux_run(
-        ["list-panes", "-a", "-F", "#{session_name}:#{window_index}\t#{pane_pid}"]
-    )
-    if cp is None:
-        return []
-    out: list[tuple[str, int]] = []
-    for line in cp.stdout.splitlines():
-        target, _, pid_s = line.partition("\t")
-        try:
-            out.append((target.strip(), int(pid_s.strip())))
-        except ValueError:
-            continue
-    return out
-
-
-def window_containing(
-    panes: list[tuple[str, int]], ancestors: set[int]
-) -> str | None:
-    """PURE: the pane target whose pane_pid appears in `ancestors`, or None.
-
-    A session process hosted by a tmux pane has that pane's pid in its
-    ancestor chain (the pane pid is the window's root process)."""
-    for target, pane_pid in panes:
-        if pane_pid in ancestors:
-            return target
-    return None
-
-
-def find_session_window(pids: list[int]) -> str | None:
-    """The tmux window (\"session:index\") hosting any of `pids`, or None.
-
-    Walks each pid's `/proc` ancestor chain and matches it against every tmux
-    pane's root pid — finds windows in ANY tmux session (cc, rc, user-made)."""
-    panes = _tmux_list_all_panes()
-    if not panes:
-        return None
-    for pid in pids:
-        target = window_containing(panes, proc.ancestors_of(pid))
-        if target:
-            return target
-    return None
-
-
-def select_window(target: str) -> bool:
-    """tmux select-window -t <target>; False on failure (non-fatal for attach)."""
-    cp = _tmux_run(["select-window", "-t", target])
-    return cp is not None and cp.returncode == 0
-
-
-def switch_client(target: str) -> bool:
-    """tmux switch-client -t <target> — the inside-tmux attach equivalent."""
-    cp = _tmux_run(["switch-client", "-t", target])
-    return cp is not None and cp.returncode == 0
-
-
 def _read_rc_at_startup(directory: str) -> bool | None:
     for name in ("settings.local.json", "settings.json"):
         path = os.path.join(directory, ".claude", name)
@@ -456,15 +289,15 @@ def start_one(proj: str) -> bool:
         f"--name {shlex.quote(remote_name)} --spawn same-dir"
     )
 
-    return run_in_tmux(cfg.rc_session, proj, cmd) is not None
+    return tmux.run_in_tmux(cfg.rc_session, proj, cmd) is not None
 
 
 def stop_one(proj: str) -> bool:
-    return _tmux_kill_window(f"{cfg.rc_session}:{proj}")
+    return tmux.kill_window(f"{cfg.rc_session}:{proj}")
 
 
 def stop_all() -> bool:
-    return _tmux_kill_session(cfg.rc_session)
+    return tmux.kill_session(cfg.rc_session)
 
 
 def start_many(projects: list[str]) -> int:

{cc_session_control-0.6.4 → cc_session_control-0.6.5}/src/cc_session_control/data/snapshot.py

@@ -6,10 +6,10 @@ computes that world ONCE on the worker thread; `App` then hands the same
 immutable snapshot to each view's `fetch_pending(snapshot)` so they only project
 it (no per-view IO). Views stay back-compatible: `fetch_pending(None)` self-fetches.
 
-This is the TOP of the data layer — it composes `sessions` / `rc` / `registry` /
-`environments` / `proc`. Nothing in `data/` imports it (only `app`/`views` do),
-so there is no cycle. Errors are swallowed by the callees; `App` additionally
-guards `build_world_snapshot` so a failed build degrades to per-view self-fetch.
+This is the TOP of the data layer — it composes `sessions` / `rc` / `liveness` /
+`environments`. Nothing in `data/` imports it (only `app`/`views` do), so there
+is no cycle. Errors are swallowed by the callees; `App` additionally guards
+`build_world_snapshot` so a failed build degrades to per-view self-fetch.
 """
 
 from __future__ import annotations
@@ -17,7 +17,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 
 from ..models import AgentJob, EnvRecord, RCProject, RCServer, Session, SessionProc
-from . import environments, liveness, proc, rc, registry, sessions
+from . import environments, liveness, rc, sessions
 
 
 @dataclass
@@ -35,7 +35,7 @@ class WorldSnapshot:
     `session_procs` (with `/proc` liveness already injected), `agents_map`
     (`claude agents --json`) and `cur` (the ancestor-pid set) are the raw liveness
     inputs `build_world_snapshot` already computes for the scan; they are exposed
-    here so the Sessions cleanup submenu can feed `cleanup_classified` /
+    here so the Sessions cleanup submenu can feed `cleanup.build_plan` /
     `select_zombie_pids` WITHOUT a second scan (R11/D8).
     """
     sessions: list[Session] = field(default_factory=list)
@@ -49,29 +49,6 @@ class WorldSnapshot:
     cur: set[int] = field(default_factory=set)
 
 
-def liveness_inputs() -> tuple[
-    list[SessionProc], set[int], list[AgentJob], dict[str, int | None]
-]:
-    """The shared liveness inputs — `(session_procs, cur, agent_jobs,
-    agents_map)` — fetched ONCE, jobs already host-enriched.
-
-    Both `build_world_snapshot` and the Sessions view's `fetch_pending(None)`
-    self-fetch consume this, so the degraded path is the same assembly instead
-    of a hand-kept mirror that can drift. Each read swallows its own errors →
-    safe empties.
-    """
-    session_procs = liveness.live_session_procs()
-    try:
-        agent_jobs = liveness.enrich_jobs(registry.read_agent_jobs(), session_procs)
-    except Exception:
-        agent_jobs = []
-    try:
-        agents_map = liveness.alive_map()
-    except Exception:
-        agents_map = {}
-    return session_procs, proc.ancestor_pids(), agent_jobs, agents_map
-
-
 def build_world_snapshot() -> WorldSnapshot:
     """Compute the shared per-cycle world once (worker thread, R11/D8).
 
@@ -80,7 +57,7 @@ def build_world_snapshot() -> WorldSnapshot:
     registry reads are ~5s-TTL cached so the few repeat reads inside `scan()`
     hit the cache. Each callee swallows its own errors and returns safe empties.
     """
-    session_procs, cur, agent_jobs, agents_map = liveness_inputs()
+    session_procs, cur, agent_jobs, agents_map = liveness.liveness_inputs()
     all_sessions = sessions.scan()
     rc_projects = rc.scan()
     rc_servers = rc.scan_servers()