comate-cli 0.12.1__tar.gz → 0.12.2__tar.gz

{comate_cli-0.12.1 → comate_cli-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.12.1
+Version: 0.12.2
 Summary: Comate terminal CLI built on comate-agent-sdk
 Project-URL: Homepage, https://github.com/AndyLee1024/agent-sdk
 Project-URL: Repository, https://github.com/AndyLee1024/agent-sdk
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <3.14,>=3.11
 Requires-Dist: charset-normalizer==3.4.7
-Requires-Dist: comate-agent-sdk<0.13,>=0.12.7
+Requires-Dist: comate-agent-sdk<0.13,>=0.12.8
 Requires-Dist: concurrent-log-handler>=0.9.25
 Requires-Dist: curl-cffi==0.13.0
 Requires-Dist: httpx<0.29.0,>=0.28.1

{comate_cli-0.12.1 → comate_cli-0.12.2}/comate_cli/terminal_agent/config/picker.py

@@ -15,7 +15,6 @@ from prompt_toolkit.layout.controls import FormattedTextControl
 from comate_cli.terminal_agent.figures import (
     EFFORT_HIGH,
     EFFORT_LOW,
-    HEAVY_HORIZONTAL,
     PLAY_ICON,
 )
 
@@ -217,11 +216,6 @@ class ConfigPickerUI:
             dont_extend_height=True,
             style="class:selection.title",
         )
-        divider = Window(
-            height=1,
-            char=HEAVY_HORIZONTAL,
-            style="class:selection.divider",
-        )
         self._content_window = Window(
             content=FormattedTextControl(self._content_fragments, focusable=True),
             wrap_lines=True,
@@ -234,4 +228,4 @@ class ConfigPickerUI:
             dont_extend_height=True,
             style="class:selection.body",
         )
-        return HSplit([header, divider, self._content_window, footer])
+        return HSplit([header, self._content_window, footer])

{comate_cli-0.12.1 → comate_cli-0.12.2}/comate_cli/terminal_agent/effort_menu.py

@@ -10,7 +10,7 @@ from typing import Any, Callable
 
 from comate_agent_sdk.agent.events import EffortSwitchedEvent
 from comate_agent_sdk.llm.effort import EFFORT_LADDER, EffortResolution, fold_down
-from comate_cli.terminal_agent.effort_style import effort_glyph, effort_style_str
+from comate_cli.terminal_agent.effort_style import ULTRACODE, effort_glyph, effort_style_str
 from comate_cli.terminal_agent.i18n import i18n, message
 from comate_cli.terminal_agent.output_style_menu import SCOPE_TAGS
 
@@ -21,8 +21,13 @@ _OPTION_TEXT = {
     "high": message.effort_option_high,
     "xhigh": message.effort_option_xhigh,
     "max": message.effort_option_max,
+    ULTRACODE: message.effort_option_ultracode,
 }
 
+# 刻度尺上的 7 格（左→右）；auto 不占格，用 `a` 键。ultracode 不是档位（rules/effort.md），
+# 在 CLI 层拆成 xhigh + 会话开关，只在这里当作第 7 格展示。
+RULER_VALUES: tuple[str, ...] = ("off", *EFFORT_LADDER, ULTRACODE)
+
 
 @dataclass(frozen=True, slots=True)
 class EffortMenuSpec:
@@ -31,8 +36,10 @@ class EffortMenuSpec:
     options: list[dict[str, Any]] = field(default_factory=list)
 
 
-def effort_level_label(level: str | None) -> str:
-    """档位名（None = auto）；auto 这个词整句跟随界面语言。"""
+def effort_level_label(level: str | None, *, ultracode: bool = False) -> str:
+    """档位名（None = auto）；auto 这个词整句跟随界面语言。开关开着时显示 ultracode。"""
+    if ultracode:
+        return i18n(message.effort_value_ultracode)
     return i18n(message.effort_value_auto) if level is None else level
 
 
@@ -109,6 +116,81 @@ def build_effort_menu(
     )
 
 
+@dataclass(frozen=True, slots=True)
+class EffortRulerSpec:
+    """横排刻度尺的纯数据：7 格 + 光标初始格 + 文案。渲染归 EffortRulerUI。"""
+
+    title: str
+    levels: list[dict[str, Any]] = field(default_factory=list)
+    current_value: str = "auto"
+    """光标初始格：档位名 / "ultracode"；auto 时落在模型默认档（没有就落 medium）。"""
+    faster_label: str = ""
+    smarter_label: str = ""
+    hint: str = ""
+
+
+def _level_note(level: str, resolution: EffortResolution) -> str:
+    """某一格的附注：不可关 / 会降级 / 不支持；正常时空串。ultracode 按 xhigh 判。"""
+    if level == "off":
+        return "" if resolution.can_disable_thinking else i18n(message.effort_option_cannot_disable)
+    probe = "xhigh" if level == ULTRACODE else level
+    if probe in resolution.available_levels:
+        return ""
+    target = fold_down(probe, resolution.available_levels)  # type: ignore[arg-type]
+    return (
+        i18n(message.effort_option_downgrade, applied=target)
+        if target
+        else i18n(message.effort_option_unsupported)
+    )
+
+
+def build_effort_ruler(
+    resolution: EffortResolution,
+    *,
+    model_name: str,
+    ultracode_enabled: bool,
+) -> EffortRulerSpec:
+    """`/effort` 刻度尺：off · low · medium · high · xhigh · max ┆ ultracode。
+
+    与竖排菜单同一套附注规则：不可用的格不隐藏不禁用，居中的备注行说清楚会降级成什么。
+    """
+    levels: list[dict[str, Any]] = []
+    for level in RULER_VALUES:
+        description = i18n(_OPTION_TEXT[level])
+        note = _level_note(level, resolution)
+        if note:
+            description = f"{description}  ({note})"
+        is_current = (
+            ultracode_enabled if level == ULTRACODE
+            else (not ultracode_enabled and resolution.requested == level)
+        )
+        levels.append(
+            {
+                "value": level,
+                "label": level,
+                "description": description,
+                "current": is_current,
+            }
+        )
+    if ultracode_enabled:
+        current_value = ULTRACODE
+    elif resolution.requested is not None:
+        current_value = resolution.requested
+    else:
+        # auto 没有格：光标落在模型默认档上，让"直接回车"等于"把 auto 固化成默认档"之前
+        # 用户能看见自己选了什么；没有默认档的开关型模型落 medium。
+        current_value = resolution.model_default or "medium"
+    del model_name  # 刻度尺不显示模型 / 默认档行（克制）；参数保留与竖排菜单签名对齐
+    return EffortRulerSpec(
+        title=i18n(message.effort_menu_title),
+        levels=levels,
+        current_value=current_value,
+        faster_label=i18n(message.effort_ruler_faster),
+        smarter_label=i18n(message.effort_ruler_smarter),
+        hint=i18n(message.effort_ruler_hint),
+    )
+
+
 def build_effort_confirm(
     *, previous: str | None, new: str | None, turn_count: int
 ) -> tuple[str, list[str], list[dict[str, Any]]]:
@@ -123,9 +205,19 @@ def build_effort_confirm(
     return title, context, options
 
 
-def effort_result_line(event: EffortSwitchedEvent, resolution: EffortResolution) -> str:
+def effort_result_line(
+    event: EffortSwitchedEvent,
+    resolution: EffortResolution,
+    *,
+    ultracode_before: bool = False,
+    ultracode_after: bool = False,
+    workflow_available: bool = True,
+) -> str:
     """切换结果行。
 
+    ultracode 两个布尔只改**措辞**（前后档位名显示成 ultracode），判据仍是 effort 解析结果；
+    开着 ultracode 但会话没有 Workflow 工具时补一行提示（Q24）。
+
     **以切换后的解析结果为准，不照抄 event.new。**用户要的和实际生效的会分叉：
     - **请求落空**：`applied=None` 且 `downgraded=False`（downgraded 要求 applied 非空）。
       判据是 `applied is None`，不是"用户选了 off"——`off` 只是其中一种措辞。
@@ -135,13 +227,17 @@ def effort_result_line(event: EffortSwitchedEvent, resolution: EffortResolution)
     - 环境变量设了 effort 时切 auto：会话层清了，env 层仍然赢，
       照抄 event.new 会说 "high → auto"，而菜单和 statusline 还显示 high。
     """
-    head, tail = _result_head_and_tail(event, resolution)
+    head, tail = _result_head_and_tail(
+        event, resolution, ultracode_before=ultracode_before, ultracode_after=ultracode_after
+    )
     tag = SCOPE_TAGS.get(event.persisted_scope or "")
     if tag:
         head = f"{head} {tag}"
     lines = [head]
     if tail is not None:
         lines.append(f"  {tail}")
+    if ultracode_after and not workflow_available:
+        lines.append(f"  {i18n(message.effort_ultracode_no_workflow_tool)}")
     if event.local_override is not None:
         lines.append(
             f"  {i18n(message.output_style_local_override_hint, name=event.local_override)}"
@@ -150,12 +246,18 @@ def effort_result_line(event: EffortSwitchedEvent, resolution: EffortResolution)
 
 
 def _result_head_and_tail(
-    event: EffortSwitchedEvent, resolution: EffortResolution
+    event: EffortSwitchedEvent,
+    resolution: EffortResolution,
+    *,
+    ultracode_before: bool = False,
+    ultracode_after: bool = False,
 ) -> tuple[str, str | None]:
     """结果主行 + 可选的第二行提示。落点标签由调用方挂在主行末尾。"""
-    prev = _label(event.previous)
-    asked = _label(event.new)
-    actual_requested = _label(resolution.requested)
+    prev = _label(event.previous, ultracode=ultracode_before)
+    asked = _label(event.new, ultracode=ultracode_after)
+    # "谁压着"这一判据比较的是**档位**：ultracode 开着时请求档就是 xhigh，
+    # 显示成 ultracode 只是措辞，不能让 "xhigh" != "ultracode" 触发 kept 分支。
+    actual_requested = _label(resolution.requested, ultracode=ultracode_after)
 
     if not resolution.supported:
         return (

comate_cli-0.12.2/comate_cli/terminal_agent/effort_ruler.py

@@ -0,0 +1,428 @@
+"""`/effort` 横排刻度尺组件：←/→ 沿刻度移动，▲ 骑线指示当前格。
+
+与 SelectionMenuUI 平级、复用 UIMode.SELECTION 的进出 / 按键通道（key_bindings 按
+`active` 分发）。内容是 9 行固定高度的单个 Window：
+
+  标题 / 空 / Faster‥Smarter / 刻度线 / 7 格 / 空 / 居中备注 / 空 / 提示
+
+档位 → 颜色 / 图标只经 effort_style；格子数据（附注、初始光标）只经
+effort_menu.build_effort_ruler，这里只管画。
+
+动效（全部由外部 frame_provider 驱动，本组件不起 task）：
+- max 选中：逐字彩虹流动（effort_style.rainbow_fragments）。
+- ultracode 选中：文字乱码解码 + 副标题右侧二进制流 + 彩色水波从格子中心向外铺满
+  整个组件区域。水波用 **背景色**——这是 rules/tui.md 的第二条具名例外
+  （2026-09-18，用户拍板），仅限本组件、仅限光标停在 ultracode 期间。
+性能：整块区域逐字符着色，单帧渲染耗时以 tests/test_effort_ruler.py 实测钉住上限。
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from prompt_toolkit.application.current import get_app_or_none
+from prompt_toolkit.layout.containers import Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.utils import get_cwidth
+
+from comate_cli.terminal_agent import theme
+from comate_cli.terminal_agent.effort_menu import EffortRulerSpec
+from comate_cli.terminal_agent.effort_style import (
+    ULTRACODE,
+    effort_color,
+    effort_style_str,
+    rainbow_fragments,
+)
+from comate_cli.terminal_agent.selection_menu import SelectionResult
+
+AREA_ROWS = 9
+_MENU_ROW = 4          # 7 格所在行（波源行，0 起算）
+_SPACING = 6           # 相邻格间距（列）
+_MARKER = "▲"
+_DIVIDER = "┆"         # Faster 段 / Smarter 段分界
+_TRACK = "─"
+_SCRAMBLE_CHARS = "!<>-_\\/[]{}=+*^?#01"  # 全窄字符，宽度安全
+_GREEN_BRIGHT = theme.EFFORT_RULER_DECODE_GREEN
+_GREEN_DIM = theme.EFFORT_RULER_STREAM_GREEN
+_DECODE_FRAMES = 6     # 6fps 下约 1 秒
+_BIN_STREAM_COLS = 20
+_RIPPLE_SPEED = 3.0    # 波前每帧推进列数（6fps）
+_TRACK_COLOR = theme.EFFORT_RULER_TRACK
+_LABEL_COLOR = theme.TEXT_FAINT
+_FALLBACK_COLUMNS = 80
+_MIN_COLUMNS = 40
+
+
+def _option_text(label: str) -> str:
+    return f" {label} "
+
+
+def _hash01(a: int, b: int) -> float:
+    """帧驱动的确定性伪随机（0~1）：可测试，不依赖 random。"""
+    h = (a * 2654435761 + b * 97531) & 0xFFFFFFFF
+    return ((h ^ (h >> 13)) % 10007) / 10007
+
+
+@dataclass(slots=True)
+class _RulerState:
+    spec: EffortRulerSpec | None = None
+    index: int = 0
+    cols: dict[int, int] = field(default_factory=dict)
+    scale_width: int = 0
+    divider_col: int = 0
+    ultra_index: int = -1
+    ultra_enter_frame: int | None = None
+    """光标最近一次落到 ultracode 格时的帧号；None = 不在 ultracode 上。"""
+
+
+class EffortRulerUI:
+    def __init__(self, *, size_provider: Callable[[], tuple[int, int]] | None = None) -> None:
+        self._size_provider = size_provider
+        self._state = _RulerState()
+        self._on_confirm: Callable[[str, bool], None] | None = None
+        self._on_cancel: Callable[[], None] | None = None
+        self._frame_provider: Callable[[], int] | None = None
+        self._control = FormattedTextControl(
+            text=self._area_fragments, focusable=True, show_cursor=False
+        )
+        self._window = Window(
+            content=self._control,
+            height=AREA_ROWS,
+            dont_extend_height=True,
+            style="class:selection.body",
+            always_hide_cursor=True,
+        )
+
+    # ── 生命周期 ────────────────────────────────────────────────────────
+
+    @property
+    def container(self) -> Window:
+        return self._window
+
+    def focus_target(self) -> Window:
+        return self._window
+
+    @property
+    def active(self) -> bool:
+        return self._state.spec is not None
+
+    @property
+    def numbered(self) -> bool:
+        """数字键 1..7 直跳（与 SelectionMenuUI.numbered 同名，key_bindings 统一判）。"""
+        return self.active
+
+    @property
+    def animates(self) -> bool:
+        """需要按帧重绘：光标停在 max（彩虹）或 ultracode（水波）上。"""
+        if not self.active or self._frame_provider is None:
+            return False
+        return self._selected_value() in ("max", ULTRACODE)
+
+    def can_toggle(self) -> bool:
+        return False
+
+    def set_levels(
+        self,
+        spec: EffortRulerSpec,
+        *,
+        on_confirm: Callable[[str, bool], None] | None = None,
+        on_cancel: Callable[[], None] | None = None,
+        frame_provider: Callable[[], int] | None = None,
+    ) -> bool:
+        if not spec.levels:
+            return False
+        cols: dict[int, int] = {}
+        col = 0
+        for i, level in enumerate(spec.levels):
+            cols[i] = col
+            col += get_cwidth(_option_text(str(level["label"]))) + _SPACING
+        ultra_index = next(
+            (i for i, level in enumerate(spec.levels) if level["value"] == ULTRACODE), -1
+        )
+        last = len(spec.levels) - 1
+        scale_width = cols[last] + get_cwidth(_option_text(str(spec.levels[last]["label"])))
+        divider_col = (cols[ultra_index] - _SPACING // 2) if ultra_index > 0 else -1
+        self._state = _RulerState(
+            spec=spec,
+            index=0,
+            cols=cols,
+            scale_width=scale_width,
+            divider_col=divider_col,
+            ultra_index=ultra_index,
+        )
+        self._on_confirm = on_confirm
+        self._on_cancel = on_cancel
+        self._frame_provider = frame_provider
+        self.select_value(spec.current_value)
+        return True
+
+    def clear(self) -> None:
+        self._state = _RulerState()
+        self._on_confirm = None
+        self._on_cancel = None
+        self._frame_provider = None
+
+    def refresh(self) -> None:
+        self._control.text = self._area_fragments
+
+    # ── 光标 ────────────────────────────────────────────────────────────
+
+    def _frame(self) -> int:
+        return int(self._frame_provider()) if self._frame_provider is not None else 0
+
+    def _selected_value(self) -> str | None:
+        spec = self._state.spec
+        if spec is None:
+            return None
+        return str(spec.levels[self._state.index]["value"])
+
+    def get_selected(self) -> dict[str, Any] | None:
+        spec = self._state.spec
+        return None if spec is None else spec.levels[self._state.index]
+
+    def _set_index(self, index: int) -> None:
+        old = self._state.index
+        self._state.index = index
+        if index == self._state.ultra_index and old != index:
+            # 重新落到 ultracode：石头再次落下（水波 / 解码从头来）
+            self._state.ultra_enter_frame = self._frame()
+        elif index != self._state.ultra_index:
+            self._state.ultra_enter_frame = None
+
+    def move_selection(self, delta: int) -> None:
+        spec = self._state.spec
+        if spec is None:
+            return
+        self._set_index((self._state.index + delta) % len(spec.levels))
+
+    def select_number(self, number: int) -> bool:
+        spec = self._state.spec
+        if spec is None or number < 1 or number > len(spec.levels):
+            return False
+        self._set_index(number - 1)
+        return True
+
+    def select_value(self, value: str) -> bool:
+        spec = self._state.spec
+        if spec is None:
+            return False
+        for i, level in enumerate(spec.levels):
+            if level["value"] == value:
+                self._set_index(i)
+                return True
+        return False
+
+    # ── 结果 ────────────────────────────────────────────────────────────
+
+    def confirm(self, *, session_only: bool = False) -> SelectionResult | None:
+        """Enter（落盘）/ s（仅本会话）确认光标所在格。"""
+        value = self._selected_value()
+        if value is None:
+            return None
+        return self._emit(value, session_only)
+
+    def confirm_auto(self, *, session_only: bool = False) -> SelectionResult | None:
+        """`a` 键：auto 不占格，直接交卷。"""
+        if not self.active:
+            return None
+        return self._emit("auto", session_only)
+
+    def _emit(self, value: str, session_only: bool) -> SelectionResult:
+        if self._on_confirm is not None:
+            self._on_confirm(value, session_only)
+        return SelectionResult(confirmed=True, value=value, label=value)
+
+    def cancel(self) -> SelectionResult:
+        if self._on_cancel is not None:
+            self._on_cancel()
+        return SelectionResult(confirmed=False)
+
+    # ── 渲染 ────────────────────────────────────────────────────────────
+
+    def _columns(self) -> int:
+        if self._size_provider is not None:
+            _rows, cols = self._size_provider()
+            return max(_MIN_COLUMNS, int(cols))
+        app = get_app_or_none()
+        if app is None:
+            return _FALLBACK_COLUMNS
+        try:
+            return max(_MIN_COLUMNS, int(app.output.get_size().columns))
+        except Exception:
+            return _FALLBACK_COLUMNS
+
+    def _decode_clock(self) -> int:
+        enter = self._state.ultra_enter_frame
+        if enter is None:
+            return _DECODE_FRAMES
+        return min(_DECODE_FRAMES, self._frame() - enter)
+
+    def _decode_frags(self, text: str, solved_color: str, col_base: int) -> list[tuple[str, str]]:
+        """scramble 逐字解码：左到右按时钟解出真字符，未解出的位置滚动亮绿乱码。"""
+        clock = self._decode_clock()
+        if clock >= _DECODE_FRAMES:
+            return [(f"fg:{solved_color} bold", text)]
+        solved = math.ceil(len(text) * clock / _DECODE_FRAMES)
+        frame = self._frame()
+        frags: list[tuple[str, str]] = []
+        for k, ch in enumerate(text):
+            if k < solved:
+                frags.append((f"fg:{solved_color} bold", ch))
+            else:
+                idx = int(_hash01(col_base + k, frame) * len(_SCRAMBLE_CHARS))
+                frags.append((f"fg:{_GREEN_BRIGHT}", _SCRAMBLE_CHARS[idx]))
+        return frags
+
+    def _menu_fragments(self) -> list[tuple[str, str]]:
+        st = self._state
+        spec = st.spec
+        assert spec is not None
+        frags: list[tuple[str, str]] = []
+        col = 0
+        frame = self._frame()
+        for i, level in enumerate(spec.levels):
+            gap = st.cols[i] - col
+            if gap > 0:
+                frags.append(("", " " * gap))
+                col = st.cols[i]
+            value = str(level["value"])
+            text = _option_text(str(level["label"]))
+            if i == st.index:
+                if value == "max":
+                    frags.extend(rainbow_fragments(text, frame=frame))
+                elif value == ULTRACODE:
+                    frags.extend(self._decode_frags(text, effort_color(value), st.cols[i]))
+                else:
+                    frags.append((f"{effort_style_str(value)} bold", text))
+            else:
+                frags.append((effort_style_str(value), text))
+            col += get_cwidth(text)
+        return frags
+
+    def _scale_fragments(self) -> list[tuple[str, str]]:
+        st = self._state
+        spec = st.spec
+        assert spec is not None
+        sel_label = str(spec.levels[st.index]["label"])
+        sel_center = st.cols[st.index] + (get_cwidth(_option_text(sel_label)) - 1) // 2
+        chars = [_TRACK] * st.scale_width
+        if 0 <= st.divider_col < st.scale_width:
+            chars[st.divider_col] = _DIVIDER
+        chars[sel_center] = _MARKER
+        # ┆ 右侧是 Smarter 段（ultracode 专属），刻度线跟 ultracode 同色，让"这一段不一样"
+        # 在没选中它时也看得出来。
+        ultra_color = effort_color(ULTRACODE)
+        frags: list[tuple[str, str]] = []
+        i = 0
+        while i < st.scale_width:
+            ch = chars[i]
+            j = i
+            while j < st.scale_width and chars[j] == ch:
+                j += 1
+            if ch == _MARKER:
+                frags.append((f"fg:{effort_color(self._selected_value() or 'low')} bold", _MARKER))
+            elif ch == _DIVIDER:
+                frags.append((f"fg:{_LABEL_COLOR}", _DIVIDER))
+            elif st.divider_col >= 0 and i > st.divider_col:
+                frags.append((f"fg:{ultra_color}", _TRACK * (j - i)))
+            else:
+                frags.append((f"fg:{_TRACK_COLOR}", _TRACK * (j - i)))
+            i = j
+        return frags
+
+    def _subtitle_fragments(self, sub_col: int, term_w: int) -> list[tuple[str, str]]:
+        """备注 = 光标所在格的说明（含降级附注），独占一行、居中；
+        ultracode 同步解码 + 二进制流。"""
+        st = self._state
+        spec = st.spec
+        assert spec is not None
+        text = str(spec.levels[st.index]["description"])
+        if self._selected_value() != ULTRACODE:
+            return [(f"fg:{_LABEL_COLOR}", text)]
+        frags = self._decode_frags(text, _LABEL_COLOR, st.cols[st.ultra_index])
+        if self._decode_clock() >= _DECODE_FRAMES:
+            stream_start = sub_col + get_cwidth(text) + 2
+            avail = min(_BIN_STREAM_COLS, term_w - stream_start)
+            if avail > 0:
+                frame = self._frame()
+                stream = "".join(
+                    "01"[int(_hash01(stream_start + k, frame) * 2)] for k in range(avail)
+                )
+                frags.append((f"fg:{_GREEN_DIM}", "  " + stream))
+        return frags
+
+    def _fill_frames(self, term_w: int, src_col: int) -> int:
+        max_dist = math.hypot(max(src_col, term_w - 1 - src_col), AREA_ROWS)
+        return math.ceil(max_dist / _RIPPLE_SPEED)
+
+    def _ripple_style(self, row: int, col: int, ctx: tuple[int, float, bool]) -> str | None:
+        """ultracode 选中时的彩色水波（背景色，rules/tui.md 具名例外）。"""
+        src_col, front, spreading = ctx
+        dist = math.hypot(col - src_col, row - _MENU_ROW)
+        if dist > front:
+            return None
+        if spreading and front - dist <= 1.5:
+            return theme.EFFORT_RULER_RIPPLE_FRONT
+        wob = math.sin(dist * 0.8 - self._frame() * 0.7) * 1.5
+        band = int(dist + wob)
+        palette = theme.EFFORT_RAINBOW_COLORS
+        return f"bg:{palette[band % len(palette)]} fg:{theme.EFFORT_RULER_RIPPLE_TEXT} bold"
+
+    def _area_fragments(self) -> list[tuple[str, str]]:
+        st = self._state
+        spec = st.spec
+        if spec is None:
+            return []
+        term_w = self._columns()
+        pad = max(0, (term_w - st.scale_width) // 2)
+        label_gap = max(
+            1, st.scale_width - get_cwidth(spec.faster_label) - get_cwidth(spec.smarter_label)
+        )
+        sel_desc = str(spec.levels[st.index]["description"])
+        # 备注独占一行、整行居中，不跟光标左右跳（跟着跳会让眼睛同时追两处）。
+        # 标题行不再带"当前档"、也没有模型/默认档行：克制，刻度上的 ▲ 已经说明一切。
+        sub_col = max(0, (term_w - get_cwidth(sel_desc)) // 2)
+        rows: list[list[tuple[str, str]]] = [
+            [("class:selection.title", "  " + spec.title)],
+            [("", "")],
+            [
+                ("", " " * pad),
+                (f"fg:{_LABEL_COLOR}", spec.faster_label),
+                ("", " " * label_gap),
+                (f"fg:{_LABEL_COLOR}", spec.smarter_label),
+            ],
+            [("", " " * pad), *self._scale_fragments()],
+            [("", " " * pad), *self._menu_fragments()],
+            [("", "")],
+            [("", " " * sub_col), *self._subtitle_fragments(sub_col, term_w)],
+            [("", "")],
+            [(f"fg:{_LABEL_COLOR}", "  " + spec.hint)],
+        ]
+        on_ultra = self._selected_value() == ULTRACODE and st.ultra_enter_frame is not None
+        if on_ultra:
+            # 每行右侧补齐到终端宽（水波才有字符可染），再逐字符按距离着色
+            padded: list[list[tuple[str, str]]] = []
+            for row in rows:
+                width = sum(get_cwidth(t) for _, t in row)
+                padded.append(row if width >= term_w else [*row, ("", " " * (term_w - width))])
+            rows = padded
+            src_col = pad + st.cols[st.ultra_index] + get_cwidth(_option_text(ULTRACODE)) // 2
+            spread = self._frame() - st.ultra_enter_frame  # type: ignore[operator]
+            spreading = spread < self._fill_frames(term_w, src_col)
+            ctx = (src_col, spread * _RIPPLE_SPEED, spreading)
+        frags: list[tuple[str, str]] = []
+        for r, row_frags in enumerate(rows):
+            if on_ultra:
+                col = 0
+                for style, text in row_frags:
+                    for ch in text:
+                        ripple = self._ripple_style(r, col, ctx)
+                        frags.append((ripple or style, ch))
+                        col += get_cwidth(ch)
+            else:
+                frags.extend(row_frags)
+            if r < AREA_ROWS - 1:
+                frags.append(("", "\n"))
+        return frags