remote-claude 0.2.14 → 1.0.0

package/README.md

@@ -123,6 +123,8 @@ remote-claude attach <会话名>
       "im:message.p2p_msg:readonly",
       "im:message.reactions:read",
       "im:message.reactions:write_only",
+      "im:message.urgent",
+      "im:message.urgent.status:write",
       "im:message:readonly",
       "im:message:recall",
       "im:message:send_as_bot",

package/lark_client/card_builder.py

@@ -1201,7 +1201,8 @@ def build_session_closed_card(session_name: str) -> Dict[str, Any]:
 
 
 def build_menu_card(sessions: List[Dict], current_session: Optional[str] = None,
-                    session_groups: Optional[Dict[str, str]] = None, page: int = 0) -> Dict[str, Any]:
+                    session_groups: Optional[Dict[str, str]] = None, page: int = 0,
+                    notify_enabled: bool = True, urgent_enabled: bool = False) -> Dict[str, Any]:
     """构建快捷操作菜单卡片（/menu 和 /list 共用）：内嵌会话列表 + 快捷操作"""
     elements = []
 
@@ -1251,6 +1252,55 @@ def build_menu_card(sessions: List[Dict], current_session: Optional[str] = None,
         ]
     })
 
+    notify_label = "🔔 完成通知: 开" if notify_enabled else "🔕 完成通知: 关"
+    if not notify_enabled:
+        urgent_label = "🔇 加急通知: 关"
+        urgent_button: Dict[str, Any] = {
+            "tag": "button",
+            "text": {"tag": "plain_text", "content": urgent_label},
+            "type": "default",
+            "disabled": True,
+        }
+    elif urgent_enabled:
+        urgent_label = "🔔 加急通知: 开"
+        urgent_button = {
+            "tag": "button",
+            "text": {"tag": "plain_text", "content": urgent_label},
+            "type": "default",
+            "behaviors": [{"type": "callback", "value": {"action": "menu_toggle_urgent"}}]
+        }
+    else:
+        urgent_label = "🔕 加急通知: 关"
+        urgent_button = {
+            "tag": "button",
+            "text": {"tag": "plain_text", "content": urgent_label},
+            "type": "default",
+            "behaviors": [{"type": "callback", "value": {"action": "menu_toggle_urgent"}}]
+        }
+    elements.append({
+        "tag": "column_set",
+        "flex_mode": "none",
+        "columns": [
+            {
+                "tag": "column",
+                "width": "weighted",
+                "weight": 1,
+                "elements": [{
+                    "tag": "button",
+                    "text": {"tag": "plain_text", "content": notify_label},
+                    "type": "default",
+                    "behaviors": [{"type": "callback", "value": {"action": "menu_toggle_notify"}}]
+                }]
+            },
+            {
+                "tag": "column",
+                "width": "weighted",
+                "weight": 1,
+                "elements": [urgent_button]
+            },
+        ]
+    })
+
     return {
         "schema": "2.0",
         "config": {"wide_screen_mode": True},

package/lark_client/card_service.py

@@ -223,11 +223,69 @@ class CardService:
         _track_stats('error', 'card_api', detail='update_card')
         return False
 
-    async def send_text(self, chat_id: str, text: str):
-        """发送纯文本消息（备用）"""
+    async def send_urgent_app(self, message_id: str, user_ids: list) -> bool:
+        """对已有消息发送应用内加急通知，避免发新消息顶高流式卡片"""
+        if not self.client:
+            return False
+
+        import asyncio
+        from lark_oapi.api.im.v1 import UrgentAppMessageRequest, UrgentReceivers
+
+        try:
+            request = UrgentAppMessageRequest.builder() \
+                .message_id(message_id) \
+                .user_id_type("open_id") \
+                .request_body(
+                    UrgentReceivers.builder()
+                    .user_id_list(user_ids)
+                    .build()
+                ) \
+                .build()
+
+            response = await asyncio.to_thread(self.client.im.v1.message.urgent_app, request)
+            if response.success():
+                logger.info(f"加急通知成功: message_id={message_id}, users={user_ids}")
+                return True
+            else:
+                logger.warning(f"加急通知失败: code={response.code} msg={response.msg}")
+                return False
+        except Exception as e:
+            logger.error(f"加急通知异常: {e}")
+            return False
+
+    async def cancel_urgent_app(self, message_id: str, user_ids: list) -> bool:
+        """取消已有消息的应用内加急通知"""
+        if not self.client:
+            return False
+
+        import asyncio
+        from lark_oapi.core.model import BaseRequest
+        from lark_oapi.core.enum import HttpMethod, AccessTokenType
+
+        try:
+            request = BaseRequest()
+            request.http_method = HttpMethod.POST
+            request.uri = "/open-apis/im/v2/urgent/batch_cancel"
+            request.token_types = {AccessTokenType.TENANT}
+            request.queries = [("user_id_type", "open_id")]
+            request.body = {"message_id": message_id, "receiver_user_ids": user_ids}
+
+            response = await asyncio.to_thread(self.client.request, request)
+            if response.success():
+                logger.info(f"取消加急成功: message_id={message_id}, code={response.code}")
+                return True
+            else:
+                logger.warning(f"取消加急失败: code={response.code} msg={response.msg}")
+                return False
+        except Exception as e:
+            logger.error(f"取消加急异常: {e}")
+            return False
+
+    async def send_text(self, chat_id: str, text: str) -> Optional[str]:
+        """发送纯文本消息，返回 message_id（失败返回 None）"""
         if not self.client:
             print(f"[Lark] 消息: {text}")
-            return
+            return None
 
         try:
             import asyncio
@@ -247,10 +305,14 @@ class CardService:
                 self.client.im.v1.message.create, request
             )
 
-            if not response.success():
+            if response.success():
+                return getattr(getattr(response, "data", None), "message_id", None)
+            else:
                 logger.warning(f"发送文本失败: code={response.code} msg={response.msg}")
+                return None
         except Exception as e:
             logger.error(f"发送文本异常: {e}")
+            return None
 
     # 管理活跃卡片的方法
     def get_active_card(self, chat_id: str) -> Optional[CardState]:

package/lark_client/lark_handler.py

@@ -115,7 +115,8 @@ class LarkHandler:
 
     # ── 统一 attach / detach / on_disconnect ────────────────────────────────
 
-    async def _attach(self, chat_id: str, session_name: str) -> bool:
+    async def _attach(self, chat_id: str, session_name: str,
+                      user_id: Optional[str] = None) -> bool:
         """统一 attach 逻辑（私聊/群聊共用）"""
         # 在断开旧连接之前，先更新旧流式卡片为已断开状态
         old_session = self._chat_sessions.get(chat_id)
@@ -138,7 +139,8 @@ class LarkHandler:
         if await bridge.connect():
             self._bridges[chat_id] = bridge
             self._chat_sessions[chat_id] = session_name
-            self._poller.start(chat_id, session_name)
+            self._poller.start(chat_id, session_name, is_group=(chat_id in self._group_chat_ids),
+                               notify_user_id=user_id)
             _track_stats('lark', 'attach', session_name=session_name,
                          chat_id=chat_id)
             return True
@@ -244,7 +246,7 @@ class LarkHandler:
             )
             return
 
-        ok = await self._attach(chat_id, session_name)
+        ok = await self._attach(chat_id, session_name, user_id=user_id)
         if ok:
             self._chat_bindings[chat_id] = session_name
             self._save_chat_bindings()
@@ -374,7 +376,7 @@ class LarkHandler:
                 await card_service.send_text(chat_id, f"错误: 会话启动超时 (12s)\n\n{log_content}")
                 return
 
-            ok = await self._attach(chat_id, session_name)
+            ok = await self._attach(chat_id, session_name, user_id=user_id)
             if ok:
                 self._chat_bindings[chat_id] = session_name
                 self._save_chat_bindings()
@@ -603,9 +605,25 @@ class LarkHandler:
             for cid in self._group_chat_ids
             if cid in self._chat_bindings
         }
-        card = build_menu_card(sessions, current_session=current, session_groups=session_groups, page=page)
+        card = build_menu_card(sessions, current_session=current, session_groups=session_groups, page=page,
+                               notify_enabled=self._poller.get_notify_enabled(),
+                               urgent_enabled=self._poller.get_urgent_enabled())
         await self._send_or_update_card(chat_id, card, message_id)
 
+    async def _cmd_toggle_notify(self, user_id: str, chat_id: str,
+                                  message_id: Optional[str] = None):
+        """切换就绪通知开关并刷新菜单卡片"""
+        new_value = not self._poller.get_notify_enabled()
+        self._poller.set_notify_enabled(new_value)
+        await self._cmd_menu(user_id, chat_id, message_id=message_id)
+
+    async def _cmd_toggle_urgent(self, user_id: str, chat_id: str,
+                                  message_id: Optional[str] = None):
+        """切换加急通知开关并刷新菜单卡片"""
+        new_value = not self._poller.get_urgent_enabled()
+        self._poller.set_urgent_enabled(new_value)
+        await self._cmd_menu(user_id, chat_id, message_id=message_id)
+
     async def _cmd_ls(self, user_id: str, chat_id: str, args: str,
                        tree: bool = False, message_id: Optional[str] = None, page: int = 0):
         """查看目录文件结构"""
@@ -715,7 +733,7 @@ class LarkHandler:
             self._group_chat_ids.add(group_chat_id)
             self._save_group_chat_ids()
             # 立即 attach，让新群即刻开始接收 Claude 输出
-            await self._attach(group_chat_id, session_name)
+            await self._attach(group_chat_id, session_name, user_id=user_id)
 
             # 刷新会话列表卡片，使"创建群聊"按钮变为"进入群聊"
             await self._cmd_list(user_id, chat_id, message_id=message_id)
@@ -804,7 +822,7 @@ class LarkHandler:
             saved_session = self._chat_bindings.get(chat_id)
             if saved_session:
                 logger.info(f"自动恢复绑定: chat_id={chat_id[:8]}..., session={saved_session}")
-                ok = await self._attach(chat_id, saved_session)
+                ok = await self._attach(chat_id, saved_session, user_id=user_id)
                 if not ok:
                     self._group_chat_ids.discard(chat_id)
                     self._save_group_chat_ids()

package/lark_client/main.py

@@ -54,11 +54,12 @@ def _setup_logging():
     for _noisy in ('urllib3', 'websockets', 'asyncio'):
         logging.getLogger(_noisy).setLevel(logging.INFO)
 
-    # 控制台输出（仅重要消息，无调试信息）
-    console_handler = logging.StreamHandler()
-    console_handler.setLevel(logging.INFO)
-    console_handler.setFormatter(formatter)
-    root_logger.addHandler(console_handler)
+    # 控制台输出（仅在终端交互模式下启用，守护进程模式下 stderr 已重定向到日志文件）
+    if sys.stderr.isatty():
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        console_handler.setFormatter(formatter)
+        root_logger.addHandler(console_handler)
 
 
 # 在导入 lark SDK 之前配置日志
@@ -305,6 +306,14 @@ def handle_card_action(event: P2CardActionTrigger) -> P2CardActionTriggerRespons
             asyncio.create_task(_multi_send())
             return None
 
+        if action_type == "menu_toggle_notify":
+            asyncio.create_task(handler._cmd_toggle_notify(user_id, chat_id, message_id=message_id))
+            return None
+
+        if action_type == "menu_toggle_urgent":
+            asyncio.create_task(handler._cmd_toggle_urgent(user_id, chat_id, message_id=message_id))
+            return None
+
         # 各卡片底部菜单按钮：辅助卡片就地→菜单，流式卡片降级新卡
         if action_type == "menu_open":
             asyncio.create_task(handler._cmd_menu(user_id, chat_id, message_id=message_id))

package/lark_client/session_bridge.py

@@ -11,7 +11,6 @@ import sys
 from pathlib import Path
 from typing import Optional, Callable, Dict
 
-logging.basicConfig(level=logging.INFO, format='[%(name)s] %(message)s')
 logger = logging.getLogger('SessionBridge')
 
 sys.path.insert(0, str(Path(__file__).parent.parent))

package/lark_client/shared_memory_poller.py

@@ -35,6 +35,8 @@ try:
 except Exception:
     def _track_stats(*args, **kwargs): pass
 
+from utils.session import ensure_user_data_dir, USER_DATA_DIR
+
 # ── 常量 ──────────────────────────────────────────────────────────────────────
 INITIAL_WINDOW = 30    # 首次 attach 最多显示最近 30 个 blocks
 from .config import MAX_CARD_BLOCKS  # 单张卡片最多 N 个 blocks → 超限冻结（可通过 .env 配置）
@@ -62,6 +64,10 @@ class StreamTracker:
     cards: List[CardSlice] = field(default_factory=list)
     content_hash: str = ""
     reader: Optional[Any] = None  # SharedStateReader，延迟初始化
+    is_group: bool = False         # 是否为群聊
+    prev_is_ready: bool = True     # 上一帧是否就绪（初始 True 避免首次误触发）
+    notify_user_id: Optional[str] = None  # 就绪通知 @ 的用户 open_id
+    last_notify_message_id: Optional[str] = None  # 上一条就绪通知的 message_id（用于后续加急复用）
 
 
 # ── 轮询器 ────────────────────────────────────────────────────────────────────
@@ -81,11 +87,13 @@ class SharedMemoryPoller:
         self._kick_events: Dict[str, asyncio.Event] = {}  # chat_id → Event（唤醒轮询）
         self._rapid_until: Dict[str, float] = {}           # chat_id → 快速模式截止时间
 
-    def start(self, chat_id: str, session_name: str) -> None:
+    def start(self, chat_id: str, session_name: str, is_group: bool = False,
+              notify_user_id: Optional[str] = None) -> None:
         """attach 成功后调用：清空旧状态，启动轮询 Task"""
         self.stop(chat_id)
 
-        tracker = StreamTracker(chat_id=chat_id, session_name=session_name)
+        tracker = StreamTracker(chat_id=chat_id, session_name=session_name, is_group=is_group,
+                                notify_user_id=notify_user_id)
         self._trackers[chat_id] = tracker
         self._kick_events[chat_id] = asyncio.Event()
 
@@ -212,6 +220,9 @@ class SharedMemoryPoller:
         option_block = state.get("option_block")
         cli_type = state.get("cli_type", "claude")
 
+        # 就绪状态转换检测
+        await self._check_ready_notification(tracker, blocks, status_line, option_block, cli_type)
+
         # 获取活跃卡片（最后一张且未冻结）
         active = None
         if tracker.cards and not tracker.cards[-1].frozen:
@@ -415,6 +426,84 @@ class SharedMemoryPoller:
                 f"blocks={len(new_blocks)} card_id={new_card_id}"
             )
 
+    async def _check_ready_notification(
+        self, tracker: StreamTracker,
+        blocks: list, status_line: Optional[dict], option_block: Optional[dict],
+        cli_type: str = "claude"
+    ) -> None:
+        """检测就绪状态转换（忙碌→就绪），群聊中发送 @所有人 提醒"""
+        current_ready = _is_ready(blocks, status_line, option_block)
+        prev_ready = tracker.prev_is_ready
+        tracker.prev_is_ready = current_ready
+
+        if current_ready and not prev_ready and tracker.is_group and _notify_enabled:
+            count = _increment_ready_count()
+            uid = tracker.notify_user_id or "all"
+            cli_name = "Claude" if cli_type == "claude" else "Codex"
+            logger.info(f"就绪提醒: chat_id={tracker.chat_id[:8]}..., count={count}, uid={uid}, "
+                        f"last_msg={'有' if tracker.last_notify_message_id else '无'}")
+
+            if tracker.last_notify_message_id and uid != "all" and _urgent_enabled:
+                # 已有通知消息 + 加急开关开启 → 尝试加急
+                try:
+                    ok = await self._card_service.send_urgent_app(
+                        tracker.last_notify_message_id, [uid]
+                    )
+                    if ok:
+                        # 加急成功 → 15 秒后自动取消
+                        asyncio.create_task(self._cancel_urgent_later(
+                            tracker.last_notify_message_id, [uid], delay=5
+                        ))
+                    else:
+                        # 加急失败（权限未开通等）→ 降级发新消息
+                        label = ""
+                        text = f'<at user_id="{uid}">{label}</at> {cli_name} 已就绪，等待您的输入...（这是第{count}次通知）'
+                        msg_id = await self._card_service.send_text(tracker.chat_id, text)
+                        if msg_id:
+                            tracker.last_notify_message_id = msg_id
+                except Exception as e:
+                    logger.warning(f"加急通知失败: {e}")
+            else:
+                # 首次通知（或无法加急时）→ 发新消息，记录 message_id
+                label = "所有人" if uid == "all" else ""
+                text = f'<at user_id="{uid}">{label}</at> {cli_name} 已就绪，等待您的输入...（这是第{count}次通知）'
+                try:
+                    msg_id = await self._card_service.send_text(tracker.chat_id, text)
+                    if msg_id:
+                        tracker.last_notify_message_id = msg_id
+                except Exception as e:
+                    logger.warning(f"就绪提醒发送失败: {e}")
+
+    async def _cancel_urgent_later(self, message_id: str, user_ids: list, delay: float = 15) -> None:
+        """延迟取消加急通知"""
+        await asyncio.sleep(delay)
+        try:
+            await self._card_service.cancel_urgent_app(message_id, user_ids)
+        except Exception as e:
+            logger.warning(f"延迟取消加急失败: {e}")
+
+    def get_notify_enabled(self) -> bool:
+        """获取就绪通知开关状态"""
+        return _notify_enabled
+
+    def set_notify_enabled(self, enabled: bool) -> None:
+        """更新就绪通知开关状态并持久化"""
+        global _notify_enabled
+        _notify_enabled = enabled
+        _save_notify_enabled(enabled)
+        logger.info(f"就绪通知开关已{'开启' if enabled else '关闭'}")
+
+    def get_urgent_enabled(self) -> bool:
+        """获取加急通知开关状态"""
+        return _urgent_enabled
+
+    def set_urgent_enabled(self, enabled: bool) -> None:
+        """更新加急通知开关状态并持久化"""
+        global _urgent_enabled
+        _urgent_enabled = enabled
+        _save_urgent_enabled(enabled)
+        logger.info(f"加急通知开关已{'开启' if enabled else '关闭'}")
+
     @staticmethod
     def _compute_hash(
         blocks: list, status_line: Optional[dict],
@@ -432,3 +521,71 @@ class SharedMemoryPoller:
         return hashlib.md5(
             json.dumps(data, ensure_ascii=False, sort_keys=True).encode()
         ).hexdigest()
+
+
+# ── 模块级辅助函数 ────────────────────────────────────────────────────────────
+
+def _is_ready(blocks: list, status_line: Optional[dict], option_block: Optional[dict]) -> bool:
+    """数据层就绪判断：无 streaming block、无 status_line（option_block 不影响就绪）"""
+    has_streaming = any(b.get("is_streaming", False) for b in blocks)
+    return not has_streaming and status_line is None
+
+
+_READY_COUNT_FILE = USER_DATA_DIR / "ready_notify_count"
+_NOTIFY_ENABLED_FILE = USER_DATA_DIR / "ready_notify_enabled"
+_URGENT_ENABLED_FILE = USER_DATA_DIR / "urgent_notify_enabled"
+
+
+def _load_notify_enabled() -> bool:
+    """读取就绪通知开关状态，不存在或解析失败返回 True（默认开启）"""
+    try:
+        return _NOTIFY_ENABLED_FILE.read_text().strip() == "1"
+    except Exception:
+        return True
+
+
+def _save_notify_enabled(enabled: bool) -> None:
+    """持久化就绪通知开关状态"""
+    try:
+        ensure_user_data_dir()
+        _NOTIFY_ENABLED_FILE.write_text("1" if enabled else "0")
+    except Exception as e:
+        logger.warning(f"_save_notify_enabled 失败: {e}")
+
+
+def _load_urgent_enabled() -> bool:
+    """读取加急通知开关状态，不存在或解析失败返回 False（默认关闭）"""
+    try:
+        return _URGENT_ENABLED_FILE.read_text().strip() == "1"
+    except Exception:
+        return False
+
+
+def _save_urgent_enabled(enabled: bool) -> None:
+    """持久化加急通知开关状态"""
+    try:
+        ensure_user_data_dir()
+        _URGENT_ENABLED_FILE.write_text("1" if enabled else "0")
+    except Exception as e:
+        logger.warning(f"_save_urgent_enabled 失败: {e}")
+
+
+# 模块级开关状态：启动时加载一次
+_notify_enabled: bool = _load_notify_enabled()
+_urgent_enabled: bool = _load_urgent_enabled()
+
+
+def _increment_ready_count() -> int:
+    """原子递增全局就绪提醒计数器，返回新值（持久化到文件）"""
+    try:
+        ensure_user_data_dir()
+        try:
+            count = int(_READY_COUNT_FILE.read_text().strip())
+        except Exception:
+            count = 0
+        count += 1
+        _READY_COUNT_FILE.write_text(str(count))
+        return count
+    except Exception as e:
+        logger.warning(f"_increment_ready_count 失败: {e}")
+        return 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-claude",
-  "version": "0.2.14",
+  "version": "1.0.0",
   "description": "双端共享 Claude CLI 工具",
   "bin": {
     "remote-claude": "bin/remote-claude",

package/server/parsers/claude_parser.py

@@ -909,22 +909,43 @@ class ClaudeParser(BaseParser):
         return None
 
     def _extract_input_area_text(self, screen: pyte.Screen, input_rows: List[int]) -> str:
-        """提取输入区 ❯ 提示符后的当前输入文本（空提示符返回空字符串）"""
-        for row in input_rows:
+        """提取输入区 ❯ 提示符后的当前输入文本（空提示符返回空字符串）。
+        多行输入时，收集 ❯ 行之后首列为空的续行，合并为完整文本。
+        """
+        for i, row in enumerate(input_rows):
             if _get_col0(screen, row) == '❯':
                 text = _get_row_text(screen, row)[1:].strip()
                 # 排除纯分割线装饰行（如 ❯─────）
                 if text and not all(c in DIVIDER_CHARS for c in text):
-                    return text
+                    # 收集续行（首列为空的非空文本行）
+                    lines = [text]
+                    for next_row in input_rows[i + 1:]:
+                        col0 = _get_col0(screen, next_row)
+                        if col0.strip():  # 首列有字符，遇到新 block 或新 ❯ 行，停止
+                            break
+                        next_text = _get_row_text(screen, next_row).strip()
+                        if next_text:
+                            lines.append(next_text)
+                    return '\n'.join(lines)
         return ''
 
     def _extract_input_area_ansi_text(self, screen: pyte.Screen, input_rows: List[int]) -> str:
-        """提取输入区 ❯ 提示符后的当前输入文本（ANSI 版本）"""
-        for row in input_rows:
+        """提取输入区 ❯ 提示符后的当前输入文本（ANSI 版本）。
+        多行输入时，收集 ❯ 行之后首列为空的续行，合并为完整文本。
+        """
+        for i, row in enumerate(input_rows):
             if _get_col0(screen, row) == '❯':
                 text = _get_row_text(screen, row)[1:].strip()
                 if text and not all(c in DIVIDER_CHARS for c in text):
-                    return _get_row_ansi_text(screen, row, start_col=1).strip()
+                    lines = [_get_row_ansi_text(screen, row, start_col=1).strip()]
+                    for next_row in input_rows[i + 1:]:
+                        col0 = _get_col0(screen, next_row)
+                        if col0.strip():  # 首列有字符，停止
+                            break
+                        next_text = _get_row_text(screen, next_row).strip()
+                        if next_text:
+                            lines.append(_get_row_ansi_text(screen, next_row).strip())
+                    return '\n'.join(lines)
         return ''
 
     def _parse_permission_area(

package/server/parsers/codex_parser.py

@@ -1,14 +1,11 @@
 """Codex CLI 输出组件解析器
 
-从 ClaudeParser 复制而来，作为独立起点，可根据 Codex CLI 实际终端输出差异逐步调整。
-
-当前解析规则与 ClaudeParser 相同，需在实际观测 Codex 终端输出后针对性修改：
-  - STAR_CHARS：状态行首列字符集（Codex 的"思考中"动画字符）
-  - DOT_CHARS：输出 block 首列指示符字符集
-  - 用户输入指示符（❯ 是否相同）
-  - 分割线识别规则
-  - 欢迎框检测（_trim_welcome 中的 'Claude Code' 字符串）
-  - 选项/权限交互格式
+独立解析器，专门处理 Codex CLI 的终端输出格式。与 ClaudeParser 的关键差异：
+  - STAR_CHARS：不使用星星字符，StatusLine 改为 DOT_CHARS blink 检测
+  - 用户输入指示符：`›` (U+203A) / `>` (U+003E)，与 ClaudeParser 的 `❯` 不同
+  - 区域分割：无 ─━═ 字符分割线，用背景色区域（连续 bg 行 + 首尾纯背景色边界）识别输入区域
+  - 欢迎框：`>_ OpenAI Codex` + `model:` + `directory:` 特征，无固定行号
+  - 选项交互：编号选项 + Enter/Esc 导航提示，通过提示符颜色和上方签名区分普通/选项模式
 """
 
 import re
@@ -35,6 +32,7 @@ STAR_CHARS: Set[str] = set(
     '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'
     '△'    # Codex 系统警告（不闪烁 → SystemBlock）
     '⚠'    # Codex 警告（不闪烁 → SystemBlock）
+    '■'    # Codex 错误提示（不闪烁 → SystemBlock）
 )
 
 # 圆点字符集（OutputBlock 首列）
@@ -111,9 +109,9 @@ def _strip_inline_boxes_pair(content: str, ansi_content: str) -> tuple:
 
 
 # 编号选项行正则（权限确认对话框特征：> 1. Yes / 2. No 等）
-_NUMBERED_OPTION_RE = re.compile(r'^(?:>\s*)?\d+[.)]\s+.+')
-# 带 > 光标的编号选项行正则（锚点）
-_CURSOR_OPTION_RE = re.compile(r'^>\s*(\d+)[.)]\s+.+')
+_NUMBERED_OPTION_RE = re.compile(r'^(?:[>❯›]\s*)?\d+[.)]\s+.+')
+# 带 > / ❯ / › 光标的编号选项行正则（锚点）
+_CURSOR_OPTION_RE = re.compile(r'^[>❯›]\s*(\d+)[.)]\s+.+')
 
 # Codex 状态行检测（首列 ● blink=True + 内容含 "esc to interrupt"）
 
@@ -197,7 +195,7 @@ def _get_row_ansi_text(screen: pyte.Screen, row: int, start_col: int = 0) -> str
     """提取指定行带 ANSI 转义码的文本。
 
     先确定有效列范围（与 _get_row_text 的 rstrip 等价），仅在有效范围内生成 ANSI 码。
-    start_col 用于跳过首列特殊字符（圆点/星星/❯）。
+    start_col 用于跳过首列特殊字符（圆点/星星/›）。
     """
     buf_row = screen.buffer[row]
 
@@ -293,36 +291,42 @@ def _is_bright_color(color: str) -> bool:
     return True
 
 
-def _is_lit_prompt_row(screen: pyte.Screen, row: int) -> bool:
-    """判断是否为亮起来的 › 行（输入区域首行）。
-
-    条件：
-    1. 行首是 ›（CODEX_PROMPT_CHARS）
-    2. 首字符前景色是亮色（非 default 且非暗色）
-    3. 上一行、当前行、下一行都有整行背景色（严格检查，缺一行则失败）
-    """
-    # 检查行首是 ›
-    if _get_col0(screen, row) not in CODEX_PROMPT_CHARS:
+def _is_white_color(color: str) -> bool:
+    """判断颜色是否为白色/亮白色"""
+    if not color or color == 'default':
         return False
+    key = color.lower().replace(' ', '').replace('-', '')
+    if key in ('white', 'brightwhite'):
+        return True
+    # hex 颜色：R/G/B 都 > 200
+    if len(color) == 6:
+        try:
+            r, g, b = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16)
+            return r > 200 and g > 200 and b > 200
+        except ValueError:
+            pass
+    return False
 
-    # 检查首字符前景色是亮色
-    try:
-        char = screen.buffer[row][0]
-        fg = getattr(char, 'fg', 'default') or 'default'
-        if not _is_bright_color(fg):
-            return False  # 前景色不是亮色（可能是暗色或 default）
-    except (KeyError, IndexError):
-        return False
 
-    # 严格检查：上一行、当前行、下一行都必须有整行背景色
-    if not _has_full_row_bg(screen, row):
-        return False
-    if row == 0 or not _has_full_row_bg(screen, row - 1):
-        return False
-    if row >= screen.lines - 1 or not _has_full_row_bg(screen, row + 1):
+def _is_light_blue_color(color: str) -> bool:
+    """判断颜色是否为浅蓝色/青色"""
+    if not color or color == 'default':
         return False
-
-    return True
+    key = color.lower().replace(' ', '').replace('-', '')
+    if key in ('cyan', 'brightcyan', 'brightblue'):
+        return True
+    # hex 颜色：偏蓝（B > R 且 B > G 且整体较亮）
+    if len(color) == 6:
+        try:
+            r, g, b = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16)
+            if b > r and b > g and (r + g + b) > 200:
+                return True
+            # 青色：G 和 B 都高
+            if g > 150 and b > 150 and r < 150:
+                return True
+        except ValueError:
+            pass
+    return False
 
 
 def _get_row_text(screen: pyte.Screen, row: int) -> str:
@@ -351,26 +355,17 @@ def _get_col0_blink(screen: pyte.Screen, row: int) -> bool:
         return False
 
 
-def _is_divider_row(screen: pyte.Screen, row: int) -> bool:
-    """判断整行是否为分割线：所有非空字符均为分割线字符，不限制行长度"""
-    found = False
-    for col in range(screen.columns):
-        c = screen.buffer[row][col].data
-        if not c.strip():
-            continue
-        if c not in DIVIDER_CHARS:
-            return False  # 发现非分割线字符，立即短路
-        found = True
-    return found
 
+def _is_pure_bg_row(screen: pyte.Screen, row: int) -> bool:
+    """纯背景色行：整行有非默认背景色但无文字内容（作为背景色区域的边界标记）。
 
-def _is_bg_divider_row(screen: pyte.Screen, row: int) -> bool:
-    """判断是否为背景色分割线：整行有非默认背景色但无文字内容。
+    等同于 Claude Code 的 ─━═ 字符分割线，但以背景色实现。
+    与底部栏区别：底部栏有文字内容，纯背景色行只有 bg 色的空格。
 
-    Codex 用这类行代替 ─━═ 字符分割线，UserInput 和输入区上下各有一条。
-    与底部栏区别：底部栏有文字内容，背景色分割线只有 bg 色的空格。
+    注意：使用 _has_row_bg（检测所有列含空格）而非 _get_row_dominant_bg
+    （只统计非空格字符），确保纯空格背景行能被正确识别。
     """
-    if _get_row_dominant_bg(screen, row) == 'default':
+    if not _has_row_bg(screen, row):
         return False
     return _get_row_text(screen, row).strip() == ''
 
@@ -471,7 +466,7 @@ def _find_contiguous_options(lines, nav_re):
         line = lines[i]
         if not line or nav_re.search(line):
             continue
-        m = re.match(r'^(?:>\s*)?(\d+)[.)]\s+', line)
+        m = re.match(r'^(?:[>❯›]\s*)?(\d+)[.)]\s+', line)
         if m:
             if int(m.group(1)) == expected:
                 first_option_idx = i
@@ -487,7 +482,7 @@ def _find_contiguous_options(lines, nav_re):
         line = lines[i]
         if not line or nav_re.search(line):
             continue
-        m = re.match(r'^(?:>\s*)?(\d+)[.)]\s+', line)
+        m = re.match(r'^(?:[>❯›]\s*)?(\d+)[.)]\s+', line)
         if m:
             if int(m.group(1)) == expected:
                 last_option_idx = i
@@ -512,13 +507,15 @@ class CodexParser(BaseParser):
         # 星号滑动窗口（1.5秒）：记录每行最近 1.5 秒内出现的 (timestamp, char)，
         # 窗口内 ≥2 种不同字符 → spinner 旋转 → StatusLine；始终只有 1 种字符 → SystemBlock
         self._star_row_history: Dict[int, deque] = {}
-        # 最近一次解析到的输入区 ❯ 文本（用于 MessageQueue 追踪变更）
+        # 最近一次解析到的输入区 › 文本（用于 MessageQueue 追踪变更）
         self.last_input_text: str = ''
         self.last_input_ansi_text: str = ''
         # 最近一次 parse 的内部耗时（供外部写日志用）
         self.last_parse_timing: str = ''
         # 布局模式："normal" | "option" | "detail" | "agent_list" | "agent_detail"
         self.last_layout_mode: str = 'normal'
+        # Pass 1 区域切分确定的布局模式（None 表示 Pass 1 未成功）
+        self._pass1_mode: Optional[str] = None
 
     def parse(self, screen: pyte.Screen) -> List[Component]:
         """解析 pyte 屏幕，返回组件列表"""
@@ -529,11 +526,13 @@ class CodexParser(BaseParser):
         output_rows, input_rows, bottom_rows = self._split_regions(screen)
         _t1 = _time.perf_counter()
 
-        # 布局模式判定
+        # 布局模式判定（优先使用 Pass 1 的结果）
         prev_mode = self.last_layout_mode
-        if input_rows:
+        if self._pass1_mode is not None:
+            self.last_layout_mode = self._pass1_mode
+        elif input_rows:
             if _has_numbered_options(screen, input_rows):
-                self.last_layout_mode = 'option'    # 2 分割线 + 编号选项
+                self.last_layout_mode = 'option'    # 回退路径：编号选项检测
             else:
                 self.last_layout_mode = 'normal'
         elif bottom_rows:
@@ -561,7 +560,7 @@ class CodexParser(BaseParser):
             self._dot_attr_cache.clear()
             self._star_row_history.clear()
 
-        # 提取输入区 ❯ 文本（用于 MessageQueue 追踪变更）
+        # 提取输入区 › 文本（用于 MessageQueue 追踪变更）
         self.last_input_text = self._extract_input_area_text(screen, input_rows)
         self.last_input_ansi_text = self._extract_input_area_ansi_text(screen, input_rows)
 
@@ -611,7 +610,7 @@ class CodexParser(BaseParser):
             if text:
                 bottom_parts.append(text)
                 ansi_bottom_parts.append(_get_row_ansi_text(screen, r).strip())
-        if bottom_parts and not option and not agent_panel:
+        if bottom_parts and not agent_panel:
             bar_text = '\n'.join(bottom_parts)
             bar_ansi = '\n'.join(ansi_bottom_parts)
             has_agents, agent_count, agent_summary = _parse_bottom_bar_agents(bar_text)
@@ -637,58 +636,47 @@ class CodexParser(BaseParser):
     def _split_regions(
         self, screen: pyte.Screen
     ) -> Tuple[List[int], List[int], List[int]]:
-        """Codex 无 ─━═ 分割线，用背景色分割线（整行 bg 色且无文字）定位区域。
+        """Codex 无 ─━═ 分割线，用背景色区域（连续 bg 行 + 首尾纯背景色边界）定位输入区域。
 
-        Codex UserInput 和输入区上下各有一条背景色分割线，效果等同 ─━═。
-        从底部向上找最后两条背景色分割线，按以下结构拆分：
-          [输出区] / [bg divider] / [› 输入行] / [bg divider] / [底部栏]
+        背景色区域：连续 3 行以上都有背景色，且第一行和最后一行是纯背景色（无文字），
+        整个区域即为输入区域。
 
         优先级：
-          1. 背景色分割线（强）：从下往上找最后两条无文字 bg 行
-          2. 精确检测输入区域首行（亮起的 › + 连续三行背景色）：
-             - 行首是 ›（CODEX_PROMPT_CHARS）
-             - 首字符前景色是亮色（非 default 且非暗色）
-             - 上一行、当前行、下一行都有整行背景色（严格检查）
-          3. 位置弱信号（回退）：找最后一个其后无 block 字符的 › 行
+          1. 背景色区域（强）：_find_bg_region 找连续 bg zone 内首尾纯背景色边界对
+          2. 宽松亮色 › 检测（回退）：只检查行首字符和前景色
+          3. 位置弱信号：找最后一个其后无 block 字符的 › 行
           4. 纯背景色兜底：无 › 时用 _find_chrome_boundary
         """
         scan_limit = min(screen.cursor.y + 5, screen.lines - 1)
         _BLOCK_CHARS = DOT_CHARS | CODEX_PROMPT_CHARS | STAR_CHARS
 
-        # Pass 1：背景色分割线（最强信号，等同 ─━═）
-        bg_dividers: List[int] = []
-        for row in range(scan_limit, -1, -1):
-            if _is_bg_divider_row(screen, row):
-                bg_dividers.append(row)
-                if len(bg_dividers) == 2:
-                    break
-        if len(bg_dividers) == 2:
-            div_bottom, div_top = bg_dividers[0], bg_dividers[1]
-            output_rows = self._trim_welcome(screen, list(range(div_top)))
-            input_rows = list(range(div_top + 1, div_bottom))
-            bottom_rows = list(range(div_bottom + 1, scan_limit + 1))
+        # Pass 1：找"背景色区域"（连续 bg zone 内首尾纯背景色边界对，区域 >= 3 行）
+        self._pass1_mode = None
+        bg_region = self._find_bg_region(screen, scan_limit)
+        if bg_region is not None:
+            region_start, region_end = bg_region
+            content_rows = list(range(region_start + 1, region_end))
+            # 确定布局模式
+            mode = self._determine_input_mode(screen, region_start, content_rows)
+            self._pass1_mode = mode
+            output_rows = self._trim_welcome(screen, list(range(region_start)))
+            input_rows = content_rows
+            bottom_rows = list(range(region_end + 1, scan_limit + 1))
             return output_rows, input_rows, bottom_rows
 
-        # Pass 2：精确检测输入区域首行（亮起的 › + 连续三行背景色）
+        # Pass 2：宽松检测亮起的 › 行（只检查行首字符和前景色，不检查背景色）
         input_boundary = None
         for row in range(scan_limit, -1, -1):
-            if _is_lit_prompt_row(screen, row):
-                input_boundary = row
-                break
-
-        # Pass 2.5：宽松检测亮起的 › 行（只检查行首字符和前景色，不检查背景色）
-        if input_boundary is None:
-            for row in range(scan_limit, -1, -1):
-                col0 = _get_col0(screen, row)
-                if col0 in CODEX_PROMPT_CHARS:
-                    try:
-                        char = screen.buffer[row][0]
-                        fg = getattr(char, 'fg', 'default') or 'default'
-                        if _is_bright_color(fg):
-                            input_boundary = row
-                            break
-                    except (KeyError, IndexError):
-                        pass
+            col0 = _get_col0(screen, row)
+            if col0 in CODEX_PROMPT_CHARS:
+                try:
+                    char = screen.buffer[row][0]
+                    fg = getattr(char, 'fg', 'default') or 'default'
+                    if _is_bright_color(fg):
+                        input_boundary = row
+                        break
+                except (KeyError, IndexError):
+                    pass
 
         # Pass 3：位置弱信号
         if input_boundary is None:
@@ -719,6 +707,141 @@ class CodexParser(BaseParser):
         output_rows = self._trim_welcome(screen, list(range(scan_limit + 1)))
         return output_rows, [], []
 
+    def _find_bg_region(
+        self, screen: pyte.Screen, scan_limit: int
+    ) -> Optional[Tuple[int, int]]:
+        """在连续 bg zone 内找背景色区域（首尾纯背景色边界对，区域 >= 3 行）。
+
+        算法：
+        1. 从 scan_limit 往上扫描找连续 bg 行 zone（用 _has_row_bg）
+        2. zone 内找所有纯背景色行（用 _is_pure_bg_row）
+        3. 取首条和末条纯背景色行作为边界对
+        4. 验证 region_end - region_start >= 2（至少 3 行：边界 + 内容行）
+
+        Returns: (region_start, region_end) 含边界行，或 None
+        """
+        zone_end: Optional[int] = None
+        zone_start: Optional[int] = None
+        for row in range(scan_limit, -1, -1):
+            if _has_row_bg(screen, row):
+                if zone_end is None:
+                    zone_end = row
+                zone_start = row
+            elif zone_end is not None:
+                break  # 遇到无 bg 行，zone 边界确定
+
+        if zone_start is None or zone_end is None:
+            return None
+
+        # 在 zone 内找所有纯背景色行（背景色区域边界候选）
+        pure_bg_rows = [r for r in range(zone_start, zone_end + 1)
+                        if _is_pure_bg_row(screen, r)]
+        if len(pure_bg_rows) < 2:
+            return None
+
+        region_start, region_end = pure_bg_rows[0], pure_bg_rows[-1]
+        # 区域至少 3 行（边界对 + 至少 1 行内容）
+        if region_end - region_start < 2:
+            return None
+
+        return region_start, region_end
+
+    def _determine_input_mode(
+        self, screen: pyte.Screen, region_start: int, content_rows: List[int]
+    ) -> str:
+        """判断背景色区域的布局模式：'option' 或 'normal'。
+
+        判断优先级：
+        1. 条件 4b：首个内容行行首是 ›，白色/亮色 → 'normal'
+        2. 条件 4a：上方依次是空行+分割线+空行 → 'option'
+        3. 条件 4c：内容行中有浅蓝色 › 且整行同色 → 'option'
+        4. 兜底：_has_numbered_options → 'option'，否则 'normal'
+        """
+        if not content_rows:
+            return 'normal'
+
+        # 条件 4b：首个内容行行首是 › + 白色/亮色 → normal
+        first_content = content_rows[0]
+        col0 = _get_col0(screen, first_content)
+        if col0 in CODEX_PROMPT_CHARS:
+            try:
+                char = screen.buffer[first_content][0]
+                fg = getattr(char, 'fg', 'default') or 'default'
+                if _is_white_color(fg) or _is_bright_color(fg):
+                    return 'normal'
+            except (KeyError, IndexError):
+                pass
+
+        # 条件 4a：上方有空行+分割线+空行 → option
+        if self._has_option_context_above(screen, region_start):
+            return 'option'
+
+        # 条件 4c：内容行中有浅蓝色 › 且整行同色 → option
+        for row in content_rows:
+            col0 = _get_col0(screen, row)
+            if col0 in CODEX_PROMPT_CHARS:
+                try:
+                    char = screen.buffer[row][0]
+                    fg = getattr(char, 'fg', 'default') or 'default'
+                    if _is_light_blue_color(fg) and self._is_whole_row_same_fg(screen, row, fg):
+                        return 'option'
+                except (KeyError, IndexError):
+                    pass
+
+        # 兜底：编号选项检测
+        if _has_numbered_options(screen, content_rows):
+            return 'option'
+
+        return 'normal'
+
+    def _has_option_context_above(self, screen: pyte.Screen, region_start: int) -> bool:
+        """检测条件 4a：背景色区域上方依次是
+        默认背景色空行 → 默认背景色普通分割线（─━═）→ 默认背景色空行
+        """
+        if region_start < 3:
+            return False
+
+        empty_below = region_start - 1
+        divider_row = region_start - 2
+        empty_above = region_start - 3
+
+        # 检查 empty_below：默认 bg + 无文字
+        if _get_row_dominant_bg(screen, empty_below) != 'default':
+            return False
+        if _get_row_text(screen, empty_below).strip():
+            return False
+
+        # 检查 divider_row：默认 bg + 含 ─━═ 字符
+        if _get_row_dominant_bg(screen, divider_row) != 'default':
+            return False
+        divider_text = _get_row_text(screen, divider_row).strip()
+        if not divider_text or not any(c in DIVIDER_CHARS for c in divider_text):
+            return False
+
+        # 检查 empty_above：默认 bg + 无文字
+        if _get_row_dominant_bg(screen, empty_above) != 'default':
+            return False
+        if _get_row_text(screen, empty_above).strip():
+            return False
+
+        return True
+
+    def _is_whole_row_same_fg(self, screen: pyte.Screen, row: int, expected_fg: str) -> bool:
+        """检查整行非空字符是否都有相同的前景色（条件 4c 的整行同色检测）"""
+        has_chars = False
+        for col in range(screen.columns):
+            try:
+                char = screen.buffer[row][col]
+                if not char.data.strip():
+                    continue
+                has_chars = True
+                fg = getattr(char, 'fg', 'default') or 'default'
+                if fg != expected_fg:
+                    return False
+            except (KeyError, IndexError):
+                continue
+        return has_chars
+
     def _find_chrome_boundary(self, screen: pyte.Screen, scan_limit: int) -> Optional[int]:
         """背景色检测：从底部往上找连续的非默认背景行（UI chrome）。
 
@@ -917,7 +1040,7 @@ class CodexParser(BaseParser):
         # UserInput：› U+203A（Codex 实际使用字符）或 > U+003E（兼容）
         if col0 in CODEX_PROMPT_CHARS:
             first_text = lines[0][1:].strip()
-            # 内容全是分割线字符（如 ❯─────...─）→ 装饰性分隔符，忽略
+            # 内容全是分割线字符（如 ›─────...─）→ 装饰性分隔符，忽略
             if not first_text or all(c in DIVIDER_CHARS for c in first_text):
                 return None
             # 收集后续续行（多行输入 / 屏幕自动换行），过滤尾部空白行
@@ -1092,7 +1215,7 @@ class CodexParser(BaseParser):
         if not input_rows:
             return None
 
-        # 入口检测：是否有编号选项行（需 ❯ 锚点）
+        # 入口检测：是否有编号选项行（需 > 锚点）
         if not _has_numbered_options(screen, input_rows):
             return None
 
@@ -1142,7 +1265,7 @@ class CodexParser(BaseParser):
             if NAV_RE.search(line):
                 continue
             # 编号选项行
-            m = re.match(r'^(?:>\s*)?(\d+)[.)]\s*(.+)', line)
+            m = re.match(r'^(?:[>❯›]\s*)?(\d+)[.)]\s*(.+)', line)
             if m:
                 if current_opt is not None:
                     options.append(current_opt)
@@ -1168,22 +1291,48 @@ class CodexParser(BaseParser):
         return None
 
     def _extract_input_area_text(self, screen: pyte.Screen, input_rows: List[int]) -> str:
-        """提取输入区提示符后的当前输入文本（空提示符返回空字符串）"""
-        for row in input_rows:
+        """提取输入区提示符后的当前输入文本（空提示符返回空字符串）。
+        选项交互模式下不提取输入文本（input_rows 是选项内容，非用户输入）。
+        多行输入时，收集 › 行之后首列为空的续行，合并为完整文本。
+        """
+        if self.last_layout_mode == 'option':
+            return ''
+        for i, row in enumerate(input_rows):
             if _get_col0(screen, row) in CODEX_PROMPT_CHARS:
                 text = _get_row_text(screen, row)[1:].strip()
                 # 排除纯分割线装饰行（如 ›─────）
                 if text and not all(c in DIVIDER_CHARS for c in text):
-                    return text
+                    # 收集续行（首列为空的非空文本行）
+                    lines = [text]
+                    for next_row in input_rows[i + 1:]:
+                        col0 = _get_col0(screen, next_row)
+                        if col0.strip():  # 首列有字符，遇到新 block 或新 › 行，停止
+                            break
+                        next_text = _get_row_text(screen, next_row).strip()
+                        if next_text:
+                            lines.append(next_text)
+                    return '\n'.join(lines)
         return ''
 
     def _extract_input_area_ansi_text(self, screen: pyte.Screen, input_rows: List[int]) -> str:
-        """提取输入区提示符后的当前输入文本（ANSI 版本）"""
-        for row in input_rows:
+        """提取输入区提示符后的当前输入文本（ANSI 版本）。
+        多行输入时，收集 › 行之后首列为空的续行，合并为完整文本。
+        """
+        if self.last_layout_mode == 'option':
+            return ''
+        for i, row in enumerate(input_rows):
             if _get_col0(screen, row) in CODEX_PROMPT_CHARS:
                 text = _get_row_text(screen, row)[1:].strip()
                 if text and not all(c in DIVIDER_CHARS for c in text):
-                    return _get_row_ansi_text(screen, row, start_col=1).strip()
+                    lines = [_get_row_ansi_text(screen, row, start_col=1).strip()]
+                    for next_row in input_rows[i + 1:]:
+                        col0 = _get_col0(screen, next_row)
+                        if col0.strip():  # 首列有字符，停止
+                            break
+                        next_text = _get_row_text(screen, next_row).strip()
+                        if next_text:
+                            lines.append(_get_row_ansi_text(screen, next_row).strip())
+                    return '\n'.join(lines)
         return ''
 
     def _parse_permission_area(
@@ -1193,8 +1342,8 @@ class CodexParser(BaseParser):
     ) -> Optional[OptionBlock]:
         """解析 1 条分割线布局下的权限确认区域，返回 OptionBlock(sub_type="permission")
 
-        检测条件：bottom_rows 中含 ❯ 锚点 + ≥2 个编号选项行。
-        通过 _find_contiguous_options 以 ❯ 为锚点双向扫描，只收集连续编号选项。
+        检测条件：bottom_rows 中含 > 锚点 + ≥2 个编号选项行。
+        通过 _find_contiguous_options 以 > 为锚点双向扫描，只收集连续编号选项。
         """
         if not bottom_rows:
             return None
@@ -1261,7 +1410,7 @@ class CodexParser(BaseParser):
         for i in range(first_opt_idx, last_opt_idx + 1):
             line, cat = classified[i]
             if cat == 'option':
-                m = re.match(r'^(?:>\s*)?(\d+)[.)]\s*(.+)', line)
+                m = re.match(r'^(?:[>❯›]\s*)?(\d+)[.)]\s*(.+)', line)
                 if m:
                     options.append({
                         'label': m.group(2).strip(),