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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ring-cli
-Version: 0.12.0
+Version: 0.13.0
 Summary: RiNG — Realtime Instance Notification Grid for active agent CLI sessions.
 Keywords: claude-code,codex,ollama,llama-cpp,tui,dashboard,session,monitor,rich
 Author: Wei Lee
@@ -326,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:
 
@@ -409,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

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

@@ -301,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:
 
@@ -384,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

{ring_cli-0.12.0 → 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.12.0"
+version = "0.13.0"
 description = "RiNG — Realtime Instance Notification Grid for active agent CLI sessions."
 readme = "README.en.md"
 requires-python = ">=3.13"

{ring_cli-0.12.0 → 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.12.0 → 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）
@@ -64,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
@@ -139,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
@@ -212,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,

{ring_cli-0.12.0 → 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,16 +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,
@@ -46,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 會被升上來。
@@ -171,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"
@@ -197,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,
@@ -211,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
@@ -244,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:
@@ -258,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`` 就不發。
 
@@ -274,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.12.0 → 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/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.12.0 → 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,
@@ -1329,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.12.0 → 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.12.0 → 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，失敗安靜吞）。