ring-cli 0.11.4__tar.gz → 0.13.0__tar.gz

{ring_cli-0.11.4 → ring_cli-0.13.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: ring-cli
-Version: 0.11.4
+Version: 0.13.0
 Summary: RiNG — Realtime Instance Notification Grid for active agent CLI sessions.
-Keywords: claude-code,codex,tui,dashboard,session,monitor,rich
+Keywords: claude-code,codex,ollama,llama-cpp,tui,dashboard,session,monitor,rich
 Author: Wei Lee
 Author-email: Wei Lee <weilee.rx@gmail.com>
 License-Expression: MIT
@@ -268,11 +268,18 @@ RiNG collects sessions from registered sources. Built-ins:
 |--------|------------|-----------|
 | **Claude Code zero-config** | `~/.claude/projects/**/*.jsonl`, mtimes, and `cwd` fields | no setup; detects recent activity and turn completion. Precise user-action prompts require hooks |
 | **Codex zero-config** | `~/.codex/state_5.sqlite`, rollout JSONL, and live `codex` processes | no setup; detects live / ended / turn completion. Use hooks for precise jumps when multiple sessions share a cwd |
+| **Ollama zero-config** | interactive `ollama run` processes with a controlling terminal | process-liveness only; shows cwd, TTY, and model, and excludes `ollama serve` |
+| **llama.cpp zero-config** | interactive `llama-cli` processes with a controlling terminal | process-liveness only; shows cwd, TTY, and model, and excludes `llama-server` |
 | **hook registry** | `~/.config/ring/sessions/`, written by `ring hook` | precise: 🔴 waiting / 🟢 working / 🟡 idle / ⚫ ended |
 
 Zero-config needs no setup. For precise “who needs me”, install hooks so provider events feed the RiNG registry.
 RiNG includes installers for Claude Code and Codex; other tools can use the provider-neutral `ring hook` protocol.
 
+Ollama and llama.cpp do not expose a session transcript or interaction hooks that RiNG can read, so their
+zero-config rows stay 🟡: the row means the interactive CLI is alive, not that RiNG can distinguish generation
+from waiting for the next prompt. The row disappears when the CLI exits. An outer agent that can emit lifecycle
+events can use the provider-neutral hook protocol for precise states.
+
 ## States
 
 RiNG reduces every session to four user-facing states. 🔴 waiting is sorted first.
@@ -319,9 +326,31 @@ Claude Code events:
 | `PermissionRequest` / `PreToolUse` with `AskUserQuestion` | 🔴 waiting |
 | `SessionEnd` | removed from the board |
 
-Codex currently installs the supported interactive events: `PreToolUse`, `PermissionRequest`, and `Stop`. Codex
-also emits `PermissionRequest` before an existing policy auto-approves the call; a bare event therefore stays
-🟢 working, and it only turns 🔴 waiting when the payload explicitly carries `requires_action` / `waiting_for`.
+`Stop` has one more exception: an agent sometimes doesn't use `AskUserQuestion` or trigger a permission
+request, and just asks a plain-text question before stopping (e.g. "want me to fix B too?"). RiNG looks at
+the **end** of the last assistant message for this: if it ends in a question mark (`？` / `?`, with any
+trailing fenced code block stripped first) the session is promoted to 🔴 waiting (`waiting_kind="question"`),
+with the question as its detail; a question that only appears mid-message, with a statement at the end,
+does not count — conservative on purpose, biased toward missing a case rather than a false positive. This
+applies to both Claude Code and Codex (`Stop` payloads from both carry `last_assistant_message`); the
+`detect_stop_questions` config key can turn it off (on by default).
+
+Codex currently installs the supported interactive events: `PreToolUse`, `PermissionRequest`, `PostToolUse`,
+and `Stop`. Codex also emits `PermissionRequest` before an existing policy auto-approves the call, so a bare
+event stays 🟢 working at the hook level. Codex hooks have no "user approved" event and no heartbeat — while
+an approval prompt is pending, the hook channel is **completely silent**. RiNG therefore treats the silence
+itself as the signal: when the last hook event is a `PermissionRequest` and nothing has followed for more than
+`codex_permission_wait_seconds` (default 10s), the board marks the session 🔴 waiting with the pending command
+as its detail; any subsequent event (the next tool call, `Stop`) naturally clears it.
+
+Known Codex-side limitations (verified against 0.144.4; the hook payload has no field that could distinguish
+these):
+
+- **Approve and deny are indistinguishable**: neither emits a hook event. After you approve a long-running
+  command, 🔴 lingers until the command finishes (`PostToolUse`); after a deny with no immediate follow-up
+  action, 🔴 lingers until the next event or `Stop`.
+- The system notification for this timeout-promoted 🔴 is sent by the TUI's alert scheduler (there is no hook
+  event to notify from); headless `--watch` does not send this particular notification.
 
 Verify that hooks are writing:
 
@@ -402,6 +431,8 @@ legend = true
 active_window_seconds = 21600
 working_threshold_seconds = 90
 waiting_window_seconds = 1800
+codex_permission_wait_seconds = 10  # bare Codex PermissionRequest + hook silence beyond this → 🔴 waiting; 0 = off
+detect_stop_questions = true     # promote Stop to 🔴 waiting when it ends in a plain-text question; false = Stop always 🟡
 notify_sound = true
 notify_sound_name = "Glass"
 notify_ignore_dnd = false
@@ -431,7 +462,7 @@ RiNG is not tied to a specific tool or terminal.
 
 | Extension Point | Purpose | Built-ins |
 |-----------------|---------|-----------|
-| `SessionSource` | find sessions | Claude Code, Codex, hook registry |
+| `SessionSource` | find sessions | Claude Code, Codex, Ollama, llama.cpp, hook registry |
 | `Focuser` | jump to terminals | tmux, iTerm2, Terminal.app, Linux X11 (wmctrl) |
 | `Notifier` | notify when sessions are waiting | terminal-notifier, osascript, notify-send, ntfy, webhook |
 

{ring_cli-0.11.4 → ring_cli-0.13.0}/README.en.md

@@ -243,11 +243,18 @@ RiNG collects sessions from registered sources. Built-ins:
 |--------|------------|-----------|
 | **Claude Code zero-config** | `~/.claude/projects/**/*.jsonl`, mtimes, and `cwd` fields | no setup; detects recent activity and turn completion. Precise user-action prompts require hooks |
 | **Codex zero-config** | `~/.codex/state_5.sqlite`, rollout JSONL, and live `codex` processes | no setup; detects live / ended / turn completion. Use hooks for precise jumps when multiple sessions share a cwd |
+| **Ollama zero-config** | interactive `ollama run` processes with a controlling terminal | process-liveness only; shows cwd, TTY, and model, and excludes `ollama serve` |
+| **llama.cpp zero-config** | interactive `llama-cli` processes with a controlling terminal | process-liveness only; shows cwd, TTY, and model, and excludes `llama-server` |
 | **hook registry** | `~/.config/ring/sessions/`, written by `ring hook` | precise: 🔴 waiting / 🟢 working / 🟡 idle / ⚫ ended |
 
 Zero-config needs no setup. For precise “who needs me”, install hooks so provider events feed the RiNG registry.
 RiNG includes installers for Claude Code and Codex; other tools can use the provider-neutral `ring hook` protocol.
 
+Ollama and llama.cpp do not expose a session transcript or interaction hooks that RiNG can read, so their
+zero-config rows stay 🟡: the row means the interactive CLI is alive, not that RiNG can distinguish generation
+from waiting for the next prompt. The row disappears when the CLI exits. An outer agent that can emit lifecycle
+events can use the provider-neutral hook protocol for precise states.
+
 ## States
 
 RiNG reduces every session to four user-facing states. 🔴 waiting is sorted first.
@@ -294,9 +301,31 @@ Claude Code events:
 | `PermissionRequest` / `PreToolUse` with `AskUserQuestion` | 🔴 waiting |
 | `SessionEnd` | removed from the board |
 
-Codex currently installs the supported interactive events: `PreToolUse`, `PermissionRequest`, and `Stop`. Codex
-also emits `PermissionRequest` before an existing policy auto-approves the call; a bare event therefore stays
-🟢 working, and it only turns 🔴 waiting when the payload explicitly carries `requires_action` / `waiting_for`.
+`Stop` has one more exception: an agent sometimes doesn't use `AskUserQuestion` or trigger a permission
+request, and just asks a plain-text question before stopping (e.g. "want me to fix B too?"). RiNG looks at
+the **end** of the last assistant message for this: if it ends in a question mark (`？` / `?`, with any
+trailing fenced code block stripped first) the session is promoted to 🔴 waiting (`waiting_kind="question"`),
+with the question as its detail; a question that only appears mid-message, with a statement at the end,
+does not count — conservative on purpose, biased toward missing a case rather than a false positive. This
+applies to both Claude Code and Codex (`Stop` payloads from both carry `last_assistant_message`); the
+`detect_stop_questions` config key can turn it off (on by default).
+
+Codex currently installs the supported interactive events: `PreToolUse`, `PermissionRequest`, `PostToolUse`,
+and `Stop`. Codex also emits `PermissionRequest` before an existing policy auto-approves the call, so a bare
+event stays 🟢 working at the hook level. Codex hooks have no "user approved" event and no heartbeat — while
+an approval prompt is pending, the hook channel is **completely silent**. RiNG therefore treats the silence
+itself as the signal: when the last hook event is a `PermissionRequest` and nothing has followed for more than
+`codex_permission_wait_seconds` (default 10s), the board marks the session 🔴 waiting with the pending command
+as its detail; any subsequent event (the next tool call, `Stop`) naturally clears it.
+
+Known Codex-side limitations (verified against 0.144.4; the hook payload has no field that could distinguish
+these):
+
+- **Approve and deny are indistinguishable**: neither emits a hook event. After you approve a long-running
+  command, 🔴 lingers until the command finishes (`PostToolUse`); after a deny with no immediate follow-up
+  action, 🔴 lingers until the next event or `Stop`.
+- The system notification for this timeout-promoted 🔴 is sent by the TUI's alert scheduler (there is no hook
+  event to notify from); headless `--watch` does not send this particular notification.
 
 Verify that hooks are writing:
 
@@ -377,6 +406,8 @@ legend = true
 active_window_seconds = 21600
 working_threshold_seconds = 90
 waiting_window_seconds = 1800
+codex_permission_wait_seconds = 10  # bare Codex PermissionRequest + hook silence beyond this → 🔴 waiting; 0 = off
+detect_stop_questions = true     # promote Stop to 🔴 waiting when it ends in a plain-text question; false = Stop always 🟡
 notify_sound = true
 notify_sound_name = "Glass"
 notify_ignore_dnd = false
@@ -406,7 +437,7 @@ RiNG is not tied to a specific tool or terminal.
 
 | Extension Point | Purpose | Built-ins |
 |-----------------|---------|-----------|
-| `SessionSource` | find sessions | Claude Code, Codex, hook registry |
+| `SessionSource` | find sessions | Claude Code, Codex, Ollama, llama.cpp, hook registry |
 | `Focuser` | jump to terminals | tmux, iTerm2, Terminal.app, Linux X11 (wmctrl) |
 | `Notifier` | notify when sessions are waiting | terminal-notifier, osascript, notify-send, ntfy, webhook |
 

{ring_cli-0.11.4 → ring_cli-0.13.0}/pyproject.toml

@@ -2,7 +2,7 @@
 # import 的 module（見 [tool.uv.build-backend] module-name）與 CLI 指令仍是 `ring`。
 [project]
 name = "ring-cli"
-version = "0.11.4"
+version = "0.13.0"
 description = "RiNG — Realtime Instance Notification Grid for active agent CLI sessions."
 readme = "README.en.md"
 requires-python = ">=3.13"
@@ -12,6 +12,8 @@ authors = [{ name = "Wei Lee", email = "weilee.rx@gmail.com" }]
 keywords = [
   "claude-code",
   "codex",
+  "ollama",
+  "llama-cpp",
   "tui",
   "dashboard",
   "session",

{ring_cli-0.11.4 → ring_cli-0.13.0}/src/ring/cli.py

@@ -402,6 +402,8 @@ def run_config(args: list[str]) -> int:
 def watch(interval: float, count: int, show_all: bool, show_legend: bool) -> int:
     # 系統通知由 ``ring hook`` 在 session 轉 🔴 等你的當下就地發出（見 hook._ring_waiting_now）；
     # watch 只負責顯示看板，不再輪詢發通知——這樣關掉看板也照樣 ring 你。
+    # 例外：codex 核可等待是讀取側的靜默逾時判定，沒有 hook 事件可發通知，由 TUI 的
+    # 提醒排程器代發（tui._ring_on_waiting_alerts）；headless watch 仍不發，是已知限制。
     frames = 0
     footer_text = _("每 {interval}s 刷新 · Ctrl-C 離場", interval=int(interval))
     if not HAVE_RICH:

{ring_cli-0.11.4 → ring_cli-0.13.0}/src/ring/config.py

@@ -9,6 +9,11 @@
     active_window_seconds = 21600     # 只看最近這段時間動過的 session（預設 6h）
     working_threshold_seconds = 90    # 多久沒動就從 🟢 工作中 變 🟡 閒置
     waiting_window_seconds = 1800     # 跑完停著升等你的時間窗上限（預設 30 分）
+    codex_permission_wait_seconds = 10  # Codex 裸 PermissionRequest 後 hook 靜默超過這秒數
+                                      #   → 看板判定真的停下來等核可（🔴 等你）；0 = 關閉
+    detect_stop_questions = true      # Stop 事件時，若最後一則 assistant 訊息「結尾」是純文字
+                                      #   提問（沒用 AskUserQuestion、沒有權限請求）→ 🔴 等你
+                                      #   （waiting_kind="question"）；關閉則 Stop 一律 🟡
     notify_sound = true               # 系統通知帶聲音
     notify_sound_name = "Glass"       # macOS / terminal-notifier sound name
     notify_ignore_dnd = false         # terminal-notifier 是否加 -ignoreDnD（穿透勿擾 / Focus）
@@ -27,6 +32,10 @@
     notify_also = ["ntfy"]            # 主後端之外「加發」的後端（例如桌面通知＋手機各一份）
     focusers = ["Neovim", "tmux", "iTerm2", "Terminal", "linux-wm"]  # 跳轉嘗試順序；省略＝內建預設
     plugins = ["my_ring_plugin"]      # 啟動時 import 的外部 plugin 模組（自行 register_*）
+    debug_payload_log = false         # 診斷用：記錄 hook 收到的原始 payload
+                                      #   （見 payload_log.py，寫到 ~/.config/ring/hook_payloads.jsonl）；
+                                      #   預設關閉，payload 可能含使用者輸入才要開；
+                                      #   環境變數 RING_DEBUG_PAYLOAD_LOG 可覆寫（優先於本鍵）
 """
 
 from __future__ import annotations
@@ -60,6 +69,13 @@ class Config:
     active_window_seconds: int = 6 * 60 * 60
     working_threshold_seconds: int = 90
     waiting_window_seconds: int = 1800  # 跑完停著升等你的時間窗上限（預設 30 分）
+    # Codex 的 hook 沒有「使用者已核可」事件也沒有心跳（0.144.4 實證）：policy 自動放行時
+    # 下一個事件幾秒內就到；真的停下來等人時 hook 通道完全靜默。所以「最後一個事件是
+    # PermissionRequest 且已靜默超過這個門檻」就判定在等核可。0 = 關閉這個判定。
+    codex_permission_wait_seconds: int = 10
+    # Stop 事件時，若最後一則 assistant 訊息結尾是純文字提問（見 question_detect.py）
+    # → 升級成 🔴 等你（waiting_kind="question"）。預設開；關閉則 Stop 一律維持 🟡。
+    detect_stop_questions: bool = True
     notify_sound: bool = True
     notify_sound_name: str = "Glass"
     notify_ignore_dnd: bool = False
@@ -77,6 +93,7 @@ class Config:
     notify_also: tuple[str, ...] = ()  # 主後端之外加發的後端名（如 ["ntfy"]）
     focusers: tuple[str, ...] = ()  # 空＝用內建預設順序
     plugins: tuple[str, ...] = ()  # 啟動時 import 的外部 plugin 模組（entry point 之外的本機路）
+    debug_payload_log: bool = False  # 診斷用：記錄 hook 收到的原始 payload；預設關閉
     colors: dict[str, str] = field(default_factory=lambda: dict(_DEFAULT_COLORS))
 
 
@@ -134,6 +151,10 @@ def load(path: Path | None = None) -> Config:
         active_window_seconds=_as_int(raw.get("active_window_seconds"), d.active_window_seconds),
         working_threshold_seconds=_as_int(raw.get("working_threshold_seconds"), d.working_threshold_seconds),
         waiting_window_seconds=_as_int(raw.get("waiting_window_seconds"), d.waiting_window_seconds),
+        codex_permission_wait_seconds=_as_int(
+            raw.get("codex_permission_wait_seconds"), d.codex_permission_wait_seconds
+        ),
+        detect_stop_questions=_as_bool(raw.get("detect_stop_questions"), d.detect_stop_questions),
         notify_sound=_as_bool(raw.get("notify_sound"), d.notify_sound),
         notify_sound_name=(
             raw["notify_sound_name"] if isinstance(raw.get("notify_sound_name"), str) else d.notify_sound_name
@@ -148,6 +169,7 @@ def load(path: Path | None = None) -> Config:
         notify_also=_as_str_tuple(raw.get("notify_also")),
         focusers=_as_str_tuple(raw.get("focusers")),
         plugins=_as_str_tuple(raw.get("plugins")),
+        debug_payload_log=_as_bool(raw.get("debug_payload_log"), d.debug_payload_log),
         colors=_parse_colors(raw.get("colors")),
     )
 
@@ -206,6 +228,8 @@ _SETTERS: dict[str, Callable[[str], object]] = {
     "active_window_seconds": _coerce_int,
     "working_threshold_seconds": _coerce_int,
     "waiting_window_seconds": _coerce_int,
+    "codex_permission_wait_seconds": _coerce_int,
+    "detect_stop_questions": _coerce_bool,
     "notify_sound": _coerce_bool,
     "notify_sound_name": str,
     "notify_ignore_dnd": _coerce_bool,
@@ -218,6 +242,7 @@ _SETTERS: dict[str, Callable[[str], object]] = {
     "notify_also": _coerce_str_list,
     "focusers": _coerce_str_list,
     "plugins": _coerce_str_list,
+    "debug_payload_log": _coerce_bool,
 }
 
 

{ring_cli-0.11.4 → ring_cli-0.13.0}/src/ring/hook.py

@@ -9,8 +9,15 @@ Agent CLI 在各事件把一段 JSON 從 stdin 餵進來。我們據此 upsert
 事件 → 狀態：
   SessionStart / UserPromptSubmit → 🟢 工作中（剛開始 / 你剛回話，台上在跑）
   PreToolUse（非 action）/ PostToolUse → 🟢 工作中（工具在動，順便清掉剛答完的等你）
-  Stop                            → 🟡 跑完停著（回完一輪，不代表需要你回應）
-  PermissionRequest / actionable Notification / AskUserQuestion → 🔴 等你（需要你決策）
+  Stop                            → 🟡 跑完停著（回完一輪，不代表需要你回應）；但最後一則
+                                    assistant 訊息「結尾」像純文字提問時 → 🔴 等你
+                                    （waiting_kind="question"，見 question_detect.py；
+                                    config 鍵 detect_stop_questions 可關閉，預設開）
+  PermissionRequest（裸）          → 🟢 工作中（權限判定中，多半瞬間自動放行；Claude Code
+                                    真的停下來等人由後續的 permission_prompt Notification
+                                    兜底轉 🔴；Codex 沒有這種事件，改由讀取側的靜默逾時
+                                    判定補上，見 registry._promote_codex_permission_wait）
+  actionable Notification / AskUserQuestion → 🔴 等你（需要你決策）
   SessionEnd                      → 刪檔（乾淨離場）
 """
 
@@ -22,15 +29,17 @@ import shutil
 import subprocess
 import sys
 import time
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from pathlib import Path
 from typing import Any
 from urllib.parse import quote
 
 from ring.config import get_config
-from ring.hook_protocol import HOOK_EVENTS, adapter_for, provider_from_payload
+from ring.hook_protocol import HOOK_EVENTS, NormalizedHookEvent, adapter_for, provider_from_payload
 from ring.i18n import gettext as _
 from ring.i18n import set_lang
+from ring.payload_log import maybe_log_raw_payload
+from ring.question_detect import stop_last_assistant_text, trailing_question_detail
 from ring.registry import (
     RING_REGISTRY,
     Session,
@@ -45,9 +54,10 @@ _HOOK_EVENTS = list(HOOK_EVENTS)
 
 # Codex 的 hooks.json 用跟 Claude 同樣的 PascalCase 事件名，但只支援其中一小撮。
 # 保守取有實證可用的：PermissionRequest（裸事件只代表權限準備判定；明確需互動才 → 🔴）、
-# PreToolUse（→ 動作/清除）、Stop（→ 🟡 回合結束、清掉 waiting）。多裝 Codex 不認的事件
-# 有風險，故不照搬 Claude 全套。
-_CODEX_HOOK_EVENTS = ["PreToolUse", "PermissionRequest", "Stop"]
+# PreToolUse（→ 動作/清除）、PostToolUse（工具跑完 → 清除；0.144.4 binary 內嵌 schema
+# 證實存在——它是「核可後最早的下一個事件」，能盡早清掉讀取側的核可等待判定）、
+# Stop（→ 🟡 回合結束、清掉 waiting）。多裝 Codex 不認的事件有風險，故不照搬 Claude 全套。
+_CODEX_HOOK_EVENTS = ["PreToolUse", "PermissionRequest", "PostToolUse", "Stop"]
 
 # hook command 的 timeout（秒）。給足，因為 notify_backend="agent-hooks" 時權限 modal 會
 # block 到使用者作答。install 用它判斷「既有條目要不要更新」——舊版裝的 timeout=10 會被升上來。
@@ -157,6 +167,9 @@ def run_hook(provider: str = "claude-code") -> int:
         return 0
 
     selected_provider = provider_from_payload(data, fallback=provider)
+    # 取證 log：診斷用、預設關閉（見 payload_log.py）。故意放在任何狀態判定/改寫之前，
+    # 記下 hook 實際收到的原始資料——不影響、不參與下面的正規化流程。
+    maybe_log_raw_payload(selected_provider, data)
     _record_session_state(data, selected_provider)
     return _delegate_to_agent_hooks(raw, selected_provider)
 
@@ -167,6 +180,7 @@ def _record_session_state(data: dict[str, Any], selected_provider: str) -> None:
     event = adapter.normalize(data)
     if event is None:
         return
+    event = _maybe_flag_trailing_question(event, data)
 
     unhide_session(event.session_id)
     path = RING_REGISTRY / f"{quote(event.session_id, safe=':')}.json"
@@ -193,6 +207,9 @@ def _record_session_state(data: dict[str, Any], selected_provider: str) -> None:
         "cwd": event.cwd,
         "origin_cwd": event.cwd,
         "status": event.status.value,
+        # 最後一個 hook 事件名：讀取側據此做 codex 的核可等待判定（最後事件是
+        # PermissionRequest 且靜默逾時 → 🔴），任何後續事件覆寫它就自然清紅。
+        "last_event": event.event,
         "last_active": now,
         "heartbeat_at": now,
         "last_action": last_action,
@@ -207,10 +224,26 @@ def _record_session_state(data: dict[str, Any], selected_provider: str) -> None:
         payload["todo"] = list(todo)
     if event.waiting_for:
         payload["waiting_for"] = event.waiting_for
+
+    # 裸 PermissionRequest（→ WORKING）帶著最具體的 tool/指令摘要；真的停下來等人時，
+    # Claude Code 只補發籠統的 permission_prompt Notification（"Claude needs your
+    # permission"，不含 tool/指令）。所以把摘要暫存進 row，Notification 轉 WAITING 時
+    # （還新鮮的話）拿它當 waiting_detail，看板與通知才看得到具體是哪條指令在等核可。
+    # Codex 沒有 Notification：這份暫存改由讀取側的靜默逾時判定拿去當 waiting_detail
+    # （見 registry._promote_codex_permission_wait）。
+    pending_detail, pending_at = _pending_permission_detail(event, prev_row, now)
+    if pending_detail:
+        payload["pending_permission_detail"] = pending_detail
+        payload["pending_permission_detail_at"] = pending_at
+
     if event.status is Status.WAITING and event.waiting_kind:
         payload["waiting_kind"] = event.waiting_kind
-    if event.status is Status.WAITING and event.detail:
-        payload["waiting_detail"] = event.detail
+    if event.status is Status.WAITING:
+        waiting_detail = event.detail
+        if event.event == "Notification" and event.waiting_kind == "permission" and pending_detail:
+            waiting_detail = pending_detail
+        if waiting_detail:
+            payload["waiting_detail"] = waiting_detail
     tty = event.tty or _controlling_tty() or _session_tty(adapter.process_names)
     if tty:
         payload["tty"] = tty
@@ -240,6 +273,26 @@ def _record_session_state(data: dict[str, Any], selected_provider: str) -> None:
         _ring_waiting_now(event, payload, last_action)
 
 
+def _maybe_flag_trailing_question(event: NormalizedHookEvent, data: dict[str, Any]) -> NormalizedHookEvent:
+    """Stop 事件、目前判定 🟡 跑完停著、且訊息結尾像純文字提問時，升級成 🔴 等你。
+
+    這是 hook_protocol._ALWAYS_STATUS 的 Stop→IDLE 之外唯一會讀 assistant 文字的地方——
+    寫死的映射本身測不到「agent 用文字問了問題但沒用 AskUserQuestion」這種情況（見
+    ring.question_detect 模組 docstring）。保守判準：只看訊息結尾，中段有問句、結尾是
+    陳述句一律不算，寧可漏報不要誤報。config 關閉（detect_stop_questions=false）或非
+    Stop / 非 IDLE 一律原樣放行；抓不到文字或結尾不是問句也放行。
+    """
+    if event.event != "Stop" or event.status is not Status.IDLE:
+        return event
+    if not get_config().detect_stop_questions:
+        return event
+    text = stop_last_assistant_text(data)
+    detail = trailing_question_detail(text)
+    if not detail:
+        return event
+    return replace(event, status=Status.WAITING, waiting_kind="question", detail=detail)
+
+
 def _previous_row(path: Path) -> dict[str, Any]:
     """讀 registry 檔目前的內容（給轉換偵測與通知冷卻用）；沒檔 / 壞檔回空 dict。"""
     try:
@@ -254,6 +307,32 @@ def _as_epoch(v: Any) -> float | None:
     return float(v) if isinstance(v, (int, float)) and not isinstance(v, bool) else None
 
 
+# 暫存的權限 detail 新鮮期（秒）：permission_prompt Notification 通常在裸 PermissionRequest
+# 後 ~6 秒到；超過這個窗口的暫存視為過期（大概率屬於已解決的舊請求），不再拿來當 detail。
+_PENDING_DETAIL_TTL = 120.0
+
+# 這些事件代表權限已放行（工具跑完）或回合已推進（新輸入 / 回合結束）→ 清掉暫存。
+_PENDING_DETAIL_CLEAR_EVENTS = {"PostToolUse", "UserPromptSubmit", "Stop"}
+
+
+def _pending_permission_detail(event: NormalizedHookEvent, prev_row: dict[str, Any], now: float) -> tuple[str, float]:
+    """決定這次要寫進 row 的「暫存權限 detail」：(detail, 暫存時間戳)；不留就回 ("", 0.0)。
+
+    - 裸 PermissionRequest（→ WORKING）帶 detail → 以這次的 detail 起新暫存
+    - PostToolUse / UserPromptSubmit / Stop → 清掉（已放行或回合推進，舊暫存失效）
+    - 其餘事件 → 沿用 prev_row 的暫存（row 每次重建，不帶會遺失），但過期就丟
+    """
+    if event.event == "PermissionRequest" and event.status is Status.WORKING and event.detail:
+        return event.detail, now
+    if event.event in _PENDING_DETAIL_CLEAR_EVENTS:
+        return "", 0.0
+    prev_detail = prev_row.get("pending_permission_detail")
+    prev_at = _as_epoch(prev_row.get("pending_permission_detail_at"))
+    if isinstance(prev_detail, str) and prev_detail and prev_at is not None and now - prev_at <= _PENDING_DETAIL_TTL:
+        return prev_detail, prev_at
+    return "", 0.0
+
+
 def _waiting_ring_allowed(last_notified: float | None, now: float) -> bool:
     """hook 的 waiting 通知是否放行：距上次通知未滿 ``waiting_cooldown_seconds`` 就不發。
 
@@ -270,9 +349,11 @@ def _waiting_ring_allowed(last_notified: float | None, now: float) -> bool:
 def _ring_waiting_now(event: Any, payload: dict[str, Any], last_action: str) -> None:
     """session 轉 🔴 等你的當下，就地由 hook 發系統通知——不必等 RiNG 看板輪詢。
 
-    WAITING 只會從 hook 來（scan 模式永不標 WAITING），所以 hook 是第一手知道「等你」
+    WAITING 是 hook 資料驅動的（scan 模式永不標 WAITING），hook 是第一手知道「等你」
     的地方；在事件當下通知最即時，也不依賴看板有沒有開著（看板沒開時舊版根本不會 ring
-    你）。backend=none / agent-hooks 由 notify_waiting → _select_notifier 自動短路
+    你）。唯一的例外是 codex 的核可等待：那是讀取側對 hook row 的靜默逾時判定，沒有
+    對應的 hook 事件可在這裡發通知，由 TUI 的提醒排程器代發（見 tui._ring_on_waiting_alerts）。
+    backend=none / agent-hooks 由 notify_waiting → _select_notifier 自動短路
     （agent-hooks 改走 _delegate_to_agent_hooks 的 modal 委派），不會重複發。
     失敗安靜吞掉，絕不擋住 session。
     """

{ring_cli-0.11.4 → ring_cli-0.13.0}/src/ring/hook_protocol.py

@@ -44,7 +44,6 @@ _ALWAYS_STATUS = {
     "UserPromptSubmit": Status.WORKING,
     "Stop": Status.IDLE,
     "SessionEnd": Status.ENDED,
-    "PermissionRequest": Status.WAITING,
 }
 
 _ACTION_REQUIRED_NOTIFICATION_TYPES = {
@@ -105,13 +104,17 @@ class CommonHookAdapter:
             status = Status.WORKING
         elif explicit_requires_action is not None:
             status = Status.WAITING if explicit_requires_action else Status.IDLE
-        elif event == "PermissionRequest" and self.provider == "codex":
-            # Codex 會在權限「準備判定」時送 PermissionRequest；即使既有 policy
-            # 隨後自動放行、畫面從未停下來等人，也會經過這個 hook。裸事件因此只能
-            # 證明 agent 還在處理工具呼叫，不能當成使用者需要回應。若 payload 有
-            # requires_action / waiting_for 等明確訊號，已由上面的分支判成 WAITING；
-            # 明確的 requires_action=false 也在上面判成 IDLE，不會落到這裡的 WORKING。
-            status = Status.WORKING
+        elif event == "PermissionRequest":
+            # PermissionRequest 在權限「準備判定」時就發，不分 provider：Claude Code
+            # 連 subagent 的唯讀工具呼叫都會經過（帶 agent_id/agent_type），Codex 則在
+            # policy 判定前發。多數在幾秒內被 policy 自動放行、畫面從未停下來等人——
+            # 裸事件因此只能證明 agent 還在處理工具呼叫，不能當成使用者需要回應
+            # → WORKING。payload 本身就要求互動（AskUserQuestion / questions / options）
+            # 才直接判 WAITING。Claude Code 真的停下來等人時，會在數秒後補發
+            # notification_type=permission_prompt 的 Notification，由下面的 Notification
+            # 分支兜底轉 WAITING（內建 debounce）。顯式 requires_action / waiting_for
+            # 訊號已由上面的分支先處理（true → WAITING、false → IDLE），不會落到這裡。
+            status = Status.WAITING if _is_action_required_payload(data) else Status.WORKING
         elif event == "Notification":
             status = Status.WAITING if _is_action_required_notification(data) else Status.IDLE
         elif event == "PreToolUse":
@@ -238,12 +241,14 @@ def _waiting_kind(data: Mapping[str, Any], event: str, status: Status) -> str:
 
     if "plan" in waiting_for or "plan" in tool_name or "plan" in detail:
         return "plan"
+    if tool_name == "askuserquestion":
+        # 先於 PermissionRequest 判斷：AskUserQuestion 也會以 PermissionRequest 事件
+        # 進來（權限判定包著問題），但使用者要回的是「問題」不是「權限」。
+        return "question"
     if event == "PermissionRequest" or notification_type == "permission_prompt":
         return "permission"
     if waiting_for in {"approval", "permission"}:
         return "permission"
-    if tool_name == "askuserquestion":
-        return "question"
     if waiting_for in {
         "choice",
         "choices",

ring_cli-0.13.0/src/ring/payload_log.py

@@ -0,0 +1,110 @@
+"""原始 hook payload 取證 logger——診斷用，預設關閉。
+
+診斷「claude-code 裸 PermissionRequest 被誤判 WAITING」與「codex 裸 PermissionRequest
+永遠判 WORKING」這類問題時，需要看到 hook 實際收到的原始 event payload——現有的
+registry（``~/.config/ring/sessions/*.json``）與 ``events.jsonl`` 都只留正規化後的
+status，原始資料在 ``hook_protocol.normalize`` 跑完就遺失了。
+
+這支 logger 在 hook 收到 stdin 的當下、任何狀態判定/改寫之前，把原始 payload 整段
+append 一行，供事後分析用。設計原則跟 ``stats.log_transition`` 一致：
+
+- append-only、JSONL，一行一事件
+- 檔案超過上限自動砍半保新，不無限成長
+- 任何錯誤（含讀 config 失敗、payload 無法序列化）一律安靜吞掉，絕不影響 hook 主流程
+
+開關：``debug_payload_log`` config 鍵，或環境變數 ``RING_DEBUG_PAYLOAD_LOG``
+（``1``/``true``/``yes``/``on`` 開，``0``/``false``/``no``/``off`` 關；env 優先於 config）。
+**預設關閉**——payload 可能含使用者輸入/檔案內容，開了才寫。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+PAYLOAD_LOG_PATH = Path.home() / ".config" / "ring" / "hook_payloads.jsonl"
+
+# log 檔上限；超過就砍半保新（append 前檢查）。原始 payload 比 events.jsonl 的轉換記錄
+# 大很多（可能含完整 tool_input／transcript 片段），給足空間再砍半。
+_MAX_BYTES = 20 * 1024 * 1024
+
+_ENV_FLAG = "RING_DEBUG_PAYLOAD_LOG"
+
+_TRUE = {"1", "true", "yes", "on"}
+_FALSE = {"0", "false", "no", "off"}
+
+
+def payload_log_enabled() -> bool:
+    """是否要記原始 payload：env var 優先，其次 config 鍵，預設關閉。"""
+    env = os.environ.get(_ENV_FLAG, "").strip().lower()
+    if env in _TRUE:
+        return True
+    if env in _FALSE:
+        return False
+    try:
+        from ring.config import get_config
+
+        return get_config().debug_payload_log
+    except Exception:
+        return False
+
+
+def _raw_event_name(data: Mapping[str, Any]) -> str:
+    """從原始 payload 猜事件名（只為了記錄好讀，不影響任何判定邏輯）。"""
+    for key in ("event", "event_name", "hook_event_name", "hookEventName"):
+        v = data.get(key)
+        if isinstance(v, str) and v:
+            return v
+    return ""
+
+
+def maybe_log_raw_payload(
+    provider: str,
+    data: Mapping[str, Any],
+    *,
+    path: Path | None = None,
+    now: float | None = None,
+) -> None:
+    """開關開啟時，把 hook 收到的原始 payload 整段 append 一行（診斷用）。
+
+    呼叫端應放在 hook 處理最前端，早於 ``hook_protocol`` 的任何狀態判定/改寫。
+    開關預設關閉（見模組 docstring）；任何錯誤一律安靜吞掉，呼叫端不需要自己包 try。
+    """
+    try:
+        if not payload_log_enabled():
+            return
+        p = path or PAYLOAD_LOG_PATH
+        line = json.dumps(
+            {
+                "ts": now if now is not None else time.time(),
+                "provider": provider,
+                "event": _raw_event_name(data),
+                "payload": data,
+            },
+            ensure_ascii=False,
+            default=str,
+        )
+        p.parent.mkdir(parents=True, exist_ok=True)
+        _trim_if_oversized(p)
+        with p.open("a", encoding="utf-8") as f:
+            f.write(line + "\n")
+    except Exception:
+        pass
+
+
+def _trim_if_oversized(p: Path) -> None:
+    """log 超過 ``_MAX_BYTES`` 時砍半保新，避免無上限成長。失敗安靜放棄（不擋 append）。"""
+    try:
+        if p.stat().st_size <= _MAX_BYTES:
+            return
+        lines = p.read_text(encoding="utf-8").splitlines()
+        keep = lines[len(lines) // 2 :]
+        tmp = p.with_suffix(".jsonl.tmp")
+        tmp.write_text("\n".join(keep) + "\n", encoding="utf-8")
+        tmp.replace(p)  # atomic
+    except Exception:
+        pass

ring_cli-0.13.0/src/ring/question_detect.py

@@ -0,0 +1,93 @@
+"""偵測 Stop 事件裡「回合結尾純文字提問」。
+
+agent 有時不用 ``AskUserQuestion``、不觸發權限請求，只是在文字裡問了一句話就停下來
+（例如「要不要順便修 B？」）。既有的 Stop → 🟡 跑完停著是寫死的（見
+``hook_protocol._ALWAYS_STATUS``），從不讀 assistant 文字，這類提問因此測不到、使用者
+以為沒東西要回。
+
+設計原則：保守，寧可漏報也不要誤報。只看**訊息結尾**：
+
+- 問句出現在訊息中段、結尾是陳述句 → 不算（避免把「先確認一下：你要 A 還是 B？我會用
+  A 繼續做」這種訊息誤判——它結尾是陳述句，不該轉紅）。
+- 結尾若是圍欄程式碼區塊（```` ``` ... ``` ````），先把整個區塊剝掉再看區塊之前的最後一行
+  ——常見於「這樣可以嗎？\\n\\n```bash\\nls -la\\n```」，圍欄本身不是問句，但它前面那句是。
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from ring.transcript import _last_assistant_text, _tail_records
+
+_DETAIL_MAX = 160
+
+# 收尾判斷前，先剝掉這些包裹字元（markdown 強調記號、引號、括號），
+# 例如「...要繼續嗎？**」「...要繼續嗎？」」。
+_TRAILING_WRAPPERS = "*_`\"' )]>"
+
+_QUESTION_MARKS = ("?", "？")
+
+
+def stop_last_assistant_text(data: Mapping[str, Any]) -> str:
+    """取得 Stop payload 對應的最後一則 assistant 訊息文字。
+
+    優先讀 payload 本身的 ``last_assistant_message``（Claude Code、Codex 的實際 Stop
+    payload 都帶這欄——見 ``~/.config/ring/hook_payloads.jsonl`` 實錄）；缺欄位或空字串
+    才退回從 ``transcript_path`` 尾端讀（有界讀取，缺檔／壞格式安全回空字串，不炸）。
+    """
+    text = data.get("last_assistant_message")
+    if isinstance(text, str) and text.strip():
+        return text
+    tp = data.get("transcript_path") or data.get("transcriptPath")
+    if isinstance(tp, str) and tp:
+        try:
+            records = _tail_records(Path(tp))
+        except Exception:
+            return ""
+        return _last_assistant_text(records)
+    return ""
+
+
+def _strip_trailing_code_fence(text: str) -> str:
+    """剝掉文字尾端的圍欄程式碼區塊（可能不只一個），回傳剝除後的文字。"""
+    lines = text.splitlines()
+    changed = True
+    while changed and lines:
+        changed = False
+        while lines and not lines[-1].strip():
+            lines.pop()
+        if lines and lines[-1].strip().startswith("```"):
+            closing = len(lines) - 1
+            opening = None
+            for i in range(closing - 1, -1, -1):
+                if lines[i].strip().startswith("```"):
+                    opening = i
+                    break
+            if opening is not None:
+                lines = lines[:opening]
+                changed = True
+    return "\n".join(lines)
+
+
+def _strip_trailing_wrappers(line: str) -> str:
+    line = line.rstrip()
+    while line and line[-1] in _TRAILING_WRAPPERS:
+        line = line[:-1].rstrip()
+    return line
+
+
+def trailing_question_detail(text: str) -> str:
+    """``text`` 的結尾若是問句，回傳該行摘要（截斷合理長度）；否則回傳空字串。"""
+    if not text:
+        return ""
+    stripped = _strip_trailing_code_fence(text.rstrip())
+    lines = [ln for ln in stripped.splitlines() if ln.strip()]
+    if not lines:
+        return ""
+    last_line = _strip_trailing_wrappers(lines[-1])
+    if not last_line or last_line[-1] not in _QUESTION_MARKS:
+        return ""
+    detail = " ".join(last_line.split())
+    return detail if len(detail) <= _DETAIL_MAX else detail[: _DETAIL_MAX - 1] + "…"

{ring_cli-0.11.4 → ring_cli-0.13.0}/src/ring/registry.py

@@ -8,7 +8,9 @@
 2. zero-config fallback：直接掃 ``~/.claude/projects/**/*.jsonl``，用檔案 mtime
    推活躍度，從記錄裡的 ``cwd`` 欄位還原真實路徑（避開目錄名以 ``-`` 編碼
    造成的 hyphen 還原歧義）。scan 模式不把「回完一輪」當成 🔴 WAITING；
-   WAITING 只保留給 hook 可確認的權限 / 選項等互動。
+   WAITING 一律由 hook 資料驅動：hook 事件直接標的權限 / 選項互動，加上
+   codex 的核可等待靜默逾時判定（``_promote_codex_permission_wait``——它讀的
+   也是 hook row，是推遲判定而非 scan 猜測）。
 
 額外富化：
 - ``tmux_target``：靠 tmux pane 的 current_path 對 cwd，給你「去哪」的座標。
@@ -53,6 +55,8 @@ _CFG = get_config()
 ACTIVE_WINDOW_SECONDS = _CFG.active_window_seconds  # 只看最近這段時間動過的 session（預設 6h）
 WORKING_THRESHOLD_SECONDS = _CFG.working_threshold_seconds  # 多久沒動 → 🟢 工作中 變 🟡 閒置
 WAITING_WINDOW_SECONDS = _CFG.waiting_window_seconds  # IDLE 升 WAITING 的時間窗上限（預設 30 分）
+# codex 裸 PermissionRequest 後 hook 靜默超過這秒數 → 判定真的停下來等核可（0 = 關閉）
+CODEX_PERMISSION_WAIT_SECONDS = _CFG.codex_permission_wait_seconds
 _SUBPROCESS_CACHE_TTL = 1.0  # ps / tmux 結果的短快取，省掉同一次刷新內的重複呼叫
 
 # Claude Code SessionStart payload 的 source 值（不是 provider）。舊版 bug 曾把它誤當
@@ -349,7 +353,9 @@ def _apply_waiting(
     """對話尾是 end_turn 且在時間窗內時，將 live/idle scan row 收斂為 IDLE。
 
     純函式、可單測，不依賴 module-level 常數。
-    不把回合結束升成 WAITING；WAITING 只保留給 hook 確認的權限 / 選項互動：
+    不把回合結束升成 WAITING；WAITING 一律由 hook 資料驅動（hook 直接標的權限 /
+    選項互動，或 ``_promote_codex_permission_wait`` 對 hook row 的靜默逾時判定），
+    scan 猜測永遠不標：
     - WORKING（< 90s）：若尾端已是 end_turn，代表回合其實結束了，收斂成 IDLE。
     - ENDED：超過活躍窗，不升。
     """
@@ -358,6 +364,34 @@ def _apply_waiting(
     return status
 
 
+def _promote_codex_permission_wait(
+    provider: str,
+    status: Status,
+    last_event: str,
+    age_seconds: float,
+    threshold: float,
+) -> bool:
+    """codex hook row 的核可等待判定：裸 PermissionRequest 後靜默逾時 → 該升 🔴 嗎。
+
+    Codex（0.144.4 實證）的 hook 是封閉的 10 事件枚舉：沒有「使用者已核可」事件、沒有
+    心跳，rollout 檔在等核可期間也完全靜默。policy 自動放行時，下一個事件（PostToolUse /
+    下一個 PreToolUse / Stop）幾秒內就會到；真的停下來等人時 hook 通道只會一直沉默。
+    所以「最後一個 hook 事件是 PermissionRequest 且已靜默超過門檻」本身就是可靠的等待
+    訊號——這是對 hook 資料的推遲判定，不是 scan 猜測。任何後續 hook 事件會覆寫
+    last_event，自然清紅。
+
+    只對 codex 啟用：claude-code 真的停下來等人時會補發 permission_prompt Notification
+    （hook 直接標 🔴），不需要、也不該重複走這條路。純函式、可單測。
+    """
+    return (
+        provider == "codex"
+        and status is Status.WORKING
+        and last_event == "PermissionRequest"
+        and threshold > 0
+        and age_seconds > threshold
+    )
+
+
 def _hook_heartbeat_stale(
     source_path: str,
     heartbeat_at: float,
@@ -872,7 +906,10 @@ def running_agent_pids() -> list[int]:
     顯示用途，不是存活判定；真正的 ENDED 判定路徑（``_hook_sessions``）用的是
     未攤平的 ``running_claude_pids`` / ``running_codex_pids`` 原始回傳值。
     """
-    return [*(running_claude_pids() or []), *(running_codex_pids() or [])]
+    # 延後 import，避免 registry（Session model）與 sources package 初始化時循環相依。
+    from ring.sources.local_llm import running_pids as running_local_llm_pids
+
+    return [*(running_claude_pids() or []), *(running_codex_pids() or []), *running_local_llm_pids()]
 
 
 def _pids_cwd(pids: list[int]) -> dict[int, str] | None:
@@ -1326,26 +1363,40 @@ def _hook_sessions(
                 if purge_session_start_phantoms:
                     f.unlink(missing_ok=True)
                 continue
-            out.append(
-                Session(
-                    session_id=str(data["session_id"]),
-                    cwd=str(data.get("cwd", "")),
-                    status=Status(data.get("status", "idle")),
-                    last_active=float(data.get("last_active", 0.0)),
-                    last_action=str(data.get("last_action", "—")),
-                    source="hook",
-                    tmux_pane=str(data.get("tmux_pane", "")) or None,
-                    tty=str(data.get("tty", "")) or None,
-                    hook_pid=int(data["hook_pid"]) if str(data.get("hook_pid", "")).isdigit() else None,
-                    heartbeat_at=float(data.get("heartbeat_at", data.get("last_active", 0.0))),
-                    source_path=str(data.get("source_path", "")),
-                    todo=tuple(todo) if isinstance(todo, list) and len(todo) == 2 else None,
-                    provider=provider,
-                    waiting_kind=str(data.get("waiting_kind", "")),
-                    waiting_detail=str(data.get("waiting_detail", "")),
-                    origin_cwd=str(data.get("origin_cwd", "")),
-                )
+            row = Session(
+                session_id=str(data["session_id"]),
+                cwd=str(data.get("cwd", "")),
+                status=Status(data.get("status", "idle")),
+                last_active=float(data.get("last_active", 0.0)),
+                last_action=str(data.get("last_action", "—")),
+                source="hook",
+                tmux_pane=str(data.get("tmux_pane", "")) or None,
+                tty=str(data.get("tty", "")) or None,
+                hook_pid=int(data["hook_pid"]) if str(data.get("hook_pid", "")).isdigit() else None,
+                heartbeat_at=float(data.get("heartbeat_at", data.get("last_active", 0.0))),
+                source_path=str(data.get("source_path", "")),
+                todo=tuple(todo) if isinstance(todo, list) and len(todo) == 2 else None,
+                provider=provider,
+                waiting_kind=str(data.get("waiting_kind", "")),
+                waiting_detail=str(data.get("waiting_detail", "")),
+                origin_cwd=str(data.get("origin_cwd", "")),
             )
+            if _promote_codex_permission_wait(
+                _canonical_provider(provider),
+                row.status,
+                str(data.get("last_event", "")),
+                time.time() - row.last_active,
+                CODEX_PERMISSION_WAIT_SECONDS,
+            ):
+                row.status = Status.WAITING
+                row.waiting_kind = "permission"
+                pending_detail = data.get("pending_permission_detail")
+                if isinstance(pending_detail, str) and pending_detail:
+                    # hook 在裸 PermissionRequest 當下暫存的指令摘要（120s TTL 只管
+                    # 「下一個事件來時還新不新鮮」；這裡 hook 靜默 = 同一筆請求還掛著，
+                    # 摘要必然還是它，直接沿用）。
+                    row.waiting_detail = pending_detail
+            out.append(row)
         except (KeyError, ValueError):
             continue
     for s in out:

{ring_cli-0.11.4 → ring_cli-0.13.0}/src/ring/sources/__init__.py

@@ -13,9 +13,11 @@ from ring.sources.base import SessionSource
 from ring.sources.claude_code import source as _claude_code
 from ring.sources.codex import source as _codex
 from ring.sources.hook_registry import source as _hook_registry
+from ring.sources.local_llm import llama_cpp_source as _llama_cpp
+from ring.sources.local_llm import ollama_source as _ollama
 
 # 註冊表（順序＝彙整順序）。hook registry 先於 zero-config source，精準事件優先。
-_SOURCES: list[SessionSource] = [_hook_registry, _claude_code, _codex]
+_SOURCES: list[SessionSource] = [_hook_registry, _claude_code, _codex, _ollama, _llama_cpp]
 
 
 def register_source(source: SessionSource, *, first: bool = False) -> None:

ring_cli-0.13.0/src/ring/sources/local_llm.py

@@ -0,0 +1,157 @@
+"""Ollama 與 llama.cpp 互動式 CLI 的 zero-config 行程來源。
+
+兩者都沒有可供 RiNG 讀取的 session transcript；這個來源因此只承諾行程層級的
+存活資訊。只收有控制終端的 ``ollama run`` / ``llama-cli``，刻意排除長駐 API
+server，避免把基礎設施誤當成「需要使用者回去處理」的 session。
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import time
+from dataclasses import dataclass
+
+import ring.registry as registry
+from ring.registry import Session, Status
+
+_CACHE_TTL = 1.0
+
+
+@dataclass(frozen=True)
+class LocalLLMProcess:
+    pid: int
+    provider: str
+    cwd: str
+    tty: str
+    started_at: float
+    model: str
+
+
+_process_cache: tuple[float, list[LocalLLMProcess] | None] = (-1.0, [])
+
+
+def _elapsed_seconds(value: str) -> int | None:
+    """解析 ps ``etime``（``[[dd-]hh:]mm:ss``）。"""
+    try:
+        day_part, clock = value.split("-", 1) if "-" in value else ("0", value)
+        fields = [int(part) for part in clock.split(":")]
+        if len(fields) == 2:
+            hours, minutes, seconds = 0, fields[0], fields[1]
+        elif len(fields) == 3:
+            hours, minutes, seconds = fields
+        else:
+            return None
+        return int(day_part) * 86400 + hours * 3600 + minutes * 60 + seconds
+    except ValueError:
+        return None
+
+
+def _command_tokens(comm: str, args: str) -> tuple[str, list[str]]:
+    """找出實際 executable 與其後參數；ps args 不保證保留 shell quoting。"""
+    tokens = args.split()
+    executable = os.path.basename(comm.strip())
+    for index, token in enumerate(tokens):
+        if os.path.basename(token) == executable:
+            return executable, tokens[index + 1 :]
+    return executable, tokens[1:] if tokens else []
+
+
+def _classify(comm: str, args: str) -> tuple[str, str] | None:
+    executable, argv = _command_tokens(comm, args)
+    if executable == "ollama":
+        if len(argv) < 2 or argv[0] != "run":
+            return None
+        return "ollama", argv[1]
+    if executable == "llama-cli":
+        model_flags = {"-m", "--model", "-hf", "-hfr", "--hf-repo", "-mu", "--model-url"}
+        for index, token in enumerate(argv[:-1]):
+            if token in model_flags:
+                return "llama.cpp", argv[index + 1]
+        return "llama.cpp", "llama-cli"
+    return None
+
+
+def _scan_processes() -> list[LocalLLMProcess] | None:
+    """一次 ps + 一次批次 lsof 找出兩種本機互動 CLI；失敗以 ``None`` 表示未知。"""
+    global _process_cache
+    monotonic_now = time.monotonic()
+    if 0 <= monotonic_now - _process_cache[0] <= _CACHE_TTL:
+        return _process_cache[1]
+
+    try:
+        result = subprocess.run(
+            ["ps", "-Ao", "pid=,tty=,etime=,comm=,args="],
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if result.returncode != 0:
+        return None
+
+    now = time.time()
+    candidates: list[tuple[int, str, float, str, str]] = []
+    for line in result.stdout.splitlines():
+        parts = line.split(None, 4)
+        if len(parts) < 4:
+            continue
+        tty = registry._normalize_tty(parts[1])
+        if not tty:
+            continue
+        classified = _classify(parts[3], parts[4] if len(parts) == 5 else "")
+        elapsed = _elapsed_seconds(parts[2])
+        if classified is None or elapsed is None:
+            continue
+        try:
+            pid = int(parts[0])
+        except ValueError:
+            continue
+        provider, model = classified
+        candidates.append((pid, tty, now - elapsed, provider, model))
+
+    cwd_by_pid = registry._pids_cwd([pid for pid, *_rest in candidates])
+    if cwd_by_pid is None:
+        return None
+    processes = [
+        LocalLLMProcess(pid, provider, cwd, tty, started_at, model)
+        for pid, tty, started_at, provider, model in candidates
+        if (cwd := cwd_by_pid.get(pid, ""))
+    ]
+    _process_cache = (monotonic_now, processes)
+    return processes
+
+
+def running_pids() -> list[int]:
+    """顯示用途的 live local-LLM CLI pid；掃描未知時回空清單。"""
+    return [process.pid for process in (_scan_processes() or [])]
+
+
+class LocalLLMSource:
+    def __init__(self, provider: str) -> None:
+        self.name = provider
+
+    def discover(self) -> list[Session]:
+        processes = _scan_processes()
+        if processes is None:
+            return []
+        return [
+            Session(
+                session_id=f"{self.name}:pid-{process.pid}",
+                cwd=process.cwd,
+                status=Status.IDLE,
+                last_active=process.started_at,
+                last_action=process.model,
+                source=self.name,
+                tty=process.tty,
+                provider=self.name,
+                origin_cwd=process.cwd,
+            )
+            for process in processes
+            if process.provider == self.name
+        ]
+
+
+ollama_source = LocalLLMSource("ollama")
+llama_cpp_source = LocalLLMSource("llama.cpp")

{ring_cli-0.11.4 → ring_cli-0.13.0}/src/ring/transcript.py

@@ -131,6 +131,26 @@ def _latest_action(records: list[dict[str, Any]]) -> str:
     return "—"
 
 
+def _last_assistant_text(records: list[dict[str, Any]]) -> str:
+    """從新到舊找最後一筆帶文字的 assistant 記錄，回傳其 text block 合併後的完整文字。
+
+    跳過沒有 text block 的 assistant 記錄（例如純 tool_use）；找不到回空字串。
+    給 Stop 事件「回合結尾純文字提問」偵測用——跟 ``_latest_action`` 不同，這裡要完整
+    文字（不截斷、不退回 tool_use 摘要），才能判斷訊息結尾是不是問句。
+    """
+    for record in reversed(records):
+        if record.get("type") != "assistant":
+            continue
+        texts = [
+            str(b.get("text", ""))
+            for b in _blocks(record)
+            if isinstance(b, dict) and b.get("type") == "text" and b.get("text")
+        ]
+        if texts:
+            return "\n".join(texts)
+    return ""
+
+
 def _extract_todo(records: list[dict[str, Any]]) -> tuple[int, int] | None:
     """從新到舊找最新的 TodoWrite，回傳 (done, total)。真進度訊號。"""
     for record in reversed(records):

{ring_cli-0.11.4 → ring_cli-0.13.0}/src/ring/tui.py

@@ -289,11 +289,29 @@ class RingApp(App[None]):
         return labeled_project(s.project, get_label(s.session_id))
 
     def _ring_on_waiting_alerts(self, alerts: list[Session]) -> None:
-        """有 session 需要提醒 → RiNG 真的「ring」你（響鈴 + toast 通知）。"""
-        if alerts:
-            self.bell()
-            names = ", ".join(sorted(self._display_name(s) for s in alerts))
-            self.notify(_("🔔 {names} 在等你回話", names=names), timeout=8)
+        """有 session 需要提醒 → RiNG 真的「ring」你（響鈴 + toast 通知）。
+
+        系統通知原則上由 ``ring hook`` 在轉 🔴 的事件當下發（這裡不重複發，只響
+        in-app 鈴）。唯一的例外是 codex 的核可等待：它是讀取側的靜默逾時判定
+        （registry._promote_codex_permission_wait），沒有對應 hook 事件可發通知，
+        所以由這裡代發系統通知——初次與重複提醒都走 WaitingAlertScheduler 同一條路。
+        codex + waiting_kind="permission" 只可能來自逾時判定（hook 對 codex 裸
+        PermissionRequest 一律記 working；AskUserQuestion 形狀的是 "question"），
+        不會跟 hook 端的通知重複。失敗安靜吞，不影響看板。
+        """
+        if not alerts:
+            return
+        self.bell()
+        names = ", ".join(sorted(self._display_name(s) for s in alerts))
+        self.notify(_("🔔 {names} 在等你回話", names=names), timeout=8)
+        promoted = [s for s in alerts if s.provider == "codex" and s.waiting_kind == "permission"]
+        if promoted:
+            try:
+                from ring.notify import notify_waiting
+
+                notify_waiting(promoted)
+            except Exception:
+                pass
 
     def _activate_own_window(self) -> None:
         """把 RiNG 自己的終端視窗帶到前景（best-effort，失敗安靜吞）。