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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-control
-Version: 0.6.4
+Version: 0.7.0
 Summary: TUI manager for Claude Code sessions and Remote Control
 Author: dzshzx
 License-Expression: MIT
@@ -29,8 +29,8 @@ TUI manager for [Claude Code](https://claude.ai/code) sessions and Remote Contro
 
 ## Features
 
-- **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
+- **Sessions Tab** — View, resume (tmux-first: `Enter` resumes into the per-project tmux window; `t` bare-terminal fallback; `R` backgrounds into tmux; ⧉ marks tmux-resident sessions), terminate, and delete Claude Code sessions across all projects; a cleanup submenu (`c`) prunes empty/short sessions and sweeps orphan artifact directories
+- **Projects Tab** — The startup tab: start a new tmux claude session in a project dir (`Enter`), start/stop RC servers per project (`o`/`s`), toggle auto-start, show running/stopped/dead states
 - **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.4 → cc_session_control-0.7.0}/README.md

@@ -6,8 +6,8 @@ TUI manager for [Claude Code](https://claude.ai/code) sessions and Remote Contro
 
 ## Features
 
-- **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
+- **Sessions Tab** — View, resume (tmux-first: `Enter` resumes into the per-project tmux window; `t` bare-terminal fallback; `R` backgrounds into tmux; ⧉ marks tmux-resident sessions), terminate, and delete Claude Code sessions across all projects; a cleanup submenu (`c`) prunes empty/short sessions and sweeps orphan artifact directories
+- **Projects Tab** — The startup tab: start a new tmux claude session in a project dir (`Enter`), start/stop RC servers per project (`o`/`s`), toggle auto-start, show running/stopped/dead states
 - **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.4 → cc_session_control-0.7.0}/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.7.0"

{cc_session_control-0.6.4 → cc_session_control-0.7.0}/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) --------------------------------------------------------
@@ -128,7 +120,10 @@ def resume_takeover(job: AgentJob) -> Session:
     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
-    protected. Does NOT itself replace the csctl process.
+    protected. `tmux_target` is filled here at action time (the agents list
+    renders no ⧉ badge, so there is no batch snapshot value to reuse) so the
+    tmux-first Enter can enter a resident worker in place. Does NOT itself
+    replace the csctl process.
     """
     pid, alive = job_host(job)
     current = bool(pid) and pid in proc.ancestor_pids()
@@ -144,6 +139,7 @@ def resume_takeover(job: AgentJob) -> Session:
         proc_start=_host_start(pid),
         source="bg",
         agent_short=job.short,
+        tmux_target=tmux.find_session_window([pid]) if alive and pid else None,
     )
 
 

{cc_session_control-0.6.4 → cc_session_control-0.7.0}/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
 
@@ -87,7 +87,7 @@ def would_take_over(s: Session, fork: bool = False) -> bool:
     The single source of the "needs confirmation" decision for the UI: it reads
     `_resume_plan`'s `should_kill` so views never re-derive `s.alive and not
     s.current` themselves (CLAUDE.md: should_kill is single-point — re-derivation
-    was the old divergence). `do_resume`/`relaunch_in_tmux` and the confirm gate
+    was the old divergence). `do_resume`/`do_tmux_resume` and the confirm gate
     thus agree by construction.
     """
     return _resume_plan(s, fork)[2]
@@ -126,86 +126,67 @@ def do_resume(s: Session, fork: bool = False) -> None:
     os.execvp("claude", args)
 
 
-def _rc_name(s: Session) -> str:
-    """Remote-control label (shown in claude.ai/code) for a relaunched session."""
-    base = s.cwd.rstrip("/").rsplit("/", 1)[-1] if s.cwd else ""
-    return f"{base or 'session'}-{s.sid[:8]}"
-
-
-def tmux_resume_cmd(s: Session, fork: bool = False) -> str:
-    """Shell command that resumes the session under remote control."""
-    cwd, args, _ = _resume_plan(s, fork)
-    args = args + ["--remote-control", _rc_name(s)]
-    line = shlex.join(args)
-    return f"cd {shlex.quote(cwd)} && {line}" if cwd else line
-
-
 def _spawn_in_tmux(s: Session, cmd: str, fork: bool = False) -> str | None:
     """Kill-if-takeover, then spawn `cmd` in the session's per-project tmux
-    session — the shared skeleton behind `relaunch_in_tmux` (R key, with
-    --remote-control) and `do_tmux_resume` (t key, foreground): the two
-    differed only in the command builder. Returns the exact tmux target,
-    or None on R10 refusal ("refused" from `take_over`) / tmux failure;
-    "gone"/"failed" fall through like `do_resume` (best-effort kill).
+    session — the shared skeleton behind `do_tmux_resume` (Enter/f/R, the
+    tmux-first dispatch verbs, ADR-0001). A fork is a copy (never kills) and
+    gets its own `<sid8>-fork` window so it doesn't shadow the original's.
+    Returns the exact tmux target, or None on R10 refusal ("refused" from
+    `take_over`) / tmux failure; "gone"/"failed" fall through like
+    `do_resume` (best-effort kill).
     """
     _, _, 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)
-
-
-def relaunch_in_tmux(s: Session, fork: bool = False) -> bool:
-    """Relaunch a session as `claude --resume … --remote-control …` inside a
-    tmux window, so it outlives the terminal and is remotely controllable.
-
-    A live, non-current session is taken over (old pid killed first, like
-    terminate); a fork leaves the original running. csctl is NOT replaced —
-    it just spawns the tmux window.
-    """
-    return _spawn_in_tmux(s, tmux_resume_cmd(s, fork), fork=fork) is not None
+    window = f"{s.sid[:8]}-fork" if fork else s.sid[:8]
+    return tmux.run_in_tmux(tmux.session_name_for(s.cwd), window, cmd)
 
 
 def attach_target(s: Session) -> str | None:
     """The tmux window ("session:index") already hosting this live session.
 
-    Non-None means the `t` key can attach directly — no kill, no respawn (the
-    session survives in place). None for dead sessions or live ones running in
-    a bare terminal (those need `do_tmux_resume`)."""
-    if not s.alive or not s.pid:
+    Non-None means the session is tmux-resident and can be entered in place —
+    no kill, no respawn. Reads the snapshot-computed `Session.tmux_target`
+    (the SAME data the ⧉ badge renders — one source, no per-action
+    re-detection), guarded on `alive` so a stale target on a dead session
+    never answers."""
+    if not s.alive:
         return None
-    return rc.find_session_window([s.pid])
+    return s.tmux_target
 
 
-def tmux_foreground_cmd(s: Session) -> str:
-    """Shell command for the `t`-key window: plain resume, NO --remote-control.
+def tmux_foreground_cmd(s: Session, fork: bool = False) -> str:
+    """Shell command for a tmux-dispatch window: plain resume, NO
+    --remote-control.
 
-    Deliberately unlike `tmux_resume_cmd` (the `R` key): a foreground tmux
-    resume only needs the disconnect safety net; every --remote-control process
-    mints a new cloud environment entry, which piles up with frequent use."""
-    cwd, args, _ = _resume_plan(s)
+    Deliberate (ADR-0001): tmux residency is the anti-disconnect mechanism;
+    every --remote-control process mints a new cloud environment entry, which
+    piles up with frequent use — the Sessions tab never mints cloud envs."""
+    cwd, args, _ = _resume_plan(s, fork)
     line = shlex.join(args)
     return f"cd {shlex.quote(cwd)} && {line}" if cwd else line
 
 
-def do_tmux_resume(s: Session) -> str | None:
-    """Kill-if-takeover, spawn the resume window in the session's per-project
-    tmux session, and return the exact tmux target to enter; None on failure.
-    The caller (cli) then calls `enter_window` on the target."""
-    return _spawn_in_tmux(s, tmux_foreground_cmd(s))
+def do_tmux_resume(s: Session, fork: bool = False) -> str | None:
+    """Kill-if-takeover (fork never kills), spawn the resume window in the
+    session's per-project tmux session, and return the exact tmux target;
+    None on failure. Enter/f enter the target afterwards (`TmuxResumeIntent`);
+    R 转后台 spawns it and stays in csctl."""
+    return _spawn_in_tmux(s, tmux_foreground_cmd(s, fork), fork=fork)
 
 
 def do_tmux_new(directory: str) -> str | None:
     """Start a NEW claude session in `directory`, inside that project's own
     tmux session, and return the exact tmux target to enter; None on failure.
 
-    The 项目-tab `t` key: same skeleton as `do_tmux_resume` but nothing exists
+    The 项目-tab Enter key: same skeleton as `do_tmux_resume` but nothing exists
     yet — no kill, no confirm, no R10 gate (no process is terminated). Plain
     `claude` with NO --remote-control (same tradeoff as `tmux_foreground_cmd`:
     every RC process mints a new cloud environment entry). No trust gate
     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) ------------
@@ -226,7 +207,8 @@ class ExitIntent:
 
 @dataclass(frozen=True)
 class ResumeIntent(ExitIntent):
-    """Enter/f: bare-terminal resume (execvp; takeover kill inside do_resume)."""
+    """`t` 终端接回: bare-terminal resume (execvp; takeover kill inside
+    do_resume) — the fallback when tmux is unavailable or unwanted."""
 
     session: Session
     fork: bool = False
@@ -237,7 +219,7 @@ class ResumeIntent(ExitIntent):
 
 @dataclass(frozen=True)
 class AttachIntent(ExitIntent):
-    """`t` on a tmux-hosted session: enter its window in place (no kill)."""
+    """Enter on a tmux-resident session: enter its window in place (no kill)."""
 
     target: str
 
@@ -248,12 +230,14 @@ class AttachIntent(ExitIntent):
 
 @dataclass(frozen=True)
 class TmuxResumeIntent(ExitIntent):
-    """`t` on a dead / bare-terminal session: resume inside tmux, then enter."""
+    """Enter/f on a dead / bare-terminal session: resume (or fork) inside
+    tmux, then enter — the primary tmux-first dispatch (ADR-0001)."""
 
     session: Session
+    fork: bool = False
 
     def run(self) -> None:
-        target = do_tmux_resume(self.session)
+        target = do_tmux_resume(self.session, fork=self.fork)
         if target is None:
             print("Failed to resume the session inside tmux (R10 degraded, or tmux unavailable).")
         elif not enter_window(target):
@@ -262,7 +246,7 @@ class TmuxResumeIntent(ExitIntent):
 
 @dataclass(frozen=True)
 class TmuxNewIntent(ExitIntent):
-    """项目-tab `t`: start a NEW claude in tmux, then enter (pure spawn)."""
+    """项目-tab Enter: start a NEW claude in tmux, then enter (pure spawn)."""
 
     directory: str
 
@@ -282,10 +266,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.7.0}/src/cc_session_control/app.py

@@ -69,7 +69,9 @@ PALETTE = [
     ("col_header",  "dark cyan",   "black", None,       "#9cc",       "#181818"),
 ]
 
-TAB_NAMES = ["会话", "项目", "后台"]
+# Launcher-first order (ADR-0001): startup lands on 项目 (the tmux-first
+# dispatch entry), then 会话 / 后台. In lockstep with `self.views` below.
+TAB_NAMES = ["项目", "会话", "后台"]
 
 # D1: all three tabs share ONE footer prefix — the universal verbs (Tab/q/r) live
 # here exactly once so `r 刷新` shows identically on every tab. View-specific keys
@@ -104,8 +106,9 @@ class App:
         self._confirm_yes: Callable[[], None] | None = None
         self._confirm_base: urwid.Widget | None = None
 
-        # Order is in lockstep with TAB_NAMES: 会话 / 项目 / 后台.
-        self.views: list[TabView] = [SessionsView(self), RCView(self), AgentsView(self)]
+        # Order is in lockstep with TAB_NAMES: 项目 / 会话 / 后台 (launcher-first,
+        # ADR-0001 — startup loads the 项目 tab at _active=0).
+        self.views: list[TabView] = [RCView(self), SessionsView(self), AgentsView(self)]
         self._active = 0
 
         self.body = urwid.WidgetPlaceholder(self.views[0].widget)

{cc_session_control-0.6.4 → cc_session_control-0.7.0}/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.7.0}/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.7.0}/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],