mixhub-cli 0.1.0__py3-none-any.whl

agy_claude_filter.py

@@ -0,0 +1,1042 @@
+#!/usr/bin/env python3
+"""
+agy_claude_filter.py — Zero-latency PTY ANSI stream filter that transforms `agy`
+terminal output to match Claude Code's clean, low-noise visual palette:
+  1. User messages (`> ...`): Full-width dark-gray box (ANSI 236) + crisp white text (ANSI 255)
+  2. Assistant body text: Crisp pure white (ANSI 255) instead of bluish-purple tint (ANSI 189)
+  3. Markdown headings (`###`): Pure white bold (ANSI 255;1) instead of neon cyan (ANSI 39;1)
+  4. Inline code: Soft lavender text (ANSI 147, #afafff) with NO background block (49)
+  5. Subagent live context badge: `Agent(self: ...)` -> `Agent(Argon: ...) · ctx XXXk`
+  6. Mouse click-to-move-cursor in prompt input box (`> ...`): left-clicking any character
+     in the bottom prompt line moves the input cursor directly to that character.
+
+Set AGY_RAW_COLORS=1 to bypass filtering at any time.
+Non-interactive invocations (`-p` / `--print` / piped stdout) bypass the PTY completely.
+"""
+try:
+    import fcntl
+except ImportError:
+    fcntl = None
+import json
+import os
+try:
+    import pty
+except ImportError:
+    pty = None
+import re
+import select
+import signal
+import struct
+import sys
+try:
+    import termios
+except ImportError:
+    termios = None
+import time
+try:
+    import tty
+except ImportError:
+    tty = None
+import unicodedata
+
+def _resolve_real_agy() -> str:
+    env_bin = os.environ.get("AGY_REAL_BIN")
+    if env_bin and os.path.exists(env_bin):
+        return env_bin
+    bin_candidate = os.path.expanduser("~/.local/bin/agy-bin")
+    if os.path.exists(bin_candidate):
+        return bin_candidate
+    return os.path.expanduser("~/.local/bin/agy")
+
+
+REAL_AGY = _resolve_real_agy()
+SUB_LIVE_PATH = "/tmp/agy-subagent-live.json"
+ACTIVE_EXT_PATH = "/tmp/agy-active-ext.json"
+_IN_PTY_MAIN = False
+SUB_LIVE_CACHE = {"ts": 0.0, "model": "Argon", "role": "", "ctx": "", "ext_tag": ""}
+CURRENT_CID = ""
+AGENT_ROLE_RE = re.compile(rb"Agent\(self:\s*[^)\r\n]*\)")
+AGENT_TIMER_RE = re.compile(
+    rb"(Agent\([^\r\n]*?\xc2\xb7(?:\x1b\[[0-9;]*m|\s)*\d+(?:h\d+m|m(?:\d+s)?|s))(?!\s*\xc2\xb7\s*ctx)"
+)
+
+# Regexes to track single-line and multi-line wrapped prompt blocks and cursor coordinates in `agy` output
+PROMPT_HEAD_RE = re.compile(
+    rb"(?:\x1b\[K(?:>|\x1b\[[0-9;]*m>\x1b\[m) ([^\r\n\x1b]*)(?:\x1b\[\?7h)?(?:\x1b\[(\d+);(\d+)H|\x1b\[(\d+)G)?|\r\n(?:>|\x1b\[[0-9;]*m>\x1b\[m) ([^\r\n\x1b]*)(?=(?:(?:\x1b\[\?7l)?\r\n(?:\x1b\[\?7l)?(?:\x1b\[K)?  [^\r\n\x1b]*(?:\x1b\[K)?)*\r\n(?:\x1b\[[0-9;]*m)*\xe2\x94\x80))"
+)
+PROMPT_CONT_RE = re.compile(
+    rb"^(?:\x1b\[\?7l)?\r\n(?:\x1b\[\?7l)?(?:\x1b\[K)?  ([^\r\n\x1b]*)(?:\x1b\[K)?(?:\x1b\[\?7h)?(?:\x1b\[(\d+);(\d+)H|\x1b\[(\d+)G)?"
+)
+INCREMENTAL_WRAP_RE = re.compile(
+    rb"\r\n(?:\x1b\[\?7l)?(?:\x1b\[K)?  ([^\r\n\x1b]+)\x1b\[K\r\n(?:\x1b\[[0-9;]*m)*\xe2\x94\x80"
+)
+ASCII_FIRST_RE = re.compile(
+    rb"\x1b\[\?25l(?:\r|\n)*\x1b\[J\x1b\[\d+A\x1b\[2C([\x20-\x7e]+)\r?\n"
+)
+ASCII_INC_RE = re.compile(
+    rb"\x1b\[\?25l([\x20-\x7e]+)(?:\x1b\[(\d+)D)?\x1b\[\?25h"
+)
+ASCII_BS_RE = re.compile(rb"\x1b\[\?25l(?:(\x08+)|\x1b\[(\d+)D)\x1b\[\?25h")
+CURSOR_STEP_RE = re.compile(
+    rb"\x1b\[(\d+);(\d+)H|\x1b\[(\d+)G|\x1b\[(\d*)D|\x1b\[(\d*)C|\x1b\[(\d*)A|\x1bM|\x08"
+)
+FOOTER_CURSOR_RE = re.compile(rb"\r\x1b\[(\d*)A(?:\x1b\[(\d*)C)?\x1b\[\?25h")
+FOOTER_END_RE = re.compile(rb"\r\x1b\[(\d*)A(?:\x1b\[(\d*)C)?$")
+UP_ESCAPE_RE = re.compile(rb"\x1b\[(\d*)A|\x1bM")
+MOUSE_EVENT_RE = re.compile(
+    rb"\x1b\[<(\d+);(\d+);(\d+)([Mm])|\x1b\[M([\x20-\xff])([\x21-\xff])([\x21-\xff])"
+)
+SGR_MOUSE_RE = MOUSE_EVENT_RE
+DSR_REPLY_RE = re.compile(rb"\x1b\[(\d+);(\d+)R")
+
+
+def _char_disp_width(ch: str) -> int:
+    if not ch or ord(ch) < 32:
+        return 0
+    if ord(ch) < 127:
+        return 1
+    if unicodedata.combining(ch):
+        return 0
+    return 2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1
+
+
+def col_to_char_idx(prompt_text: str, target_col: int) -> int:
+    """
+    Map a 1-based terminal visual column (`target_col`, where `> ` or `  ` occupies cols 1..2
+    and character 0 starts at col 3) to character index `0..len(prompt_text)`.
+    For 2-column CJK characters occupying `[col, col + 1]`, clicking either half (`col` or `col + 1`)
+    selects that character (`idx`).
+    """
+    if target_col <= 3 or not prompt_text:
+        return 0
+    col = 3
+    for idx, ch in enumerate(prompt_text):
+        cw = _char_disp_width(ch)
+        if cw <= 0:
+            continue
+        if target_col < col + cw:
+            return idx
+        col += cw
+    return len(prompt_text)
+
+
+def char_idx_to_col(prompt_text: str, char_idx: int) -> int:
+    """Map a character index `0..len(prompt_text)` on a prompt line to its 1-based visual column."""
+    col = 3
+    for ch in prompt_text[:max(0, char_idx)]:
+        col += _char_disp_width(ch)
+    return col
+
+
+class PromptCursorTracker:
+    """
+    Tracks single-line and multi-line wrapped prompt text and cursor position from both stdin
+    keystrokes and `agy` ANSI stdout, converting visual `(row, col)` mouse clicks into exact
+    `\x1b[D` / `\x1b[C` character steps.
+    """
+    def __init__(self):
+        self.text = ""
+        self.lines: list[str] = [""]
+        self.top_row: int | None = None
+        self.cur_row: int | None = None
+        self.cur_col: int = 3
+        self.cur_idx: int = 0
+        self.cur_line_idx: int = 0
+        self.last_prompt_row: int | None = None
+        self.term_rows = 40
+        self.term_cols = 100
+        self._tail_buf = b""
+        self._stdin_utf8_buf = b""
+        self._stdin_esc_buf = b""
+        self._stdin_esc_ts = 0.0
+        self._in_paste = False
+        self._alt_screen = False
+        self.need_dsr = False
+        self._last_footer_down = 4
+        self._pending_stdin_left = 0
+        self._pending_stdin_chars = 0
+        self._allow_output_shrink = False
+
+    def reset(self) -> None:
+        self.text = ""
+        self.lines = [""]
+        self.top_row = None
+        self.cur_row = None
+        self.cur_col = 3
+        self.cur_idx = 0
+        self.cur_line_idx = 0
+        self.last_prompt_row = None
+        self._stdin_utf8_buf = b""
+        self._stdin_esc_buf = b""
+        self._stdin_esc_ts = 0.0
+        self._in_paste = False
+        self._pending_stdin_left = 0
+        self._pending_stdin_chars = 0
+        self._allow_output_shrink = False
+
+    def _sync_cursor_from_idx(self) -> None:
+        if not self.lines:
+            self.lines = [""]
+        self.cur_idx = max(0, min(len(self.text), self.cur_idx))
+        rem = self.cur_idx
+        for i, line in enumerate(self.lines):
+            if rem < len(line) or i == len(self.lines) - 1:
+                self.cur_line_idx = i
+                self.cur_col = char_idx_to_col(line, rem)
+                break
+            rem -= len(line)
+        if self.top_row is not None:
+            self.cur_row = self.top_row + self.cur_line_idx
+
+    def _recompute_lines(self) -> None:
+        if not self.text:
+            self.lines = [""]
+            self.cur_idx = 0
+            self.cur_line_idx = 0
+            self.cur_col = 3
+            if self.top_row is not None:
+                self.cur_row = self.top_row
+            return
+        avail_w = max(10, self.term_cols - 2)
+        lines: list[str] = []
+        cur_line: list[str] = []
+        cur_w = 0
+        for ch in self.text:
+            if ch == "\n":
+                lines.append("".join(cur_line))
+                cur_line = []
+                cur_w = 0
+                continue
+            cw = _char_disp_width(ch)
+            if cur_w + cw > avail_w and cur_line:
+                lines.append("".join(cur_line))
+                cur_line = [ch]
+                cur_w = cw
+            else:
+                cur_line.append(ch)
+                cur_w += cw
+        lines.append("".join(cur_line))
+        self.lines = lines or [""]
+        self._sync_cursor_from_idx()
+
+    def _move_word_left(self) -> None:
+        while self.cur_idx > 0 and self.text[self.cur_idx - 1].isspace():
+            self.cur_idx -= 1
+        while self.cur_idx > 0 and not self.text[self.cur_idx - 1].isspace():
+            self.cur_idx -= 1
+        self._sync_cursor_from_idx()
+
+    def _move_word_right(self) -> None:
+        n = len(self.text)
+        while self.cur_idx < n and not self.text[self.cur_idx].isspace():
+            self.cur_idx += 1
+        while self.cur_idx < n and self.text[self.cur_idx].isspace():
+            self.cur_idx += 1
+        self._sync_cursor_from_idx()
+
+    def _delete_word_left(self) -> bool:
+        old = self.cur_idx
+        while self.cur_idx > 0 and self.text[self.cur_idx - 1].isspace():
+            self.cur_idx -= 1
+        while self.cur_idx > 0 and not self.text[self.cur_idx - 1].isspace():
+            self.cur_idx -= 1
+        if self.cur_idx < old:
+            self.text = self.text[: self.cur_idx] + self.text[old:]
+            return True
+        return False
+
+    def feed_stdin(self, data: bytes) -> None:
+        if not data:
+            return
+        now = time.monotonic()
+        if self._stdin_esc_buf:
+            if now - self._stdin_esc_ts <= 0.05 and len(self._stdin_esc_buf) <= 512:
+                data = self._stdin_esc_buf + data
+            self._stdin_esc_buf = b""
+        buf = self._stdin_utf8_buf + data
+        self._stdin_utf8_buf = b""
+        i = 0
+        n = len(buf)
+        text_changed = False
+        while i < n:
+            b = buf[i]
+            if b == 0x1B:
+                if i + 1 >= n:
+                    self._stdin_esc_buf = buf[i:]
+                    self._stdin_esc_ts = now
+                    break
+                nxt = buf[i + 1]
+                if nxt == ord("["):
+                    j = i + 2
+                    while j < n and not (0x40 <= buf[j] <= 0x7E):
+                        j += 1
+                    if j >= n:
+                        if n - i <= 256:
+                            self._stdin_esc_buf = buf[i:]
+                            self._stdin_esc_ts = now
+                        break
+                    seq = buf[i : j + 1]
+                    i = j + 1
+                    if seq == b"\x1b[200~":
+                        self._in_paste = True
+                    elif seq == b"\x1b[201~":
+                        self._in_paste = False
+                    elif seq == b"\x1b[D":
+                        if self.cur_idx > 0:
+                            self.cur_idx -= 1
+                            self._pending_stdin_left += 1
+                            self._sync_cursor_from_idx()
+                    elif seq == b"\x1b[C":
+                        self._pending_stdin_left = 0
+                        if self.cur_idx < len(self.text):
+                            self.cur_idx += 1
+                            self._sync_cursor_from_idx()
+                    elif seq in (b"\x1b[H", b"\x1b[1~", b"\x1b[7~"):
+                        self._pending_stdin_left = 0
+                        self.cur_idx = 0
+                        self._sync_cursor_from_idx()
+                    elif seq in (b"\x1b[F", b"\x1b[4~", b"\x1b[8~"):
+                        self._pending_stdin_left = 0
+                        self.cur_idx = len(self.text)
+                        self._sync_cursor_from_idx()
+                    elif seq == b"\x1b[3~":
+                        self._pending_stdin_left = 0
+                        if 0 <= self.cur_idx < len(self.text):
+                            self.text = self.text[: self.cur_idx] + self.text[self.cur_idx + 1 :]
+                            text_changed = True
+                    elif seq in (b"\x1b[1;3D", b"\x1b[1;5D"):
+                        self._pending_stdin_left = 0
+                        self._move_word_left()
+                    elif seq in (b"\x1b[1;3C", b"\x1b[1;5C"):
+                        self._pending_stdin_left = 0
+                        self._move_word_right()
+                    elif seq in (b"\x1b[A", b"\x1b[B"):
+                        self._pending_stdin_left = 0
+                        self._allow_output_shrink = True
+                    continue
+                if nxt in (ord("]"), ord("P"), ord("_"), ord("^"), ord("X")):
+                    # OSC (`\x1b]...\x07` or `\x1b\\`), DCS (`\x1bP...\x1b\\`), APC/PM/SOS
+                    j = i + 2
+                    found_end = False
+                    while j < n:
+                        if buf[j] == 0x07:
+                            i = j + 1
+                            found_end = True
+                            break
+                        if buf[j] == 0x1B and j + 1 < n and buf[j + 1] == ord("\\"):
+                            i = j + 2
+                            found_end = True
+                            break
+                        j += 1
+                    if not found_end:
+                        if n - i <= 512:
+                            self._stdin_esc_buf = buf[i:]
+                            self._stdin_esc_ts = now
+                        break
+                    continue
+                if nxt == ord("O"):
+                    if i + 2 < n:
+                        code = buf[i + 2]
+                        i += 3
+                        if code == ord("D") and self.cur_idx > 0:
+                            self.cur_idx -= 1
+                            self._pending_stdin_left += 1
+                            self._sync_cursor_from_idx()
+                        elif code == ord("C") and self.cur_idx < len(self.text):
+                            self._pending_stdin_left = 0
+                            self.cur_idx += 1
+                            self._sync_cursor_from_idx()
+                        elif code == ord("H"):
+                            self._pending_stdin_left = 0
+                            self.cur_idx = 0
+                            self._sync_cursor_from_idx()
+                        elif code == ord("F"):
+                            self._pending_stdin_left = 0
+                            self.cur_idx = len(self.text)
+                            self._sync_cursor_from_idx()
+                        continue
+                    self._stdin_esc_buf = buf[i:]
+                    self._stdin_esc_ts = now
+                    break
+                i += 2
+                self._pending_stdin_left = 0
+                if nxt in (ord("b"), ord("B")):
+                    self._move_word_left()
+                elif nxt in (ord("f"), ord("F")):
+                    self._move_word_right()
+                elif nxt in (0x7F, 0x08):
+                    if self._delete_word_left():
+                        text_changed = True
+                continue
+            if b in (0x0D, 0x0A):
+                if self._in_paste:
+                    self.text = self.text[: self.cur_idx] + "\n" + self.text[self.cur_idx :]
+                    self.cur_idx += 1
+                    text_changed = True
+                else:
+                    self.reset()
+                    text_changed = False
+                i += 1
+            elif b in (0x7F, 0x08):
+                self._pending_stdin_left = 0
+                if self.cur_idx > 0:
+                    self.text = self.text[: self.cur_idx - 1] + self.text[self.cur_idx :]
+                    self.cur_idx -= 1
+                    text_changed = True
+                i += 1
+            elif b == 0x01:
+                self._pending_stdin_left = 0
+                self.cur_idx = 0
+                self._sync_cursor_from_idx()
+                i += 1
+            elif b == 0x05:
+                self._pending_stdin_left = 0
+                self.cur_idx = len(self.text)
+                self._sync_cursor_from_idx()
+                i += 1
+            elif b == 0x02:
+                if self.cur_idx > 0:
+                    self.cur_idx -= 1
+                    self._pending_stdin_left += 1
+                    self._sync_cursor_from_idx()
+                i += 1
+            elif b == 0x06:
+                self._pending_stdin_left = 0
+                if self.cur_idx < len(self.text):
+                    self.cur_idx += 1
+                    self._sync_cursor_from_idx()
+                i += 1
+            elif b == 0x04:
+                self._pending_stdin_left = 0
+                if 0 <= self.cur_idx < len(self.text):
+                    self.text = self.text[: self.cur_idx] + self.text[self.cur_idx + 1 :]
+                    text_changed = True
+                i += 1
+            elif b == 0x0B:
+                self._pending_stdin_left = 0
+                if self.cur_idx < len(self.text):
+                    self.text = self.text[: self.cur_idx]
+                    text_changed = True
+                i += 1
+            elif b == 0x15:
+                self._pending_stdin_left = 0
+                self.text = ""
+                self.cur_idx = 0
+                text_changed = True
+                i += 1
+            elif b == 0x17:
+                self._pending_stdin_left = 0
+                if self._delete_word_left():
+                    text_changed = True
+                i += 1
+            elif b == 0x03:
+                self.reset()
+                text_changed = False
+                i += 1
+            elif b == 0x09:
+                self._pending_stdin_left = 0
+                self._allow_output_shrink = True
+                i += 1
+            elif b < 0x20:
+                i += 1
+            else:
+                j = i
+                while j < n and buf[j] >= 0x20 and buf[j] != 0x7F and buf[j] != 0x1B:
+                    j += 1
+                chunk = buf[i:j]
+                i = j
+                self._pending_stdin_left = 0
+                s = ""
+                for trim in range(min(4, len(chunk))):
+                    try:
+                        s = (chunk[: len(chunk) - trim] if trim else chunk).decode("utf-8")
+                        if trim and i == n:
+                            self._stdin_utf8_buf = chunk[len(chunk) - trim :]
+                        break
+                    except UnicodeDecodeError:
+                        s = ""
+                else:
+                    s = chunk.decode("utf-8", errors="ignore")
+                if s:
+                    self.text = self.text[: self.cur_idx] + s + self.text[self.cur_idx :]
+                    self.cur_idx += len(s)
+                    self._pending_stdin_chars += len(s)
+                    text_changed = True
+        if text_changed:
+            self._recompute_lines()
+
+    def _row_col_to_char_idx(self, row: int | None, col: int, line_idx_hint: int | None = None) -> int:
+        if not self.lines:
+            return 0
+        if len(self.lines) == 1:
+            return col_to_char_idx(self.lines[0], col)
+        if self.top_row is not None and row is not None:
+            line_idx = max(0, min(len(self.lines) - 1, row - self.top_row))
+        elif line_idx_hint is not None:
+            line_idx = max(0, min(len(self.lines) - 1, line_idx_hint))
+        else:
+            line_idx = max(0, min(len(self.lines) - 1, self.cur_line_idx))
+        prefix_chars = sum(len(x) for x in self.lines[:line_idx])
+        return prefix_chars + col_to_char_idx(self.lines[line_idx], col)
+
+    def update_from_output(self, raw_bytes: bytes):
+        if not raw_bytes:
+            return
+        if b"\x1b[?1049h" in raw_bytes:
+            self._alt_screen = True
+        if b"\x1b[?1049l" in raw_bytes:
+            self._alt_screen = False
+        combined = self._tail_buf + raw_bytes
+        if len(combined) > 8192:
+            combined = combined[-8192:]
+        new_start = max(0, len(combined) - len(raw_bytes))
+        self._tail_buf = combined
+        buf = combined
+        matched_prompt_in_chunk = False
+        footer_handled_in_head = False
+
+        for m in PROMPT_HEAD_RE.finditer(buf):
+            raw_l0 = m.group(1) if m.group(1) is not None else m.group(5)
+            try:
+                line0 = (raw_l0 or b"").decode("utf-8", errors="ignore")
+            except Exception:
+                line0 = ""
+            r0 = int(m.group(2)) if m.group(2) else None
+            c0 = (
+                int(m.group(3))
+                if m.group(3)
+                else (int(m.group(4)) if m.group(4) else char_idx_to_col(line0, len(line0)))
+            )
+            lines = [line0]
+            cur_r = r0
+            cur_c = c0
+            pos = m.end()
+            while True:
+                cm = PROMPT_CONT_RE.match(buf[pos:])
+                if not cm:
+                    break
+                try:
+                    cont_txt = cm.group(1).decode("utf-8", errors="ignore")
+                except Exception:
+                    cont_txt = ""
+                if cont_txt.startswith("─"):
+                    break
+                lines.append(cont_txt)
+                if cm.group(2):
+                    cur_r = int(cm.group(2))
+                    cur_c = int(cm.group(3))
+                    if r0 is None:
+                        r0 = max(1, cur_r - (len(lines) - 1))
+                elif cm.group(4):
+                    if cur_r is not None:
+                        cur_r += 1
+                    cur_c = int(cm.group(4))
+                else:
+                    if cur_r is not None:
+                        cur_r += 1
+                    cur_c = char_idx_to_col(cont_txt, len(cont_txt))
+                pos += cm.end()
+
+            cur_line_idx = len(lines) - 1
+            after_prompt = buf[pos:]
+            show_idx = after_prompt.find(b"\x1b[?25h")
+            if show_idx != -1:
+                frame_slice = after_prompt[:show_idx]
+                end_with_tail = pos + show_idx + 6
+            else:
+                frame_slice = after_prompt[:64]
+                end_with_tail = pos + len(frame_slice)
+
+            if end_with_tail <= new_start:
+                continue
+
+            # Split at the first \r or \n so footer excursions (\n\n...\x1b[3A\x1b[58D) never corrupt prompt cur_c
+            nl_pos = -1
+            for k, ch_b in enumerate(frame_slice):
+                if ch_b in (0x0A, 0x0D):
+                    nl_pos = k
+                    break
+            intra_prompt_slice = frame_slice[:nl_pos] if nl_pos != -1 else frame_slice
+            footer_slice = frame_slice[nl_pos:] if nl_pos != -1 else b""
+
+            for sm in CURSOR_STEP_RE.finditer(intra_prompt_slice):
+                tok = sm.group(0)
+                if sm.group(1):  # \x1b[row;colH
+                    cand_r = int(sm.group(1))
+                    cand_c = int(sm.group(2))
+                    if r0 is None:
+                        r0 = max(1, cand_r - (len(lines) - 1))
+                    if r0 <= cand_r < r0 + len(lines):
+                        cur_r, cur_c = cand_r, cand_c
+                        cur_line_idx = cand_r - r0
+                elif sm.group(3):  # \x1b[colG
+                    cur_c = int(sm.group(3))
+                elif sm.group(4) is not None:  # \x1b[nD
+                    n = int(sm.group(4)) if sm.group(4) else 1
+                    cur_c = max(3, cur_c - n)
+                elif sm.group(5) is not None:  # \x1b[nC
+                    n = int(sm.group(5)) if sm.group(5) else 1
+                    cur_c += n
+                elif sm.group(6) is not None:  # \x1b[nA
+                    n = int(sm.group(6)) if sm.group(6) else 1
+                    if cur_r is not None:
+                        cur_r = max(1, cur_r - n)
+                    cur_line_idx = max(0, cur_line_idx - n)
+                elif tok == b"\x1bM":
+                    if cur_r is not None:
+                        cur_r = max(1, cur_r - 1)
+                    cur_line_idx = max(0, cur_line_idx - 1)
+                elif tok == b"\x08":
+                    cur_c = max(3, cur_c - 1)
+
+            if footer_slice and show_idx != -1:
+                fm_end = FOOTER_END_RE.search(footer_slice)
+                if fm_end:
+                    footer_body = footer_slice[: fm_end.start()]
+                    up_in_body = sum(
+                        (int(um.group(1)) if um.group(1) else 1)
+                        for um in UP_ESCAPE_RE.finditer(footer_body)
+                    )
+                    down_rows = max(0, footer_body.count(b"\n") - up_in_body)
+                    if down_rows > 0:
+                        self._last_footer_down = down_rows
+                    up_rows = int(fm_end.group(1)) if fm_end.group(1) else 1
+                    right_shift = int(fm_end.group(2)) if fm_end.group(2) else (1 if fm_end.group(2) is not None else 0)
+                    cur_line_idx = max(
+                        0, min(len(lines) - 1, (len(lines) - 1) + down_rows - up_rows)
+                    )
+                    if r0 is not None:
+                        cur_r = r0 + cur_line_idx
+                    if right_shift >= 2:
+                        cur_c = 1 + right_shift
+                    footer_handled_in_head = True
+
+            out_text = "".join(lines)
+            if r0 is not None:
+                self.top_row = r0
+            if (
+                self.text
+                and self.text.startswith(out_text)
+                and len(self.text) > len(out_text)
+                and not self._allow_output_shrink
+            ):
+                self._pending_stdin_chars = len(self.text) - len(out_text)
+                continue
+
+            self._allow_output_shrink = False
+            self._pending_stdin_left = 0
+            self._pending_stdin_chars = 0
+            self.lines = lines
+            self.text = out_text
+            self.cur_row = cur_r
+            self.cur_line_idx = cur_line_idx
+            self.cur_col = max(3, cur_c)
+            self.cur_idx = self._row_col_to_char_idx(self.cur_row, self.cur_col, line_idx_hint=cur_line_idx)
+            matched_prompt_in_chunk = True
+            if self.top_row is None and self.last_prompt_row is None:
+                self.need_dsr = True
+
+        matched_wrap_in_chunk = False
+        if not matched_prompt_in_chunk:
+            for wm in INCREMENTAL_WRAP_RE.finditer(raw_bytes):
+                try:
+                    cont_txt = wm.group(1).decode("utf-8", errors="ignore")
+                except Exception:
+                    cont_txt = ""
+                if cont_txt and not cont_txt.startswith("─"):
+                    if self.text.endswith(cont_txt) and len(self.text) > len(cont_txt):
+                        prefix = self.text[: -len(cont_txt)]
+                        self.lines = [prefix, cont_txt]
+                        self._sync_cursor_from_idx()
+                        matched_wrap_in_chunk = True
+
+            for fm1 in ASCII_FIRST_RE.finditer(raw_bytes):
+                try:
+                    first_s = fm1.group(1).decode("utf-8", errors="ignore")
+                except Exception:
+                    first_s = ""
+                if not first_s:
+                    continue
+                if self._pending_stdin_chars > 0:
+                    used = min(self._pending_stdin_chars, len(first_s))
+                    self._pending_stdin_chars -= used
+                    first_s = first_s[used:]
+                if first_s:
+                    self.text = self.text[: self.cur_idx] + first_s + self.text[self.cur_idx :]
+                    self.cur_idx += len(first_s)
+                    self._recompute_lines()
+
+            for im in ASCII_INC_RE.finditer(raw_bytes):
+                try:
+                    inc_s = im.group(1).decode("utf-8", errors="ignore")
+                except Exception:
+                    inc_s = ""
+                back_n = int(im.group(2)) if im.group(2) else 0
+                ins_len = max(0, len(inc_s) - back_n)
+                ins_s = inc_s[:ins_len]
+                if not ins_s:
+                    continue
+                if self._pending_stdin_chars > 0:
+                    used = min(self._pending_stdin_chars, len(ins_s))
+                    self._pending_stdin_chars -= used
+                    ins_s = ins_s[used:]
+                if ins_s:
+                    self.text = self.text[: self.cur_idx] + ins_s + self.text[self.cur_idx :]
+                    self.cur_idx += len(ins_s)
+                    self._recompute_lines()
+
+        for bm in ASCII_BS_RE.finditer(raw_bytes):
+            n_bs = len(bm.group(1)) if bm.group(1) else int(bm.group(2))
+            if self._pending_stdin_left > 0:
+                used = min(self._pending_stdin_left, n_bs)
+                self._pending_stdin_left -= used
+                n_bs -= used
+            if n_bs > 0:
+                self.cur_idx = max(0, self.cur_idx - n_bs)
+                self._sync_cursor_from_idx()
+
+        if not footer_handled_in_head:
+            for fm in FOOTER_CURSOR_RE.finditer(raw_bytes):
+                up_rows = int(fm.group(1)) if fm.group(1) else 1
+                right_shift = int(fm.group(2)) if fm.group(2) else (1 if fm.group(2) is not None else 0)
+                if right_shift >= 2 and (matched_prompt_in_chunk or matched_wrap_in_chunk or not self.text):
+                    down_rows = self._last_footer_down
+                    target_line_idx = max(
+                        0, min(len(self.lines) - 1, (len(self.lines) - 1) + down_rows - up_rows)
+                    )
+                    self.cur_line_idx = target_line_idx
+                    self.cur_col = 1 + right_shift
+                    self.cur_idx = self._row_col_to_char_idx(
+                        self.cur_row, self.cur_col, line_idx_hint=target_line_idx
+                    )
+                    self._sync_cursor_from_idx()
+                    if self.top_row is None and self.last_prompt_row is None:
+                        self.need_dsr = True
+
+    def arrows_for_click(self, click_col: int, click_row: int) -> bytes:
+        """Return `\x1b[D` or `\x1b[C` sequence to move cursor to `(click_row, click_col)` in prompt."""
+        if self._alt_screen or not self.text:
+            return b""
+        if self.top_row is not None:
+            # Accept clicks on any line of the prompt (`top_row .. top_row + len(lines) - 1`) with 1-row tolerance
+            if not (self.top_row - 1 <= click_row <= self.top_row + len(self.lines)):
+                return b""
+            line_idx = max(0, min(len(self.lines) - 1, click_row - self.top_row))
+        else:
+            if not (1 <= click_row <= self.term_rows):
+                return b""
+            if len(self.lines) == 1:
+                self.last_prompt_row = click_row
+                line_idx = 0
+            else:
+                if self.last_prompt_row is None or click_row < self.last_prompt_row:
+                    self.last_prompt_row = click_row
+                elif click_row - self.last_prompt_row > len(self.lines) + 2:
+                    self.last_prompt_row = click_row - (len(self.lines) - 1)
+                line_idx = max(0, min(len(self.lines) - 1, click_row - self.last_prompt_row))
+
+        prefix_chars = sum(len(x) for x in self.lines[:line_idx])
+        target_idx = prefix_chars + col_to_char_idx(self.lines[line_idx], click_col)
+        delta = target_idx - self.cur_idx
+        self.cur_idx = target_idx
+        self.cur_line_idx = line_idx
+        if self.top_row is not None:
+            self.cur_row = max(self.top_row, min(self.top_row + len(self.lines) - 1, click_row))
+        self.cur_col = char_idx_to_col(self.lines[line_idx], target_idx - prefix_chars)
+        if delta < 0:
+            self._pending_stdin_left += -delta
+            return b"\x1b[D" * (-delta)
+        if delta > 0:
+            self._pending_stdin_left = 0
+            return b"\x1b[C" * delta
+        return b""
+
+
+def _get_subagent_badge() -> tuple[str, str, str, str]:
+    now = time.monotonic()
+    if now - SUB_LIVE_CACHE["ts"] < 1.5:
+        return (
+            SUB_LIVE_CACHE["model"],
+            SUB_LIVE_CACHE["role"],
+            SUB_LIVE_CACHE["ctx"],
+            SUB_LIVE_CACHE["ext_tag"],
+        )
+    SUB_LIVE_CACHE["ts"] = now
+    model_str, role_str, ctx_str, ext_tag = "Argon", "", "", ""
+    allow_live = _IN_PTY_MAIN or (SUB_LIVE_PATH != "/tmp/agy-subagent-live.json") or (ACTIVE_EXT_PATH != "/tmp/agy-active-ext.json")
+    if allow_live:
+        try:
+            if os.path.exists(SUB_LIVE_PATH):
+                with open(SUB_LIVE_PATH, encoding="utf-8") as f:
+                    d = json.load(f)
+                by_cid = d.get("by_cid") or {}
+                entry = by_cid.get(CURRENT_CID) if (CURRENT_CID and CURRENT_CID in by_cid) else d
+                if isinstance(entry, dict) and time.time() - float(entry.get("ts") or 0) < 90:
+                    model_str = str(entry.get("model") or "Argon")
+                    raw_role = str(entry.get("role") or "").strip()
+                    role_str = re.sub(r"^(?:Flash|Argon)\s*[·:]\s*", "", raw_role, flags=re.I)
+                    ctx_str = str(entry.get("ctx") or "")
+        except Exception:
+            pass
+        try:
+            if os.path.exists(ACTIVE_EXT_PATH):
+                with open(ACTIVE_EXT_PATH, encoding="utf-8") as f:
+                    ae = json.load(f)
+                pid = int(ae.get("pid") or 0)
+                if pid > 0:
+                    os.kill(pid, 0)
+                    em = str(ae.get("model") or ae.get("tool") or "ext").replace("claude-", "")
+                    et = str(ae.get("title") or "顾问").strip()[:12]
+                    el = max(0, int(time.time() - float(ae.get("start_ts") or time.time())))
+                    ext_tag = f"  \x1b[38;5;141m◆\x1b[m Ext({em}: {et}) · {el}s"
+        except Exception:
+            pass
+    SUB_LIVE_CACHE["model"] = model_str
+    SUB_LIVE_CACHE["role"] = role_str
+    SUB_LIVE_CACHE["ctx"] = ctx_str
+    SUB_LIVE_CACHE["ext_tag"] = ext_tag
+    return model_str, role_str, ctx_str, ext_tag
+
+
+REPLACEMENTS = (
+    # 1. User message lines: full-width dark gray background box (48;5;236) + white text (38;5;255)
+    (b"\x1b[K\x1b[38;5;111;1m", b"\x1b[48;5;236m\x1b[K\x1b[38;5;255m"),
+    (b"\x1b[K\x1b[38;2;138;180;248;1m", b"\x1b[48;5;236m\x1b[K\x1b[38;5;255m"),
+    # 2. Inline code: remove background block (48;5;236 -> 49), use soft lavender foreground (38;5;147)
+    (b"\x1b[38;5;111;48;5;236", b"\x1b[38;5;147;49"),
+    (b"\x1b[38;2;138;180;248;48;5;236", b"\x1b[38;5;147;49"),
+    (b"\x1b[38;2;174;203;250;48;2;4;30;73", b"\x1b[38;5;147;49"),
+    (b"\x1b[38;2;138;180;248;48;2;4;30;73", b"\x1b[38;5;147;49"),
+    # 3. Markdown headings: pure white bold instead of bright cyan (38;5;39)
+    (b"\x1b[38;5;39;1m", b"\x1b[38;5;255;1m"),
+    (b"\x1b[38;5;39;49m", b"\x1b[38;5;255;49;1m"),
+    # 4. Assistant body text: crisp pure white (255) instead of bluish-tinted gray (189 / #e8eaed)
+    (b"\x1b[38;5;189m", b"\x1b[38;5;255m"),
+    (b"\x1b[38;5;189;", b"\x1b[38;5;255;"),
+    (b"\x1b[38;2;232;234;237m", b"\x1b[38;5;255m"),
+    (b"\x1b[38;2;232;234;237;", b"\x1b[38;5;255;"),
+    # 5. Input prompt `>`: crisp white instead of bright blue
+    (b"\x1b[38;5;111m>\x1b[m", b"\x1b[38;5;255;1m>\x1b[m"),
+    (b"\x1b[38;2;138;180;248m>\x1b[m", b"\x1b[38;5;255;1m>\x1b[m"),
+    # 6. Prevent `agy` from disabling outer terminal SGR mouse reporting (`?1000l` / `?1002l` / `?1003l` / `?1006l`)
+    (b"\x1b[?1000l", b"\x1b[?1000h\x1b[?1006h"),
+    (b"\x1b[?1002l", b"\x1b[?1000h\x1b[?1006h"),
+    (b"\x1b[?1003l", b"\x1b[?1000h\x1b[?1006h"),
+    (b"\x1b[?1006l", b"\x1b[?1000h\x1b[?1006h"),
+)
+
+MAX_PAT_LEN = max(len(src) for src, _ in REPLACEMENTS)
+
+
+def transform_chunk(data: bytes, carry: bytes = b"") -> tuple[bytes, bytes]:
+    """
+    Transform ANSI sequences in `carry + data`, holding back ONLY a trailing prefix that
+    could complete one of `REPLACEMENTS` across read boundaries (never trapping `\x1b[?25h`).
+    """
+    buf = carry + data
+    hold = b""
+    scan_start = max(0, len(buf) - MAX_PAT_LEN)
+    idx = buf.find(b"\x1b", scan_start)
+    while idx != -1:
+        tail = buf[idx:]
+        if any(src.startswith(tail) and tail != src for src, _ in REPLACEMENTS):
+            buf, hold = buf[:idx], tail
+            break
+        idx = buf.find(b"\x1b", idx + 1)
+    for src, dst in REPLACEMENTS:
+        if src in buf:
+            buf = buf.replace(src, dst)
+    if b"Agent(" in buf:
+        sub_mod, sub_role, sub_ctx, ext_tag = _get_subagent_badge()
+        if b"Agent(self:" in buf:
+            if sub_role:
+                buf = AGENT_ROLE_RE.sub(f"Agent({sub_mod}: {sub_role})".encode("utf-8"), buf)
+            else:
+                buf = buf.replace(b"Agent(self:", f"Agent({sub_mod}:".encode("utf-8"))
+        if (sub_ctx or ext_tag) and b"\xc2\xb7" in buf:
+            suffix_str = (f" · ctx {sub_ctx}" if sub_ctx else "") + ext_tag
+            buf = AGENT_TIMER_RE.sub(rb"\1" + suffix_str.encode("utf-8"), buf)
+    if b"\x1b[?1049l" in buf:
+        buf = buf + b"\x1b[?1000h\x1b[?1006h"
+    return buf, hold
+
+
+def filter_stdin_mouse(in_bytes: bytes, tracker: PromptCursorTracker) -> bytes:
+    """
+    Intercept SGR (`\x1b[<btn;col;rowM/m`) and X10 (`\x1b[M<cb><cx><cy>`) mouse sequences
+    and DSR replies (`\x1b[row;colR`), swallowing non-left-press mouse events so zero mouse
+    bytes ever leak into `agy`.
+    """
+    if tracker._alt_screen:
+        return in_bytes
+
+    if b"\x1b[" in in_bytes and b"R" in in_bytes:
+        for dm in DSR_REPLY_RE.finditer(in_bytes):
+            dsr_row = int(dm.group(1))
+            if 1 <= dsr_row <= tracker.term_rows:
+                tracker.last_prompt_row = max(1, dsr_row - tracker.cur_line_idx)
+        in_bytes = DSR_REPLY_RE.sub(b"", in_bytes)
+        if not in_bytes:
+            return b""
+
+    if b"\x1b[<" not in in_bytes and b"\x1b[M" not in in_bytes:
+        tracker.feed_stdin(in_bytes)
+        return in_bytes
+
+    out = bytearray()
+    last_end = 0
+    for m in MOUSE_EVENT_RE.finditer(in_bytes):
+        seg = in_bytes[last_end:m.start()]
+        if seg:
+            tracker.feed_stdin(seg)
+            out.extend(seg)
+        last_end = m.end()
+        if tracker._in_paste:
+            out.extend(m.group(0))
+            continue
+        if m.group(1) is not None:
+            btn = int(m.group(1))
+            col = int(m.group(2))
+            row = int(m.group(3))
+            act = m.group(4)
+            is_left_press = (btn == 0 and act == b"M")
+        else:
+            btn = m.group(5)[0] - 32
+            col = m.group(6)[0] - 32
+            row = m.group(7)[0] - 32
+            is_left_press = (btn == 0)
+        if is_left_press:
+            arrows = tracker.arrows_for_click(col, row)
+            if arrows:
+                out.extend(arrows)
+    tail_seg = in_bytes[last_end:]
+    if tail_seg:
+        tracker.feed_stdin(tail_seg)
+        out.extend(tail_seg)
+    return bytes(out)
+
+
+def sync_winsize(src_fd: int, dst_fd: int, tracker: PromptCursorTracker | None = None) -> None:
+    try:
+        ws = fcntl.ioctl(src_fd, termios.TIOCGWINSZ, b"\x00" * 8)
+        rows, cols, _, _ = struct.unpack("HHHH", ws)
+        if tracker is not None and rows > 0 and cols > 0:
+            tracker.term_rows = rows
+            tracker.term_cols = cols
+        fcntl.ioctl(dst_fd, termios.TIOCSWINSZ, ws)
+    except OSError:
+        pass
+
+
+def main(argv: list[str] | None = None) -> int:
+    global CURRENT_CID, _IN_PTY_MAIN, REAL_AGY
+    _IN_PTY_MAIN = True
+    args = list(sys.argv[1:] if argv is None else argv)
+    if args and os.path.isabs(args[0]) and os.path.isfile(args[0]) and os.access(args[0], os.X_OK):
+        REAL_AGY = args.pop(0)
+    else:
+        REAL_AGY = _resolve_real_agy()
+    for idx, a in enumerate(args):
+        if a in ("--conversation", "-c") and idx + 1 < len(args):
+            CURRENT_CID = args[idx + 1]
+            break
+    non_interactive = (
+        os.environ.get("AGY_RAW_COLORS") == "1"
+        or os.environ.get("AGY_FILTER_ACTIVE") == "1"
+        or not sys.stdin.isatty()
+        or not sys.stdout.isatty()
+        or any(
+            a in ("-p", "--print", "--prompt", "-v", "--version", "version", "help", "--help", "-h", "models", "mcp", "plugin", "plugins", "update", "auth", "login", "logout", "config", "completion")
+            for a in args
+        )
+    )
+    if non_interactive:
+        os.execvp(REAL_AGY, ["agy", *args])
+
+    if os.path.basename(sys.argv[0]) == "agy" and not any(
+        a == "--mode" or a.startswith("--mode=") for a in args
+    ):
+        args = ["--mode", "auto", *args]
+
+    os.environ["AGY_FILTER_ACTIVE"] = "1"
+    stdin_fd = sys.stdin.fileno()
+    stdout_fd = sys.stdout.fileno()
+    orig_termios = termios.tcgetattr(stdin_fd)
+    tracker = PromptCursorTracker()
+
+    pid, master_fd = pty.fork()
+    if pid == 0:
+        os.execvp(REAL_AGY, ["agy", *args])
+
+    sync_winsize(stdin_fd, master_fd, tracker)
+
+    def _on_sigwinch(signum, frame):
+        sync_winsize(stdin_fd, master_fd, tracker)
+        tracker.top_row = None
+        tracker.last_prompt_row = None
+        tracker.need_dsr = True
+        try:
+            os.kill(pid, signal.SIGWINCH)
+        except OSError:
+            pass
+
+    signal.signal(signal.SIGWINCH, _on_sigwinch)
+
+    carry = b""
+    # Enable SGR button click reporting (`?1000h` + `?1006h`); DSR (`\x1b[6n`) is queried after prompt renders
+    try:
+        os.write(stdout_fd, b"\x1b[?1000h\x1b[?1006h")
+    except OSError:
+        pass
+    try:
+        tty.setraw(stdin_fd)
+        while True:
+            rlist, _, _ = select.select([stdin_fd, master_fd], [], [])
+            if stdin_fd in rlist:
+                try:
+                    in_bytes = os.read(stdin_fd, 4096)
+                except OSError:
+                    break
+                if not in_bytes:
+                    break
+                filtered_in = filter_stdin_mouse(in_bytes, tracker)
+                if filtered_in:
+                    os.write(master_fd, filtered_in)
+            if master_fd in rlist:
+                try:
+                    out_bytes = os.read(master_fd, 65536)
+                except OSError:
+                    break
+                if not out_bytes:
+                    break
+                tracker.update_from_output(out_bytes)
+                transformed, carry = transform_chunk(out_bytes, carry)
+                if tracker.need_dsr:
+                    tracker.need_dsr = False
+                    transformed = transformed + b"\x1b[6n"
+                if transformed:
+                    os.write(stdout_fd, transformed)
+        if carry:
+            for src, dst in REPLACEMENTS:
+                carry = carry.replace(src, dst)
+            os.write(stdout_fd, carry)
+    finally:
+        try:
+            os.write(stdout_fd, b"\x1b[?1000l\x1b[?1006l")
+        except OSError:
+            pass
+        try:
+            termios.tcsetattr(stdin_fd, termios.TCSAFLUSH, orig_termios)
+        except termios.error:
+            pass
+        try:
+            os.close(master_fd)
+        except OSError:
+            pass
+
+    _, status = os.waitpid(pid, 0)
+    return os.waitstatus_to_exitcode(status)
+
+
+if __name__ == "__main__":
+    sys.exit(main())