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

{cc_session_control-0.6.5/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.5
+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.5 → 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.5 → 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.5"
+__version__ = "0.7.0"

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

@@ -120,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()
@@ -136,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.5 → cc_session_control-0.7.0}/src/cc_session_control/actions/session_ops.py

@@ -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,79 +126,60 @@ 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 tmux.run_in_tmux(tmux.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 tmux.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
@@ -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
 

{cc_session_control-0.6.5 → 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.5 → cc_session_control-0.7.0}/src/cc_session_control/data/sessions.py

@@ -8,7 +8,7 @@ import os
 
 from ..config import cfg
 from ..models import LiveInfo, Session
-from . import registry
+from . import registry, tmux
 from .liveness import alive_map, is_rc_exposed, live_index, live_session_procs
 from .proc import ancestor_pids as _ancestor_pids  # /proc walk moved to proc.py
 
@@ -160,14 +160,49 @@ def _parse_transcript(
     )
 
 
+def _candidate_pids(info: LiveInfo | None) -> list[int]:
+    """A LiveInfo's pid candidate set — `pids` when filled, else the chosen pid
+    (same fallback rule the `current` check in `_parse_transcript` uses)."""
+    if info is None:
+        return []
+    if info.pids:
+        return info.pids
+    return [info.pid] if info.pid else []
+
+
+def _inject_tmux_residency(rows: list[Session], idx: dict[str, LiveInfo]) -> None:
+    """Fill `Session.tmux_target` for every ALIVE session, in ONE batch.
+
+    Collects all alive sessions' candidate pids, calls
+    `tmux.residency_targets` once (one `list-panes -a` per scan cycle), and
+    backfills each session with its first hit — any alive pid inside a tmux
+    pane makes the session resident (ADR-0001). Dead sessions stay None; the
+    badge and the resume/backgrounding actions read this SAME field, so there
+    is no per-action re-detection (no second source of truth)."""
+    alive_pids = {
+        pid for row in rows if row.alive for pid in _candidate_pids(idx.get(row.sid))
+    }
+    targets = tmux.residency_targets(alive_pids)
+    if not targets:
+        return
+    for row in rows:
+        if not row.alive:
+            continue
+        for pid in _candidate_pids(idx.get(row.sid)):
+            if pid in targets:
+                row.tmux_target = targets[pid]
+                break
+
+
 def scan() -> list[Session]:
     """Unified transcript-driven session scan.
 
     Merges the three liveness/identity sources once per scan — registry
     `sessions/<pid>.json`, `claude agents --json`, and `jobs/*/state.json` — then
     projects each transcript through `live_index()` to fill source/liveness/
-    rc-exposure. Scan stays transcript-driven: an agent-only sid (present in the
-    live index but with no transcript) is surfaced by the Agents tab, not here.
+    rc-exposure, and batch-injects tmux residency (`tmux_target`). Scan stays
+    transcript-driven: an agent-only sid (present in the live index but with no
+    transcript) is surfaced by the Agents tab, not here.
     """
     root = str(cfg.projects_root)
     session_procs = live_session_procs()
@@ -182,5 +217,6 @@ def scan() -> list[Session]:
         if row is not None:
             rows.append(row)
 
+    _inject_tmux_residency(rows, idx)
     rows.sort(key=lambda r: r.mtime, reverse=True)
     return rows

{cc_session_control-0.6.5 → cc_session_control-0.7.0}/src/cc_session_control/data/tmux.py

@@ -16,6 +16,7 @@ don't conflate tmux windows with Remote Control).
 from __future__ import annotations
 
 import subprocess
+from collections.abc import Iterable
 
 from . import proc
 
@@ -170,18 +171,37 @@ def window_containing(
     return None
 
 
-def find_session_window(pids: list[int]) -> str | None:
-    """The tmux window ("session:index") hosting any of `pids`, or None.
+def residency_targets(pids: Iterable[int]) -> dict[int, str]:
+    """{pid: "session:window_index"} for every pid hosted by a tmux pane.
 
-    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)."""
+    THE batch tmux-residency computation (ADR-0001 badge + actions share it):
+    ONE `list-panes -a` for the whole pid set, then each pid's `/proc` ancestor
+    chain is matched against the pane root pids — finds windows in ANY tmux
+    session (per-project, rc, user-made). Misses are simply absent from the
+    dict; tmux failure returns {} (swallow-errors contract)."""
+    pid_list = list(pids)
+    if not pid_list:
+        return {}
     panes = _tmux_list_all_panes()
     if not panes:
-        return None
-    for pid in pids:
+        return {}
+    out: dict[int, str] = {}
+    for pid in pid_list:
         target = window_containing(panes, proc.ancestors_of(pid))
         if target:
-            return target
+            out[pid] = target
+    return out
+
+
+def find_session_window(pids: list[int]) -> str | None:
+    """The tmux window ("session:index") hosting any of `pids`, or None.
+
+    Single-target convenience over `residency_targets` (first hit in `pids`
+    order) — used by the action layer when only one session is in play."""
+    targets = residency_targets(pids)
+    for pid in pids:
+        if pid in targets:
+            return targets[pid]
     return None
 
 

{cc_session_control-0.6.5 → cc_session_control-0.7.0}/src/cc_session_control/models.py

@@ -34,6 +34,11 @@ class Session:
     env_id: str | None = None   # bound bridge environment id, if any
     agent_short: str | None = None  # linked background-agent short id, if any
     status: str = ""            # registry `status` (busy / idle)
+    # tmux residency (CONTEXT.md / ADR-0001): non-None means a live pid of this
+    # session runs inside a tmux pane; the value is the enterable
+    # "session:window_index" target. Batch-computed in sessions.scan() via
+    # tmux.residency_targets — actions and the ⧉ badge read the SAME field.
+    tmux_target: str | None = None
 
     @property
     def bridge_or_sdk(self) -> bool:

{cc_session_control-0.6.5 → cc_session_control-0.7.0}/src/cc_session_control/skill/SKILL.md

@@ -12,10 +12,10 @@ description: Diagnose and rescue local Claude Code sessions via csctl — list l
 ## 交互式 TUI
 
 ```bash
-csctl          # 三个 tab：会话 / 项目（远控 + t 新建 tmux 会话）/ 后台 agent；清理在会话 tab 的子菜单
+csctl          # 三个 tab（tmux-first，启动落在项目 tab）：项目（Enter 新建 tmux 会话 / o 启动远控）/ 会话 / 后台 agent；清理在会话 tab 的子菜单
 ```
 
-会话 tab 键位：方向键移动 · `/` 过滤 · `Enter` 接回（真接续，自动 cd+kill，接活会话先确认）· `t` tmux 接回（进 tmux 窗口，断线不死）· `f` 分叉接回 · `s` 停止活会话(确认) · `R` 转入后台+远控(确认) · `d` 删除已结束会话 · `y` 复制命令到剪贴板 · `h` 桥接/SDK 显隐 · `c` 清理子菜单 · `r` 刷新 · `q` 退出。接回时 csctl exec 成 claude 接管终端。
+会话 tab 键位：方向键移动 · `/` 过滤 · `Enter` tmux 接回（主操作：恢复进 per-project tmux 窗口并进入，断线不死；已驻留 ⧉ 会话就地进入；接活会话先确认）· `t` 终端接回（裸终端兜底，真接续自动 cd+kill）· `f` 分叉进 tmux · `s` 停止活会话(确认) · `R` 转后台（进 tmux 不进入、不开远控，留在 csctl）· `d` 删除已结束会话 · `y` 复制命令到剪贴板 · `h` 桥接/SDK 显隐 · `c` 清理子菜单 · `r` 刷新 · `q` 退出。接回 = 离开 csctl（attach 进 tmux 或 exec 成 claude）。
 
 ## 心智模型：会话形态
 
@@ -63,7 +63,7 @@ csctl resume [关键词] --all      # 不分页全列
 
 ## 接管远程控制 / 网页会话到本地
 
-`claude --remote-control` 或 claude.ai 网页控制的会话，在本机就是一个普通的**活会话**（会进 `claude agents`）。想搬到本地终端接管，照「接回规则」当"还活着"处理即可；`csctl resume` 已自动给出对应命令。TUI 里也可以选中后接回或 relaunch 进 tmux（`--remote-control` 恢复远控暴露）。
+`claude --remote-control` 或 claude.ai 网页控制的会话，在本机就是一个普通的**活会话**（会进 `claude agents`）。想搬到本地终端接管，照「接回规则」当"还活着"处理即可；`csctl resume` 已自动给出对应命令。TUI 里选中后 `Enter` tmux 接回（或 `t` 终端接回）。注意 0.7 起会话 tab **不再提供带 `--remote-control` 的 relaunch**（每个远控进程都会新铸一个云端环境）；要恢复远控暴露，用项目 tab 的 `o`/`c` 或会话内 `/remote-control`。
 
 ## 清理残留 bg agent
 

{cc_session_control-0.6.5 → cc_session_control-0.7.0}/src/cc_session_control/views/_confirm.py

@@ -12,7 +12,12 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import TYPE_CHECKING
 
-from ..actions.session_ops import would_take_over
+from ..actions.session_ops import (
+    AttachIntent,
+    TmuxResumeIntent,
+    attach_target,
+    would_take_over,
+)
 from ..data import proc
 from ._rows import CONFIRM_NAME_CELLS, truncate_cells
 
@@ -89,3 +94,33 @@ def confirm_takeover(
         return
     shown = truncate_cells(s.label if name is None else name, CONFIRM_NAME_CELLS)
     app.confirm(f"{verb}「{shown}」？将先终止原进程。", on_yes)
+
+
+def confirm_tmux_takeover(
+    app: App,
+    s: Session,
+    verb: str,
+    *,
+    fork: bool = False,
+    name: str | None = None,
+) -> None:
+    """The tmux-first Enter/f body, shared by the 会话/后台 tabs (ADR-0001).
+
+    A tmux-resident session is entered IN PLACE (`AttachIntent` — no kill, no
+    confirm, no R10 gate: nothing destructive happens). Anything else goes
+    through the standard takeover gate (`confirm_takeover`) into
+    `TmuxResumeIntent` — resume (or fork) inside its per-project tmux window,
+    then enter. A fork is a copy: it never enters the original's window in
+    place, it always spawns its own (and never kills, so the confirm path
+    falls straight through).
+    """
+    if not fork:
+        target = attach_target(s)
+        if target:
+            app.exit_with(AttachIntent(target))
+            return
+    confirm_takeover(
+        app, s, verb,
+        lambda: app.exit_with(TmuxResumeIntent(s, fork=fork)),
+        name=name, fork=fork,
+    )

{cc_session_control-0.6.5 → cc_session_control-0.7.0}/src/cc_session_control/views/_session_row.py

@@ -34,7 +34,7 @@ _SOURCE_BADGES = {
 # left; the numeric 提问 and the ragged relative 时间 right-align so their line-
 # to-line anchor is stable.
 SESSION_COLS = [
-    (6, "left", "状态"),
+    (8, "left", "状态"),
     (4, "left", "来源"),
     (4, "left", "远控"),
     (11, "right", "时间"),
@@ -74,11 +74,18 @@ def _status_parts(session: Session) -> tuple[str, str]:
     meaning (忙 = generating/tool-running, 闲 = waiting for input, 停 = no
     process), the ●/○ shape survives colorless terminals, and only the
     established ●=on / ○=off convention is used (no ◐ — ambiguous, and an
-    East-Asian-Ambiguous width risk, the P5 glyph lesson)."""
+    East-Asian-Ambiguous width risk, the P5 glyph lesson).
+
+    A live tmux-resident session (ADR-0001) additionally shows the ⧉ badge —
+    U+29C9 is East_Asian_Width=Neutral (width-stable 1 cell, verified against
+    wcwidth + urwid.calc_width, the P5 check), unlike the ambiguous glyphs the
+    P5 lesson banned. Data comes from the snapshot's `tmux_target`; the resume
+    actions read the SAME field."""
     cur = "▸" if session.current else " "
     if session.alive:
         word = "忙" if session.status == "busy" else "闲"
-        return f"{cur}● {word}", ("status_busy" if word == "忙" else "alive")
+        badge = " ⧉" if session.tmux_target else ""
+        return f"{cur}● {word}{badge}", ("status_busy" if word == "忙" else "alive")
     return f"{cur}○ 停", "dead"
 
 

{cc_session_control-0.6.5 → cc_session_control-0.7.0}/src/cc_session_control/views/agents.py

@@ -21,7 +21,7 @@ from ..models import AgentJob
 from ._base import ListTabView
 from ._colspec import header_columns, row_columns
 from ._confirm import DEGRADED as _DEGRADED
-from ._confirm import confirm_stop, confirm_takeover
+from ._confirm import confirm_stop, confirm_takeover, confirm_tmux_takeover
 from ._keytable import HelpLayout, Key, footer_hints, help_lines
 from ._rows import TextRow
 
@@ -77,9 +77,15 @@ class AgentsView(ListTabView):
     # help, and dispatch are generated from this table. `r 刷新` stays in the
     # App-level FOOTER_PREFIX, so its entry is hint-less.
     KEY_TABLE = (
-        Key(("enter", "o"), "Enter/o 接回", "_takeover",
+        Key(("enter",), "Enter 接回", "_takeover",
             section="后台 agent 生命周期:", help_lines=(
-                "  Enter/o 接回（拉回前台，复用 resume；接运行中的 agent 会先确认接管）",
+                "  Enter   tmux 接回（恢复进 tmux 窗口并接入前台，断线不死；",
+                "          已驻留 tmux 的 agent 就地进入；接运行中的会先确认接管）",
+            )),
+        Key(("t",), "t 终端接回", "_terminal",
+            section="后台 agent 生命周期:", help_lines=(
+                "  t       终端接回（在当前终端恢复，随终端关闭而结束——兜底；",
+                "          接运行中的会先确认接管）",
             )),
         Key(("s",), "s 停止", "_stop", section="后台 agent 生命周期:", help_lines=(
             "  s       停止（仅运行中，需确认）",
@@ -187,14 +193,26 @@ class AgentsView(ListTabView):
         self.app.trigger_async_refresh()
 
     def _takeover(self, job: AgentJob) -> None:
+        """Enter — tmux 接回: a tmux-resident worker is entered in place;
+        otherwise resume it inside its per-project tmux window (ADR-0001)."""
         s = agent_ops.resume_takeover(job)
         if s.current:
             self.app.notify("不能接回当前会话")
             return
         # B1: takeover of a RUNNING worker kills its host pid (should_kill) — same
         # as Sessions Enter-live. A dead worker resumes directly, unconfirmed.
+        confirm_tmux_takeover(
+            self.app, s, "接回后台 agent", name=job.name or job.short,
+        )
+
+    def _terminal(self, job: AgentJob) -> None:
+        """t — 终端接回 (fallback): bare-terminal resume via the existing path."""
+        s = agent_ops.resume_takeover(job)
+        if s.current:
+            self.app.notify("不能接回当前会话")
+            return
         confirm_takeover(
-            self.app, s, "接回后台 agent",
+            self.app, s, "终端接回后台 agent",
             lambda: self.app.exit_with(ResumeIntent(s)),
             name=job.name or job.short,
         )

{cc_session_control-0.6.5 → cc_session_control-0.7.0}/src/cc_session_control/views/rc.py

@@ -2,8 +2,10 @@
 
 Shows two things:
   1. managed projects (RCProject) with the tri-state `remoteControlAtStartup`
-     and `remoteControlSpawnMode`, plus the start/stop/autostart keys and `t`
-     (start a NEW claude session in the project dir inside tmux, then enter it);
+     and `remoteControlSpawnMode`, plus Enter (start a NEW claude session in
+     the project dir inside tmux, then enter it — the tmux-first launcher,
+     ADR-0001), `o` (start the project RC server, the demoted secondary), and
+     the stop/autostart keys;
   2. project RC servers (RCServer) discovered via tmux ∪ /proc, badged
      managed/external — external servers are READ-ONLY (no takeover/restart key).
 
@@ -137,13 +139,14 @@ class RCView(ListTabView):
     # help, and dispatch are generated from this table. `r 刷新` stays in the
     # App-level FOOTER_PREFIX, so its entry is hint-less.
     KEY_TABLE = (
-        Key(("t",), "t 新建会话", "_key_tmux_new",
+        Key(("enter",), "Enter 新建会话", "_key_tmux_new",
             section="项目操作（仅对「项目」行生效）:", help_lines=(
-                "  t      在项目目录新建 tmux claude 会话并直接进入（离开 csctl）",
+                "  Enter  在项目目录新建 tmux claude 会话并直接进入（离开 csctl；",
+                "         tmux-first 主入口，会话默认获得断线保护）",
             )),
-        Key(("enter",), "Enter 启动远控", "_key_start",
+        Key(("o",), "o 启动远控", "_key_start",
             section="项目操作（仅对「项目」行生效）:", help_lines=(
-                "  Enter  启动选中项目的远程控制服务",
+                "  o      启动选中项目的远程控制服务（手机/网页控制面，次要入口）",
             )),
         Key(("s",), "s 停止", "_key_stop",
             section="项目操作（仅对「项目」行生效）:", help_lines=(