ring-cli 0.11.1__tar.gz → 0.11.2__tar.gz

{ring_cli-0.11.1 → ring_cli-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ring-cli
-Version: 0.11.1
+Version: 0.11.2
 Summary: RiNG — Realtime Instance Notification Grid for active agent CLI sessions.
 Keywords: claude-code,codex,tui,dashboard,session,monitor,rich
 Author: Wei Lee
@@ -157,6 +157,7 @@ Completes subcommands, flags, and `config set` keys; `ring focus` prompts for a
   Use `↑/↓` to select, `Enter` / `Space` to jump, `p` to reply to a permission request in place, `n` to name a session, `a` to toggle ended sessions, `dd` to hide a session (it reappears automatically once it has new activity), `r` to refresh, and `q` to quit.
   If you have vim muscle memory like I do, `j/k` move up/down and `g/G` jump to the first/last row.
   When the selected row is 🔴 waiting, a line under the table shows **what it is concretely waiting for** (the command to run, the question asked; hook mode only).
+  Claude Code background agents carry a `⚙` badge. They have no terminal to jump to, so selecting one shows a `claude --resume` hint; completed agents are folded into ended sessions by default and remain available via `a`.
 - Otherwise: Rich polling; without Rich, plain text.
 
 ### Jump To A Session
@@ -181,6 +182,8 @@ ones with a "from the … agent" header), and lists the numbered options verbati
 After you pick one, RiNG **captures the screen again** to confirm the dialog is still there and
 unchanged (it may have been answered while you were deciding), only then sends that single
 digit, and re-checks that the dialog actually disappeared.
+Once the reply is verified, the TUI immediately clears that waiting revision. Only a newer hook
+event, such as another permission request, can mark the session as waiting again.
 
 - **Sessions inside tmux**: reads the screen with `tmux capture-pane` and sends keys with
   `tmux send-keys`.

{ring_cli-0.11.1 → ring_cli-0.11.2}/README.en.md

@@ -132,6 +132,7 @@ Completes subcommands, flags, and `config set` keys; `ring focus` prompts for a
   Use `↑/↓` to select, `Enter` / `Space` to jump, `p` to reply to a permission request in place, `n` to name a session, `a` to toggle ended sessions, `dd` to hide a session (it reappears automatically once it has new activity), `r` to refresh, and `q` to quit.
   If you have vim muscle memory like I do, `j/k` move up/down and `g/G` jump to the first/last row.
   When the selected row is 🔴 waiting, a line under the table shows **what it is concretely waiting for** (the command to run, the question asked; hook mode only).
+  Claude Code background agents carry a `⚙` badge. They have no terminal to jump to, so selecting one shows a `claude --resume` hint; completed agents are folded into ended sessions by default and remain available via `a`.
 - Otherwise: Rich polling; without Rich, plain text.
 
 ### Jump To A Session
@@ -156,6 +157,8 @@ ones with a "from the … agent" header), and lists the numbered options verbati
 After you pick one, RiNG **captures the screen again** to confirm the dialog is still there and
 unchanged (it may have been answered while you were deciding), only then sends that single
 digit, and re-checks that the dialog actually disappeared.
+Once the reply is verified, the TUI immediately clears that waiting revision. Only a newer hook
+event, such as another permission request, can mark the session as waiting again.
 
 - **Sessions inside tmux**: reads the screen with `tmux capture-pane` and sends keys with
   `tmux send-keys`.

{ring_cli-0.11.1 → ring_cli-0.11.2}/pyproject.toml

@@ -2,7 +2,7 @@
 # import 的 module（見 [tool.uv.build-backend] module-name）與 CLI 指令仍是 `ring`。
 [project]
 name = "ring-cli"
-version = "0.11.1"
+version = "0.11.2"
 description = "RiNG — Realtime Instance Notification Grid for active agent CLI sessions."
 readme = "README.en.md"
 requires-python = ">=3.13"

{ring_cli-0.11.1 → ring_cli-0.11.2}/src/ring/registry.py

@@ -633,6 +633,24 @@ def running_claude_pids() -> list[int]:
     return pids
 
 
+def running_foreground_claude_pids() -> list[int]:
+    """目前仍有可聚焦終端的 Claude session pid。
+
+    ``running_claude_pids`` 也包含 agents mode 的背景 session，因為 scan 需要靠它們
+    找到對應 transcript；但 hook registry 不能拿背景 agent 的 cwd／數量替同專案的
+    舊前景 row 證明存活，否則一個 agent 就可能讓 crash 數小時的 session 繼續顯示。
+    """
+    bg_ids = background_agent_session_ids()
+    if not bg_ids:
+        return running_claude_pids()
+    args_by_pid = {pid: args for pid, args, _is_bg_host in _parse_ps_claude_lines(_ps_claude_snapshot())}
+    return [
+        pid
+        for pid in running_claude_pids()
+        if (session_id := _arg_session_id(args_by_pid.get(pid, ""))) is None or session_id not in bg_ids
+    ]
+
+
 def background_agent_session_ids() -> set[str]:
     """所有背景 agent（``--bg-pty-host`` 承載且已載入真 session）的 session-id 集合。
 
@@ -686,13 +704,16 @@ def running_codex_pids() -> list[int]:
     if 0.0 <= now - _codex_pids_cache[0] <= _SUBPROCESS_CACHE_TTL:
         return _codex_pids_cache[1]
     try:
-        out = subprocess.run(["ps", "-Ao", "pid,comm"], capture_output=True, text=True, timeout=3).stdout
+        out = subprocess.run(["ps", "-Ao", "pid=,comm=,args="], capture_output=True, text=True, timeout=3).stdout
     except (OSError, subprocess.SubprocessError):
         out = ""
     pids: list[int] = []
-    for line in out.splitlines()[1:]:
-        parts = line.split(None, 1)
-        if len(parts) == 2 and os.path.basename(parts[1].strip()) == "codex":
+    for line in out.splitlines():
+        parts = line.split(None, 2)
+        if len(parts) >= 2 and os.path.basename(parts[1].strip()) == "codex":
+            args = parts[2] if len(parts) == 3 else ""
+            if _is_codex_internal_process(args):
+                continue
             try:
                 pids.append(int(parts[0]))
             except ValueError:
@@ -701,6 +722,18 @@ def running_codex_pids() -> list[int]:
     return pids
 
 
+def _is_codex_internal_process(args: str) -> bool:
+    """Codex app 為工具呼叫啟動的同名內部 process，不是獨立互動 session。"""
+    tokens = args.split()
+    if not tokens:
+        return False
+    try:
+        command_index = next(i for i, token in enumerate(tokens) if os.path.basename(token) == "codex")
+    except StopIteration:
+        return False
+    return command_index + 1 < len(tokens) and tokens[command_index + 1] in {"app-server", "sandbox"}
+
+
 def running_agent_pids() -> list[int]:
     """所有內建來源看得到的 live agent CLI 行程。"""
     return [*running_claude_pids(), *running_codex_pids()]
@@ -776,14 +809,15 @@ def _pid_tty(pid: int) -> str:
 
 
 def _claude_procs() -> list[tuple[str, str]]:
-    """每個還活著的 claude：(cwd, tty)。cwd 判活躍/分流，tty 給終端跳轉。
+    """每個可聚焦的前景 Claude：(cwd, tty)。cwd 判活躍/分流，tty 給終端跳轉。
 
-    claude 不會把 session 的 jsonl 一直開著（lsof 看不到），但給得到 cwd 與 tty。
+    背景 agent 不在這裡按 cwd 配對；它們由 source 依 process args 的 session id 精準
+    認領，避免背景 process 的啟動 cwd 讓同專案舊 transcript 誤判成仍在場。
     同一個 cwd 可能同時開好幾個 session，所以之後在 cwd 群組裡只有 mtime 最新的
     這幾個算活著，其餘同專案的舊 session＝已離場。
     """
     procs: list[tuple[str, str]] = []
-    for pid in running_claude_pids():
+    for pid in running_foreground_claude_pids():
         cwd = _pid_cwd(pid)
         if cwd:
             procs.append((cwd, _pid_tty(pid)))
@@ -1153,11 +1187,17 @@ def _hook_sessions(
                     proc_ttys.setdefault(key, set()).add(tty)
                 proc_cwds_by_provider.setdefault(pk, []).append(real_cwd)
 
+        # 背景 agent 的 process 沒有可聚焦終端，不能拿來替同 cwd 的舊前景 hook row
+        # 證明存活；它只精準認領 args 裡明載的 session id。Claude scan 仍使用包含背景
+        # agent 的 session-id 配對，因此沒有 hook row 的 agent 也不會從看板消失。
+        background_ids = background_agent_session_ids()
         rows_by_key: dict[tuple[str, str], list[Session]] = {}
         for s in out:
             pk = _canonical_provider(s.provider)
             if pk not in _PROVIDER_PROCS:
                 continue  # 沒有 proc 偵測器 → 無法驗活性 → fail-open，交給 SessionEnd
+            if pk == "claude-code" and s.session_id in background_ids:
+                continue
             rows_by_key.setdefault((pk, _real(s.cwd)), []).append(s)
 
         for key, rows in rows_by_key.items():

{ring_cli-0.11.1 → ring_cli-0.11.2}/src/ring/sources/__init__.py

@@ -60,6 +60,11 @@ def discover_sessions() -> list[Session]:
     for s in found:
         if s.session_id in bg_agent_ids:
             s.kind = "agent"
+            # 背景 agent 跑完後不會像前景 session 一樣停在終端等下一輪輸入；它只會由
+            # daemon 暫留 process。繼續顯示成「跑完停著」既無法跳轉也無事可處理，反而
+            # 把已完成工作混進在場清單。歸入 ENDED 後預設收起，`--all` / TUI 的 a 仍可查。
+            if s.status is Status.IDLE:
+                s.status = Status.ENDED
 
     bound_targets = registry._tmux_pane_targets()
     process_targets = registry._tmux_process_tree_targets(found)

ring_cli-0.11.2/src/ring/sources/claude_code.py

@@ -0,0 +1,46 @@
+"""Claude Code：掃 ``~/.claude/projects`` 的 JSONL。"""
+
+from __future__ import annotations
+
+import time
+
+import ring.registry as registry
+from ring.registry import Session
+
+
+def _activate_background_agents(sessions: list[Session], agent_ids: set[str]) -> None:
+    """只依明確 session id 恢復仍有 process 的背景 agent，不用它們的 cwd 猜前景活性。"""
+    now = time.time()
+    for session in sessions:
+        if session.session_id not in agent_ids:
+            continue
+        idle = now - session.last_active
+        session.status = registry._scan_status(idle)
+        session.status = registry._apply_waiting(
+            session.status,
+            idle,
+            session._tail_kind,
+            registry.WAITING_WINDOW_SECONDS,
+        )
+
+
+class ClaudeCodeSource:
+    name = "claude-code"
+
+    def discover(self) -> list[Session]:
+        # 背景 agent 的 process cwd 可能仍是 daemon／啟動目錄，不能拿來按 cwd 猜哪些
+        # 前景 transcript 活著。前景先只用可聚焦 process 判活，背景再按 session id 認領。
+        procs = registry._claude_procs()
+        agent_ids = registry.background_agent_session_ids()
+        merged: dict[str, Session] = {}
+        scanned = registry._scan_sessions(procs)
+        _activate_background_agents(scanned, agent_ids)
+        for s in scanned:
+            merged.setdefault(s.session_id, s)
+        existing = list(merged.values())
+        for s in registry._synthetic_sessions(procs, existing):
+            merged.setdefault(s.session_id, s)  # 合成列只填無 row 的 cwd
+        return list(merged.values())
+
+
+source = ClaudeCodeSource()

{ring_cli-0.11.1 → ring_cli-0.11.2}/src/ring/tui.py

@@ -197,6 +197,9 @@ class RingApp(App[None]):
         self._own_tty: str = self._detect_own_tty()
         self._delete_armed_sid: str | None = None
         self._delete_armed_until: float = 0.0
+        # p 已確認終端對話框消失，但 provider 尚未送後續 hook 時，別讓同一筆舊
+        # PermissionRequest 又把列拉回 WAITING。value 是已回覆那筆 row 的 last_active revision。
+        self._permission_acks: dict[str, float] = {}
 
     @staticmethod
     def _detect_own_tty() -> str:
@@ -345,6 +348,7 @@ class RingApp(App[None]):
         # 退回去跳 session 自己的終端（scan 模式常沒 tty → 跳轉失敗）。
         write_tui_presence()
         self._sessions = board(self._show_all)
+        self._apply_permission_acks()
         table = self.query_one(DataTable)
         # cursor 快照要在「任何」clear 之前取：clear(columns=True) 會把 cursor_row reset 成 0。
         cursor = table.cursor_row
@@ -389,6 +393,30 @@ class RingApp(App[None]):
         self._update_detail()
         self._poll_focus_request()
 
+    def _apply_permission_acks(self) -> None:
+        """以終端回覆結果蓋過同一 revision 的 stale WAITING，直到 provider 送來新事件。"""
+        present_ids = {s.session_id for s in self._sessions}
+        for session_id in set(self._permission_acks) - present_ids:
+            del self._permission_acks[session_id]
+
+        for s in self._sessions:
+            acknowledged_revision = self._permission_acks.get(s.session_id)
+            if acknowledged_revision is None:
+                continue
+            if s.last_active > acknowledged_revision:
+                # 新 hook event（可能是下一個權限請求）已到，重新採信 provider 狀態。
+                del self._permission_acks[s.session_id]
+                continue
+            if s.status is Status.WAITING:
+                # 終端畫面已證實原對話框消失；provider 尚未回報後續狀態時先視為處理中。
+                s.status = Status.WORKING
+                s.waiting_kind = ""
+                s.waiting_detail = ""
+            else:
+                # provider 已用同 revision 清掉 WAITING，不再需要本地 acknowledgment。
+                del self._permission_acks[s.session_id]
+        self._sessions.sort(key=lambda s: (s.status.rank, s.idle_for))
+
     def _update_detail(self) -> None:
         """detail 列：選中的 session 在 🔴 等什麼（hook 有給具體內容才顯示）。
 
@@ -541,6 +569,7 @@ class RingApp(App[None]):
         if outcome is permission.ReplyOutcome.OK:
             if s.session_id == self._focused_sid:
                 self._focused_sid = None  # 已就地回覆，解除通知標記
+            self._permission_acks[s.session_id] = s.last_active
             self._toast(_("→ {project}：已回覆權限（{option}）", project=name, option=option), ok=True)
             self._reload()
             return

ring_cli-0.11.1/src/ring/sources/claude_code.py

@@ -1,23 +0,0 @@
-"""Claude Code：掃 ``~/.claude/projects`` 的 JSONL。"""
-
-from __future__ import annotations
-
-import ring.registry as registry
-from ring.registry import Session
-
-
-class ClaudeCodeSource:
-    name = "claude-code"
-
-    def discover(self) -> list[Session]:
-        procs = registry._claude_procs()
-        merged: dict[str, Session] = {}
-        for s in registry._scan_sessions(procs):
-            merged.setdefault(s.session_id, s)
-        existing = list(merged.values())
-        for s in registry._synthetic_sessions(procs, existing):
-            merged.setdefault(s.session_id, s)  # 合成列只填無 row 的 cwd
-        return list(merged.values())
-
-
-source = ClaudeCodeSource()