comate-cli 0.12.4b9__tar.gz → 0.12.4b11__tar.gz

{comate_cli-0.12.4b9 → comate_cli-0.12.4b11}/CONTEXT.md

@@ -1,6 +1,16 @@
 # Comate CLI Domain Model
 
-Canonical language for Comate CLI command discovery, transient terminal display, session reporting boundaries, and plugin auto update.
+Canonical language for Comate CLI command discovery, slash input completion, menu panels, transient terminal display, session reporting boundaries, and plugin auto update.
+
+## Menu Panel Language
+
+**Menu Panel（菜单面板）**:
+由 slash 命令打开的暂态操作界面。多个菜单使用一致的视觉与导航规则，关闭后返回对话输入。
+_Avoid_: menu output（菜单输出）, history block（历史块）
+
+**Settings Edit Session（设置编辑会话）**:
+从打开设置面板到保留或取消更改的一次编辑过程。更改即时保存；保留操作接受这些更改，取消操作撤销本次仍未被外部再次修改的更改。
+_Avoid_: settings draft（设置草稿）, save-on-close（关闭时才保存）
 
 ## Slash Command Language
 
@@ -19,6 +29,30 @@ Describes how a registered command is dispatched. Values: `"builtin"` (hardcoded
 The slash entry of a runtime skill that is enabled and user-invocable. Its name is the skill's call name; plugin skills carry a `namespace:` prefix and so never collide with plain names. A skill that is disabled or declares `user-invocable: false` has no slash entry and claims no name. When its name is shadowed by a higher-priority command, the skill stays callable by the model through the Skill tool; only the slash entry is lost, and the user is told once per name per process.
 _Avoid_: skill command (ambiguous with custom command)
 
+**Skill Slash Mention**:
+A complete call name of a model-visible skill appearing in prose with a valid whitespace/punctuation boundary before and after. A mention is the authorization fact that drives the model-visible reminder injection and, together with Inline Skill Invocation, the in-prose highlight; a typing-in-progress prefix is never a mention.
+_Avoid_: slash reference, skill authorization (names the effect), partial mention
+
+**Inline Skill Invocation**:
+A complete call name of a user-only skill (user-invocable, `disable-model-invocation: true`) appearing in prose with the same boundaries as a Skill Slash Mention. The system loads that skill's prompt into the user's turn right after the user's text, the way a Head Slash call does; it never authorizes the model.
+_Avoid_: inline slash command, middle slash invocation, mention (names the authorization path)
+
+**Skill Slash Token**:
+The incomplete slash-prefixed fragment at the cursor while typing: the slash plus the name characters typed so far, whitespace-free. The raw material of middle skill completion. It becomes a Skill Slash Mention only when the typed characters are the complete call name.
+_Avoid_: partial mention, prefix mention
+
+**Head Slash / Middle Slash**:
+The two position classes of a Skill Slash Token in the input box. Head Slash: the whole buffer is one token — the head command menu's territory, matched by subsequence fuzzy completion. Middle Slash: a token after a whitespace boundary inside the buffer — the middle skill completion's territory, matched by Trailing Segment Match. A slash at the start of a later line is a Middle Slash; only buffer position zero is Head.
+_Avoid_: 行首/中段 as canonical terms, line-initial slash (wrong for later lines), in-prose slash
+
+**Trailing Segment Match**:
+The matching semantics of middle skill completion: a Skill Slash Command matches when its full name, or the segment after its last namespace colon, starts with the typed name characters case-insensitively. `/grill` matches `mattpocock-skills:grilling` via its trailing segment. Mention judgment never follows this relaxation.
+_Avoid_: substring match, fuzzy match (the head menu's semantics)
+
+**Middle Slash Preview**:
+The gray text after a Middle Slash token at the end of the input: the remaining characters of the chosen Skill Slash Command's name, or of its trailing segment when it matches through that segment alone. It is display-only; only Tab acts on it, and Tab always writes the full slash name.
+_Avoid_: ghost text, inline suggestion, 灰字建议
+
 **Source Axis** (`CustomSlashCommand.source_scope`):
 Describes where a markdown-template command's definition lives. Values: `"project"`, `"user"`, `"plugin"`, `"default"`. Determines override priority only.
 
@@ -46,6 +80,14 @@ _Avoid_: typewriter effect (that is character-level), throttling (that is the sc
 The short English phrase in the breathing-yellow part of the loading line's status suffix, shown only while the model thinks and thinking display is off. It names the thinking effort that the in-flight request actually uses (the applied level, or ultracode when that switch is on). It is chosen when a request starts to think and does not change until that request ends. When no applied level is known, it shows the neutral word `thinking`. It is a word, not a color: it never takes the effort level colors.
 _Avoid_: effort badge, hidden thinking label, random thinking word
 
+**Tool Args Progress**:
+The `↓ N tokens` part of the loading line's status suffix: an estimate of how large the arguments of the tool call the model is still generating have grown so far. It appears only after the arguments pass a visibility threshold, and it can only move when the provider delivers the arguments incrementally; a provider that delivers them in one piece at the end leaves nothing to show. It concerns the main agent's in-flight request only.
+_Avoid_: token 下行状态 (reads as network bytes), download progress, output token counter
+
+**Buffered Tool Args**:
+A provider behavior in which a streaming response holds back a tool call's name and arguments and delivers them in one piece at the end, instead of incrementally as they are generated. While it lasts, nothing tells the CLI that a tool call has begun, so Tool Args Progress cannot appear. Some endpoints buffer by default and stream incrementally only when the request opts in.
+_Avoid_: 攒包, non-streaming tool call (the response is still a stream)
+
 **Immutable Scrollback Commit**:
 The point at which staged terminal output is appended to terminal scrollback and can no longer be replaced. An open Streaming Markdown Container remains transient until its closing boundary or a normal turn boundary makes it complete.
 _Avoid_: history render, live Markdown rerender
@@ -114,6 +156,16 @@ _Avoid_: auto update enablement (inverted semantics), plugin pin (no version pin
 The invariant that an update changes only on-disk plugin state. The running session keeps its already-loaded resources until the next startup or an explicit user reload. A background update therefore never shifts agent behavior mid-session.
 _Avoid_: hot reload, live update
 
+## Plugin Marketplace Language
+
+**Marketplace Source**:
+The coordinate a user types to reach a marketplace: a GitHub `owner/repo` shorthand, a git URL (https or ssh), or a direct `marketplace.json` URL. It is only an address; it carries no name.
+_Avoid_: marketplace url (too narrow), repo (only one of the forms)
+
+**Marketplace**:
+A registered plugin source, named by its own manifest rather than by whatever the user typed. One Marketplace Source resolves to at most one Marketplace, however it is spelled.
+_Avoid_: plugin store, registry (the registry is the collection of Marketplaces)
+
 ## CLI Self-Update Language
 
 **Self-Update**:
@@ -220,6 +272,16 @@ _Avoid_: todo panel, tasklist (spoken shorthand only)
 A state in which the run is alive but does not advance any task: context compaction in progress, or an LLM retry backoff countdown. Only the countdown counts as Stall Status; the retried request itself does not.
 _Avoid_: blocking status ("blocking" in this repo means blocking the event loop), waiting state
 
+## Event Loop Health Language
+
+**Event Loop Lag**:
+The measured gap between two consecutive UI ticks that exceeds the lag threshold. It tells how long the loop did not run, not where it was stuck. A lag that occurs while the TUI is idle is still an Event Loop Lag; whether it is recorded is a detector choice, not part of the term.
+_Avoid_: slow turn (an awaited operation that is slow does not stop the loop), UI stutter
+
+**Loop Freeze Snapshot**:
+The main-thread stack captured from outside the loop while an Event Loop Lag is still in progress, together with the most recent first-turn phase name. It is the attribution evidence for a lag; the lag log alone is not.
+_Avoid_: lag log, profiler output (the profiler records phase durations, not a stuck stack)
+
 ## Relationships
 
 - A **Core Slash Command** is always registered with `source="builtin"` on the Execution Axis. Its name belongs to the **Reserved Name Set** and cannot be overridden by any markdown-template command.
@@ -229,6 +291,12 @@ _Avoid_: blocking status ("blocking" in this repo means blocking the event loop)
 - **Default Custom Commands** are loaded from package resources via `importlib.resources`, parsed by the same frontmatter pipeline as project/user commands, and subject to the **Override Priority Chain** at registration time.
 - A **Default Custom Command** parse failure is a developer-visible error (raised at discovery), not a user-visible warning, because package resources are trusted input maintained by the comate_cli maintainers.
 - The **Reserved Name Set** gates discovery only; it prevents user-authored markdown commands from shadowing **Core Slash Commands**, and only Core Slash Commands.
+- Only a **Middle Slash** token enters middle skill completion; a **Head Slash** token belongs to the head command menu.
+- **Trailing Segment Match** never turns a **Skill Slash Token** into a **Skill Slash Mention**: a mention still requires the complete call name with valid boundaries.
+- Under **Trailing Segment Match**, a full-name prefix match always outranks a match through the trailing segment alone; trailing segments only fill in when no full-name prefix matches.
+- In middle skill completion, model-visible candidates outrank user-only candidates; user-only skills only fill in when no model-visible skill matches.
+- Only a user-only skill forms an **Inline Skill Invocation**; a model-visible skill named in prose is always a **Skill Slash Mention**. An Inline Skill Invocation loads the skill and never authorizes the model; a mention authorizes the model and never loads the skill.
+- A **Middle Slash Preview** and Tab always pick the same Skill Slash Command; Tab writes its full slash name even when the preview only completed the trailing segment.
 - **Fence Boundary Recognition** belongs to the streaming lifecycle: `EventRenderer` preserves container atomicity, while Rich remains responsible for Markdown parsing, selecting the first info-string word as the lexer name, syntax highlighting, and plaintext fallback for unknown lexers.
 - A fenced code opening or closing delimiter may have zero to three leading spaces. Four or more leading spaces retain Markdown's indented-code semantics and must not open or close a fenced container.
 - A normally completed turn may add a synthetic closing delimiter before the **Immutable Scrollback Commit**. An interrupted turn discards its uncommitted container instead.
@@ -251,6 +319,9 @@ _Avoid_: blocking status ("blocking" in this repo means blocking the event loop)
 - The **Update Effectiveness Boundary** holds for both Plugin Auto Update and manual plugin updates: neither may mutate the running session's loaded resources.
 - An **Auto Update Opt-out** affects only Plugin Auto Update; it does not disable manual per-plugin updates.
 
+- A **Marketplace** takes its name from its manifest, never from the **Marketplace Source** the user typed; duplicate detection therefore compares resolved sources, not names or spellings.
+- Adding a **Marketplace** is never silent: the user confirms the **Marketplace Source** once before any clone or download starts, whether the source was typed into the panel or prefilled from a slash command argument.
+
 - **Self-Update** and **Plugin Auto Update** are separate concepts with separate vocabularies: a **Version Check** orders versions, plugin **Update Detection** only compares for equality. Neither triggers the other.
 - A **Side-Install** followed by an **Entrypoint Flip** is one Self-Update strategy; an in-process reinstall of the current installation is another. Which one applies is a property of the platform, not of the user's choice.
 - **Restart-to-Apply** holds for every Self-Update strategy and mirrors the plugin **Update Effectiveness Boundary**: on-disk state changes, the running process does not.

{comate_cli-0.12.4b9 → comate_cli-0.12.4b11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.12.4b9
+Version: 0.12.4b11
 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.16
+Requires-Dist: comate-agent-sdk<0.13,>=0.12.18
 Requires-Dist: comate-rpc<0.2,>=0.1.4
 Requires-Dist: concurrent-log-handler>=0.9.25
 Requires-Dist: curl-cffi==0.13.0

{comate_cli-0.12.4b9 → comate_cli-0.12.4b11}/comate_cli/terminal_agent/animations.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import random
+import re
 import time
 from collections.abc import Sequence
 from enum import Enum
@@ -281,6 +282,52 @@ def loading_spinner_glyph(frame: int) -> str:
     return LOADING_SPINNER_FRAMES[frame % len(LOADING_SPINNER_FRAMES)]
 
 
+_RGB_RE = re.compile(r"rgb\((\d+),\s*(\d+),\s*(\d+)\)")
+
+
+def _rich_style_to_pt_style(rich_style: str) -> str:
+    """把 rich style 字符串转为 prompt_toolkit fragment style 字符串。
+
+    ``_cyan_sweep_text`` 输出形如 ``bold rgb(R,G,B)``，转为 ``#rrggbb bold``。
+    仅识别 ``bold`` 与 ``rgb(r,g,b)`` 两类标记。
+    """
+    pieces: list[str] = []
+    match = _RGB_RE.search(rich_style)
+    if match is not None:
+        r, g, b = (max(0, min(255, int(match.group(i)))) for i in (1, 2, 3))
+        pieces.append(f"#{r:02x}{g:02x}{b:02x}")
+    if "bold" in rich_style:
+        pieces.append("bold")
+    return " ".join(pieces)
+
+
+def sweep_fragments(phrase: str, frame: int) -> list[tuple[str, str]]:
+    """``_cyan_sweep_text`` 的 prompt_toolkit fragments 版本（底部面板用）。
+
+    退化路径：如果 spans 缺失，整段返回默认样式。
+    """
+    rich_text = _cyan_sweep_text(phrase, frame)
+    plain = rich_text.plain
+    spans = list(getattr(rich_text, "_spans", []) or [])
+    if not spans:
+        return [("", plain)]
+    return [
+        (_rich_style_to_pt_style(str(span.style)), plain[span.start : span.end])
+        for span in spans
+    ]
+
+
+def loading_line_fragments(phrase: str, frame: int) -> list[tuple[str, str]]:
+    """底部面板的加载行：与主 loading 行同款——盲文 spinner（品牌青加粗）+ 流光文字。
+
+    帧号由调用方提供（全局 ``_loading_frame`` 或组件自己的 ticker），本函数不起 task。
+    """
+    return [
+        (f"bold fg:{theme.ACCENT}", f"{loading_spinner_glyph(frame)} "),
+        *sweep_fragments(phrase, frame),
+    ]
+
+
 def _lerp_rgb(
     start_rgb: tuple[int, int, int],
     end_rgb: tuple[int, int, int],

{comate_cli-0.12.4b9 → comate_cli-0.12.4b11}/comate_cli/terminal_agent/app.py

@@ -1576,6 +1576,10 @@ async def run(
                 f"MCP: {', '.join(aliases)} unavailable",
                 duration_s=5.0,
             )
+        # 工具说明全部到位后查一次：固定开销挤掉对话空间时，第一条消息前就警告
+        from comate_cli.terminal_agent.event_renderer import report_conversation_budget
+
+        await report_conversation_budget(session, renderer)
 
     await tui.run(mcp_init=_mcp_loader, profiler=profiler)
     profiler.mark("tui.run.done")

comate_cli-0.12.4b11/comate_cli/terminal_agent/config/edit_session.py

@@ -0,0 +1,172 @@
+"""设置编辑的写入与撤销生命周期；磁盘工作不占用交互事件循环。"""
+
+from __future__ import annotations
+
+from dataclasses import replace
+import logging
+from typing import Any, Callable
+
+from comate_agent_sdk.utils.daemon_thread import run_sync_in_daemon_thread
+
+from . import store
+from .model import ConfigSnapshot
+
+logger = logging.getLogger(__name__)
+
+
+class SettingsEditSession:
+    def __init__(
+        self,
+        snapshot: ConfigSnapshot,
+        *,
+        runtime_read: Callable[[str], Any] | None = None,
+        runtime_apply: Callable[[str, Any], None] | None = None,
+    ) -> None:
+        self.current = snapshot
+        self._read = runtime_read
+        self._apply = runtime_apply
+        self._runtime_origin = (
+            {
+                attr: runtime_read(attr)
+                for attr in (
+                    "display_thinking",
+                    "stream_pacing",
+                    "display_language",
+                    "recap_enabled",
+                    "suggestion_enabled",
+                )
+            }
+            if runtime_read is not None
+            else {}
+        )
+        self._runtime_last: dict[str, Any] = {}
+        self._edits: dict[str, store.FieldEdit] = {}
+        self.errors: tuple[str, ...] = ()
+        self.notices: tuple[str, ...] = ()
+        self.active = True
+
+    async def _disk(self, operation: Callable, *args: Any) -> Any:
+        # 不使用默认 executor。最终退出单独限制等待预算，daemon worker 不阻塞退出。
+        return await run_sync_in_daemon_thread(
+            operation,
+            *args,
+            timeout=None,
+            thread_name="config-settings-edit",
+        )
+
+    async def change(self, attribute: str, value: Any) -> bool:
+        self.errors = ()
+        previous = self._edits.get(attribute)
+        try:
+            runtime_before = (
+                self._read(attribute)
+                if attribute in self._runtime_origin and self._read
+                else None
+            )
+        except Exception as exc:
+            logger.exception("config runtime read failed: %s", attribute)
+            self.errors = (f"{attribute}: {exc}",)
+            return False
+        result = await self._disk(store.write_field, attribute, value, previous)
+        if not result.ok:
+            self.errors = result.error_messages
+            return False
+        assert result.edit is not None
+        self._edits[attribute] = result.edit
+        try:
+            if attribute in self._runtime_origin and self._apply is not None:
+                self._apply(attribute, value)
+                self._runtime_last[attribute] = (
+                    self._read(attribute) if self._read else value
+                )
+        except Exception as exc:
+            logger.exception("config runtime apply failed: %s", attribute)
+            self.errors = (f"{attribute}: {exc}",)
+            runtime_restored = True
+            try:
+                if self._apply is not None:
+                    self._apply(attribute, runtime_before)
+            except Exception as restore_exc:
+                logger.exception("config runtime compensation failed: %s", attribute)
+                self.errors += (f"Runtime compensation failed: {restore_exc}",)
+                runtime_restored = False
+                self._runtime_last[attribute] = value
+                if self._read:
+                    try:
+                        self._runtime_last[attribute] = self._read(attribute)
+                    except Exception:
+                        logger.exception(
+                            "config runtime compensation read failed: %s", attribute
+                        )
+            # 只撤销这一次写入；更早成功的本次编辑仍可在取消时回滚。
+            step = store.FieldEdit(
+                attribute,
+                result.step_before or result.edit.before,
+                result.edit.after,
+            )
+            compensation = await self._disk(store.rollback_field, step)
+            if compensation.ok and not compensation.conflict:
+                if not runtime_restored:
+                    self._edits[attribute] = store.FieldEdit(
+                        attribute,
+                        result.edit.before,
+                        step.before,
+                        result.edit.original_value,
+                    )
+                elif previous is None or step.before != previous.after:
+                    self._edits.pop(attribute, None)
+                else:
+                    self._edits[attribute] = previous
+            else:
+                self.errors += compensation.error_messages or (
+                    "Compensation conflicted; external value retained.",
+                )
+            return False
+        self.current = replace(self.current, **{attribute: value})
+        return True
+
+    def keep(self) -> None:
+        self.active = False
+        self.errors = ()
+        self._edits.clear()
+        self._runtime_last.clear()
+
+    async def cancel(self) -> bool:
+        errors = []
+        notices = list(self.notices)
+        for attribute, edit in tuple(self._edits.items()):
+            result = await self._disk(store.rollback_field, edit)
+            if not result.ok:
+                errors.extend(
+                    f"{attribute}: {error}" for error in result.error_messages
+                )
+                continue
+            if result.conflict:
+                notices.append(f"{attribute}: external change retained")
+            elif attribute in self._runtime_last and self._apply is not None:
+                try:
+                    if (
+                        self._read is None
+                        or self._read(attribute) == self._runtime_last[attribute]
+                    ):
+                        self._apply(attribute, self._runtime_origin[attribute])
+                    else:
+                        notices.append(f"{attribute}: external runtime change retained")
+                except Exception as exc:
+                    logger.exception("config runtime rollback failed: %s", attribute)
+                    errors.append(f"{attribute}: {exc}")
+                    # 磁盘已恢复，重试时仍需重试运行时，而不能把原值误判成外部修改。
+                    self._edits[attribute] = store.FieldEdit(
+                        attribute, edit.before, edit.before, edit.original_value
+                    )
+                    continue
+            if not result.conflict:
+                self.current = replace(self.current, **{attribute: edit.original_value})
+            self._edits.pop(attribute, None)
+            self._runtime_last.pop(attribute, None)
+        self.errors = tuple(errors)
+        self.notices = tuple(notices)
+        if errors:
+            return False
+        self.active = False
+        return True

comate_cli-0.12.4b11/comate_cli/terminal_agent/config/picker.py

@@ -0,0 +1,275 @@
+"""采用共享内联菜单布局的 /config 编辑器。"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Callable
+
+from prompt_toolkit.application.current import get_app_or_none
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.layout import HSplit, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+from comate_cli.terminal_agent.i18n import i18n, message
+from comate_cli.terminal_agent.menu_panel import (
+    MenuPanel,
+    search_input,
+    setting_row,
+    terminal_size,
+)
+from comate_cli.terminal_agent.model_tier_style import tier_name
+
+from .edit_session import SettingsEditSession
+from .model import ConfigSnapshot
+from .picker_state import (
+    ConfigField,
+    ConfigPickerState,
+    PickerExit,
+    PickerExitKind,
+    RESTART_FIELDS,
+    field_attribute,
+)
+
+logger = logging.getLogger(__name__)
+
+_FIELD_LABELS = {
+    ConfigField.DISPLAY_THINKING: "Thinking display",
+    ConfigField.STREAM_PACING: "Reply pacing",
+    ConfigField.MODEL_LEVEL: "Default model tier",
+    ConfigField.MEMORY_BACKGROUND: "Memory background",
+    ConfigField.MEMORY_DREAMING: "Memory dreaming",
+    ConfigField.TOKEN_COST: "Token cost",
+    ConfigField.RECAP: "Recap",
+}
+
+
+def _field_label(field: ConfigField) -> str:
+    if field == ConfigField.LANGUAGE:
+        return i18n(message.config_language_label)
+    if field == ConfigField.SUGGESTION:
+        return i18n(message.config_suggestion_label)
+    return _FIELD_LABELS[field]
+
+
+class ConfigPickerUI:
+    def __init__(self) -> None:
+        self._state: ConfigPickerState | None = None
+        self._session: SettingsEditSession | None = None
+        self._busy = False
+        self._operation: asyncio.Task | None = None
+        self._search_focused = True
+        self._search_area = search_input(
+            lambda: i18n(message.config_search_placeholder)
+        )
+        self._search_area.buffer.on_text_changed += self._search_changed
+        self._content_window = Window(
+            FormattedTextControl(
+                self._content_fragments,
+                focusable=True,
+                get_cursor_position=self._cursor,
+            ),
+            wrap_lines=False,
+            always_hide_cursor=True,
+            style="class:selection.body",
+        )
+        self._panel = MenuPanel(
+            header=self._header_fragments,
+            body=self._content_window,
+            footer=self._footer_fragments,
+            search=self._search_area,
+            show_search=lambda: True,
+        )
+
+    def enter(
+        self,
+        snapshot: ConfigSnapshot,
+        *,
+        runtime_read: Callable | None = None,
+        runtime_apply: Callable | None = None,
+    ) -> None:
+        self._state = ConfigPickerState(snapshot)
+        self._session = SettingsEditSession(
+            snapshot, runtime_read=runtime_read, runtime_apply=runtime_apply
+        )
+        self._busy = False
+        self._search_focused = True
+        self._search_area.text = ""
+
+    @property
+    def container(self) -> HSplit:
+        return self._panel.container
+
+    @property
+    def search_area_window(self) -> Window:
+        return self._search_area.window
+
+    def focus_target(self) -> Window:
+        return self._panel.focus(self._search_focused)
+
+    def search_has_focus(self) -> bool:
+        return self._search_focused
+
+    def focus_search(self, active: bool = True) -> None:
+        self._search_focused = active
+        app = get_app_or_none()
+        if app is not None:
+            app.layout.focus(self.focus_target())
+
+    def inject_search_char(self, char: str) -> None:
+        self.focus_search()
+        self._search_area.buffer.insert_text(char)
+
+    def _search_changed(self, _buffer: Any) -> None:
+        if self._state:
+            self._state.filter(
+                self._search_area.text, {f: _field_label(f) for f in ConfigField}
+            )
+
+    def handle_up(self) -> None:
+        if not self._state or self._search_focused:
+            return
+        if (
+            self._state.visible_fields
+            and self._state.focused_field == self._state.visible_fields[0]
+        ):
+            self.focus_search()
+        else:
+            self._state.move(-1)
+
+    def handle_down(self) -> None:
+        if self._search_focused:
+            self.focus_search(False)
+        elif self._state:
+            self._state.move(1)
+
+    async def handle_tab(self) -> None:
+        if (
+            self._busy
+            or self._search_focused
+            or not self._state
+            or not self._state.visible_fields
+            or not self._session
+        ):
+            return
+        self._busy = True
+        self._operation = asyncio.current_task()
+        try:
+            attribute = field_attribute(self._state.focused_field)
+            candidate = self._state.candidate()
+            if await self._session.change(attribute, getattr(candidate, attribute)):
+                self._state.current = self._session.current
+            self._state.last_save_error_messages = self._session.errors
+        finally:
+            self._busy = False
+            self._operation = None
+
+    def handle_enter(self) -> PickerExit | None:
+        if self._busy or not self._session:
+            return None
+        if self._search_focused:
+            self.focus_search(False)
+            return None
+        self._session.keep()
+        if self._state:
+            self._state.save_called = True
+        return PickerExit(PickerExitKind.SAVED)
+
+    async def handle_escape(self) -> PickerExit | None:
+        if self._busy:
+            return None
+        if self._search_focused:
+            if self._search_area.text:
+                self._search_area.text = ""
+            else:
+                self.focus_search(False)
+            return None
+        return await self.rollback()
+
+    async def rollback(self) -> PickerExit | None:
+        if not self._session or not self._session.active:
+            return PickerExit(PickerExitKind.CLEAN_EXIT)
+        self._busy = True
+        self._operation = asyncio.current_task()
+        try:
+            if await self._session.cancel():
+                return PickerExit(PickerExitKind.DISCARDED)
+            if self._state:
+                self._state.current = self._session.current
+                self._state.last_save_error_messages = self._session.errors
+            return None
+        finally:
+            self._busy = False
+            self._operation = None
+
+    async def rollback_before_exit(self) -> tuple[str, ...]:
+        if self._operation is not None:
+            await asyncio.shield(self._operation)
+        await self.rollback()
+        if self._session:
+            return self._session.errors + self._session.notices
+        return ()
+
+    def handle_ctrl_s(self) -> PickerExit | None:
+        # 保留旧快捷键作为显式接受剩余更改的入口，包含部分回滚失败的恢复路径。
+        if self._search_focused:
+            self.focus_search(False)
+        return self.handle_enter()
+
+    def take_result(self) -> tuple[bool, tuple[str, ...]]:
+        if not self._session or not self._state:
+            return False, ()
+        return self._state.save_called, self._session.errors + self._session.notices
+
+    def _header_fragments(self) -> list[tuple[str, str]]:
+        return [("class:selection.title", "  Config")]
+
+    def _render_field_value(self, field: ConfigField, snapshot: ConfigSnapshot) -> str:
+        value = getattr(snapshot, field_attribute(field))
+        if field == ConfigField.MODEL_LEVEL:
+            return tier_name(value)
+        return str(value).lower() if isinstance(value, bool) else str(value)
+
+    def _main_fragments(self) -> list[tuple[str, str]]:
+        if not self._state:
+            return []
+        _, columns = terminal_size()
+        rows = []
+        for field in self._state.visible_fields:
+            value = self._render_field_value(field, self._state.current)
+            if field in RESTART_FIELDS:
+                value += " · " + i18n(message.config_restart_marker)
+            rows.extend(
+                setting_row(
+                    _field_label(field),
+                    value,
+                    selected=field == self._state.focused_field,
+                    columns=columns,
+                )
+            )
+        return rows or [
+            ("class:selection.description", "  " + i18n(message.menu_no_matches))
+        ]
+
+    def _content_fragments(self) -> list[tuple[str, str]]:
+        return self._main_fragments()
+
+    def _cursor(self) -> Point:
+        _, columns = terminal_size()
+        return Point(
+            0,
+            MenuPanel.selected_line(self._main_fragments())
+            + (1 if columns < 60 and self._state and self._state.visible_fields else 0),
+        )
+
+    def _footer_fragments(self) -> list[tuple[str, str]]:
+        if self._busy:
+            return [("class:selection.hint", "  " + i18n(message.config_applying))]
+        if self._session and self._session.errors:
+            return [
+                ("class:error", "  " + " | ".join(self._session.errors) + "\n"),
+                ("class:selection.hint", "  " + i18n(message.config_rollback_hint)),
+            ]
+        if self._search_focused:
+            return [("class:selection.hint", "  " + i18n(message.config_search_hint))]
+        return [("class:selection.hint", "  " + i18n(message.config_list_hint))]