lcode-agent 0.1.0__py3-none-any.whl

lcode/app.py

@@ -0,0 +1,4140 @@
+"""一个最小的 Textual TUI agent 骨架。
+
+运行方式:
+    uv run lcode                 普通运行
+    uv run textual run           开发模式(多一个 dev console)
+    uv run python -m lcode       等价于 lcode
+
+这个文件演示了 Textual 的五个核心概念:
+    1. App 子类 = 整个应用
+    2. compose() = 声明界面有哪些部件
+    3. on_<部件>_<事件> = 事件处理
+    4. @work 装饰器 = 后台任务(不卡 UI)
+    5. 内联 CSS = 布局和样式
+"""
+
+import asyncio
+import base64
+import json
+import math
+import re
+import time
+from pathlib import Path
+
+from rich.console import Group
+from rich.console import RenderableType
+from rich.markdown import Markdown
+from rich.table import Table
+from rich.text import Text
+from textual import work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.events import Click
+from textual.message import Message
+from textual.reactive import reactive
+from textual.screen import ModalScreen
+from textual.timer import Timer
+from textual.widget import Widget
+from textual.widgets import Button, Collapsible, Footer, Input, Label, OptionList, Static
+from textual.widgets.option_list import Option
+from textual.worker import get_current_worker
+
+from lcode.compress import prepare_context
+from lcode.protocol import (
+    REASONING_EFFORT,
+    ask_stream,
+    fetch_model_limits,
+    reset_model_limits,
+    set_model,
+    set_reasoning_effort,
+)
+from lcode.settings import get_permission_mode, load_runtime, save_permission_mode
+from lcode.store import Store
+from lcode.tools import (
+    execute_tool_async,
+    looks_like_tool_args,
+    normalize_tool_name,
+    openai_tools,
+    parse_tool_arguments,
+    permit_preview,
+    pretty_stream_text,
+    preview_tool_arguments,
+    set_todo_hook,
+    set_todos,
+    set_write_hook,
+    terminate_running_tools,
+    tool_is_sensitive,
+    tool_result_summary,
+    tool_title,
+)
+
+CONFIG = load_runtime()
+
+# 请求失败自动重试总次数;每次失败在输入框上方红字显示错误和 重试 n/10
+_RETRY_TOTAL = 10
+
+# 每百万 token 的单价(美元),config.json 里可配:
+# "pricing": {"input": 0.3, "output": 1.2, "cacheRead": 0.03}
+_PRICING = CONFIG.get("pricing") if isinstance(CONFIG.get("pricing"), dict) else {}
+
+# @补全扫描项目文件时的上限,防止巨大仓库拖慢输入
+_AT_SCAN_CAP = 8000
+_AT_MATCH_CAP = 8
+_IMAGE_SUFFIXES = (".png", ".jpg", ".jpeg", ".webp", ".gif")
+_MIME = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+}
+# 图片 data 落库的 base64 总量上限;超了只存文件名
+_IMG_PERSIST_CAP = 3 * 1024 * 1024
+
+
+def _est_tokens(text: str) -> int:
+    """本地粗估 token:汉字约 1 个,英文约 4 字符 1 个。接口正式用量到了会再校准。"""
+    if not text:
+        return 0
+    cjk = 0
+    other = 0
+    for ch in text:
+        if ord(ch) >= 0x2E80:
+            cjk += 1
+        else:
+            other += 1
+    return cjk + (other + 3) // 4
+
+
+def fmt_tok(n: int) -> str:
+    """上千用 k,上百万用 m。"""
+    n = max(0, int(n))
+    if n >= 1_000_000:
+        text = f"{n / 1_000_000:.1f}m"
+        return text.replace(".0m", "m")
+    if n >= 1000:
+        text = f"{n / 1000:.1f}k"
+        return text.replace(".0k", "k")
+    return str(n)
+
+
+def _value_tokens(value: object) -> int:
+    if value is None:
+        return 0
+    if isinstance(value, str):
+        return _est_tokens(value)
+    if isinstance(value, (dict, list)):
+        try:
+            return _est_tokens(json.dumps(value, ensure_ascii=False))
+        except (TypeError, ValueError):
+            return _est_tokens(str(value))
+    return _est_tokens(str(value))
+
+
+def _messages_tokens(msgs: list) -> int:
+    total = 0
+    for msg in msgs:
+        if not isinstance(msg, dict):
+            continue
+        total += _value_tokens(msg.get("content"))
+        total += _value_tokens(msg.get("tool_calls"))
+    return total
+
+
+def _cache_pct(cache: int, inp: int) -> int:
+    """缓存命中百分比:没命中或没有输入就返回 0,调用方按 0 隐藏。"""
+    if cache <= 0 or inp <= 0:
+        return 0
+    return min(100, round(cache * 100 / inp))
+
+
+def _msg_meta(raw: str) -> dict:
+    if not raw:
+        return {}
+    try:
+        data = json.loads(raw)
+    except (TypeError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+# 只读工具的大结果送进上下文时的长度上限(字符);截断只影响发给模型的,
+# 磁盘里的全文和卡片上展示的都还是完整的。
+_TOOL_CONTEXT_CAP = 16_000
+_TOOL_CONTEXT_HEAD = 12_000
+_TOOL_CONTEXT_TAIL = 3_600
+
+_CLIP_TOOLS = (
+    "read_file",
+    "grep",
+    "list_dir",
+    "run_terminal_command",
+    "web_search",
+    "web_fetch",
+)
+
+
+def _clip_tool_context(name: str, result: str) -> str:
+    """大文件 read_file / grep / 终端输出掐头去尾,别把窗口迅速打满。"""
+    if normalize_tool_name(name) not in _CLIP_TOOLS:
+        return result
+    if len(result) <= _TOOL_CONTEXT_CAP:
+        return result
+    omitted = len(result) - _TOOL_CONTEXT_HEAD - _TOOL_CONTEXT_TAIL
+    return (
+        result[:_TOOL_CONTEXT_HEAD]
+        + f"\n…(中间省略 {omitted} 字,完整结果太长;需要更多请用 offset/limit 再读)…\n"
+        + result[-_TOOL_CONTEXT_TAIL:]
+    )
+
+
+_SKIP_DIR_NAMES = {".git", "__pycache__", ".venv", "node_modules", ".lcode", ".idea"}
+
+
+def _project_files() -> list[str]:
+    """项目里的相对路径文件列表,@补全用;目录太深就截断。"""
+    out: list[str] = []
+    root = Path.cwd()
+    stack = [root]
+    while stack and len(out) < _AT_SCAN_CAP:
+        current = stack.pop()
+        try:
+            entries = sorted(current.iterdir(), key=lambda p: p.name)
+        except OSError:
+            continue
+        for entry in entries:
+            if entry.name.startswith(".") or entry.name in _SKIP_DIR_NAMES:
+                continue
+            if entry.is_dir():
+                stack.append(entry)
+            else:
+                try:
+                    out.append(str(entry.relative_to(root)).replace("\\", "/"))
+                except ValueError:
+                    continue
+            if len(out) >= _AT_SCAN_CAP:
+                break
+    return out
+
+
+def _at_matches(typed: str) -> tuple[str, list[str]]:
+    """从输入末尾抠出 @token,返回 (前缀, 匹配的文件路径)。不是 @补全就返回 ("", [])。"""
+    m = re.search(r"@([^\s@]*)$", typed or "")
+    if not m:
+        return "", []
+    prefix = m.group(1).lower()
+    if len(prefix) < 1:
+        return "", []
+    files = getattr(_at_matches, "_cache", None)
+    now = time.monotonic()
+    if files is None or now - files[0] > 20:
+        files = (now, _project_files())
+        _at_matches._cache = files
+    hits = [f for f in files[1] if prefix in f.lower()][:_AT_MATCH_CAP]
+    return prefix, hits
+
+
+_TOOLS_TOKENS_CACHE = -1
+
+
+def _tools_tokens() -> int:
+    global _TOOLS_TOKENS_CACHE
+    if _TOOLS_TOKENS_CACHE < 0:
+        _TOOLS_TOKENS_CACHE = _est_tokens(json.dumps(openai_tools(), ensure_ascii=False))
+    return _TOOLS_TOKENS_CACHE
+
+
+_RULE_FILES = ("AGENTS.md", "LCODE.md")
+_RULES_CHAR_CAP = 16_000
+
+
+def _project_rules() -> str:
+    chunks: list[str] = []
+    used = 0
+    root = Path.cwd()
+    for name in _RULE_FILES:
+        path = root / name
+        if not path.is_file():
+            continue
+        try:
+            text = path.read_text(encoding="utf-8", errors="replace").strip()
+        except OSError:
+            continue
+        if not text:
+            continue
+        remain = _RULES_CHAR_CAP - used
+        if remain <= 80:
+            break
+        if len(text) > remain:
+            text = text[:remain].rstrip() + "\n…"
+        chunks.append(f"Project rules from {name}:\n{text}")
+        used += len(text)
+    return "\n\n".join(chunks)
+
+
+def _system_prompt() -> str:
+    cwd = str(Path.cwd())
+    body = (
+        "You are Lcode, a coding agent in the user's project. "
+        f"Workspace: {cwd}. Use tools to read and edit files; "
+        "do not guess file contents. Prefer search_replace for edits. "
+        "Use write to create new files or overwrite a whole file. "
+        "Use grep and list_dir to explore. Run commands with "
+        "run_terminal_command."
+    )
+    rules = _project_rules()
+    if rules:
+        body += "\n\n" + rules
+    return body
+
+
+def _rel_time(ts: int) -> str:
+    delta = max(0, int(time.time()) - int(ts or 0))
+    if delta < 60:
+        return "刚刚"
+    if delta < 3600:
+        return f"{delta // 60}分钟前"
+    if delta < 86400:
+        return f"{delta // 3600}小时前"
+    if delta < 86400 * 7:
+        return f"{delta // 86400}天前"
+    return time.strftime("%m-%d", time.localtime(ts))
+
+
+def _session_prompt(row: dict, current_id: str) -> Text:
+    line = Text()
+    current = row.get("id") == current_id
+    if current:
+        line.append("当前  ", style="bold yellow")
+    else:
+        line.append("窗口  ", style="dim")
+    title = " ".join(str(row.get("title") or "").split()) or "无标题"
+    if len(title) > 36:
+        title = title[:35] + "…"
+    line.append(title, style="bold" if current else "")
+    n = int(row.get("n") or 0)
+    if n:
+        line.append(f"  {n}条", style="dim")
+    line.append(f"  {str(row.get('id') or '')[:8]}  {_rel_time(int(row.get('updated_at') or 0))}", style="dim")
+    return line
+
+
+# ---------- 欢迎横幅 ----------
+
+# "LCODE" 细体:每个字母 5 列宽、5 行高,用 █▀▄ 勾边,不套框
+_LETTERS: dict[str, list[str]] = {
+    "L": ["█    ", "█    ", "█    ", "█    ", "█▄▄▄▄"],
+    "C": ["█▀▀▀▄", "█    ", "█    ", "█    ", "█▄▄▄▀"],
+    "O": ["▄▀▀▀▄", "█   █", "█   █", "█   █", "▀▄▄▄▀"],
+    "D": ["█▀▀▀▄", "█   █", "█   █", "█   █", "█▄▄▄▀"],
+    "E": ["█▀▀▀▀", "█    ", "█▀▀▀ ", "█    ", "█▄▄▄▄"],
+}
+
+# 字母配色:L 黄色,CODE 灰色
+# UI 暖色板:琥珀主色 + 暖灰辅助;绿红只做状态色,不再混青蓝
+_AMBER = "#d9a84e"
+_AMBER_DIM = "#a8843c"
+_WARM = "#8a8578"
+_WARM_HI = "#b5ae9d"
+_CREAM = "#f0e2c0"
+_OK = "#8fbf9f"
+_ERR = "#e08a8a"
+_YELLOW = _AMBER
+_GREY = _WARM
+
+# 灯笼:照参考图重画——圆顶红盖、椭圆鼓身、弧形红肋、底下一排流苏 + 黄色长尾。
+_RED = "#e33333"
+_GOLD = "#f5d90a"
+_LANTERN: list[str] = [
+    "             ║",
+    "             ║",
+    "            ▄█▄",
+    "          ▄█████▄",
+    "        ▼▼▼▼▼▼▼▼▼▼▼",
+    "      ███│█│███│█│███",
+    "    ████│█│█████│█│████",
+    "  ████│██│███████│██│████",
+    " ████│███│███████│███│████",
+    " ████│███│███████│███│████",
+    " ███│███│█████████│███│███",
+    " ████│███│███████│███│████",
+    " ████│███│███████│███│████",
+    "  ████│██│███████│██│████",
+    "  ████│██│███████│██│████",
+    "    ████│█│█████│█│████",
+    "      ███│█│███│█│███",
+    "     ▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼",
+    "         █████████",
+    "       │││││││││││││",
+    "       │││││││││││││",
+    "         │││││││││",
+    "            ▄█▄",
+    "             ║",
+    "             ║",
+    "             ║",
+    "            ▀█▀",
+]
+_GOLD_DIM = "#8a6a08"
+_GOLD_LIT = "#fff3a0"
+_RED_DIM = "#8a1c1c"
+_RED_LIT = "#ff6a6a"
+_PAPER_DIM = "#c48a12"
+_PAPER_LIT = "#ffe14a"
+_RIB_DIM = "#8a5a08"
+_RIB_LIT = "#d4a01a"
+
+# 灯笼结构行号:颜色和摆动逻辑按段处理
+_LANTERN_W = 27
+# 渲染时每行统一补到这个宽度:尾巴左右摆不改变列宽,右边的文字栏才不会跟着晃
+_L_PAD_W = 31
+_L_HANGER = (0, 1)
+_L_CAP = (2, 3)
+_L_TRIM = (4, 17)
+_L_BODY = range(5, 17)
+_L_BAND = 18
+_L_FRINGE = (19, 20, 21)
+_L_KNOT = 22
+_L_TAIL = (23, 24, 25, 26)
+
+
+def _lcode_word() -> Text:
+    """细体 LCODE:L 黄色,CODE 灰色,字母间空 2 格。"""
+    lines: list[Text | str] = []
+    for y in range(5):
+        if y:
+            lines.append("\n")
+        row = Text()
+        for i, letter in enumerate("LCODE"):
+            if i:
+                row.append("  ")
+            row.append(_LETTERS[letter][y], style=_YELLOW if letter == "L" else _GREY)
+        lines.append(row)
+    return Text.assemble(*lines)
+
+
+def _lerp_hex(dark: str, lit: str, k: float) -> str:
+    k = max(0.0, min(1.0, k))
+    dr, dg, db = int(dark[1:3], 16), int(dark[3:5], 16), int(dark[5:7], 16)
+    lr, lg, lb = int(lit[1:3], 16), int(lit[3:5], 16), int(lit[5:7], 16)
+    r = int(dr + (lr - dr) * k)
+    g = int(dg + (lg - dg) * k)
+    b = int(db + (lb - db) * k)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _wind_lit(t: float, row: int, col: int) -> float:
+    """风从斜上方扫过,亮度 0~1,结身不动,只是光在绳上走。"""
+    wave = math.sin(t * 1.7 - row * 0.45 - col * 0.22)
+    slow = math.sin(t * 0.55 + row * 0.12)
+    k = 0.5 + 0.5 * (0.72 * wave + 0.28 * slow)
+    return max(0.0, min(1.0, k))
+
+
+def _lantern(t: float = 0.0, gust: float = 0.0) -> Text:
+    """照参考图的灯笼:红盖压边、黄纸鼓身、弧形红肋、流苏长尾。
+
+    动画:风扫纸面亮暗(不变);新增尾巴摆动,点击后的 gust 会加大摆幅。
+    """
+    lamp = Text(no_wrap=True, overflow="crop")
+    sway_speed = 1.4 + 2.5 * gust
+    for i, line in enumerate(_LANTERN):
+        if i:
+            lamp.append("\n")
+        chars = list(line.ljust(_L_PAD_W))
+        if i in _L_TAIL:
+            # 尾巴摆:越往下摆得越多,像挂坠;行补齐固定宽度,摆动不改列宽
+            reach = 0.55 * (i - 22) + 2.2 * gust
+            dx = round(math.sin(t * sway_speed) * reach)
+            dx = max(-3, min(3, dx))
+            if dx:
+                shifted = [" "] * _L_PAD_W
+                for j, ch in enumerate(chars):
+                    nj = j + dx
+                    if 0 <= nj < _L_PAD_W:
+                        shifted[nj] = ch
+                chars = shifted
+        for j, ch in enumerate(chars):
+            if ch == " ":
+                lamp.append(" ")
+                continue
+            wind = _wind_lit(t, i, j)
+            k = max(wind, 0.5 + 0.5 * math.sin(t * 2.4))
+            if i in _L_TAIL or i == _L_KNOT:
+                lamp.append(ch, style=_lerp_hex(_GOLD_DIM, _GOLD_LIT, k))
+            elif i in _L_HANGER or i in _L_CAP or i in _L_TRIM or i == _L_BAND:
+                lamp.append(ch, style=_lerp_hex(_RED_DIM, _RED_LIT, k))
+            elif i in _L_FRINGE:
+                # 流苏:整排红线,亮度做一点行间相位差,像被风掀
+                k2 = max(wind, 0.5 + 0.5 * math.sin(t * 2.4 - i * 0.7))
+                lamp.append(ch, style=_lerp_hex(_RED_DIM, _RED_LIT, k2))
+            elif ch == "│":
+                lamp.append(ch, style=_lerp_hex(_RIB_DIM, _RIB_LIT, k))
+            else:
+                lamp.append(ch, style=_lerp_hex(_PAPER_DIM, _PAPER_LIT, k))
+    return lamp
+
+
+def _cwd_display() -> str:
+    """当前文件夹路径;家目录前缀缩写成 ~。"""
+    cwd = str(Path.cwd())
+    home = str(Path.home())
+    if cwd.startswith(home):
+        cwd = "~" + cwd[len(home):]
+    return cwd
+
+
+def _lcode_mark(version: str, phrase: str = "") -> Table:
+    """头部文字栏:品牌行、LCODE 字标、分隔线、路径、模型、操作提示。
+
+    和灯笼并排放,整体垂直居中(见 _welcome_banner)。
+    phrase 是点击灯笼冒出来的彩蛋,追加在最后一行。
+    """
+    brand = Text()
+    brand.append("▎", style=f"bold {_AMBER}")
+    brand.append("Lcode agent", style="bold")
+    brand.append(f"  v{version}", style="dim")
+
+    cwd_line = Text()
+    cwd_line.append("◆ ", style="dim")
+    cwd_line.append(_cwd_display(), style="dim")
+
+    model_line = Text()
+    model = str(CONFIG.get("model") or "")
+    model_line.append("◆ ", style="dim")
+    model_line.append("当前模型 ", style="dim")
+    if model:
+        model_line.append(model, style=f"bold {_AMBER}")
+    else:
+        model_line.append("（未配置）", style="dim")
+
+    help_line = Text()
+    help_line.append("◆ ", style="dim")
+    help_line.append("输入 / 看命令  ·  Ctrl+Q 退出", style="dim")
+
+    egg_line = Text()
+    egg_line.append("◆ ", style=_RED)
+    egg_line.append("点一点灯笼，讨个好彩头", style=f"{_AMBER} italic")
+
+    block = Table.grid(expand=False)
+    block.add_row(brand)
+    block.add_row(_lcode_word())
+    block.add_row(Text("─" * 21, style="dim"))
+    block.add_row(cwd_line)
+    block.add_row(model_line)
+    block.add_row(help_line)
+    block.add_row(egg_line)
+    if phrase:
+        block.add_row(Text(f"❝ {phrase} ❞", style=f"bold {_AMBER}"))
+    return block
+
+
+def _renderable_rows(renderable: object, width: int = 64) -> int:
+    """渲染一遍数行数,给头部排版做垂直居中用。"""
+    import io
+
+    from rich.console import Console
+
+    buf = io.StringIO()
+    Console(
+        width=width, file=buf, legacy_windows=False, color_system=None
+    ).print(renderable)
+    return max(1, len(buf.getvalue().rstrip("\n").splitlines()))
+
+
+def _welcome_banner(version: str, t: float = 0.0, phrase: str = "") -> RenderableType:
+    """欢迎横幅:左边灯笼,右边文字栏,文字栏对着灯笼身子垂直居中。"""
+    lamp = _lantern(t)
+    mark = _lcode_mark(version, phrase)
+    lamp_rows = str(lamp.plain).count("\n") + 1
+    mark_rows = _renderable_rows(mark)
+    pad = max(0, (lamp_rows - mark_rows) // 2)
+    stack = Table.grid(expand=False)
+    stack.add_column()
+    for _ in range(pad):
+        stack.add_row(Text(""))
+    stack.add_row(mark)
+    art = Table.grid(padding=(0, 4), expand=False, pad_edge=False)
+    art.add_column(vertical="top", no_wrap=True)
+    art.add_column(vertical="top")
+    art.add_row(lamp, stack)
+    return art
+
+
+class Hero(Static):
+    """欢迎横幅:躺在对话流最上面,往下滚就滑走。点灯笼有彩蛋。"""
+
+    _EGG_PHRASES = ("恭喜发财！", "大吉大利！", "码到成功！", "诸事顺遂！", "bug 退散！")
+
+    def on_mount(self) -> None:
+        self._t0 = time.monotonic()
+        self._gust = 0.0        # 点击后的风,越点越大摆幅
+        self._phrase = ""
+        self._phrase_until = 0.0
+        version = getattr(self.app, "VERSION", "0.0.0")
+        self.update(_welcome_banner(version, 0.0))
+        self.set_interval(0.08, self._tick)
+
+    def on_click(self, event: Click) -> None:
+        # 点灯笼:起风 + 冒一句彩蛋;点别处只起风
+        import random
+
+        self._gust = min(2.0, self._gust + 1.0)
+        self._phrase = random.choice(self._EGG_PHRASES)
+        self._phrase_until = time.monotonic() + 2.4
+
+    def _tick(self) -> None:
+        # 滚出视口就别再重绘,省刷新
+        parent = self.parent
+        if parent is not None and getattr(parent, "scroll_offset", None) is not None:
+            if parent.scroll_offset.y >= max(1, self.outer_size.height):
+                return
+        version = getattr(self.app, "VERSION", "0.0.0")
+        self._gust = max(0.0, self._gust * 0.965 - 0.004)
+        now = time.monotonic()
+        phrase = self._phrase if now < self._phrase_until else ""
+        self.update(
+            _welcome_banner(version, now - self._t0, phrase)
+        )
+
+
+class ChatLog(VerticalScroll):
+    """对话区:用户句、思考折叠、正文,都能点选展开。"""
+
+    can_focus = True
+
+    def compose(self) -> ComposeResult:
+        yield Hero(id="hero")
+
+
+class UserTurn(Static):
+    """用户说的那一句。"""
+
+    DEFAULT_CSS = """
+    UserTurn {
+        width: 1fr;
+        height: auto;
+        background: ansi_default;
+        text-wrap: wrap;
+        margin-bottom: 0;
+    }
+    """
+
+    def __init__(self, prompt: str, **kwargs) -> None:
+        body = Text()
+        body.append("▎ ", style="bold #a8843c")
+        body.append(prompt)
+        super().__init__(body, **kwargs)
+
+
+class AgentTurn(Widget):
+    """一轮回复:等待动画、默认折叠的思考、正文。"""
+
+    DEFAULT_CSS = """
+    AgentTurn {
+        width: 1fr;
+        height: auto;
+        layout: vertical;
+        background: ansi_default;
+        margin: 0 0 1 0;
+    }
+    AgentTurn > #wait {
+        width: 1fr;
+        height: auto;
+        background: ansi_default;
+        text-wrap: wrap;
+    }
+    AgentTurn > #thinking {
+        width: 1fr;
+        height: auto;
+        background: ansi_default;
+        border: none;
+        padding: 0;
+        margin: 0 0 1 0;
+    }
+    AgentTurn > #thinking.-collapsed > Contents {
+        display: none;
+    }
+    AgentTurn Collapsible Contents {
+        width: 1fr;
+        height: auto;
+        padding: 0;
+        background: ansi_default;
+    }
+    AgentTurn CollapsibleTitle {
+        width: auto;
+        height: 1;
+        background: ansi_default;
+        padding: 0 1 0 0;
+        color: #a8843c;
+        text-style: bold;
+    }
+    AgentTurn CollapsibleTitle:hover {
+        background: ansi_default;
+        color: #d9a84e;
+    }
+    AgentTurn CollapsibleTitle:focus {
+        background: ansi_default;
+        color: #d9a84e;
+        text-style: bold;
+    }
+    AgentTurn #thinking-body {
+        width: 1fr;
+        height: auto;
+        background: ansi_default;
+        text-wrap: wrap;
+        color: grey;
+        text-style: italic;
+        padding: 0 0 0 2;
+        margin: 0 0 1 0;
+    }
+    AgentTurn > #answer {
+        width: 1fr;
+        height: auto;
+        background: ansi_default;
+        text-wrap: wrap;
+        margin: 0;
+        padding: 0 0 0 1;
+        border-left: tall #57534a;
+    }
+    AgentTurn #tool-log {
+        width: 1fr;
+        height: auto;
+        background: ansi_default;
+        margin: 0 0 1 0;
+    }
+    AgentTurn #tool-log Collapsible {
+        width: 1fr;
+        height: auto;
+        background: ansi_default;
+        border: none;
+        padding: 0;
+        margin: 0 0 1 0;
+    }
+    AgentTurn #tool-log Collapsible:ansi {
+        background: ansi_default;
+        border: none;
+    }
+    AgentTurn #tool-log Collapsible.-collapsed > Contents {
+        display: none;
+    }
+    AgentTurn #tool-log CollapsibleTitle {
+        width: auto;
+        height: 1;
+        background: ansi_default;
+        padding: 0 1 0 0;
+        color: #d9a84e;
+        text-style: bold;
+    }
+    AgentTurn #tool-log Collapsible.tool-quiet CollapsibleTitle {
+        color: #8a8578;
+    }
+    AgentTurn #tool-log Collapsible.tool-quiet CollapsibleTitle:hover,
+    AgentTurn #tool-log Collapsible.tool-quiet CollapsibleTitle:focus {
+        color: #c4bfb2;
+    }
+    AgentTurn #tool-log Collapsible.tool-ok CollapsibleTitle {
+        color: #8fbf9f;
+    }
+    AgentTurn #tool-log Collapsible.tool-err CollapsibleTitle {
+        color: #e08a8a;
+    }
+    AgentTurn #tool-log CollapsibleTitle:hover,
+    AgentTurn #tool-log CollapsibleTitle:focus {
+        background: ansi_default;
+        color: #f0e2c0;
+        text-style: bold;
+    }
+    AgentTurn #tool-log .tool-body {
+        width: 1fr;
+        height: auto;
+        background: ansi_default;
+        text-wrap: wrap;
+        padding: 0 0 0 2;
+        margin: 0 0 1 0;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="wait")
+        yield Collapsible(
+            Static(id="thinking-body"),
+            title="思考",
+            collapsed=True,
+            collapsed_symbol="▶",
+            expanded_symbol="▼",
+            id="thinking",
+        )
+        yield Vertical(id="tool-log")
+        yield Static(id="answer")
+
+    def on_mount(self) -> None:
+        self._thinking_cache = ""
+        self._answer_cache = ""
+        self._title_in = 0
+        self._title_out = 0
+        self._title_cache = 0
+        self._tool_list = []
+        self.query_one("#thinking").display = False
+        self.query_one("#answer").display = False
+
+    def _set_thinking_title(
+        self,
+        elapsed: float,
+        out_tokens: int | None = None,
+        in_tokens: int | None = None,
+        cache_tokens: int | None = None,
+    ) -> None:
+        box = self.query_one("#thinking", Collapsible)
+        if not box.display:
+            return
+        if out_tokens is not None:
+            self._title_out = max(0, int(out_tokens))
+        if in_tokens is not None:
+            self._title_in = max(0, int(in_tokens))
+        if cache_tokens is not None:
+            self._title_cache = max(0, int(cache_tokens))
+        # ↑ 本轮请求(含工具结果),cache 命中百分比,↓ 思考输出;跟底部栏同一套
+        bits = [f"◆ 思考  {elapsed:.1f}s"]
+        if self._title_in:
+            bits.append(f"↑ {fmt_tok(self._title_in)}")
+        pct = _cache_pct(self._title_cache, self._title_in)
+        if pct:
+            bits.append(f"cache {pct}%")
+        if self._title_out:
+            bits.append(f"↓ {fmt_tok(self._title_out)}")
+        box.title = "  ".join(bits)
+
+    def _flush_thinking(self) -> None:
+        self.query_one("#thinking-body", Static).update(
+            Text(self._thinking_cache, style="dim italic") if self._thinking_cache else Text()
+        )
+
+    def on_collapsible_expanded(self, event: Collapsible.Expanded) -> None:
+        event.stop()
+        self._flush_thinking()
+
+    def show_wait(self, text: Text) -> None:
+        wait = self.query_one("#wait", Static)
+        wait.display = True
+        wait.update(text)
+        self.query_one("#thinking").display = False
+        self.query_one("#answer").display = False
+
+    def show_stream(
+        self,
+        thinking: str,
+        answer: str,
+        *,
+        elapsed: float = 0.0,
+        out_tokens: int = 0,
+        in_tokens: int | None = None,
+        cache_tokens: int | None = None,
+        final: bool = False,
+    ) -> None:
+        self.query_one("#wait", Static).display = False
+        box = self.query_one("#thinking", Collapsible)
+        if thinking:
+            box.display = True
+            self._thinking_cache = thinking
+            self._set_thinking_title(elapsed, out_tokens, in_tokens, cache_tokens)
+            # 折叠时只改标题;展开才写入思考正文,避免正文和思考糊成一块
+            if not box.collapsed:
+                self._flush_thinking()
+        else:
+            box.display = False
+        ans = self.query_one("#answer", Static)
+        shown = pretty_stream_text(answer) if answer else ""
+        if shown:
+            ans.display = True
+            if shown != self._answer_cache:
+                # 流式时 Markdown 每 0.15s 重排一次就够;final 必须渲染到最新
+                now = time.monotonic()
+                if final or now - getattr(self, "_md_t", 0.0) >= 0.15:
+                    self._md_t = now
+                    self._answer_cache = shown
+                    ans.update(Markdown(shown))
+        else:
+            ans.display = False
+
+    def pulse_title(
+        self,
+        elapsed: float,
+        out_tokens: int,
+        in_tokens: int | None = None,
+        cache_tokens: int | None = None,
+    ) -> None:
+        """思考折叠时标题上的秒数和 token 也要跟着走。"""
+        self._set_thinking_title(elapsed, out_tokens, in_tokens, cache_tokens)
+
+    def show_error(self, message: str) -> None:
+        self.query_one("#wait", Static).display = False
+        self.query_one("#thinking").display = False
+        ans = self.query_one("#answer", Static)
+        ans.display = True
+        ans.update(Text(f"请求失败: {message}"))
+
+    def show_empty(self) -> None:
+        self.query_one("#wait", Static).display = False
+        self.query_one("#thinking").display = False
+        ans = self.query_one("#answer", Static)
+        ans.display = True
+        ans.update(Text("(空回复)", style="dim"))
+
+    def show_interrupted(
+        self,
+        thinking: str,
+        answer: str,
+        *,
+        elapsed: float = 0.0,
+        in_tokens: int = 0,
+        cache_tokens: int = 0,
+    ) -> None:
+        """Esc / Ctrl+C 打断后留下已到的字,并标明已打断。"""
+        self.query_one("#wait", Static).display = False
+        box = self.query_one("#thinking", Collapsible)
+        if thinking:
+            box.display = True
+            self._thinking_cache = thinking
+            self._set_thinking_title(
+                elapsed,
+                _est_tokens(thinking),
+                in_tokens,
+                cache_tokens,
+            )
+        else:
+            box.display = False
+        ans = self.query_one("#answer", Static)
+        ans.display = True
+        shown = pretty_stream_text(answer) if answer else ""
+        if shown:
+            body: RenderableType = Group(Markdown(shown), Text("(已打断)", style="dim"))
+        else:
+            body = Text("(已打断)", style="dim")
+        self._answer_cache = (shown + "\n" if shown else "") + "(已打断)"
+        ans.update(body)
+
+    async def sync_tools(self, calls: list) -> None:
+        """工具参数一边到一边画,写入/替换从半截 JSON 起就按真换行展示。"""
+        self.query_one("#wait").display = False
+        log = self.query_one("#tool-log", Vertical)
+        cards = getattr(self, "_tool_list", None)
+        if cards is None:
+            cards = []
+            self._tool_list = cards
+        for i, call in enumerate(calls or []):
+            if not isinstance(call, dict):
+                continue
+            name = str(call.get("name") or "")
+            raw = str(call.get("arguments") or "")
+            parsed = parse_tool_arguments(raw)
+            title = tool_title(name, parsed) if name else (name or "tool")
+            if i < len(cards):
+                card = cards[i]
+                card.set_heading(title)
+            else:
+                card = ToolCall(title, name=name)
+                cards.append(card)
+                await log.mount(card)
+            card.stream_preview(name, raw)
+
+    async def begin_tool(
+        self, title: str, index: int | None = None, name: str = ""
+    ) -> "ToolCall":
+        self.query_one("#wait").display = False
+        cards = getattr(self, "_tool_list", None)
+        if cards is None:
+            cards = []
+            self._tool_list = cards
+        if index is not None and 0 <= index < len(cards):
+            card = cards[index]
+            card.set_heading(title)
+            return card
+        widget = ToolCall(title, name=name)
+        cards.append(widget)
+        await self.query_one("#tool-log", Vertical).mount(widget)
+        return widget
+
+
+_DEL_STYLE = "bold #e08a8a"
+_ADD_STYLE = "bold #8fbf9f"
+
+
+def paint_tool_body(raw: str) -> Text:
+    """工具正文:改文件的 +/- 行上色,其余变淡。"""
+    body = Text(no_wrap=False, overflow="fold")
+    lines = (raw or "").splitlines()
+    total = len(lines)
+    if total > 400:
+        lines = lines[:400]
+        lines.append(f"…(截断,共 {total} 行)")
+    for i, line in enumerate(lines):
+        if i:
+            body.append("\n")
+        mark = line[:1] if line else ""
+        if mark == "-" and not line.startswith("---"):
+            body.append(line, style=_DEL_STYLE)
+        elif mark == "+" and not line.startswith("+++"):
+            body.append(line, style=_ADD_STYLE)
+        else:
+            body.append(line, style="dim")
+    return body if raw else Text("运行中…", style="dim")
+
+
+_QUIET_TOOLS = {"read_file", "grep", "list_dir", "todo_write", "web_search", "web_fetch"}
+_FAIL_PREFIXES = (
+    "工具失败", "找不到", "超时", "不是文件", "不是目录", "文件不存在",
+    "缺少", "未知工具", "正则无效", "用户拒绝", "old_string", "无结果",
+)
+
+
+class ToolCall(Widget):
+    """一次工具调用:默认折叠,改文件时展开并高亮增删行。
+
+    标题按状态着色:运行中金黄、成功绿勾、失败红叉、只读工具整条灰。
+    """
+
+    DEFAULT_CSS = """
+    ToolCall {
+        width: 1fr;
+        height: auto;
+        layout: vertical;
+        background: ansi_default;
+        margin: 0;
+    }
+    """
+
+    def __init__(self, title: str, name: str = "", **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._base_title = title
+        self._tool_name = normalize_tool_name(name)
+        self._raw = ""
+        self._kind = ""
+        self._phase = "stream"
+
+    def compose(self) -> ComposeResult:
+        classes = "tool-box tool-run"
+        if self._tool_name in _QUIET_TOOLS:
+            classes += " tool-quiet"
+        yield Collapsible(
+            Static(classes="tool-body"),
+            title=f"⠋ {self._base_title}  运行中…",
+            collapsed=True,
+            collapsed_symbol="▶",
+            expanded_symbol="▼",
+            classes=classes,
+        )
+
+    def _box(self) -> Collapsible:
+        return self.query_one(".tool-box", Collapsible)
+
+    def _flush(self) -> None:
+        self.query_one(".tool-body", Static).update(paint_tool_body(self._raw))
+
+    def set_heading(self, title: str) -> None:
+        title = (title or "").strip() or self._base_title
+        self._base_title = title
+        if self._phase == "result":
+            return
+        try:
+            self._box().title = f"⠋ {self._base_title}  运行中…"
+        except Exception:
+            pass
+
+    def stream_output(self, text: str) -> None:
+        """终端跑的时候把输出实时刷进卡片;结束时 finish() 再按结果收起/展开。"""
+        if self._phase == "result":
+            return
+        self._raw = text or ""
+        box = self._box()
+        now = time.monotonic()
+        if now - getattr(self, "_preview_t", 0.0) < 0.1:
+            return
+        self._preview_t = now
+        if box.collapsed:
+            box.collapsed = False
+        self._flush()
+
+    def stream_preview(self, name: str, raw_args: str) -> None:
+        if self._phase == "result":
+            return
+        self._kind = name
+        self._tool_name = normalize_tool_name(name) or self._tool_name
+        self._raw = preview_tool_arguments(name, raw_args)
+        parsed = parse_tool_arguments(raw_args)
+        if name and parsed:
+            try:
+                self._base_title = tool_title(name, parsed)
+            except Exception:
+                pass
+        box = self._box()
+        box.title = f"⠋ {self._base_title}  运行中…"
+        key = (name or "").strip()
+        expand = key in ("write", "write_file", "search_replace")
+        if expand and box.collapsed:
+            box.collapsed = False
+        now = time.monotonic()
+        last = getattr(self, "_preview_t", 0.0)
+        if expand or not box.collapsed:
+            if now - last >= 0.05 or len(self._raw) < 240:
+                self._preview_t = now
+                self._flush()
+
+    def on_collapsible_expanded(self, event: Collapsible.Expanded) -> None:
+        event.stop()
+        if self._raw:
+            self._flush()
+
+    def finish(self, name: str, result: str) -> None:
+        self._phase = "result"
+        self._kind = name
+        self._raw = result or ""
+        summary = tool_result_summary(name, self._raw)
+        box = self._box()
+        head = "✓" if not self._failed() else "✗"
+        box.title = (
+            f"{head} {self._base_title}  {summary}".rstrip()
+            if summary
+            else f"{head} {self._base_title}"
+        )
+        ok = not self._failed()
+        box.remove_class("tool-run")
+        box.add_class("tool-ok" if ok else "tool-err")
+        expand = False
+        if name == "search_replace" and self._raw.startswith("已替换"):
+            expand = True
+        elif name in ("write", "write_file") and (
+            self._raw.startswith("已写入") or self._raw.startswith("已覆盖")
+        ):
+            expand = True
+        elif self._failed():
+            expand = True
+        box.collapsed = not expand
+        if expand:
+            self._flush()
+
+    def _failed(self) -> bool:
+        raw = self._raw or ""
+        return any(raw.startswith(p) for p in _FAIL_PREFIXES)
+
+
+class QueueItem(Horizontal):
+    """输入框上方的一条排队稿:左边预览,右边编辑/发送图标。"""
+
+    DEFAULT_CSS = """
+    QueueItem {
+        width: 1fr;
+        height: 3;
+        layout: horizontal;
+        background: ansi_default;
+        border: round grey;
+        margin: 0 1 1 1;
+        padding: 0 0 0 1;
+        align: left middle;
+    }
+    QueueItem #q-text {
+        width: 1fr;
+        height: 1;
+        background: ansi_default;
+        text-wrap: nowrap;
+        overflow: hidden;
+        padding: 0 1 0 0;
+    }
+    QueueItem #q-input {
+        width: 1fr;
+        height: 1;
+        background: ansi_default;
+        border: none;
+        padding: 0 1 0 0;
+        margin: 0;
+    }
+    QueueItem #q-edit, QueueItem #q-send {
+        width: 3;
+        min-width: 3;
+        height: 3;
+        border: none;
+        background: ansi_default;
+        padding: 0;
+        margin: 0;
+    }
+    """
+
+    class Send(Message):
+        def __init__(self, ticket_id: int) -> None:
+            super().__init__()
+            self.ticket_id = ticket_id
+
+    class Edited(Message):
+        def __init__(self, ticket_id: int, text: str) -> None:
+            super().__init__()
+            self.ticket_id = ticket_id
+            self.text = text
+
+    def __init__(self, ticket_id: int, text: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.ticket_id = ticket_id
+        self._text = text
+
+    @property
+    def text(self) -> str:
+        return self._text
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._text, id="q-text")
+        yield Button("✎", id="q-edit", compact=True, tooltip="编辑")
+        yield Button("➤", id="q-send", compact=True, tooltip="发送")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        event.stop()
+        if event.button.id == "q-edit":
+            self._start_edit()
+        elif event.button.id == "q-send":
+            sender = getattr(self.app, "force_send_queued", None)
+            if callable(sender):
+                sender(self.ticket_id)
+
+    def _start_edit(self) -> None:
+        if self.query("#q-input"):
+            self.query_one("#q-input", Input).focus()
+            return
+        self.query_one("#q-text").display = False
+        field = Input(value=self._text, id="q-input")
+        self.mount(field, before=self.query_one("#q-edit"))
+        field.focus()
+
+    def _finish_edit(self, value: str) -> None:
+        text = value.strip() or self._text
+        self._text = text
+        label = self.query_one("#q-text", Static)
+        label.update(text)
+        label.display = True
+        if self.query("#q-input"):
+            self.query_one("#q-input").remove()
+        self.post_message(self.Edited(self.ticket_id, text))
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id != "q-input":
+            return
+        event.stop()
+        self._finish_edit(event.value)
+
+    def on_input_blurred(self, event: Input.Blurred) -> None:
+        if event.input.id != "q-input":
+            return
+        event.stop()
+        self._finish_edit(event.value)
+
+
+class QueueList(Vertical):
+    """输入框上方的排队弹窗列表,有几条就显示几条。"""
+
+    DEFAULT_CSS = """
+    QueueList {
+        width: 1fr;
+        height: auto;
+        background: ansi_default;
+        display: none;
+    }
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._items: list[QueueItem] = []
+
+    def enqueue(self, ticket_id: int, text: str) -> None:
+        item = QueueItem(ticket_id, text)
+        self._items.append(item)
+        self.display = True
+        self.mount(item)
+
+    def _sync_display(self) -> None:
+        self.display = bool(self._items)
+
+    def take(self, ticket_id: int) -> str | None:
+        for i, item in enumerate(self._items):
+            if item.ticket_id == ticket_id:
+                text = item.text
+                self._items.pop(i)
+                item.remove()
+                self._sync_display()
+                return text
+        return None
+
+    def pop_front(self) -> str | None:
+        if not self._items:
+            return None
+        item = self._items.pop(0)
+        text = item.text
+        item.remove()
+        self._sync_display()
+        return text
+
+    def move_front(self, ticket_id: int) -> None:
+        idx = next(
+            (i for i, item in enumerate(self._items) if item.ticket_id == ticket_id),
+            -1,
+        )
+        if idx <= 0:
+            return
+        item = self._items.pop(idx)
+        self._items.insert(0, item)
+        others = [c for c in self.children if c is not item]
+        if others:
+            self.move_child(item, before=others[0])
+
+
+class RunStatus(Static):
+    """输入框上方一行:等待、思考、跑工具时的加载反馈。"""
+
+    DEFAULT_CSS = """
+    RunStatus {
+        width: 1fr;
+        height: 1;
+        background: ansi_default;
+        display: none;
+        padding: 0 1;
+        text-wrap: nowrap;
+        overflow-x: hidden;
+        overflow-y: hidden;
+    }
+    """
+
+    def show_line(self, renderable: Text) -> None:
+        self.display = True
+        self.update(renderable)
+
+    def hide(self) -> None:
+        self.display = False
+        self.update("")
+
+
+SLASH_COMMANDS: tuple[tuple[str, str, tuple[str, ...]], ...] = (
+    ("/new", "新开一扇对话窗口，当前会话先收进栈里", ("/clear",)),
+    ("/changewin", "打开窗口列表选择会话，也可跟 id", ("/win", "/change-win")),
+    ("/zip", "手动压缩上下文，可加保留提示", ("/compact",)),
+    ("/history", "回退到某次提问前的代码和对话", ("/rewind", "/undo")),
+    ("/model", "切换模型：/model 弹列表，/model <序号或id> 直接切", ()),
+    ("/effort", "推理等级：/effort 弹列表，或 /effort low|medium|high|默认", ()),
+    ("/rename", "给当前窗口改名：/rename <新标题>", ()),
+    ("/delwin", "删除一个历史窗口：/delwin <id前缀>，当前窗口不能删", ()),
+    ("/export", "把当前窗口的对话导出成 Markdown 文件", ("/save",)),
+    ("/img", "附加一张图片随下一条消息发给模型：/img <路径>", ("/image", "/pic")),
+    ("/ask", "切换到 ask：敏感操作先问你", ()),
+    ("/pass", "切换到 pass：一条龙不问", ()),
+)
+
+
+def _slash_matches(typed: str) -> list[tuple[str, str]]:
+    raw = typed.strip()
+    if not raw.startswith("/"):
+        return []
+    head = raw.split(None, 1)[0].lower()
+    if " " in raw.strip():
+        return []
+    out: list[tuple[str, str]] = []
+    for cmd, help_text, aliases in SLASH_COMMANDS:
+        keys = (cmd,) + aliases
+        if head == "/" or any(key.startswith(head) for key in keys):
+            alias = f"  别名 {' '.join(aliases)}" if aliases else ""
+            out.append((cmd, help_text + alias))
+    return out
+
+
+class CommandHints(Vertical):
+    """输入 / 时出现的命令补全,带每条命令的作用。"""
+
+    DEFAULT_CSS = """
+    CommandHints {
+        width: 1fr;
+        height: auto;
+        background: ansi_default;
+        display: none;
+        padding: 0 1 1 1;
+    }
+    CommandHints Static {
+        width: 1fr;
+        height: 1;
+        background: ansi_default;
+        text-wrap: nowrap;
+        overflow: hidden;
+    }
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._items: list[tuple[str, str]] = []
+        self._index = 0
+
+    def hide(self) -> None:
+        self._items = []
+        self._index = 0
+        self.display = False
+        self.remove_children()
+
+    def set_items(self, items: list[tuple[str, str]]) -> None:
+        if not items:
+            self.hide()
+            return
+        if self._items != items:
+            self._index = 0
+        self._items = items
+        if self._index >= len(items):
+            self._index = 0
+        self.display = True
+        self._render_rows()
+
+    def move(self, delta: int) -> None:
+        if not self._items:
+            return
+        self._index = (self._index + delta) % len(self._items)
+        self._render_rows()
+
+    def current_cmd(self) -> str:
+        if not self._items:
+            return ""
+        return self._items[self._index][0]
+
+    def _render_rows(self) -> None:
+        self.remove_children()
+        for i, (cmd, help_text) in enumerate(self._items):
+            line = Text()
+            if i == self._index:
+                line.append("› ", style="bold #d9a84e")
+                line.append(f"{cmd:<12}", style="bold #d9a84e")
+            else:
+                line.append("  ")
+                line.append(f"{cmd:<12}", style="bold #b5ae9d")
+            line.append(help_text, style="dim")
+            self.mount(Static(line))
+
+
+def _cost_usd(inp: int, out: int, cache: int) -> float:
+    """按 config.json 的 pricing(每百万 token 美元)估成本;没配就返回 0。"""
+    if not _PRICING:
+        return 0.0
+    pin = float(_PRICING.get("input") or 0)
+    pout = float(_PRICING.get("output") or 0)
+    pcache = _PRICING.get("cacheRead")
+    if pcache is None:
+        pcache = _PRICING.get("cache_read")
+    pcache = float(pcache or 0)
+    if not (pin or pout or pcache):
+        return 0.0
+    miss = max(0, int(inp) - int(cache))
+    return (miss * pin + int(cache) * pcache + int(out) * pout) / 1_000_000
+
+
+class TodoPanel(Vertical):
+    """todo_write 的可视面板:模型列待办,这里实时画出来;没待办就整块隐藏。"""
+
+    _MARKS = (
+        ("completed", "✓", "bold #8fbf9f"),
+        ("in_progress", "→", "bold #d9a84e"),
+        ("cancelled", "x", "dim strike"),
+        ("pending", "·", "dim"),
+    )
+
+    DEFAULT_CSS = """
+    TodoPanel {
+        width: 1fr;
+        height: auto;
+        max-height: 8;
+        background: ansi_default;
+        display: none;
+        padding: 0 1;
+        overflow-x: hidden;
+        overflow-y: auto;
+    }
+    TodoPanel Static {
+        width: 1fr;
+        height: 1;
+        background: ansi_default;
+        text-wrap: nowrap;
+        overflow: hidden;
+    }
+    """
+
+    def set_todos(self, todos: list) -> None:
+        self.remove_children()
+        rows = [t for t in (todos or []) if isinstance(t, dict)]
+        self.display = bool(rows)
+        for t in rows:
+            status = str(t.get("status") or "pending")
+            mark, style = next(
+                ((m, s) for key, m, s in self._MARKS if key == status), ("·", "dim")
+            )
+            line = Text()
+            line.append(f"{mark} ", style=style)
+            line.append(str(t.get("content") or t.get("id") or ""), style=style)
+            self.mount(Static(line))
+
+
+class FileHints(Vertical):
+    """输入 @ 时弹出的项目文件补全,Tab 选中。"""
+
+    DEFAULT_CSS = """
+    FileHints {
+        width: 1fr;
+        height: auto;
+        max-height: 9;
+        background: ansi_default;
+        display: none;
+        padding: 0 1 1 1;
+        overflow-x: hidden;
+        overflow-y: auto;
+    }
+    FileHints Static {
+        width: 1fr;
+        height: 1;
+        background: ansi_default;
+        text-wrap: nowrap;
+        overflow: hidden;
+    }
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._items: list[str] = []
+        self._prefix = ""
+        self._index = 0
+
+    def set_items(self, prefix: str, items: list[str]) -> None:
+        if not items:
+            self.hide()
+            return
+        self._prefix = prefix
+        self._items = items
+        if self._index >= len(items):
+            self._index = 0
+        self.display = True
+        self._render_rows()
+
+    def hide(self) -> None:
+        self._items = []
+        self._index = 0
+        self.display = False
+        self.remove_children()
+
+    def move(self, delta: int) -> None:
+        if not self._items:
+            return
+        self._index = (self._index + delta) % len(self._items)
+        self._render_rows()
+
+    def current(self) -> str:
+        if not self._items:
+            return ""
+        return self._items[self._index]
+
+    def _render_rows(self) -> None:
+        self.remove_children()
+        for i, path in enumerate(self._items):
+            line = Text()
+            if i == self._index:
+                line.append("› ", style="bold #d9a84e")
+                line.append(path, style="bold #d9a84e")
+            else:
+                line.append("  ")
+                line.append(path, style="#b5ae9d")
+            self.mount(Static(line))
+
+
+class ModelPicker(Vertical):
+    """ /model 或 Ctrl+M 弹出的模型列表,选一个立即切换。"""
+
+    class Picked(Message):
+        def __init__(self, model_id: str) -> None:
+            super().__init__()
+            self.model_id = model_id
+
+    DEFAULT_CSS = """
+    ModelPicker {
+        width: 1fr;
+        height: auto;
+        max-height: 14;
+        background: ansi_default;
+        display: none;
+        padding: 0 1 1 1;
+        overflow-x: hidden;
+        overflow-y: auto;
+    }
+    ModelPicker #model-head {
+        width: 1fr;
+        height: 1;
+        background: ansi_default;
+        color: grey;
+        text-wrap: nowrap;
+        overflow: hidden;
+    }
+    ModelPicker OptionList {
+        width: 1fr;
+        height: auto;
+        max-height: 12;
+        background: ansi_default;
+        color: grey;
+        border: none;
+        padding: 0;
+        overflow-x: hidden;
+    }
+    ModelPicker OptionList:focus {
+        background: ansi_default;
+        background-tint: ansi_default;
+        border: none;
+    }
+    ModelPicker OptionList > .option-list--option-highlighted {
+        color: #f0e2c0;
+        background: #4a3f22;
+        text-style: bold;
+    }
+    ModelPicker OptionList:focus > .option-list--option-highlighted {
+        color: #f5e6c4;
+        background: #5a4b28;
+        text-style: bold;
+    }
+    ModelPicker OptionList > .option-list--option-hover {
+        background: #3a3222;
+        color: #f0e2c0;
+    }
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._models: list[str] = []
+
+    def compose(self) -> ComposeResult:
+        yield Static(
+            Text.from_markup(f"[bold {_AMBER}]▎[/]选择模型    ↑↓ 移动  回车切换  Esc取消"),
+            id="model-head",
+        )
+        yield OptionList(id="model-list", compact=True)
+
+    def _listing(self) -> OptionList:
+        return self.query_one("#model-list", OptionList)
+
+    def set_models(self, models: list[str], current: str) -> None:
+        self._models = list(models)
+        options: list[Option] = []
+        for m in self._models:
+            label = Text()
+            if m == current:
+                label.append("● ", style=f"bold {_AMBER}")
+                label.append(m, style=f"bold {_AMBER}")
+            else:
+                label.append("  ")
+                label.append(m, style="#b5ae9d")
+            options.append(Option(label, id=m))
+        listing = self._listing()
+        if options:
+            listing.set_options(options)
+            listing.highlighted = (
+                self._models.index(current) if current in self._models else 0
+            )
+        else:
+            listing.clear_options()
+        self.display = True
+
+    def hide(self) -> None:
+        self.display = False
+        try:
+            self._listing().clear_options()
+        except Exception:
+            pass
+
+    def confirm(self) -> None:
+        try:
+            self._listing().action_select()
+        except Exception:
+            pass
+
+    def move(self, delta: int) -> None:
+        listing = self._listing()
+        if delta > 0:
+            listing.action_cursor_down()
+        elif delta < 0:
+            listing.action_cursor_up()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        event.stop()
+        mid = event.option_id or (event.option.id if event.option else "")
+        if mid:
+            self.post_message(self.Picked(mid))
+
+
+# 等级名用协议原值,说明给人看;"" 即 default,不发参数
+_EFFORT_DESC: dict[str, str] = {
+    "": "服务端自己决定",
+    "low": "快，省 token",
+    "medium": "均衡",
+    "high": "慢，推理更深",
+    "minimal": "最快",
+}
+
+# 启发式:模型 id 长这样的多半是推理模型(o3/gpt-5/R1/QwQ/thinking…)
+_REASONING_HINT = re.compile(
+    r"(^|[-_/.])(o[1345](-mini|preview|-pro)?|gpt-5|reasoner|r[12]|qwq|thinking)",
+    re.I,
+)
+
+
+def _looks_like_reasoning_model(model_id: str) -> bool:
+    return bool(_REASONING_HINT.search(model_id or ""))
+
+
+class EffortPicker(Vertical):
+    """选完模型后弹出的推理等级选择;也由 /effort 唤出。"""
+
+    class Picked(Message):
+        def __init__(self, effort: str) -> None:
+            super().__init__()
+            self.effort = effort
+
+    DEFAULT_CSS = """
+    EffortPicker {
+        width: 1fr;
+        height: auto;
+        max-height: 14;
+        background: ansi_default;
+        display: none;
+        padding: 0 1 1 1;
+        overflow-x: hidden;
+        overflow-y: auto;
+    }
+    EffortPicker #effort-head {
+        width: 1fr;
+        height: 1;
+        background: ansi_default;
+        color: grey;
+        text-wrap: nowrap;
+        overflow: hidden;
+    }
+    EffortPicker OptionList {
+        width: 1fr;
+        height: auto;
+        max-height: 8;
+        background: ansi_default;
+        color: grey;
+        border: none;
+        padding: 0;
+        overflow-x: hidden;
+    }
+    EffortPicker OptionList:focus {
+        background: ansi_default;
+        background-tint: ansi_default;
+        border: none;
+    }
+    EffortPicker OptionList > .option-list--option-highlighted {
+        color: #f0e2c0;
+        background: #4a3f22;
+        text-style: bold;
+    }
+    EffortPicker OptionList:focus > .option-list--option-highlighted {
+        color: #f5e6c4;
+        background: #5a4b28;
+        text-style: bold;
+    }
+    EffortPicker OptionList > .option-list--option-hover {
+        background: #3a3222;
+        color: #f0e2c0;
+    }
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._values: list[str] = []
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="effort-head")
+        yield OptionList(id="effort-list", compact=True)
+
+    def _listing(self) -> OptionList:
+        return self.query_one("#effort-list", OptionList)
+
+    def set_efforts(
+        self,
+        model_id: str,
+        current: str,
+        detected: bool,
+        levels: list[str] | None = None,
+    ) -> None:
+        """levels 是 /models 元数据里拿到的支持等级;空则用标准四档兜底。"""
+        head = self.query_one("#effort-head", Static)
+        line = Text()
+        line.append("▎", style=f"bold {_AMBER}")
+        line.append(f"{model_id} ", style=f"bold {_AMBER}")
+        if levels:
+            line.append("支持的推理等级（来自 /models）    ", style="dim")
+        elif detected:
+            line.append("疑似推理模型，选推理等级    ", style="dim")
+        else:
+            line.append("选推理等级（看不出来的就选 default）    ", style="dim")
+        line.append("↑↓ 移动  回车确定  Esc跳过", style="dim")
+        head.update(line)
+        known = levels or ["low", "medium", "high"]
+        self._values = [""] + [v for v in known if v in _EFFORT_DESC and v]
+        options: list[Option] = []
+        highlight = 0
+        for i, value in enumerate(self._values):
+            name = value or "default"
+            label = Text()
+            chosen = value == current
+            if chosen:
+                label.append("● ", style=f"bold {_AMBER}")
+                label.append(f"{name:<8}", style=f"bold {_AMBER}")
+            else:
+                label.append("  ")
+                label.append(f"{name:<8}", style="#b5ae9d")
+            label.append(_EFFORT_DESC.get(value, ""), style="dim")
+            options.append(Option(label, id=name))
+            if chosen:
+                highlight = i
+        listing = self._listing()
+        listing.set_options(options)
+        listing.highlighted = highlight
+        self.display = True
+
+    def hide(self) -> None:
+        self.display = False
+        try:
+            self._listing().clear_options()
+        except Exception:
+            pass
+
+    def confirm(self) -> None:
+        try:
+            self._listing().action_select()
+        except Exception:
+            pass
+
+    def move(self, delta: int) -> None:
+        listing = self._listing()
+        if delta > 0:
+            listing.action_cursor_down()
+        elif delta < 0:
+            listing.action_cursor_up()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        event.stop()
+        oid = event.option_id or (event.option.id if event.option else "")
+        self.post_message(self.Picked("" if oid == "default" else oid))
+
+
+class SessionPicker(Vertical):
+    """ /changewin 弹出的窗口列表,选一扇再切。"""
+
+    class Picked(Message):
+        def __init__(self, session_id: str) -> None:
+            super().__init__()
+            self.session_id = session_id
+
+    DEFAULT_CSS = """
+    SessionPicker {
+        width: 1fr;
+        height: auto;
+        max-height: 14;
+        background: ansi_default;
+        display: none;
+        padding: 0 1 1 1;
+        overflow-x: hidden;
+        overflow-y: auto;
+    }
+    SessionPicker #win-head {
+        width: 1fr;
+        height: 1;
+        background: ansi_default;
+        color: grey;
+        text-wrap: nowrap;
+        overflow: hidden;
+        margin-bottom: 0;
+    }
+    SessionPicker OptionList {
+        width: 1fr;
+        height: auto;
+        max-height: 12;
+        background: ansi_default;
+        color: grey;
+        border: none;
+        padding: 0;
+        overflow-x: hidden;
+    }
+    SessionPicker OptionList:focus {
+        background: ansi_default;
+        background-tint: ansi_default;
+        border: none;
+    }
+    SessionPicker OptionList > .option-list--option-highlighted {
+        color: #f0e2c0;
+        background: #4a3f22;
+        text-style: bold;
+    }
+    SessionPicker OptionList:focus > .option-list--option-highlighted {
+        color: #f5e6c4;
+        background: #5a4b28;
+        text-style: bold;
+    }
+    SessionPicker OptionList > .option-list--option-hover {
+        background: #3a3222;
+        color: #f0e2c0;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Static(
+            Text.from_markup(f"[bold {_AMBER}]▎[/]选择窗口    ↑↓ 移动  回车打开  Esc取消"),
+            id="win-head",
+        )
+        yield OptionList(id="win-list", compact=True)
+
+    def set_sessions(
+        self,
+        rows: list[dict],
+        current_id: str,
+        preferred_id: str = "",
+    ) -> None:
+        listing = self.query_one("#win-list", OptionList)
+        options: list[Option] = []
+        ids: list[str] = []
+        for row in rows:
+            sid = str(row.get("id") or "")
+            if not sid:
+                continue
+            options.append(Option(_session_prompt(row, current_id), id=sid))
+            ids.append(sid)
+        highlight = 0
+        if preferred_id and preferred_id in ids:
+            highlight = ids.index(preferred_id)
+        else:
+            for i, sid in enumerate(ids):
+                if sid != current_id:
+                    highlight = i
+                    break
+        if options:
+            listing.set_options(options)
+            listing.highlighted = highlight
+        else:
+            listing.clear_options()
+        self.display = True
+
+    def hide(self) -> None:
+        self.display = False
+        try:
+            self.query_one("#win-list", OptionList).clear_options()
+        except Exception:
+            pass
+
+    def confirm(self) -> None:
+        try:
+            self.query_one("#win-list", OptionList).action_select()
+        except Exception:
+            pass
+
+    def move(self, delta: int) -> None:
+        listing = self.query_one("#win-list", OptionList)
+        if delta > 0:
+            listing.action_cursor_down()
+        elif delta < 0:
+            listing.action_cursor_up()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        event.stop()
+        sid = event.option_id or (event.option.id if event.option else "")
+        if sid:
+            self.post_message(self.Picked(sid))
+
+
+class HistoryPicker(Vertical):
+    """ /history 弹出的回退点,先选提问再选回退代码/对话。"""
+
+    class Picked(Message):
+        def __init__(self, checkpoint_id: str, action: str) -> None:
+            super().__init__()
+            self.checkpoint_id = checkpoint_id
+            self.action = action
+
+    DEFAULT_CSS = """
+    HistoryPicker {
+        width: 1fr;
+        height: auto;
+        max-height: 14;
+        background: ansi_default;
+        display: none;
+        padding: 0 1 1 1;
+        overflow-x: hidden;
+        overflow-y: auto;
+    }
+    HistoryPicker #hist-head {
+        width: 1fr;
+        height: 1;
+        background: ansi_default;
+        color: grey;
+        text-wrap: nowrap;
+        overflow: hidden;
+    }
+    HistoryPicker OptionList {
+        width: 1fr;
+        height: auto;
+        max-height: 12;
+        background: ansi_default;
+        color: grey;
+        border: none;
+        padding: 0;
+        overflow-x: hidden;
+    }
+    HistoryPicker OptionList:focus {
+        background: ansi_default;
+        background-tint: ansi_default;
+        border: none;
+    }
+    HistoryPicker OptionList > .option-list--option-highlighted {
+        color: #f0e2c0;
+        background: #4a3f22;
+        text-style: bold;
+    }
+    HistoryPicker OptionList:focus > .option-list--option-highlighted {
+        color: #f5e6c4;
+        background: #5a4b28;
+        text-style: bold;
+    }
+    HistoryPicker OptionList > .option-list--option-hover {
+        background: #3a3222;
+        color: #f0e2c0;
+    }
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._rows: list[dict] = []
+        self._phase = "turns"
+        self._current: dict | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Static(
+            Text.from_markup(f"[bold {_AMBER}]▎[/]选择回退点    ↑↓ 移动  回车  Esc取消"),
+            id="hist-head",
+        )
+        yield OptionList(id="hist-list", compact=True)
+
+    def _listing(self) -> OptionList:
+        return self.query_one("#hist-list", OptionList)
+
+    def _head(self) -> Static:
+        return self.query_one("#hist-head", Static)
+
+    def set_rows(self, rows: list[dict]) -> None:
+        self._rows = list(rows)
+        self._phase = "turns"
+        self._current = None
+        self._render_turns()
+        self.display = True
+
+    def hide(self) -> None:
+        self.display = False
+        self._phase = "turns"
+        self._current = None
+        self._rows = []
+        try:
+            self._listing().clear_options()
+        except Exception:
+            pass
+
+    def confirm(self) -> None:
+        try:
+            self._listing().action_select()
+        except Exception:
+            pass
+
+    def move(self, delta: int) -> None:
+        listing = self._listing()
+        if delta > 0:
+            listing.action_cursor_down()
+        elif delta < 0:
+            listing.action_cursor_up()
+
+    def back_or_close(self) -> bool:
+        """Esc:动作菜单退回列表,返回 True 表示已处理。"""
+        if self._phase == "actions":
+            self._render_turns()
+            return True
+        return False
+
+    def _render_turns(self) -> None:
+        self._phase = "turns"
+        self._current = None
+        self._head().update("选择回退点    ↑↓ 移动  回车  Esc取消")
+        options: list[Option] = []
+        for row in self._rows:
+            cid = str(row.get("id") or "")
+            if not cid:
+                continue
+            options.append(Option(_history_prompt(row), id=cid))
+        listing = self._listing()
+        if options:
+            listing.set_options(options)
+            listing.highlighted = 0
+        else:
+            listing.clear_options()
+
+    def _render_actions(self, row: dict) -> None:
+        self._phase = "actions"
+        self._current = row
+        title = str(row.get("title") or "这一轮")
+        if len(title) > 24:
+            title = title[:23] + "…"
+        self._head().update(f"回退到「{title}」之前    Esc返回")
+        dirty = int(row.get("later_files") or 0) > 0
+        options: list[Option] = []
+        if dirty:
+            options.append(Option("回退代码和对话", id="both"))
+            options.append(Option("只回退对话，代码不动", id="chat"))
+            options.append(Option(f"只回退代码（{row.get('later_files')} 个文件）", id="code"))
+        else:
+            options.append(Option("回退对话（这轮之后没有改文件）", id="chat"))
+        options.append(Option("取消", id="back"))
+        listing = self._listing()
+        listing.set_options(options)
+        listing.highlighted = 0
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        event.stop()
+        oid = event.option_id or (event.option.id if event.option else "")
+        if not oid:
+            return
+        if self._phase == "turns":
+            hit = next((r for r in self._rows if r.get("id") == oid), None)
+            if hit:
+                self._render_actions(hit)
+            return
+        if oid == "back":
+            self._render_turns()
+            return
+        current = self._current
+        if not current:
+            return
+        self.post_message(self.Picked(str(current["id"]), oid))
+
+
+class PermitScreen(ModalScreen[bool]):
+    """ask 模式:弹窗让用户允许或拒绝敏感操作。"""
+
+    BINDINGS = [
+        Binding("y", "yes", show=False),
+        Binding("n", "no", show=False),
+        Binding("escape", "no", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    PermitScreen {
+        align: center middle;
+        background: ansi_default 40%;
+    }
+    PermitScreen #permit-box {
+        width: 64;
+        max-width: 90%;
+        height: auto;
+        background: ansi_default;
+        border: round #d9a84e;
+        padding: 1 2;
+    }
+    PermitScreen #permit-title {
+        width: 1fr;
+        height: auto;
+        color: #d9a84e;
+        text-style: bold;
+        background: ansi_default;
+    }
+    PermitScreen #permit-body {
+        width: 1fr;
+        height: auto;
+        margin: 1 0;
+        background: ansi_default;
+        text-wrap: wrap;
+    }
+    PermitScreen #permit-actions {
+        width: 1fr;
+        height: auto;
+        align: center middle;
+        background: ansi_default;
+    }
+    PermitScreen Button {
+        min-width: 10;
+        margin: 0 1;
+        background: ansi_default;
+    }
+    """
+
+    def __init__(self, preview: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._preview = (preview or "").strip() or "（无说明）"
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="permit-box"):
+            yield Static("允许这次操作？", id="permit-title")
+            yield Static(self._preview, id="permit-body")
+            with Horizontal(id="permit-actions"):
+                yield Button("允许  Y", id="permit-yes")
+                yield Button("拒绝  N", id="permit-no")
+
+    def on_mount(self) -> None:
+        self.query_one("#permit-yes", Button).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        event.stop()
+        self.dismiss(event.button.id == "permit-yes")
+
+    def action_yes(self) -> None:
+        self.dismiss(True)
+
+    def action_no(self) -> None:
+        self.dismiss(False)
+
+
+def _history_prompt(row: dict) -> Text:
+    line = Text()
+    title = " ".join(str(row.get("title") or "").split()) or "无标题"
+    if len(title) > 32:
+        title = title[:31] + "…"
+    line.append(title)
+    n = int(row.get("later_files") or 0)
+    if n:
+        line.append(f"  {n} 个文件", style="dim")
+    else:
+        line.append("  无改动", style="dim")
+    line.append(f"  {_rel_time(int(row.get('created_at') or 0))}", style="dim")
+    return line
+
+
+class AgentFooter(Footer):
+    """底部栏:左边模型名和 token,右边仍是快捷键 / palette。"""
+
+    meta = reactive(Text(""))
+
+    def compose(self) -> ComposeResult:
+        yield Label(self.meta, id="footer-meta")
+        yield from super().compose()
+
+    def watch_meta(self, value: str) -> None:
+        try:
+            self.query_one("#footer-meta", Label).update(value)
+        except Exception:
+            pass
+
+
+class AgentApp(App):
+    """一个聊天风格的终端 agent 外壳。"""
+
+    # 窗口标题,显示在 Header 里
+    TITLE = CONFIG.get("name", "Agent TUI")
+    # agent 版本号,来自 config.json,欢迎语里会显示
+    VERSION = CONFIG.get("version", "0.0.0")
+
+    BINDINGS = [
+        Binding("escape", "interrupt", "打断", show=False, priority=True),
+        Binding("ctrl+c", "interrupt_or_quit", "打断", show=False, priority=True),
+        Binding("ctrl+m", "pick_model", "切模型", show=True, priority=True),
+        Binding("tab", "slash_complete", show=False, priority=True),
+        Binding("down", "slash_next", show=False, priority=True),
+        Binding("up", "slash_prev", show=False, priority=True),
+        Binding("enter", "confirm_overlay", show=False, priority=True),
+        Binding("shift+tab", "toggle_perm_mode", show=False, priority=True),
+    ]
+
+    # 内联样式表。Textual 用 CSS 描述布局和外观。
+    # 颜色用十六进制值或内置色名(grey/white 等)都可以。
+    #
+    # 背景必须用 ansi_default,不能用 transparent:
+    #   transparent 的 RGB 是 (0,0,0)、alpha 是 0;Textual 画底时会丢掉 alpha,
+    #   变成纯黑 #000000,于是日志区四周、输入框左右会出现一圈黑边。
+    #   ansi_default 发给终端的是"用你自己的底色"(SGR 49),终端透明底才能透出来。
+    CSS = """
+    App {
+        background: ansi_default;
+    }
+    Screen {
+        background: ansi_default;
+    }
+    #composer {
+        dock: bottom;
+        height: auto;
+        background: ansi_default;
+        margin-bottom: 1;          /* 给底部 Footer 留一行 */
+    }
+    #prompt {
+        background: ansi_default;
+        padding: 0 1;              /* 覆盖默认 padding: 0 2,否则左右各空 2 格,透出黑底 */
+        margin-bottom: 0;
+        border-top: tall grey;     /* 上边框:灰色 */
+        border-bottom: tall grey;  /* 下边框:灰色 */
+        border-left: none;         /* 去掉左边竖线 */
+        border-right: none;        /* 去掉右边竖线 */
+    }
+    #prompt:focus {
+        background: ansi_default;
+        background-tint: ansi_default;  /* 关掉默认的 $foreground 5% 着色,否则聚焦时又变成实心色块 */
+        border-top: tall grey;     /* 聚焦时同样只留上下两条灰线 */
+        border-bottom: tall grey;
+        border-left: none;
+        border-right: none;
+    }
+    ChatLog {
+        background: ansi_default;
+        border: none;
+        padding: 1 1;
+        overflow-x: hidden;
+        overflow-y: auto;
+        scrollbar-background: ansi_default;
+        scrollbar-color: grey;
+        scrollbar-size-vertical: 1;
+        scrollbar-corner-color: ansi_default;
+    }
+    ChatLog:focus {
+        background: ansi_default;
+        background-tint: ansi_default;
+    }
+    ChatLog Collapsible {
+        width: 1fr;
+        height: auto;
+        background: ansi_default;
+        border: none;
+        padding: 0;
+    }
+    ChatLog Collapsible.-collapsed Contents {
+        display: none;
+    }
+    ChatLog CollapsibleTitle {
+        width: auto;
+        background: ansi_default;
+    }
+    Footer {
+        background: ansi_default;  /* 底部状态栏跟终端底色走,不留实心色块 */
+    }
+    FooterKey {
+        background: ansi_default;
+    }
+    #footer-meta {
+        width: auto;
+        height: 1;
+        padding: 0 1;
+        color: grey;
+        background: ansi_default;
+        text-wrap: nowrap;
+    }
+    Hero {
+        width: auto;
+        height: auto;
+        background: ansi_default;
+        padding: 0 0 1 0;
+        overflow-x: hidden;
+        overflow-y: hidden;
+    }
+    SessionPicker {
+        width: 1fr;
+        height: auto;
+        max-height: 14;
+        background: ansi_default;
+        display: none;
+        padding: 0 1 1 1;
+    }
+    HistoryPicker {
+        width: 1fr;
+        height: auto;
+        max-height: 14;
+        background: ansi_default;
+        display: none;
+        padding: 0 1 1 1;
+    }
+    #run-status {
+        width: 1fr;
+        height: 1;
+        background: ansi_default;
+        display: none;
+        padding: 0 1;
+        text-wrap: nowrap;
+        overflow-x: hidden;
+        overflow-y: hidden;
+    }
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        # 必须开原生 ANSI 色:默认主题会把 ansi_default 转成 Monokai 的 #0c0c0c,看起来仍是黑底。
+        kwargs.setdefault("ansi_color", True)
+        super().__init__(*args, **kwargs)
+        self._committed_in = 0
+        self._committed_out = 0
+        self._committed_cache = 0
+        self._live_in = 0
+        self._live_out = 0
+        self._live_cache = 0
+        # 本轮已收到的官方用量累加(多轮工具调用每轮都给一份 usage)
+        self._usage_in = 0
+        self._usage_out = 0
+        self._usage_cache = 0
+        self._got_official = False
+        self._retry_attempt = 0
+        self._retry_total = 0
+        self._pending_images: list[tuple[str, str]] = []
+        self._current_prompt = ""
+        self._waiting = False
+        self._wait_timer: Timer | None = None
+        self._wait_t0 = 0.0
+        self._active_turn: AgentTurn | None = None
+        self._thinking_text = ""
+        self._answer_text = ""
+        self._store = Store()
+        self._session_id = self._store.open_or_create()
+        # 上次跑到一半退过,也要把库里记的用量接上,底部 ↑↓ 才和磁盘会话对得上
+        saved_in, saved_out, saved_cache = self._store.usage_of(self._session_id)
+        self._committed_in = saved_in
+        self._committed_out = saved_out
+        self._committed_cache = saved_cache
+        self._ticket_seq = 0
+        self._busy = False
+        self._hold_queue = False
+        self._pending_prompt: str | None = None
+        self._pending_model: str = ""  # 模型选择器里选中、等待选推理等级的模型
+        self._session_stack: list[str] = []
+        self._checkpoint_id: str | None = None
+        self._run_id = 0
+        self._writes_frozen = False
+        self._perm_mode = get_permission_mode()
+        self._permit_future: asyncio.Future | None = None
+        self._input_history: list[str] = []
+        self._input_hist_idx = -1
+        self._input_draft = ""
+        self._status_kind = "idle"
+        self._status_label = ""
+
+    # compose() 返回界面上所有部件,从上到下、按 yield 顺序排列。
+    # 部件可以带 id(如 id="output"),之后用 query_one("#output") 精准拿到它。
+    def compose(self) -> ComposeResult:
+        yield ChatLog(id="output")                                # 欢迎横幅在对话流里,往下滚就看不见
+        with Vertical(id="composer"):
+            yield TodoPanel(id="todo-panel")
+            yield QueueList(id="queue")
+            yield CommandHints(id="slash-hints")
+            yield FileHints(id="file-hints")
+            yield SessionPicker(id="win-picker")
+            yield ModelPicker(id="model-picker")
+            yield EffortPicker(id="effort-picker")
+            yield HistoryPicker(id="hist-picker")
+            yield RunStatus(id="run-status")
+            yield Input(placeholder="Ask the Lcode something, then Enter, bro.", id="prompt")
+        yield AgentFooter()                                       # 底部:模型 + token,右边 palette
+
+    # on_mount 在界面第一次渲染完成后调用,是初始化的好地方。
+    def on_mount(self) -> None:
+        # 把键盘焦点放到输入框上,这样打开就能直接打字
+        self.query_one(Input).focus()
+        set_write_hook(self._on_file_write)
+        set_todo_hook(self._on_todos_changed)
+        todos = self._store.load_todos(str(Path.cwd()))
+        if todos:
+            set_todos(todos)  # 会通过 hook 画到面板上
+        self._refresh_footer_meta()
+        self._restore_history()
+        self._load_model_limits()
+
+    def _on_todos_changed(self, todos: list) -> None:
+        """todo_write 变化:落库 + 刷新面板。"""
+        try:
+            self._store.save_todos(str(Path.cwd()), todos)
+        except Exception:
+            pass
+        try:
+            self.query_one("#todo-panel", TodoPanel).set_todos(todos)
+        except Exception:
+            pass
+
+    @work
+    async def _load_model_limits(self) -> None:
+        """按模型 context_length 的百分比自动 compact,和 Grok 一样。"""
+        info = await fetch_model_limits()
+        window = int(info.get("context_length") or info.get("input_budget") or 128_000)
+        try:
+            percent = int(CONFIG.get("autoCompactPercent") or 85)
+        except (TypeError, ValueError):
+            percent = 85
+        self._store.apply_window(window, percent)
+        self._refresh_footer_meta()
+
+    async def _mount_history_messages(self, chat: ChatLog) -> None:
+        """把 session 的对话挂回画面:用户句、思考、正文,连带工具卡片一起。"""
+        turn: AgentTurn | None = None
+        # call_id -> (卡片, 工具名),等后面的 tool 结果消息来收尾
+        pending: dict[str, tuple[ToolCall, str]] = {}
+        for msg in self._store.list_messages(self._session_id):
+            meta = _msg_meta(msg.meta)
+            if msg.role == "user":
+                turn = None
+                pending = {}
+                await chat.mount(UserTurn(msg.content))
+                names = meta.get("images") or []
+                if names:
+                    shown = "、".join(str(n) for n in names[:6])
+                    extra = f" 等 {len(names)} 张" if len(names) > 6 else ""
+                    await chat.mount(Static(Text(f"  🖼 {shown}{extra}", style="dim")))
+            elif msg.role == "assistant":
+                calls = meta.get("tool_calls") or []
+                if calls:
+                    if turn is None:
+                        turn = AgentTurn()
+                        await chat.mount(turn)
+                    pending = {}
+                    for i, call in enumerate(calls):
+                        if not isinstance(call, dict):
+                            continue
+                        fn = call.get("function") if isinstance(call.get("function"), dict) else {}
+                        name = str(call.get("name") or fn.get("name") or "")
+                        raw = str(fn.get("arguments") or call.get("arguments") or "{}")
+                        args = parse_tool_arguments(raw)
+                        title = tool_title(name, args) if name else f"tool {i}"
+                        card = await turn.begin_tool(title, name=name)
+                        card.stream_preview(name, raw)
+                        cid = str(call.get("id") or fn.get("id") or "")
+                        if cid:
+                            pending[cid] = (card, name)
+                elif msg.content.strip() or msg.thinking.strip():
+                    if turn is None:
+                        turn = AgentTurn()
+                        await chat.mount(turn)
+                    turn.show_stream(
+                        msg.thinking,
+                        msg.content,
+                        elapsed=0.0,
+                        out_tokens=_est_tokens(msg.thinking),
+                        final=True,
+                    )
+                    turn._thinking_cache = msg.thinking
+                    turn = None
+            elif msg.role == "tool":
+                hit = pending.get(str(meta.get("tool_call_id") or ""))
+                if hit is not None:
+                    card, name = hit
+                    card.finish(name, msg.content)
+
+    @work
+    async def _restore_history(self) -> None:
+        """把当前 session 里已有的对话挂回画面。"""
+        await self._mount_history_messages(self.query_one(ChatLog))
+        self._reload_input_history()
+        self._stick_bottom()
+
+    # 事件处理:方法名遵循 on_<部件类型>_<事件名> 的约定,Textual 会自动绑定。
+    # Input.Submitted 表示用户在输入框按了回车。
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        prompt = event.value.strip()          # event.value 是输入框当前内容
+        if self._file_hints_open():
+            # @补全开着,回车先选中高亮的文件;补完带空格,再按回车才发送
+            self._complete_at()
+            return
+        if self._slash_open() and " " not in prompt:
+            picked = self._slash_menu().current_cmd()
+            if picked:
+                prompt = picked
+        if not prompt:                        # 空输入直接忽略
+            return
+        event.input.value = ""                # 清空输入框,准备下一次输入
+        self._hide_slash_hints()
+        self._hide_picker()
+        self._hide_hist()
+        self._hide_model_picker()
+        self._hide_effort_picker()
+        if prompt.startswith("/"):
+            self._slash(prompt)
+            return
+        self._remember_prompt(prompt)
+        if self._is_generating():
+            self._enqueue(prompt)
+            return
+        self._current_prompt = prompt
+        self._begin_turn(prompt)
+
+    @work
+    async def _slash(self, raw: str) -> None:
+        parts = raw.strip().split(None, 1)
+        cmd = parts[0].lower()
+        arg = parts[1] if len(parts) > 1 else ""
+        if cmd in ("/new", "/clear"):
+            self._run_id += 1
+            self._writes_frozen = True
+            self._checkpoint_id = None
+            if self._is_generating():
+                self.action_interrupt()
+            self._session_stack.append(self._session_id)
+            self._session_id = self._store.create_session()
+            self._pending_images = []
+            self._committed_in = 0
+            self._committed_out = 0
+            self._committed_cache = 0
+            self._live_in = 0
+            self._live_out = 0
+            self._live_cache = 0
+            await self._reload_session_view()
+            self._refresh_footer_meta()
+            await self._note("新窗口已打开。/changewin 可选择历史窗口。")
+            return
+        if cmd in ("/changewin", "/change-win", "/win"):
+            if arg.strip():
+                target, err = self._resolve_session_id(arg.strip())
+                if not target:
+                    await self._note(err or "找不到窗口。")
+                    return
+                await self._switch_window(target)
+                return
+            rows = self._store.list_sessions_for_project()
+            if not rows:
+                await self._note("没有可切换的历史窗口。")
+                return
+            self._show_session_picker(rows)
+            return
+        if cmd in ("/zip", "/compact"):
+            await self._note("正在压缩上下文…")
+            await prepare_context(self._store, self._session_id, force=True, hint=arg)
+            used = self._occupancy_tokens()
+            await self._note(f"压缩完成，当前带上约 {fmt_tok(used)} token。")
+            self._refresh_footer_meta()
+            return
+        if cmd in ("/history", "/rewind", "/undo"):
+            rows = self._store.list_checkpoints(self._session_id)
+            if not rows:
+                await self._note("还没有可回退的提问。发一条消息后才会有快照。")
+                return
+            self._show_history_picker(rows)
+            return
+        if cmd in ("/model",):
+            models = self._model_list()
+            arg = arg.strip()
+            if not arg:
+                # 弹出模型列表,↑↓ 回车切换
+                self._show_model_picker()
+                return
+            if arg.isdigit() and 1 <= int(arg) <= len(models):
+                name = models[int(arg) - 1]
+            else:
+                name = arg  # 直接给 id,不在列表里也允许切
+            if name == str(CONFIG.get("model") or ""):
+                await self._note(f"当前就是这个模型: {name}")
+                return
+            self._switch_model(name)
+            await self._note(f"已切到模型 {name}，写回 ~/.lcode/config.json。")
+            return
+        if cmd in ("/effort", "/reasoning"):
+            arg2 = arg.strip().lower()
+            if arg2 in ("low", "medium", "high", "minimal", "default", "none"):
+                picked = "" if arg2 in ("default", "none") else arg2
+                if picked != self._current_effort():
+                    set_reasoning_effort(picked)
+                    CONFIG["reasoningEffort"] = picked
+                await self._note(
+                    f"reasoning effort: {picked or 'default'}{'（不发参数）' if not picked else ''}。"
+                )
+                return
+            self._open_effort_picker(str(CONFIG.get("model") or ""))
+            return
+        if cmd in ("/rename",):
+            if not arg.strip():
+                await self._note("用法: /rename <新标题>")
+                return
+            self._store.rename_session(self._session_id, arg)
+            await self._note(f"已改名为「{' '.join(arg.split())[:40]}」。")
+            return
+        if cmd in ("/delwin",):
+            target, err = self._resolve_session_id(arg.strip())
+            if not target:
+                await self._note(err or "用法: /delwin <id前缀或标题>")
+                return
+            if target == self._session_id:
+                await self._note("当前窗口不能删，先 /changewin 切走。")
+                return
+            self._store.delete_session(target)
+            await self._note(f"已删除窗口 {target[:8]}。")
+            return
+        if cmd in ("/export", "/save"):
+            path = await self._export_markdown(arg.strip())
+            await self._note(f"已导出: {path}" if path else "导出失败。")
+            return
+        if cmd in ("/img", "/image", "/pic"):
+            await self._attach_image(arg.strip())
+            return
+        if cmd == "/ask":
+            self._set_perm_mode("ask")
+            await self._note("已切到 ask：改文件和终端会先问你。Shift+Tab 也可切换。")
+            return
+        if cmd == "/pass":
+            self._set_perm_mode("pass")
+            await self._note("已切到 pass：一条龙，不再询问。Shift+Tab 也可切换。")
+            return
+        await self._note(
+            "未知命令。可用: /new /changewin /zip /history /model /rename /delwin /export /img /ask /pass"
+        )
+
+    async def _export_markdown(self, raw_name: str) -> str:
+        """把当前窗口的对话写成 Markdown;返回文件路径,空串表示失败。"""
+        try:
+            msgs = self._store.list_messages(self._session_id)
+        except Exception:
+            return ""
+        name = re.sub(r'[\\/:*?"<>|]+', "-", raw_name) if raw_name else ""
+        if not name:
+            title = " ".join(
+                str(next((r["title"] for r in self._store.list_sessions_for_project() if r["id"] == self._session_id), "") or "").split()
+            )[:24] or self._session_id[:8]
+            name = f"lcode-{title}-{time.strftime('%m%d-%H%M%S')}"
+        if not name.endswith(".md"):
+            name += ".md"
+        dest = Path.cwd() / name
+        lines = [f"# Lcode 会话导出 · {self._session_id[:8]}", ""]
+        for msg in msgs:
+            meta = _msg_meta(msg.meta)
+            if msg.role == "user":
+                lines += ["## 您", "", msg.content, ""]
+            elif msg.role == "assistant":
+                if msg.thinking.strip():
+                    lines += ["<details><summary>思考</summary>", "", msg.thinking, "", "</details>", ""]
+                if msg.content.strip():
+                    lines += [msg.content, ""]
+                calls = meta.get("tool_calls") or []
+                for call in calls:
+                    fn = call.get("function") if isinstance(call.get("function"), dict) else {}
+                    args = parse_tool_arguments(str(fn.get("arguments") or "{}"))
+                    lines += [f"- 调用 `{tool_title(str(fn.get('name') or ''), args)}`"]
+                if calls:
+                    lines.append("")
+            elif msg.role == "tool":
+                first = " ".join(msg.content.split())[:200]
+                lines += [f"> 工具结果: {first}", ""]
+        try:
+            dest.write_text("\n".join(lines), encoding="utf-8")
+        except OSError:
+            return ""
+        return str(dest)
+
+    async def _attach_image(self, raw_path: str) -> None:
+        """/img:读图片转 base64,随下一条消息发出去;只存名字进磁盘。"""
+        if not raw_path:
+            await self._note("用法: /img <图片路径>，可连用多次附加多张。")
+            return
+        path = Path(raw_path)
+        if not path.is_absolute():
+            path = Path.cwd() / path
+        path = path.resolve()
+        suffix = path.suffix.lower()
+        if suffix not in _IMAGE_SUFFIXES or not path.is_file():
+            await self._note(f"不是支持的图片文件: {raw_path}")
+            return
+        try:
+            data = base64.b64encode(path.read_bytes()).decode("ascii")
+        except OSError as exc:
+            await self._note(f"读不出来: {exc}")
+            return
+        if not hasattr(self, "_pending_images"):
+            self._pending_images = []
+        self._pending_images.append((path.name, f"data:{_MIME[suffix]};base64,{data}"))
+        await self._note(
+            f"已附加 {path.name}（共 {len(self._pending_images)} 张），随下一条消息发送。"
+        )
+
+    async def _note(self, text: str) -> None:
+        chat = self.query_one(ChatLog)
+        await chat.mount(Static(Text(text, style="dim")))
+        self._stick_bottom()
+
+    async def _reload_session_view(self) -> None:
+        chat = self.query_one(ChatLog)
+        for child in list(chat.children):
+            if getattr(child, "id", None) == "hero":
+                continue
+            await child.remove()
+        await self._mount_history_messages(chat)
+        self._reload_input_history()
+        self._stick_bottom()
+
+    def _reload_input_history(self) -> None:
+        self._input_history = [
+            msg.content
+            for msg in self._store.list_messages(self._session_id)
+            if msg.role == "user" and msg.content.strip()
+        ]
+        if len(self._input_history) > 200:
+            self._input_history = self._input_history[-200:]
+        self._input_hist_idx = -1
+        self._input_draft = ""
+
+    def _remember_prompt(self, text: str) -> None:
+        text = text.strip()
+        if not text:
+            return
+        if not self._input_history or self._input_history[-1] != text:
+            self._input_history.append(text)
+            if len(self._input_history) > 200:
+                self._input_history = self._input_history[-200:]
+        self._input_hist_idx = -1
+        self._input_draft = ""
+
+    def _recall_prompt(self, delta: int) -> None:
+        """delta < 0 更早, > 0 更新。"""
+        hist = self._input_history
+        try:
+            field = self.query_one("#prompt", Input)
+        except Exception:
+            return
+        if self._input_hist_idx < 0:
+            if delta >= 0 or not hist:
+                return
+            self._input_draft = field.value
+            self._input_hist_idx = len(hist) - 1
+        else:
+            nxt = self._input_hist_idx + delta
+            if nxt >= len(hist):
+                self._input_hist_idx = -1
+                field.value = self._input_draft
+                field.cursor_position = len(field.value)
+                return
+            if nxt < 0:
+                nxt = 0
+            self._input_hist_idx = nxt
+        field.value = hist[self._input_hist_idx]
+        field.cursor_position = len(field.value)
+
+    def _enqueue(self, text: str) -> None:
+        self._ticket_seq += 1
+        self.query_one(QueueList).enqueue(self._ticket_seq, text)
+
+    def _kickoff(self, text: str) -> None:
+        self._current_prompt = text
+        self._begin_turn(text)
+
+    def _send_next_queued(self) -> None:
+        if self._hold_queue or self._is_generating():
+            return
+        text = self.query_one(QueueList).pop_front()
+        if not text:
+            return
+        self._kickoff(text)
+
+    def force_send_queued(self, ticket_id: int) -> None:
+        """队列上点发送:打断当前回答,立刻发出这一条。"""
+        text = self.query_one(QueueList).take(ticket_id)
+        if not text:
+            return
+        if not self._is_generating():
+            self._hold_queue = False
+            self._pending_prompt = None
+            self._kickoff(text)
+            return
+        self._pending_prompt = text
+        self._hold_queue = True
+        self.action_interrupt()
+
+    def on_queue_item_send(self, event: QueueItem.Send) -> None:
+        event.stop()
+        self.force_send_queued(event.ticket_id)
+
+    def on_queue_item_edited(self, event: QueueItem.Edited) -> None:
+        event.stop()
+
+    def _is_generating(self) -> bool:
+        return (
+            self._busy
+            or self._waiting
+            or any(
+                worker.group == "agent" and worker.is_running for worker in self.workers
+            )
+        )
+
+    def _slash_menu(self) -> CommandHints:
+        return self.query_one("#slash-hints", CommandHints)
+
+    def _slash_open(self) -> bool:
+        try:
+            return bool(self._slash_menu().display)
+        except Exception:
+            return False
+
+    def _hide_slash_hints(self) -> None:
+        try:
+            self._slash_menu().hide()
+        except Exception:
+            pass
+
+    def _refresh_slash_hints(self, typed: str) -> None:
+        try:
+            self._slash_menu().set_items(_slash_matches(typed))
+        except Exception:
+            pass
+
+    def _picker(self) -> SessionPicker:
+        return self.query_one("#win-picker", SessionPicker)
+
+    def _model_picker(self) -> ModelPicker:
+        return self.query_one("#model-picker", ModelPicker)
+
+    def _model_picker_open(self) -> bool:
+        try:
+            return bool(self._model_picker().display)
+        except Exception:
+            return False
+
+    def _hide_model_picker(self, *, focus_input: bool = False) -> None:
+        try:
+            self._model_picker().hide()
+        except Exception:
+            pass
+        if focus_input:
+            try:
+                self.query_one("#prompt", Input).focus()
+            except Exception:
+                pass
+
+    def _model_list(self) -> list[str]:
+        """config 里的 models 列表;没配就把当前模型兜底成唯一一项。"""
+        raw = CONFIG.get("models")
+        out: list[str] = []
+        if isinstance(raw, list):
+            out = [str(m).strip() for m in raw if str(m).strip()]
+        current = str(CONFIG.get("model") or "").strip()
+        if current and current not in out:
+            out.insert(0, current)
+        return out
+
+    def _show_model_picker(self) -> None:
+        self._hide_slash_hints()
+        self._hide_file_hints()
+        picker = self._model_picker()
+        picker.set_models(self._model_list(), str(CONFIG.get("model") or ""))
+        try:
+            self.set_focus(picker.query_one("#model-list", OptionList))
+        except Exception:
+            pass
+
+    def action_pick_model(self) -> None:
+        if not self._is_generating() and not self._model_picker_open():
+            self._show_model_picker()
+
+    def _switch_model(self, name: str) -> None:
+        set_model(name)
+        CONFIG["model"] = name
+        self._load_model_limits()
+        self._refresh_footer_meta()
+
+    def on_model_picker_picked(self, event: ModelPicker.Picked) -> None:
+        event.stop()
+        self._hide_model_picker()
+        mid = event.model_id
+        if not mid:
+            return
+        if mid == str(CONFIG.get("model") or ""):
+            # 同一个模型也允许只改推理等级:接着弹等级选择
+            self._open_effort_picker(mid)
+            return
+        # 选完模型 → 链式弹出推理等级选择
+        self._open_effort_picker(mid)
+
+    def _effort_picker(self) -> EffortPicker:
+        return self.query_one("#effort-picker", EffortPicker)
+
+    def _effort_picker_open(self) -> bool:
+        try:
+            return bool(self._effort_picker().display)
+        except Exception:
+            return False
+
+    def _hide_effort_picker(self, *, focus_input: bool = False) -> None:
+        try:
+            self._effort_picker().hide()
+        except Exception:
+            pass
+        if focus_input:
+            try:
+                self.query_one("#prompt", Input).focus()
+            except Exception:
+                pass
+
+    def _current_effort(self) -> str:
+        effort = str(CONFIG.get("reasoningEffort") or REASONING_EFFORT or "").strip().lower()
+        return "" if effort in ("default", "none", "无", "默认") else effort
+
+    def _show_effort_picker(
+        self, model_id: str, levels: list[str] | None = None
+    ) -> None:
+        self._hide_slash_hints()
+        self._hide_file_hints()
+        self._pending_model = model_id or self._pending_model
+        detected = bool(levels) or _looks_like_reasoning_model(self._pending_model)
+        self._effort_picker().set_efforts(
+            self._pending_model,
+            self._current_effort(),
+            detected,
+            levels,
+        )
+        try:
+            self.set_focus(self._effort_picker().query_one("#effort-list", OptionList))
+        except Exception:
+            pass
+
+    @work
+    async def _open_effort_picker(self, model_id: str) -> None:
+        """先问 /models 拿这个模型支持的推理等级,拿不到就走启发式。"""
+        levels: list[str] = []
+        try:
+            info = await fetch_model_limits(model_id)
+            levels = [str(x) for x in (info.get("reasoning_levels") or [])]
+        except Exception:
+            levels = []
+        self._show_effort_picker(model_id, levels)
+
+    def on_effort_picker_picked(self, event: EffortPicker.Picked) -> None:
+        event.stop()
+        self._hide_effort_picker(focus_input=True)
+        effort = event.effort or ""
+        target = self._pending_model or str(CONFIG.get("model") or "")
+        self._pending_model = ""
+        if effort != self._current_effort():
+            set_reasoning_effort(effort)
+            CONFIG["reasoningEffort"] = effort
+        switched = bool(target) and target != str(CONFIG.get("model") or "")
+        if switched:
+            self._switch_model(target)
+        bits = []
+        if switched:
+            bits.append(f"已切到模型 {target}")
+        else:
+            bits.append(f"推理等级已更新（{target}）")
+        bits.append(f"reasoning {effort or 'default'}")
+        self.run_worker(self._note("，".join(bits) + "。"))
+
+    def _picker_open(self) -> bool:
+        try:
+            return bool(self._picker().display)
+        except Exception:
+            return False
+
+    def _hide_picker(self, *, focus_input: bool = False) -> None:
+        try:
+            self._picker().hide()
+        except Exception:
+            pass
+        if focus_input:
+            try:
+                self.query_one("#prompt", Input).focus()
+            except Exception:
+                pass
+
+    def _hist(self) -> HistoryPicker:
+        return self.query_one("#hist-picker", HistoryPicker)
+
+    def _hist_open(self) -> bool:
+        try:
+            return bool(self._hist().display)
+        except Exception:
+            return False
+
+    def _hide_hist(self, *, focus_input: bool = False) -> None:
+        try:
+            self._hist().hide()
+        except Exception:
+            pass
+        if focus_input:
+            try:
+                self.query_one("#prompt", Input).focus()
+            except Exception:
+                pass
+
+    def _show_history_picker(self, rows: list[dict]) -> None:
+        self._hide_slash_hints()
+        self._hide_picker()
+        picker = self._hist()
+        picker.set_rows(rows)
+        try:
+            self.set_focus(picker.query_one("#hist-list", OptionList))
+        except Exception:
+            pass
+
+    def _on_file_write(self, path: Path) -> None:
+        if self._writes_frozen:
+            raise RuntimeError("已回退,未写入")
+        cid = self._checkpoint_id
+        if cid:
+            self._store.snapshot_file(cid, path)
+
+    def _show_session_picker(self, rows: list[dict]) -> None:
+        self._hide_slash_hints()
+        preferred = self._session_stack[-1] if self._session_stack else ""
+        picker = self._picker()
+        picker.set_sessions(rows, self._session_id, preferred)
+        try:
+            self.set_focus(picker.query_one("#win-list", OptionList))
+        except Exception:
+            pass
+
+    def _resolve_session_id(self, raw: str) -> tuple[str, str]:
+        text = (raw or "").strip()
+        if not text:
+            return "", "没有可切换的历史窗口。"
+        rows = self._store.list_sessions_for_project()
+        for row in rows:
+            if row["id"] == text:
+                return row["id"], ""
+        prefix = [row for row in rows if row["id"].startswith(text)]
+        if len(prefix) == 1:
+            return prefix[0]["id"], ""
+        if len(prefix) > 1:
+            return "", f"有 {len(prefix)} 个窗口 id 以 {text} 开头，请写完整一点。"
+        titled = [
+            row
+            for row in rows
+            if text.lower() in str(row.get("title") or "").lower()
+        ]
+        if len(titled) == 1:
+            return titled[0]["id"], ""
+        if len(titled) > 1:
+            return "", f"有 {len(titled)} 个窗口标题包含「{text}」，请用 id。"
+        return "", f"找不到窗口: {text}"
+
+    async def _switch_window(self, target: str) -> None:
+        self._hide_picker()
+        if target == self._session_id:
+            await self._note("已在这个窗口。")
+            try:
+                self.query_one("#prompt", Input).focus()
+            except Exception:
+                pass
+            return
+        self._run_id += 1
+        self._writes_frozen = True
+        self._checkpoint_id = None
+        if self._is_generating():
+            self.action_interrupt()
+        self._session_stack.append(self._session_id)
+        try:
+            self._store.switch_session(target)
+        except Exception as exc:
+            await self._note(f"切换失败: {exc}")
+            return
+        self._session_id = target
+        saved_in, saved_out, saved_cache = self._store.usage_of(target)
+        self._committed_in = saved_in
+        self._committed_out = saved_out
+        self._committed_cache = saved_cache
+        self._live_in = 0
+        self._live_out = 0
+        self._live_cache = 0
+        await self._reload_session_view()
+        title = ""
+        for row in self._store.list_sessions_for_project():
+            if row["id"] == target:
+                title = row["title"]
+                break
+        await self._note(f"已切到窗口 {target[:8]} {title}".rstrip())
+        self._refresh_footer_meta()
+        try:
+            self.query_one("#prompt", Input).focus()
+        except Exception:
+            pass
+
+    def on_session_picker_picked(self, event: SessionPicker.Picked) -> None:
+        event.stop()
+        self._hide_picker()
+        self.run_worker(self._switch_window(event.session_id))
+
+    def on_history_picker_picked(self, event: HistoryPicker.Picked) -> None:
+        event.stop()
+        self._hide_hist()
+        self.run_worker(self._apply_history(event.checkpoint_id, event.action))
+
+    async def _apply_history(self, checkpoint_id: str, action: str) -> None:
+        rows = self._store.list_checkpoints(self._session_id)
+        hit = next((r for r in rows if r.get("id") == checkpoint_id), None)
+        if not hit:
+            await self._note("找不到这个快照。")
+            return
+        self._run_id += 1
+        self._writes_frozen = True
+        self._checkpoint_id = None
+        if self._is_generating():
+            self.action_interrupt()
+        prompt = str(hit.get("title") or "")
+        for msg in self._store.list_messages(self._session_id):
+            if msg.id == int(hit["message_id"]) and msg.role == "user":
+                prompt = msg.content
+                break
+        files: list[str] = []
+        try:
+            if action in ("both", "code"):
+                files = self._store.restore_files(self._session_id, checkpoint_id)
+            if action in ("both", "chat"):
+                self._store.truncate_from_message(
+                    self._session_id, int(hit["message_id"])
+                )
+                await self._reload_session_view()
+            elif action == "code":
+                self._store.drop_checkpoints_after(
+                    self._session_id, int(hit["message_id"]), include=False
+                )
+        except Exception as exc:
+            await self._note(f"回退失败: {exc}")
+            return
+        bits = []
+        if action in ("both", "chat"):
+            bits.append("对话")
+        if action in ("both", "code"):
+            bits.append("代码")
+        extra = f"，还原 {len(files)} 个文件" if files else ""
+        await self._note(f"已回退{'和'.join(bits)}到这一问之前{extra}。")
+        self._refresh_footer_meta()
+        try:
+            field = self.query_one("#prompt", Input)
+            if action in ("both", "chat") and prompt:
+                field.value = prompt
+                field.cursor_position = len(prompt)
+            field.focus()
+        except Exception:
+            pass
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id != "prompt":
+            return
+        if event.value.strip():
+            if self._picker_open():
+                self._hide_picker()
+            if self._hist_open():
+                self._hide_hist()
+            if self._model_picker_open():
+                self._hide_model_picker()
+            if self._effort_picker_open():
+                self._hide_effort_picker()
+        if event.value.lstrip().startswith("/"):
+            try:
+                self._file_hints().hide()
+            except Exception:
+                pass
+        else:
+            self._refresh_file_hints(event.value)
+        self._refresh_slash_hints(event.value)
+
+    def _file_hints(self) -> FileHints:
+        return self.query_one("#file-hints", FileHints)
+
+    def _file_hints_open(self) -> bool:
+        try:
+            return bool(self._file_hints().display)
+        except Exception:
+            return False
+
+    def _hide_file_hints(self) -> None:
+        try:
+            self._file_hints().hide()
+        except Exception:
+            pass
+
+    def _refresh_file_hints(self, typed: str) -> None:
+        try:
+            prefix, hits = _at_matches(typed)
+            if hits:
+                self._file_hints().set_items(prefix, hits)
+            else:
+                self._file_hints().hide()
+        except Exception:
+            pass
+
+    def _complete_at(self) -> None:
+        """Tab/回车选中 @补全,把选中的路径替换进输入框。"""
+        path = self._file_hints().current()
+        self._hide_file_hints()
+        if not path:
+            return
+        try:
+            field = self.query_one("#prompt", Input)
+        except Exception:
+            return
+        m = re.search(r"@([^\s@]*)$", field.value)
+        if not m:
+            return
+        field.value = field.value[: m.start()] + "@" + path + " "
+        field.cursor_position = len(field.value)
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        if action == "slash_complete":
+            return not self._permit_open()
+        if action == "confirm_overlay":
+            if self._permit_open():
+                return False
+            return (
+                self._picker_open()
+                or self._hist_open()
+                or self._model_picker_open()
+                or self._effort_picker_open()
+            )
+        if action in ("slash_next", "slash_prev"):
+            if self._permit_open():
+                return False
+            if (
+                self._hist_open()
+                or self._picker_open()
+                or self._model_picker_open()
+                or self._effort_picker_open()
+                or self._slash_open()
+            ):
+                return True
+            focused = self.focused
+            return bool(focused is not None and getattr(focused, "id", None) == "prompt")
+        return True
+
+    def action_confirm_overlay(self) -> None:
+        if self._hist_open():
+            self._hist().confirm()
+            return
+        if self._picker_open():
+            self._picker().confirm()
+            return
+        if self._model_picker_open():
+            self._model_picker().confirm()
+            return
+        if self._effort_picker_open():
+            self._effort_picker().confirm()
+
+    def action_toggle_perm_mode(self) -> None:
+        nxt = "pass" if self._perm_mode == "ask" else "ask"
+        self._set_perm_mode(nxt)
+
+    def _set_perm_mode(self, mode: str) -> None:
+        self._perm_mode = save_permission_mode(mode)
+        self._refresh_footer_meta()
+
+    def _permit_open(self) -> bool:
+        return isinstance(self.screen, PermitScreen)
+
+    def _dismiss_permit(self, allow: bool) -> None:
+        if isinstance(self.screen, PermitScreen):
+            self.screen.dismiss(allow)
+            return
+        fut = self._permit_future
+        if fut is not None and not fut.done():
+            fut.set_result(bool(allow))
+
+    async def _confirm_tool(self, name: str, args: dict, title: str = "") -> bool:
+        if self._perm_mode != "ask":
+            return True
+        if not tool_is_sensitive(name, args):
+            return True
+        loop = asyncio.get_running_loop()
+        fut: asyncio.Future = loop.create_future()
+        self._permit_future = fut
+        preview = permit_preview(name, args)
+        self._set_run_status("permit", title or preview)
+
+        def _done(result: bool | None) -> None:
+            if not fut.done():
+                fut.set_result(bool(result))
+
+        self.push_screen(PermitScreen(preview), _done)
+        try:
+            return bool(await fut)
+        finally:
+            if self._permit_future is fut:
+                self._permit_future = None
+            if self._status_kind == "permit":
+                self._set_run_status("tool", title or preview)
+
+    def action_slash_complete(self) -> None:
+        if self._hist_open():
+            self._hist().confirm()
+            return
+        if self._picker_open():
+            self._picker().confirm()
+            return
+        if self._model_picker_open():
+            self._model_picker().confirm()
+            return
+        if self._effort_picker_open():
+            self._effort_picker().confirm()
+            return
+        if self._file_hints_open():
+            self._complete_at()
+            return
+        if not self._slash_open():
+            return
+        cmd = self._slash_menu().current_cmd()
+        if not cmd:
+            return
+        prompt = self.query_one("#prompt", Input)
+        prompt.value = cmd + " "
+        prompt.cursor_position = len(prompt.value)
+        self._refresh_slash_hints(prompt.value)
+
+    def action_slash_next(self) -> None:
+        if self._hist_open():
+            self._hist().move(1)
+            return
+        if self._picker_open():
+            self._picker().move(1)
+            return
+        if self._model_picker_open():
+            self._model_picker().move(1)
+            return
+        if self._effort_picker_open():
+            self._effort_picker().move(1)
+            return
+        if self._file_hints_open():
+            self._file_hints().move(1)
+            return
+        if self._slash_open():
+            self._slash_menu().move(1)
+            return
+        self._recall_prompt(1)
+
+    def action_slash_prev(self) -> None:
+        if self._hist_open():
+            self._hist().move(-1)
+            return
+        if self._picker_open():
+            self._picker().move(-1)
+            return
+        if self._model_picker_open():
+            self._model_picker().move(-1)
+            return
+        if self._effort_picker_open():
+            self._effort_picker().move(-1)
+            return
+        if self._file_hints_open():
+            self._file_hints().move(-1)
+            return
+        if self._slash_open():
+            self._slash_menu().move(-1)
+            return
+        self._recall_prompt(-1)
+
+    def action_interrupt(self) -> None:
+        """打断当前这一轮生成,不自动发队列里的下一条。"""
+        if self._permit_open():
+            self._dismiss_permit(False)
+            return
+        if self._hist_open():
+            if self._hist().back_or_close():
+                try:
+                    self.set_focus(self._hist().query_one("#hist-list", OptionList))
+                except Exception:
+                    pass
+                return
+            self._hide_hist(focus_input=True)
+            return
+        if self._picker_open():
+            self._hide_picker(focus_input=True)
+            return
+        if self._model_picker_open() and not self._is_generating():
+            self._hide_model_picker()
+            return
+        if self._effort_picker_open() and not self._is_generating():
+            # Esc 跳过等级选择:刚选的模型仍然生效,等级保持原样
+            self._hide_effort_picker()
+            pending = self._pending_model
+            self._pending_model = ""
+            if pending and pending != str(CONFIG.get("model") or ""):
+                self._switch_model(pending)
+                self.run_worker(
+                    self._note(f"已切到模型 {pending}（推理等级保持不变）。")
+                )
+            return
+        if self._file_hints_open() and not self._is_generating():
+            self._hide_file_hints()
+            return
+        if self._slash_open() and not self._is_generating():
+            self._hide_slash_hints()
+            return
+        if not self._is_generating():
+            return
+        if self._pending_prompt is None:
+            self._hold_queue = True
+        self.workers.cancel_group(self, "agent")
+        # 还在跑的终端命令一并杀掉,别让它挂在后台
+        try:
+            terminate_running_tools()
+        except Exception:
+            pass
+        self._waiting = False
+        self._stop_turn_timer()
+        self._hide_run_status()
+
+    def action_interrupt_or_quit(self) -> None:
+        """生成中 Ctrl+C 打断;空闲时沿用 Textual 的退出提示。"""
+        if self._permit_open():
+            self._dismiss_permit(False)
+        if self._hist_open():
+            if not self._hist().back_or_close():
+                self._hide_hist(focus_input=True)
+            return
+        if self._picker_open():
+            self._hide_picker(focus_input=True)
+            return
+        if self._is_generating():
+            self.action_interrupt()
+            return
+        self.action_help_quit()
+
+    @work
+    async def _begin_turn(self, prompt: str) -> None:
+        """先挂好这一轮的气泡,再开等待动画和模型请求。"""
+        self._busy = True
+        try:
+            chat = self.query_one(ChatLog)
+            await chat.mount(UserTurn(prompt))
+            turn = AgentTurn()
+            await chat.mount(turn)
+            self._active_turn = turn
+            self._start_turn()
+            self._stick_bottom(force=True)  # 用户自己发的消息,必须看到
+            self.run_agent(prompt)
+        except Exception:
+            self._busy = False
+            raise
+
+    # 等待动画收着做:两句朴素文案慢慢轮换,金色三档慢呼吸,点点保留
+    _WAIT_PHRASES = ("思考中", "跑着呢")
+    _WAIT_GLOW = ("#7a6238", "#b08d4a", "#d9a84e", "#b08d4a")
+    _SPIN = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+    def _paint_wait(self, elapsed: float) -> Text:
+        """等待行:金色慢呼吸,点点 1~3 循环跳,后面跟秒数。"""
+        phrase = self._WAIT_PHRASES[int(elapsed // 6) % len(self._WAIT_PHRASES)]
+        dots = "." * (1 + int(elapsed * 4) % 3)
+        glow = self._WAIT_GLOW[int(elapsed * 3) % len(self._WAIT_GLOW)]
+        wait = Text()
+        wait.append("▎ ", style=f"bold {_AMBER}")
+        wait.append(phrase, style=f"bold {glow}")
+        wait.append(f"{dots:<3}", style=f"bold {glow}")
+        wait.append(f"  {elapsed:.1f}s", style="dim")
+        return wait
+
+    def _in_tokens(self) -> int:
+        return self._committed_in + self._live_in
+
+    def _out_tokens(self) -> int:
+        return self._committed_out + self._live_out
+
+    def _cache_tokens(self) -> int:
+        return self._committed_cache + self._live_cache
+
+    def _start_turn(self) -> None:
+        """本轮开始:立刻把输入 token 估上,等待动画和标题定时器一起跑。"""
+        self._stop_turn_timer()
+        self._waiting = True
+        self._got_official = False
+        self._thinking_text = ""
+        self._answer_text = ""
+        self._wait_t0 = time.monotonic()
+        self._live_in = self._idle_occupancy() + _est_tokens(self._current_prompt)
+        self._live_out = 0
+        self._live_cache = 0
+        self._usage_in = 0
+        self._usage_out = 0
+        self._usage_cache = 0
+        self._retry_attempt = 0
+        self._retry_total = 0
+        # run_agent 里会按整段请求(系统+工具+历史+工具结果)再校准 ↑
+        self._refresh_footer_meta()
+        self._set_run_status("wait")
+        self._tick_turn()
+        self._wait_timer = self.set_interval(0.08, self._tick_turn)
+
+    def _stop_turn_timer(self) -> None:
+        if self._wait_timer is not None:
+            self._wait_timer.stop()
+            self._wait_timer = None
+
+    def _commit_live_usage(self, session_id: str | None = None) -> None:
+        sid = session_id or self._session_id
+        # 落库:重启后底部 ↑↓ 接着这个数往上加,不再归零
+        try:
+            self._store.add_usage(
+                sid, self._live_in, self._live_out, self._live_cache
+            )
+        except Exception:
+            pass
+        self._committed_in += self._live_in
+        self._committed_out += self._live_out
+        self._committed_cache += self._live_cache
+        self._live_in = 0
+        self._live_out = 0
+        self._live_cache = 0
+        self._refresh_footer_meta()
+
+    def _tick_turn(self) -> None:
+        elapsed = time.monotonic() - self._wait_t0
+        if self._active_turn is not None:
+            if self._waiting:
+                self._active_turn.show_wait(self._paint_wait(elapsed))
+            else:
+                self._active_turn.pulse_title(
+                    elapsed,
+                    _est_tokens(self._thinking_text),
+                    self._live_in,
+                    self._live_cache,
+                )
+            self._stick_bottom()
+        self._paint_run_status()
+
+    def _set_run_status(self, kind: str, label: str = "") -> None:
+        if self._status_kind == kind and self._status_label == label:
+            return
+        self._status_kind = kind
+        self._status_label = label
+        self._paint_run_status()
+
+    def _hide_run_status(self) -> None:
+        self._status_kind = "idle"
+        self._status_label = ""
+        try:
+            self.query_one("#run-status", RunStatus).hide()
+        except Exception:
+            pass
+
+    def _paint_run_status(self) -> None:
+        try:
+            bar = self.query_one("#run-status", RunStatus)
+        except Exception:
+            return
+        kind = self._status_kind
+        if kind == "idle":
+            bar.hide()
+            return
+        elapsed = max(0.0, time.monotonic() - self._wait_t0)
+        # 金色慢呼吸;转圈只留给跑工具的状态,其他状态用静的 ◆
+        spin = self._SPIN[int(elapsed * 10) % len(self._SPIN)] if kind == "tool" else "◆"
+        glow = self._WAIT_GLOW[int(elapsed * 3) % len(self._WAIT_GLOW)]
+        label = " ".join((self._status_label or "").split())
+        if len(label) > 52:
+            label = label[:51] + "…"
+        line = Text(no_wrap=True, overflow="ellipsis")
+        line.append(f"{spin}  ", style=f"bold {glow}")
+        if kind == "wait":
+            phrase = self._WAIT_PHRASES[int(elapsed // 6) % len(self._WAIT_PHRASES)]
+            line.append(phrase, style=f"bold {glow}")
+        elif kind == "think":
+            line.append("思考中", style=f"bold {glow}")
+        elif kind == "stream":
+            line.append("回复中", style=f"bold {glow}")
+        elif kind == "tool":
+            line.append("运行  ", style=f"bold {glow}")
+            line.append(label or "工具", style="bold #b5ae9d")
+        elif kind == "permit":
+            line.append("等待允许  ", style=f"bold {glow}")
+            line.append(label or "操作", style="bold #b5ae9d")
+        elif kind == "error":
+            # 请求失败重试:输入框上方红字显示错误信息和 重试 n/10
+            line.append("✗ ", style="bold #ff6a6a")
+            line.append(label or "请求失败", style="bold #ff6a6a")
+        else:
+            line.append(label or "进行中", style=f"bold {glow}")
+        if kind != "error":
+            line.append(f"  {elapsed:.1f}s", style="dim")
+        if kind == "error":
+            if self._retry_total:
+                line.append(
+                    f"    重试 {self._retry_attempt}/{self._retry_total}",
+                    style="bold #ff6a6a",
+                )
+            line.append("    Esc 打断", style="dim")
+        elif kind == "permit":
+            line.append("    Y 允许  N 拒绝", style="dim")
+        else:
+            line.append("    Esc 打断", style="dim")
+        bar.show_line(line)
+
+    def _stick_bottom(self, force: bool = False) -> None:
+        """吸底;但用户往上翻了历史就别拽,滚回底部附近才恢复自动跟随。"""
+        try:
+            chat = self.query_one(ChatLog)
+        except Exception:
+            return
+        if not force and chat.max_scroll_y - chat.scroll_y > 3:
+            return
+        chat.scroll_end(animate=False)
+
+    def _fmt_tok(self, n: int) -> str:
+        return fmt_tok(n)
+
+    def _status_label_for_calls(self, calls: list) -> str:
+        titles: list[str] = []
+        for call in calls or []:
+            if not isinstance(call, dict):
+                continue
+            name = str(call.get("name") or "")
+            parsed = parse_tool_arguments(str(call.get("arguments") or ""))
+            title = tool_title(name, parsed) if name else "工具"
+            if title:
+                titles.append(title)
+        if not titles:
+            return "工具"
+        if len(titles) == 1:
+            return titles[-1]
+        return f"{titles[-1]}  ·  {len(titles)} 个"
+
+    def _idle_occupancy(self) -> int:
+        """下一轮会带上的上下文:系统 + 工具定义 + 摘要/历史。"""
+        try:
+            hist = self._store.context_tokens(self._session_id)
+        except Exception:
+            hist = 0
+        return _tools_tokens() + _est_tokens(_system_prompt()) + hist
+
+    def _occupancy_tokens(self) -> int:
+        if self._live_in or self._live_out:
+            return max(0, self._live_in) + max(0, self._live_out)
+        return self._idle_occupancy()
+
+    def _sync_live_in(self, working: list[dict]) -> None:
+        est = _messages_tokens(working) + _tools_tokens()
+        if self._got_official:
+            # 官方用量是每轮累加的,比"当前 working 整体估一遍"准;别再覆盖
+            self._live_in = max(self._live_in, self._usage_in)
+        else:
+            self._live_in = est
+        self._refresh_footer_meta()
+
+    def _refresh_footer_meta(self) -> None:
+        model = str(CONFIG.get("model") or "")
+        inp = self._in_tokens()
+        out = self._out_tokens()
+        cache = self._cache_tokens()
+        bar = Text(no_wrap=True)
+        sep = Text("  ·  ", style="#57534a")
+
+        def part(text: str, style: str = "") -> None:
+            if bar.plain:
+                bar.append(sep)
+            bar.append(text, style=style or None)
+
+        if model:
+            part(model, f"bold {_AMBER}")
+        effort = self._current_effort()
+        if effort:
+            part(f"reason {effort}", f"bold {_YELLOW}")
+        part(f"↑ {fmt_tok(inp)}")
+        # cache 百分比分色:命中高显绿(省钱),低命中暗灰
+        pct = _cache_pct(cache, inp)
+        if pct:
+            if pct >= 50:
+                part(f"cache {pct}%", "bold #8fbf9f")
+            elif pct < 20:
+                part(f"cache {pct}%", "#6e6a5e")
+            else:
+                part(f"cache {pct}%")
+        part(f"↓ {fmt_tok(out)}")
+        part(f"tot {fmt_tok(inp + out)}")
+        cost = _cost_usd(inp, out, cache)
+        if cost:
+            part("$" + f"{cost:.4f}".rstrip("0").rstrip("."), "#3ecf8e")
+        part("pass" if getattr(self, "_perm_mode", "ask") == "pass" else "ask", "dim")
+        used = self._occupancy_tokens()
+        window = int(getattr(self._store, "model_window", 0) or 0)
+        if window:
+            # 快到 auto-compact 阈值就提醒黄
+            occ_style = "bold #d9a84e" if used > window * 0.8 else ""
+            part(f"{fmt_tok(used)}/{fmt_tok(window)}", occ_style)
+        self.query_one(AgentFooter).meta = bar
+
+    def _set_live_out(self, thinking: str, answer: str) -> None:
+        est = _est_tokens(thinking) + _est_tokens(answer)
+        # 已到账的官方用量打底,流式估算盖在上面;下一轮 usage 到了再校准
+        self._live_out = max(self._usage_out, est)
+        self._refresh_footer_meta()
+
+    def _apply_usage(self, usage: object) -> None:
+        if not isinstance(usage, dict):
+            return
+
+        def _num(*keys: str) -> int:
+            """键可以是 "a" 或 "a.b",后者读嵌套 dict。"""
+            for key in keys:
+                value: object = usage
+                for part in key.split("."):
+                    if not isinstance(value, dict):
+                        value = None
+                        break
+                    value = value.get(part)
+                if value is None:
+                    continue
+                try:
+                    return int(value)
+                except (TypeError, ValueError):
+                    continue
+            return 0
+
+        inp = _num("prompt_tokens", "input_tokens", "input")
+        out = _num("completion_tokens", "output_tokens", "output")
+        # 缓存命中:DeepSeek 平铺一个字段,OpenAI / Responses 放在 details 里
+        cache = _num(
+            "prompt_cache_hit_tokens",
+            "prompt_tokens_details.cached_tokens",
+            "input_tokens_details.cached_tokens",
+            "cache_read_input_tokens",
+        )
+        if inp == 0 and out == 0:
+            return
+        self._got_official = True
+        # 官方用量按轮累加:一轮里跑多次工具,每轮结束都给一份 usage
+        self._usage_in += inp
+        self._usage_out += out
+        self._usage_cache += max(0, min(cache, inp) if inp else cache)
+        self._live_in = self._usage_in
+        self._live_out = self._usage_out
+        self._live_cache = self._usage_cache
+        self._refresh_footer_meta()
+
+    # @work 把方法放到后台跑,调模型这种慢请求不会冻住整个界面。
+    @work(group="agent", exclusive=True)
+    async def run_agent(self, prompt: str) -> None:
+        turn = self._active_turn
+        thinking = ""
+        answer = ""
+        err = ""
+        interrupted = False
+        shown_in = 0
+        shown_cache = 0
+        run_id = self._run_id
+        sid = self._session_id  # 中途切窗口时,这轮的用量仍记到开始的会话上
+        self._writes_frozen = False
+        user_id = self._store.add_message(self._session_id, "user", prompt)
+        self._store.set_title_if_empty(self._session_id, prompt)
+        self._checkpoint_id = self._store.open_checkpoint(
+            self._session_id, user_id, prompt
+        )
+        history = await prepare_context(self._store, self._session_id)
+        working: list[dict] = [{"role": "system", "content": _system_prompt()}]
+        working.extend(history)
+        if self._pending_images:
+            # 图片只随这条消息进当前请求;磁盘存名字,限量内连 data 也存(回放可见)
+            self._store.merge_message_meta(
+                self._session_id,
+                user_id,
+                {"images": [name for name, _ in self._pending_images]},
+            )
+            persist = [
+                {"name": name, "data": url}
+                for name, url in self._pending_images
+            ]
+            if sum(len(p["data"]) for p in persist) <= _IMG_PERSIST_CAP:
+                self._store.merge_message_meta(
+                    self._session_id, user_id, {"images_data": persist}
+                )
+            for msg in reversed(working):
+                if msg.get("role") == "user":
+                    parts: list[dict] = []
+                    if msg.get("content"):
+                        parts.append({"type": "text", "text": str(msg["content"])})
+                    parts += [
+                        {"type": "image_url", "image_url": {"url": url}}
+                        for _, url in self._pending_images
+                    ]
+                    msg["content"] = parts
+                    break
+            self._pending_images = []
+        tools = openai_tools()
+        self._sync_live_in(working)
+
+        try:
+            for _round in range(16):
+                round_answer = ""
+                calls: list = []
+                thinking_base = thinking
+                attempt = 0
+                while True:
+                    attempt += 1
+                    round_usage: list = []  # usage 先缓冲,整轮成功才入账,重试不重复计
+                    try:
+                        async for kind, payload in ask_stream(working, tools=tools):
+                            try:
+                                if get_current_worker().is_cancelled:
+                                    interrupted = True
+                                    break
+                            except Exception:
+                                pass
+                            if kind == "usage":
+                                round_usage.append(payload)
+                                continue
+                            if kind == "tool_calls":
+                                calls = list(payload or [])
+                                continue
+                            if kind == "tool_delta":
+                                if self._waiting:
+                                    self._waiting = False
+                                if looks_like_tool_args(round_answer):
+                                    round_answer = ""
+                                    answer = ""
+                                calls_delta = list(payload or [])
+                                self._set_run_status("tool", self._status_label_for_calls(calls_delta))
+                                if turn is not None:
+                                    elapsed = time.monotonic() - self._wait_t0
+                                    turn.show_stream(
+                                        thinking,
+                                        round_answer,
+                                        elapsed=elapsed,
+                                        out_tokens=_est_tokens(thinking),
+                                        in_tokens=self._live_in,
+                                        cache_tokens=self._live_cache,
+                                    )
+                                    await turn.sync_tools(calls_delta)
+                                    self._stick_bottom()
+                                await asyncio.sleep(0)
+                                continue
+                            if self._waiting:
+                                self._waiting = False
+                            if kind == "thinking":
+                                thinking += str(payload)
+                                if self._status_kind != "tool":
+                                    self._set_run_status("think")
+                            elif kind == "answer":
+                                round_answer += str(payload)
+                                if self._status_kind != "tool":
+                                    self._set_run_status("stream")
+                            else:
+                                continue
+                            answer = round_answer
+                            self._thinking_text = thinking
+                            self._answer_text = answer
+                            self._set_live_out(thinking, answer)
+                            if turn is not None:
+                                elapsed = time.monotonic() - self._wait_t0
+                                turn.show_stream(
+                                    thinking,
+                                    answer,
+                                    elapsed=elapsed,
+                                    out_tokens=_est_tokens(thinking),
+                                    in_tokens=self._live_in,
+                                    cache_tokens=self._live_cache,
+                                )
+                                self._stick_bottom()
+                            await asyncio.sleep(0)
+                        for _usage in round_usage:
+                            self._apply_usage(_usage)
+                        break
+                    except Exception as exc:
+                        if interrupted:
+                            break
+                        if attempt > _RETRY_TOTAL or run_id != self._run_id:
+                            raise
+                        # 半截内容回滚,重试从头生成本轮
+                        thinking = thinking_base
+                        round_answer = ""
+                        answer = ""
+                        self._thinking_text = thinking
+                        self._answer_text = ""
+                        if turn is not None:
+                            turn.show_stream(
+                                thinking,
+                                "",
+                                elapsed=time.monotonic() - self._wait_t0,
+                                out_tokens=_est_tokens(thinking),
+                                in_tokens=self._live_in,
+                                cache_tokens=self._live_cache,
+                            )
+                        self._retry_attempt = attempt
+                        self._retry_total = _RETRY_TOTAL
+                        self._set_run_status("error", str(exc))
+                        await asyncio.sleep(min(1.5 * attempt, 8.0))
+                        self._retry_attempt = 0
+                        self._retry_total = 0
+                if interrupted or run_id != self._run_id:
+                    interrupted = True
+                    break
+                if not calls:
+                    answer = round_answer
+                    break
+                if looks_like_tool_args(round_answer):
+                    round_answer = ""
+                    answer = ""
+                    if turn is not None:
+                        elapsed = time.monotonic() - self._wait_t0
+                        turn.show_stream(
+                            thinking,
+                            "",
+                            elapsed=elapsed,
+                            out_tokens=_est_tokens(thinking),
+                            in_tokens=self._live_in,
+                            cache_tokens=self._live_cache,
+                        )
+                tool_calls = [
+                    {
+                        "id": c.get("id") or f"call_{i}",
+                        "type": "function",
+                        "function": {
+                            "name": c.get("name") or "",
+                            "arguments": c.get("arguments") or "{}",
+                        },
+                    }
+                    for i, c in enumerate(calls)
+                ]
+                assistant_msg: dict = {"role": "assistant", "tool_calls": tool_calls}
+                if round_answer:
+                    assistant_msg["content"] = round_answer
+                working.append(assistant_msg)
+                if run_id == self._run_id:
+                    self._store.add_message(
+                        self._session_id,
+                        "assistant",
+                        (round_answer or "").strip(),
+                        meta={"tool_calls": tool_calls},
+                    )
+                for i, call in enumerate(calls):
+                    name = str(call.get("name") or "")
+                    raw_args = call.get("arguments") or "{}"
+                    try:
+                        args = json.loads(raw_args)
+                    except json.JSONDecodeError:
+                        args = parse_tool_arguments(str(raw_args))
+                    if not isinstance(args, dict):
+                        args = {}
+                    title = tool_title(name, args)
+                    self._set_run_status("tool", title)
+                    card = None
+                    if turn is not None:
+                        if self._waiting:
+                            self._waiting = False
+                            elapsed = time.monotonic() - self._wait_t0
+                            turn.show_stream(
+                                thinking,
+                                answer,
+                                elapsed=elapsed,
+                                out_tokens=_est_tokens(thinking),
+                                in_tokens=self._live_in,
+                                cache_tokens=self._live_cache,
+                            )
+                        card = await turn.begin_tool(title, index=i, name=name)
+                        self._stick_bottom()
+                    allowed = True
+                    if run_id == self._run_id:
+                        allowed = await self._confirm_tool(name, args, title=title)
+                    if run_id != self._run_id:
+                        interrupted = True
+                        break
+                    if not allowed:
+                        result = "用户拒绝了这次操作。"
+                    else:
+                        # 终端命令边跑边把输出刷进卡片
+                        on_output = None
+                        if card is not None and normalize_tool_name(name) in (
+                            "run_terminal_command",
+                        ):
+                            on_output = card.stream_output
+                        result = await execute_tool_async(
+                            name, args, on_output=on_output
+                        )
+                    if card is not None:
+                        card.finish(name, result)
+                        self._stick_bottom()
+                    tool_msg = {
+                        "role": "tool",
+                        "tool_call_id": call.get("id") or "",
+                        # 只读工具的大结果掐头去尾再进上下文;磁盘和卡片上仍是全文
+                        "content": _clip_tool_context(name, result),
+                    }
+                    working.append(tool_msg)
+                    if run_id == self._run_id:
+                        self._store.add_message(
+                            self._session_id,
+                            "tool",
+                            result,
+                            meta={
+                                "tool_call_id": call.get("id") or "",
+                                "name": name,
+                            },
+                        )
+                    self._sync_live_in(working)
+                    await asyncio.sleep(0)
+                if interrupted or run_id != self._run_id:
+                    interrupted = True
+                    break
+                self._set_run_status("wait")
+        except asyncio.CancelledError:
+            interrupted = True
+        except Exception as exc:
+            err = str(exc)
+        finally:
+            self._waiting = False
+            self._busy = False
+            self._stop_turn_timer()
+            self._hide_run_status()
+            shown_in = self._live_in
+            shown_out = self._live_out
+            shown_cache = self._live_cache
+            self._commit_live_usage(sid)
+            self._checkpoint_id = None
+            if isinstance(self.screen, PermitScreen):
+                self.screen.dismiss(False)
+            elif self._permit_future is not None and not self._permit_future.done():
+                self._permit_future.set_result(False)
+            self._permit_future = None
+
+        if run_id != self._run_id:
+            return
+        if turn is None:
+            if interrupted:
+                self._resume_after_interrupt()
+            elif not self._hold_queue:
+                self.call_after_refresh(self._send_next_queued)
+            return
+        if interrupted:
+            turn.show_interrupted(
+                thinking,
+                answer,
+                elapsed=time.monotonic() - self._wait_t0,
+                in_tokens=shown_in,
+                cache_tokens=shown_cache,
+            )
+            if answer.strip() and run_id == self._run_id:
+                self._store.add_message(
+                    self._session_id,
+                    "assistant",
+                    answer.strip(),
+                    thinking=thinking,
+                )
+            self._refresh_footer_meta()
+            self._stick_bottom()
+            self._resume_after_interrupt()
+            return
+        if err:
+            turn.show_error(err)
+        elif not thinking and not answer:
+            turn.show_empty()
+        else:
+            self._store.add_message(
+                self._session_id,
+                "assistant",
+                answer.strip(),
+                thinking=thinking,
+            )
+            elapsed = time.monotonic() - self._wait_t0
+            turn.show_stream(
+                thinking,
+                answer,
+                elapsed=elapsed,
+                out_tokens=_est_tokens(thinking),
+                in_tokens=shown_in,
+                cache_tokens=shown_cache,
+                final=True,
+            )
+            turn._thinking_cache = thinking
+            # 折叠时不要把思考正文画出来,否则会和下面的回复叠在一起
+            if thinking and not turn.query_one("#thinking", Collapsible).collapsed:
+                turn._flush_thinking()
+        self._refresh_footer_meta()
+        self._stick_bottom()
+        self._hold_queue = False
+        self.call_after_refresh(self._send_next_queued)
+
+    def _resume_after_interrupt(self) -> None:
+        """打断后:若是队列发送按钮触发的,只发那一条;Esc 则队列原样停住。"""
+        pending = self._pending_prompt
+        self._pending_prompt = None
+        if pending:
+            self._hold_queue = False
+            self.call_after_refresh(self._kickoff, pending)
+            return
+        self._hold_queue = True
+
+
+def main() -> None:
+    # .run() 会启动事件循环、渲染界面,并一直运行到用户按 Ctrl+Q 退出
+    AgentApp().run()
+
+
+if __name__ == "__main__":
+    main()