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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-control
-Version: 0.5.0
+Version: 0.6.0
 Summary: TUI manager for Claude Code sessions and Remote Control
 Author: dzshzx
 License-Expression: MIT
@@ -30,7 +30,7 @@ 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
-- **Remote Control Tab** — Start/stop RC servers per project, toggle auto-start, show running/stopped/dead states
+- **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
 
 Built with [urwid](https://urwid.org/).

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

@@ -7,7 +7,7 @@ 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
-- **Remote Control Tab** — Start/stop RC servers per project, toggle auto-start, show running/stopped/dead states
+- **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
 
 Built with [urwid](https://urwid.org/).

{cc_session_control-0.5.0 → cc_session_control-0.6.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.5.0"
+__version__ = "0.6.0"

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

@@ -97,12 +97,13 @@ def _job_window(job: AgentJob) -> str:
 def respawn(job: AgentJob) -> str:
     """Relaunch a background agent in tmux; returns the exact command string.
 
-    Runs `respawn_cmd(job)` in the shared tmux session (`cfg.tmux_session`) so it
-    outlives the terminal — it does NOT os.exec/replace the csctl process. The
-    returned string also feeds the clipboard `y`-style key.
+    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
+    os.exec/replace the csctl process. The returned string also feeds the
+    clipboard `y`-style key.
     """
     cmd = respawn_cmd(job)
-    rc.run_in_tmux(cfg.tmux_session, _job_window(job), cmd)
+    rc.run_in_tmux(rc.session_name_for(job.cwd), _job_window(job), cmd)
     return cmd
 
 

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

@@ -8,7 +8,6 @@ import signal
 import time
 
 from .. import clipboard
-from ..config import cfg
 from ..data import proc, rc
 from ..data.liveness import invalidate_cache
 from ..models import Session
@@ -143,7 +142,83 @@ def relaunch_in_tmux(s: Session, fork: bool = False) -> bool:
             pass
         time.sleep(1)
         invalidate_cache()
-    return rc.run_in_tmux(cfg.tmux_session, _rc_name(s), tmux_resume_cmd(s, fork))
+    session = rc.session_name_for(s.cwd)
+    return rc.run_in_tmux(session, s.sid[:8], tmux_resume_cmd(s, fork)) is not None
+
+
+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:
+        return None
+    return rc.find_session_window([s.pid])
+
+
+def tmux_foreground_cmd(s: Session) -> str:
+    """Shell command for the `t`-key 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)
+    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.
+
+    Mirrors `relaunch_in_tmux`'s kill handling (same `_resume_plan` should_kill
+    + R10 refusal); the caller (cli) then calls `enter_window` on the target."""
+    _, _, should_kill = _resume_plan(s)
+    if should_kill and s.pid:
+        if not proc.current_determinable():
+            return None
+        try:
+            os.kill(s.pid, signal.SIGTERM)
+        except Exception:
+            pass
+        time.sleep(1)
+        invalidate_cache()
+    session = rc.session_name_for(s.cwd)
+    return rc.run_in_tmux(session, s.sid[:8], tmux_foreground_cmd(s))
+
+
+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
+    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)
+
+
+def enter_window(target: str) -> bool:
+    """Bring `target` ("session:window") to the user's terminal foreground.
+
+    Outside tmux: exec `tmux attach-session` — replaces the csctl process (does
+    not return on success). Inside tmux ($TMUX set): `switch-client`, then
+    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)
+    session = target.split(":", 1)[0]
+    if os.environ.get("TMUX"):
+        return rc.switch_client(target)
+    try:
+        os.execvp("tmux", ["tmux", "attach-session", "-t", session])
+    except OSError:
+        return False
+    return True  # unreachable after a successful exec; keeps type-checkers calm
 
 
 def to_clipboard(text: str) -> bool:

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

@@ -43,23 +43,28 @@ class TabView(Protocol):
     def handle_key(self, key: str) -> None: ...
 
 # 6-tuple: (name, fg_16, bg_16, mono, fg_256, bg_256)
+# ONE semantic set — views reference these names only (no per-tab duplicates;
+# the old rc_running/rc_stopped were aliases of alive/dead and are gone).
+# 256-color foregrounds are kept ≥ 4.5:1 against their background (WCAG-AA-ish,
+# checked via relative luminance): #aaa/#111 ≈ 8.1, #7ab/#111 ≈ 7.4,
+# #9cc/#181818 ≈ 10.0, #bbb/#111 ≈ 9.8, #d66/#111 ≈ 5.5.
 PALETTE = [
-    ("header",     "white,bold",  "black", "bold",     "#fff,bold",  "#111"),
-    ("footer",     "light gray",  "black", None,       "#999",       "#111"),
-    ("tab_on",     "white,bold",  "dark cyan", "bold,standout", "#fff,bold", "#068"),
-    ("tab_off",    "dark cyan",   "black", None,       "#688",       "#111"),
-    ("alive",      "light green", "black", None,       "#6d6",       "#111"),
-    ("dead",       "light gray",  "black", None,       "#ccc",       "#111"),
-    ("selected",   "white,bold",  "dark cyan", "standout", "#fff,bold", "#068"),
-    ("notify",     "yellow,bold", "black", "bold",     "#ff0,bold",  "#111"),
-    ("status",     "light gray",  "black", None,       "#aaa",       "#111"),
-    ("rc_running", "light green", "black", None,       "#6d6",       "#111"),
-    ("rc_stopped", "light gray",  "black", None,       "#ccc",       "#111"),
-    ("body",       "light gray",  "black", None,       "#ccc",       "#111"),
-    ("col_header", "dark cyan",   "black", None,       "#8aa",       "#181818"),
+    ("header",      "white,bold",  "black", "bold",     "#fff,bold",  "#111"),
+    ("footer",      "light gray",  "black", None,       "#aaa",       "#111"),
+    ("tab_on",      "white,bold",  "dark cyan", "bold,standout", "#fff,bold", "#068"),
+    ("tab_off",     "light cyan",  "black", None,       "#7ab",       "#111"),
+    ("alive",       "light green", "black", None,       "#6d6",       "#111"),
+    ("status_busy", "light green,bold", "black", "bold", "#6d6,bold", "#111"),
+    ("status_err",  "light red",   "black", None,       "#d66",       "#111"),
+    ("dead",        "light gray",  "black", None,       "#ccc",       "#111"),
+    ("selected",    "white,bold",  "dark cyan", "standout", "#fff,bold", "#068"),
+    ("notify",      "yellow,bold", "black", "bold",     "#ff0,bold",  "#111"),
+    ("status",      "light gray",  "black", None,       "#bbb",       "#111"),
+    ("body",        "light gray",  "black", None,       "#ccc",       "#111"),
+    ("col_header",  "dark cyan",   "black", None,       "#9cc",       "#181818"),
 ]
 
-TAB_NAMES = ["会话", "后台", "远程控制"]
+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
@@ -87,13 +92,14 @@ class App:
         self._alarm_handle: object | None = None
         self._pipe_fd: int | None = None
         self._refreshing = False
-        # When set, a y/n confirm modal is up: `_input` routes y/n/esc here and
+        # When set, a confirm modal is up: `_input` routes Enter/y/n/esc here and
         # swallows every other key (App-level so all tabs share it — D8 view files
         # stay small). `_confirm_base` is the widget restored on close.
         self._confirm_yes: Callable[[], None] | None = None
         self._confirm_base: urwid.Widget | None = None
 
-        self.views: list[TabView] = [SessionsView(self), AgentsView(self), RCView(self)]
+        # Order is in lockstep with TAB_NAMES: 会话 / 项目 / 后台.
+        self.views: list[TabView] = [SessionsView(self), RCView(self), AgentsView(self)]
         self._active = 0
 
         self.body = urwid.WidgetPlaceholder(self.views[0].widget)
@@ -143,9 +149,12 @@ class App:
 
     def _input(self, key: str) -> None:
         if self._confirm_yes is not None:
-            # Modal: only y/n/esc are live; tab/q/everything else is swallowed so
-            # a destructive confirm can't be skipped past by an accidental key.
-            if key == "y":
+            # Modal: only Enter/y/n/esc are live; tab/q/everything else is
+            # swallowed so a destructive confirm can't be skipped past by an
+            # accidental key. Enter = 确认 (universal dialog muscle memory);
+            # the accepted cost is that double-Enter on a live session confirms
+            # its takeover — which is what Enter was asking for anyway.
+            if key in ("enter", "y"):
                 cb = self._confirm_yes
                 self._close_confirm()
                 cb()
@@ -160,24 +169,24 @@ class App:
             self.views[self._active].handle_key(key)
 
     def confirm(self, message: str, on_yes: Callable[[], None]) -> None:
-        """Show a y/n modal over the active tab; run `on_yes` only on `y`.
+        """Show a confirm modal over the active tab; run `on_yes` on Enter/y.
 
         App-level (not a per-view mode) so every tab gets confirmation for free
-        and the view files stay under budget. While up, `_input` routes y/n/esc
-        and swallows the rest. The overlay sits ABOVE the view widget in
+        and the view files stay under budget. While up, `_input` routes
+        Enter/y/n/esc and swallows the rest. The overlay sits ABOVE the view widget in
         `self.body`, so a worker-thread refresh (which only rebuilds a view's own
         walker) never disturbs it.
         """
         self._confirm_yes = on_yes
         self._confirm_base = self.body.original_widget
-        text = urwid.Text(f"  {message}\n\n  y 确认    n / Esc 取消")
+        text = urwid.Text(f"  {message}\n\n  Enter / y 确认    n / Esc 取消")
         box = urwid.AttrMap(urwid.LineBox(urwid.Filler(text)), "notify")
         self.body.original_widget = urwid.Overlay(
             box, self._confirm_base,
             align="center", width=("relative", 50),
             valign="middle", height=7,
         )
-        self.footer_text.set_text(" y 确认 · n/Esc 取消")
+        self.footer_text.set_text(" Enter/y 确认 · n/Esc 取消")
 
     def _close_confirm(self) -> None:
         if self._confirm_base is not None:
@@ -196,6 +205,18 @@ class App:
     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_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))
+
     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)

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

@@ -298,15 +298,38 @@ def _cmd_env(args: argparse.Namespace) -> None:
 
 
 def _cmd_tui(args: argparse.Namespace) -> None:
-    from .actions.session_ops import do_resume
+    from .actions.session_ops import do_resume, do_tmux_new, do_tmux_resume, enter_window
     from .app import App
 
     app = App()
     result = app.run()
 
-    if result and isinstance(result, tuple) and result[0] == "resume":
+    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.")
 
 
 def main() -> None:

{cc_session_control-0.5.0 → cc_session_control-0.6.0}/src/cc_session_control/config.py

@@ -16,10 +16,6 @@ class Config:
         self.rc_list: Path = self.config_dir / "rc-enabled"
         self.rc_session: str = os.environ.get("CSCTL_RC_SESSION", "rc")
         self.rc_stagger: int = int(os.environ.get("CSCTL_RC_STAGGER", "2"))
-        # Dedicated tmux session for interactive sessions relaunched under remote
-        # control (kept separate from rc_session, whose windows are managed RC
-        # server processes).
-        self.tmux_session: str = os.environ.get("CSCTL_TMUX_SESSION", "cc")
         # Age threshold (days) for the time/global-keyed cleanup strategy.
         self.cleanup_age_days: int = int(os.environ.get("CSCTL_CLEANUP_AGE_DAYS", "14"))
         self._workspace: Path | None = None

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

@@ -11,15 +11,36 @@ from __future__ import annotations
 import json
 import subprocess
 import time
+from collections.abc import Callable
 
 from ..models import LiveInfo, SessionProc
+from . import proc
 
 _cache: dict[str, int | None] | None = None
 _cache_time: float = 0.0
 
 
+def _scrub_dead_pids(
+    mapping: dict[str, int | None],
+    exists: Callable[[int | None], bool],
+) -> dict[str, int | None]:
+    """Blank out pids whose process no longer exists (pure; `exists` injected).
+
+    `claude agents --json` can keep reporting a pid after the worker died
+    (SIGKILL/crash before its registry caught up). A dead pid must not count as
+    alive — blanking it lets the existing "pid-less entries are not alive" rule
+    in `live_index` take over. Entries are kept, never dropped.
+    """
+    return {sid: (pid if exists(pid) else None) for sid, pid in mapping.items()}
+
+
 def alive_map(max_age: float = 5.0) -> dict[str, int | None]:
-    """Return {session_id: pid} for all known agents. Cached for max_age seconds."""
+    """Return {session_id: pid} for all known agents. Cached for max_age seconds.
+
+    With `/proc` available, pids are scrubbed against process existence at
+    cache-refresh time (see `_scrub_dead_pids`). Without `/proc` (R10 degraded
+    mode) the map is the ONLY liveness source, so it is passed through as-is.
+    """
     global _cache, _cache_time
     now = time.monotonic()
     if _cache is not None and (now - _cache_time) < max_age:
@@ -36,6 +57,8 @@ def alive_map(max_age: float = 5.0) -> dict[str, int | None]:
         }
     except Exception:
         result = {}
+    if proc.has_proc():
+        result = _scrub_dead_pids(result, proc.pid_exists)
     _cache = result
     _cache_time = now
     return result
@@ -122,19 +145,24 @@ def live_index(
         )
 
     # `claude agents --json` is authoritative for liveness: it covers agent-only
-    # sids and rescues the degraded (no-/proc) path.
+    # sids and rescues the degraded (no-/proc) path. But it also keeps listing
+    # settled/blocked bg sessions WITHOUT a pid — those are not alive (there is
+    # no process to signal; terminate/stop would always fail), so alive is
+    # judged by pid non-empty.
     for sid, pid in agents_map.items():
         if not sid:
             continue
         info = index.get(sid)
         if info is None:
             index[sid] = LiveInfo(
-                sid=sid, pid=pid, alive=True, pids=[pid] if pid else []
+                sid=sid, pid=pid, alive=bool(pid), pids=[pid] if pid else []
             )
             continue
+        if not pid:
+            continue  # pid-less entry: the proc-based verdict stands
         info.alive = True
         if info.pid is None:
             info.pid = pid
-        if pid and pid not in info.pids:
+        if pid not in info.pids:
             info.pids.append(pid)
     return index

{cc_session_control-0.5.0 → cc_session_control-0.6.0}/src/cc_session_control/data/proc.py

@@ -45,6 +45,19 @@ def current_determinable() -> bool:
     return has_proc()
 
 
+def pid_exists(pid: int | None) -> bool:
+    """Bare `/proc/<pid>` existence — no starttime / pid-reuse defense.
+
+    For scrubbing externally-reported pids (e.g. `claude agents --json`) where
+    no recorded procStart exists to compare against. Deliberately does NOT
+    check comm/cmdline (a claude process may exec under another name). Always
+    False without `/proc`, so callers must skip scrubbing in degraded mode.
+    """
+    if not pid:
+        return False
+    return os.path.isdir(f"{_PROC}/{pid}")
+
+
 def proc_starttime(pid: int) -> str | None:
     """Field 22 (starttime) from `/proc/<pid>/stat`, or None if unavailable.
 
@@ -85,18 +98,13 @@ def pid_alive(pid: int | None, proc_start: str | None) -> bool:
     return st == proc_start
 
 
-def ancestor_pids() -> set[int]:
-    """csctl's own ancestor pid chain (including self).
-
-    A session whose pid is in this set is the "current" one (it launched
-    csctl) and is protected. Linux/WSL only — returns just `{getpid()}` when
-    `/proc` is unavailable, in which case current can't be determined and
-    callers must degrade (see R10).
-    """
-    pids = {os.getpid()}
+def ancestors_of(start_pid: int) -> set[int]:
+    """Ancestor pid chain of `start_pid` (including itself), via `/proc` ppid
+    walk. Returns just `{start_pid}` when `/proc` is unavailable."""
+    pids = {start_pid}
     if not has_proc():
         return pids
-    pid = os.getpid()
+    pid = start_pid
     for _ in range(40):
         try:
             with open(f"{_PROC}/{pid}/stat") as fh:
@@ -111,6 +119,17 @@ def ancestor_pids() -> set[int]:
     return pids
 
 
+def ancestor_pids() -> set[int]:
+    """csctl's own ancestor pid chain (including self).
+
+    A session whose pid is in this set is the "current" one (it launched
+    csctl) and is protected. Linux/WSL only — returns just `{getpid()}` when
+    `/proc` is unavailable, in which case current can't be determined and
+    callers must degrade (see R10).
+    """
+    return ancestors_of(os.getpid())
+
+
 # --- project RC server discovery (R5 / D5) ---------------------------------
 # A real `claude remote-control --name <name>` server's /proc cmdline shows the
 # FULL argv (verified live: a bare interactive `claude` instead collapses its

{cc_session_control-0.5.0 → cc_session_control-0.6.0}/src/cc_session_control/data/rc.py

@@ -175,14 +175,27 @@ def _tmux_has_session(session: str) -> bool:
     return cp is not None and cp.returncode == 0
 
 
-def _tmux_new_window(session: str, name: str, cmd: str) -> bool:
-    cp = _tmux_run(["new-window", "-t", session, "-n", name, cmd])
-    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 _tmux_new_session(session: str, name: str, cmd: str) -> bool:
-    cp = _tmux_run(["new-session", "-d", "-s", session, "-n", name, cmd])
-    return cp is not None and cp.returncode == 0
+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:
@@ -203,15 +216,85 @@ def _is_alive(proj: str) -> bool:
     return _tmux_pane_alive(f"{cfg.rc_session}:{proj}")
 
 
-def run_in_tmux(session: str, window: str, cmd: str) -> bool:
+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. Public seam for relaunching a session outside the
-    managed RC server machinery."""
+    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)
@@ -380,12 +463,7 @@ def start_one(proj: str) -> bool:
         f"--name {shlex.quote(remote_name)} --spawn same-dir"
     )
 
-    session = cfg.rc_session
-    has_session = _tmux_has_session(session)
-
-    if has_session:
-        return _tmux_new_window(session, proj, cmd)
-    return _tmux_new_session(session, proj, cmd)
+    return run_in_tmux(cfg.rc_session, proj, cmd) is not None
 
 
 def stop_one(proj: str) -> bool:

{cc_session_control-0.5.0 → cc_session_control-0.6.0}/src/cc_session_control/skill/SKILL.md

@@ -12,7 +12,7 @@ description: Diagnose and rescue local Claude Code sessions via csctl — list l
 ## 交互式 TUI
 
 ```bash
-csctl          # 三个 tab：会话 / 后台 agent / 远程控制；清理在会话 tab 的子菜单
+csctl          # 三个 tab：会话 / 项目（远控 + t 新建 tmux 会话）/ 后台 agent；清理在会话 tab 的子菜单
 ```
 
 会话 tab 键位：方向键移动 · `/` 过滤 · `Enter` 接回（真接续，自动 cd+kill）· `f` 分叉接回 · `y` 复制命令到剪贴板 · `t` 终止活会话(确认) · `r` 刷新 · `q` 退出。接回时 csctl exec 成 claude 接管终端。