lithe-cli 0.2.4__tar.gz → 0.4.0__tar.gz

{lithe_cli-0.2.4 → lithe_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lithe-cli
-Version: 0.2.4
+Version: 0.4.0
 Summary: Command-line interface for the lithe agent kernel: chat, one-shot runs, undo, and run inspection.
 License: MIT License
         
@@ -39,7 +39,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: lithe>=0.9.5
+Requires-Dist: lithe>=0.9.7
+Requires-Dist: prompt-toolkit>=3.0.38
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: ruff>=0.4; extra == "dev"
@@ -117,7 +118,7 @@ usage/context gauges; `--max-steps` caps the tool loop;
 ```bash
 $ lithe chat
 ╭──────────────────────────────────────╮
-│ lithe 0.2.0                          │
+│ lithe 0.4.0                          │
 │ model   your-model                   │
 │ workdir /home/me/my-project          │
 │ /help 查看会话命令，/exit 退出       │
@@ -141,6 +142,7 @@ The kernel ships these as bundles; the CLI grants them per flag:
 | Flag | Tools granted | Notes |
 | --- | --- | --- |
 | `--code` | `run_code` / `run_file` | Python under bubblewrap when installed (passthrough otherwise); `doctor` shows which |
+| `--shell` | `run_command` | Native bash/sh on Linux and macOS, PowerShell/cmd on Windows; runs with the current user's host permissions, is not sandboxed, and cannot be undone |
 | `--skills DIR` | `load_skill` | markdown skill library; defaults to `$LITHE_HOME/skills` when it exists, `--skills ""` disables |
 | `--download` | `download_file` | SSRF-guarded, size-capped network fetch |
 | `--vision` | `image_info` / `analyze_image` | image probe is stdlib-only; analysis routes one vision call to the main endpoint |
@@ -148,6 +150,7 @@ The kernel ships these as bundles; the CLI grants them per flag:
 
 ```bash
 $ lithe run --code "用 run_code 验证 results.csv 的行数"
+$ lithe run --shell "检查当前目录的项目状态"
 $ lithe chat --skills ~/my-skills --mcp @~/mcp.json
 ```
 
@@ -197,8 +200,12 @@ them only after a session has started the servers.)
 ### Colors
 
 Output is colored when stdout is a TTY and `NO_COLOR` is unset; `--color`
-/ `--no-color` force either way. Rendering has zero dependencies — plain
-text degrades cleanly through pipes and cron.
+/ `--no-color` force either way. Output rendering itself stays
+dependency-free — plain text degrades cleanly through pipes and cron.
+Interactive *input* (the chat prompt and the setup wizard) is
+[prompt_toolkit](https://python-prompt-toolkit.readthedocs.io/):
+wide-character-safe editing, bracketed-paste handling, star-echoed API
+keys, inline wizard validation, and persistent history.
 
 ## Where things land
 
@@ -208,6 +215,7 @@ text degrades cleanly through pipes and cron.
 | `~/.lithe/runs` (or `--store`) | JSONL run store: messages, actions, undo records |
 | `~/.lithe/runs/todos-<user>.json` | the agent's task list |
 | `~/.lithe/skills` (or `--skills`) | the markdown skill library, when enabled |
+| `~/.lithe/history` | chat input history (prompt_toolkit `FileHistory`; Up/Ctrl+R recall) |
 
 ## Design notes
 

{lithe_cli-0.2.4 → lithe_cli-0.4.0}/README.md

@@ -70,7 +70,7 @@ usage/context gauges; `--max-steps` caps the tool loop;
 ```bash
 $ lithe chat
 ╭──────────────────────────────────────╮
-│ lithe 0.2.0                          │
+│ lithe 0.4.0                          │
 │ model   your-model                   │
 │ workdir /home/me/my-project          │
 │ /help 查看会话命令，/exit 退出       │
@@ -94,6 +94,7 @@ The kernel ships these as bundles; the CLI grants them per flag:
 | Flag | Tools granted | Notes |
 | --- | --- | --- |
 | `--code` | `run_code` / `run_file` | Python under bubblewrap when installed (passthrough otherwise); `doctor` shows which |
+| `--shell` | `run_command` | Native bash/sh on Linux and macOS, PowerShell/cmd on Windows; runs with the current user's host permissions, is not sandboxed, and cannot be undone |
 | `--skills DIR` | `load_skill` | markdown skill library; defaults to `$LITHE_HOME/skills` when it exists, `--skills ""` disables |
 | `--download` | `download_file` | SSRF-guarded, size-capped network fetch |
 | `--vision` | `image_info` / `analyze_image` | image probe is stdlib-only; analysis routes one vision call to the main endpoint |
@@ -101,6 +102,7 @@ The kernel ships these as bundles; the CLI grants them per flag:
 
 ```bash
 $ lithe run --code "用 run_code 验证 results.csv 的行数"
+$ lithe run --shell "检查当前目录的项目状态"
 $ lithe chat --skills ~/my-skills --mcp @~/mcp.json
 ```
 
@@ -150,8 +152,12 @@ them only after a session has started the servers.)
 ### Colors
 
 Output is colored when stdout is a TTY and `NO_COLOR` is unset; `--color`
-/ `--no-color` force either way. Rendering has zero dependencies — plain
-text degrades cleanly through pipes and cron.
+/ `--no-color` force either way. Output rendering itself stays
+dependency-free — plain text degrades cleanly through pipes and cron.
+Interactive *input* (the chat prompt and the setup wizard) is
+[prompt_toolkit](https://python-prompt-toolkit.readthedocs.io/):
+wide-character-safe editing, bracketed-paste handling, star-echoed API
+keys, inline wizard validation, and persistent history.
 
 ## Where things land
 
@@ -161,6 +167,7 @@ text degrades cleanly through pipes and cron.
 | `~/.lithe/runs` (or `--store`) | JSONL run store: messages, actions, undo records |
 | `~/.lithe/runs/todos-<user>.json` | the agent's task list |
 | `~/.lithe/skills` (or `--skills`) | the markdown skill library, when enabled |
+| `~/.lithe/history` | chat input history (prompt_toolkit `FileHistory`; Up/Ctrl+R recall) |
 
 ## Design notes
 

{lithe_cli-0.2.4 → lithe_cli-0.4.0}/lithe_cli/__init__.py

@@ -1,3 +1,3 @@
 """lithe-cli: the command-line interface for the lithe agent kernel."""
 
-__version__ = "0.2.4"
+__version__ = "0.4.0"

{lithe_cli-0.2.4 → lithe_cli-0.4.0}/lithe_cli/agent.py

@@ -8,9 +8,9 @@ Everything here maps lithe's host contract onto CLI defaults:
   kernel's zero-database default;
 - tools — the workspace bundle (read/write/edit/list/search/glob +
   apply_patch) and todos, plus opt-in capabilities: ``--code`` (sandboxed
-  Python), ``--skills`` (markdown skill library), ``--vision`` (image
-  probe/analysis), ``--download`` (SSRF-guarded network fetch) and
-  ``--mcp`` (external MCP servers);
+  Python), ``--shell`` (native host commands), ``--skills`` (markdown skill
+  library), ``--vision`` (image probe/analysis), ``--download`` (SSRF-guarded
+  network fetch) and ``--mcp`` (external MCP servers);
 - undo — the bundled tools register reverters, so ``lithe undo`` works with
   zero configuration.
 """
@@ -32,6 +32,7 @@ from lithe.bundles import (
     Workspace,
     undo_run,
 )
+from lithe.bundles.command import register_command_tools
 from lithe.bundles.download import register_download_tools
 from lithe.bundles.patch import register_apply_patch_tool
 from lithe.bundles.workspace import register_file_tools
@@ -57,6 +58,8 @@ def build_system_prompt(cfg: Config) -> str:
     extras = []
     if cfg.code:
         extras.append("可以用 run_code 执行 Python 来验证想法、计算或测试。")
+    if cfg.shell:
+        extras.append("可以用 run_command 在主机上运行系统命令；命令有当前用户权限且副作用不可撤销，执行前先确认必要性。")
     if cfg.download:
         extras.append("可以用 download_file 下载网络文件到工作区。")
     if cfg.skills_dir is not None:
@@ -97,6 +100,12 @@ def build_registry(cfg: Config) -> ToolRegistry:
 
         runner = CodeRunner(sys.executable, backend=sandbox_backend())
         register_code_tools(reg, lambda ctx: str(cfg.workspace_dir.resolve()), runner)
+    if cfg.shell:
+        from lithe.bundles.command import CommandRunner
+
+        register_command_tools(
+            reg, lambda ctx: cfg.workspace_dir.resolve(), CommandRunner()
+        )
     if cfg.skills_dir is not None:
         from lithe.bundles.skills import SkillLibrary, register_skill_tool
 
@@ -146,14 +155,14 @@ def render_event(
             ui.assistant(text)
     elif t == "tool_call":
         args = json.dumps(ev.get("args", {}), ensure_ascii=False)
-        ui.tool_call(str(ev.get("name")), args[:120])
+        ui.tool_call(str(ev.get("name")), args)
         if ev.get("id") is not None:
             pending[ev["id"]] = time.monotonic()
     elif t == "tool_result":
         summary = (ev.get("summary") or "").replace("\n", " ")
         started = pending.pop(ev.get("id"), None) if ev.get("id") else None
         elapsed = (time.monotonic() - started) if started is not None else None
-        ui.tool_result(bool(ev.get("ok")), summary[:160], elapsed)
+        ui.tool_result(bool(ev.get("ok")), summary, elapsed)
     elif t == "error":
         ui.error(str(ev.get("message", "")))
     elif t == "cancelled":

{lithe_cli-0.2.4 → lithe_cli-0.4.0}/lithe_cli/config.py

@@ -57,6 +57,7 @@ class Config:
     download: bool = False
     verbose: bool = False
     code: bool = False
+    shell: bool = False
     skills_dir: Path | None = None
     mcp_spec: str | None = None
     mcp_servers: list = field(default_factory=list)
@@ -204,6 +205,7 @@ def load_config(args: Any) -> Config:
         download=g("download", False),
         verbose=g("verbose", False),
         code=g("code", False),
+        shell=g("shell", False),
         skills_dir=skills_dir,
         mcp_spec=mcp_raw,
         mcp_servers=load_mcp_spec(mcp_raw) if mcp_raw else [],

{lithe_cli-0.2.4 → lithe_cli-0.4.0}/lithe_cli/main.py

@@ -29,9 +29,10 @@ from lithe import __version__ as lithe_version
 from lithe.bundles import JsonlRunStore
 
 from . import __version__
+from . import prompts
 from .agent import build_registry, execute, sandbox_backend, undo
 from .config import config_file, load_config, require_endpoint
-from . import ttyio
+from .prompts import open_history
 from .ui import BOLD, CYAN, GREEN, RED, YELLOW, configure, truncate, ui
 
 
@@ -65,6 +66,11 @@ def build_parser() -> argparse.ArgumentParser:
             help="grant run_code/run_file (sandboxed Python; "
             "bwrap when available, passthrough otherwise)",
         )
+        sp.add_argument(
+            "--shell",
+            action="store_true",
+            help="grant run_command (native shell with current-user host access)",
+        )
         sp.add_argument(
             "--skills",
             metavar="DIR",
@@ -177,7 +183,7 @@ def _cmd_runs(cfg: Any, limit: int) -> int:
     rows = []
     for r in reversed(runs):  # newest last, like a log
         task = (r.task or "").replace("\n", " ")
-        rows.append([r.run_id, r.status, str(r.steps), f"{r.cost:.4f}", task[:60]])
+        rows.append([r.run_id, r.status, str(r.steps), f"{r.cost:.4f}", truncate(task, 60)])
     print(
         ui.table(
             ["run", "status", "steps", "cost", "task"],
@@ -223,7 +229,7 @@ def _cmd_doctor() -> int:
     class _Args:  # doctor reuses load_config over env-only defaults
         api_key = base_url = model = store = workspace = user = None
         skills = mcp = None
-        download = code = vision = color = no_color = verbose = False
+        download = code = shell = vision = color = no_color = verbose = False
 
     cfg = load_config(_Args())
     print(ui.s(f"lithe-cli {__version__}（lithe {lithe_version}）", CYAN, BOLD))
@@ -263,6 +269,8 @@ def _cmd_doctor() -> int:
     else:
         sandbox_line = ui.s("passthrough（未找到 bwrap，无隔离）", RED)
     print(ui.kv("sandbox", sandbox_line + "；--code 启用 run_code"))
+    command_line = "已启用（run_command 可执行主机命令）" if cfg.shell else "未启用（--shell 显式授权）"
+    print(ui.kv("shell", command_line))
 
     skills = default_skills_dir()
     if cfg.skills_dir is not None:
@@ -330,13 +338,13 @@ _CHAT_HELP = """可用命令：
 def _chat_loop(cfg: Any) -> int:
     store = JsonlRunStore(cfg.store_dir)
     run_ids: list[str] = []
-    history: list[str] = []
+    input_history = open_history()  # FileHistory under $LITHE_HOME, shared runs
     print(ui.banner(__version__, cfg.model or "(scripted)", str(cfg.workspace_dir)))
     while True:
         try:
-            # raw cbreak reader, not input(): readline's redisplay can
-            # corrupt multibyte buffers on long wrapped lines
-            line = ttyio.read_line(ui.prompt(), history=history).strip()
+            # prompt_toolkit owns the terminal: wide-char safe, paste-safe,
+            # persistent history — never input()/readline
+            line = prompts.chat_line(ui.prompt(), input_history).strip()
         except (EOFError, KeyboardInterrupt):
             print()
             break
@@ -351,7 +359,6 @@ def _chat_loop(cfg: Any) -> int:
             continue
         if not line:
             continue
-        history.append(line)
         if line in ("/exit", "/quit", "exit", "quit"):
             break
         if line == "/help":

lithe_cli-0.4.0/lithe_cli/prompts.py

@@ -0,0 +1,118 @@
+"""All interactive input goes through prompt_toolkit.
+
+One seam for every prompt the CLI shows: the chat line (persistent
+history, ANSI-colored prompt), the wizard's questions (inline
+validation, hidden API key with star echo), and yes/no confirms.
+
+prompt_toolkit owns the terminal: it draws its own line editor with
+proper wide-character widths (no readline multibyte corruption), turns
+on and consumes bracketed paste itself, and masks ``is_password``
+input with asterisks — the three failure classes this CLI hit when it
+used ``input``/``getpass``/readline are all upstream concerns now.
+"""
+
+from __future__ import annotations
+
+from prompt_toolkit import prompt
+from prompt_toolkit.formatted_text import ANSI
+from prompt_toolkit.history import FileHistory, InMemoryHistory
+from prompt_toolkit.validation import ValidationError, Validator
+
+from .ui import RED, YELLOW, ui
+
+_MAX_EMPTY_TRIES = 3
+
+_UTF8_HINT = (
+    "\n  这行输入无法按 UTF-8 解码，已丢弃；"
+    "请把终端与 locale 设为 UTF-8（如 export LANG=C.UTF-8）后重试。"
+)
+
+
+def history_file():
+    """Where chat history persists, next to the saved endpoint."""
+    from .config import lithe_home
+
+    return lithe_home() / "history"
+
+
+def open_history() -> FileHistory:
+    """A FileHistory under ``$LITHE_HOME`` (dir created on demand)."""
+    path = history_file()
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        return InMemoryHistory()
+    return FileHistory(str(path))
+
+
+def chat_line(message: str, history) -> str:
+    """The chat REPL prompt: colored, history-searchable, paste-safe."""
+    return prompt(
+        ANSI(message),
+        history=history,
+        enable_history_search=True,
+    )
+
+
+class _FnValidator(Validator):
+    """Adapt a ``text -> error string | None`` callable for prompt_toolkit."""
+
+    def __init__(self, fn):
+        self.fn = fn
+
+    def validate(self, document) -> None:
+        problem = self.fn(document.text)
+        if problem:
+            raise ValidationError(message=problem, cursor_position=len(document.text))
+
+
+def ask(
+    label: str,
+    default: str = "",
+    password: bool = False,
+    validate=None,
+) -> str | None:
+    """Ask for one value; empty answers keep the default or re-prompt.
+
+    ``validate`` (text -> error string or None) is enforced inline by
+    prompt_toolkit — Enter is refused with the message until the value
+    passes. Returns None when the user bails out (empty too often,
+    Ctrl+C/D).
+    """
+    message = f"{label} [回车沿用已保存值]: " if password and default else f"{label}: "
+    validator = _FnValidator(validate) if validate is not None else None
+    for _ in range(_MAX_EMPTY_TRIES):
+        try:
+            answer = prompt(
+                message,
+                default=default if not password else "",
+                is_password=password,
+                validator=validator,
+            ).strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return None
+        except UnicodeDecodeError:
+            print(ui.s(_UTF8_HINT, RED))
+            continue
+        if not answer and default:
+            return default
+        if not answer:
+            print(ui.s("  这个值不能为空。", YELLOW))
+            continue
+        return answer
+    return None
+
+
+def yes_no(label: str, default: bool) -> bool:
+    """A y/n question; empty answer takes the default."""
+    hint = "Y/n" if default else "y/N"
+    try:
+        answer = prompt(f"{label} [{hint}]: ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return default
+    except UnicodeDecodeError:
+        print(ui.s("\n  这行输入无法按 UTF-8 解码，按默认值处理。", RED))
+        return default
+    return default if not answer else answer in ("y", "yes", "是")

lithe_cli-0.4.0/lithe_cli/setup.py

@@ -0,0 +1,109 @@
+"""First-run endpoint setup: the wizard behind `lithe-cli config`.
+
+The CLI still ships no default endpoint — that principle is untouched.
+What changes is the failure mode: on an interactive terminal, a missing
+endpoint means three prompts and a saved config file instead of a
+refusal with a wall of export lines. Non-interactive contexts (pipes,
+scripts, CI) never see the wizard; they keep the hard error.
+
+Precedence stays flag > env > config file, so the wizard only fills what
+nothing else provided. All prompting is prompt_toolkit (see
+:mod:`lithe_cli.prompts`): inline URL validation, star-echoed API key,
+paste-safe input.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+from . import prompts
+from .config import (
+    ENV_API_KEY,
+    ENV_BASE_URL,
+    ENV_MODEL,
+    config_file,
+    load_saved_endpoint,
+    save_endpoint,
+)
+from .ui import BOLD, CYAN, GREEN, RED, YELLOW, ui
+
+
+def stdin_is_interactive() -> bool:
+    """True only when both ends are TTYs — pipes and captures stay clean."""
+    return sys.stdin.isatty() and sys.stdout.isatty()
+
+
+def _http_like(value: str) -> str | None:
+    return (
+        None
+        if value.startswith(("http://", "https://"))
+        else ("Base URL 需以 http:// 或 https:// 开头。")
+    )
+
+
+def probe_endpoint(base_url: str, api_key: str, timeout: float = 10.0) -> bool:
+    """One cheap GET ``{base_url}/models`` to catch typos before chat.
+
+    The save already happened: a failed probe warns, it never blocks —
+    endpoints legitimately lack ``/models`` or auth differently.
+    """
+    url = base_url.rstrip("/") + "/models"
+    req = Request(url, headers={"Authorization": f"Bearer {api_key}"})
+    try:
+        with urlopen(req, timeout=timeout) as resp:
+            print(ui.s(f"✓ 端点可达（HTTP {resp.status}）", GREEN))
+            return True
+    except HTTPError as exc:
+        if exc.code in (401, 403):
+            print(ui.s(f"~ 端点可达但拒绝了该 key（HTTP {exc.code}）", YELLOW))
+        else:
+            print(ui.s(f"~ 端点有响应：HTTP {exc.code}（无 /models 也无妨）", YELLOW))
+        return True  # reachable is all we wanted to know
+    except (URLError, OSError, TimeoutError) as exc:
+        print(ui.s(f"✗ 连不上 {url}：{exc}", RED))
+        return False
+
+
+def run_setup_wizard() -> dict | None:
+    """Prompt for base_url / api_key / model and save the config file.
+
+    Defaults come from the already-saved file, then env vars, so
+    re-running the wizard is re-editing, not retyping. Returns the saved
+    endpoint dict, or None when the user cancels.
+    """
+    if not stdin_is_interactive():
+        print(ui.s("交互配置需要终端（stdin/stdout 不是 TTY）。", RED))
+        return None
+    saved = load_saved_endpoint()
+    env = {
+        "base_url": os.environ.get(ENV_BASE_URL, "").strip(),
+        "api_key": os.environ.get(ENV_API_KEY, "").strip(),
+        "model": os.environ.get(ENV_MODEL, "").strip(),
+    }
+    defaults = {k: saved.get(k, "") or env[k] for k in env}
+
+    print(ui.s("初始设置：配置模型端点", CYAN, BOLD))
+    print(
+        f"值保存在 {config_file()}（权限 600）；"
+        "优先级 flag > 环境变量 > 配置文件。\n"
+        "之后可用 `lithe-cli config` 重新配置。"
+    )
+    base_url = prompts.ask(
+        "Base URL（如 https://your-endpoint/api/v1）",
+        defaults["base_url"],
+        validate=_http_like,
+    )
+    api_key = prompts.ask("API key", defaults["api_key"], password=True)
+    model = prompts.ask("模型名（如 glm-4.6）", defaults["model"])
+    if not (base_url and api_key and model):
+        print(ui.s("已取消，未保存任何配置。", YELLOW))
+        return None
+
+    path = save_endpoint(api_key, base_url, model)
+    print(ui.s(f"✓ 已保存到 {path}", GREEN))
+    if prompts.yes_no("现在测试一下连接吗", True):
+        probe_endpoint(base_url, api_key)
+    return {"api_key": api_key, "base_url": base_url, "model": model}

{lithe_cli-0.2.4 → lithe_cli-0.4.0}/lithe_cli/ui.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import os
 import re
+import shutil
 import sys
 import unicodedata
 
@@ -81,8 +82,13 @@ def truncate(text: str, width: int) -> str:
 class UI:
     """All terminal output goes through here; ``color`` gates every code."""
 
-    def __init__(self, color: bool = False):
+    def __init__(self, color: bool = False, width: int | None = None):
         self.color = bool(color)
+        self._width = width
+
+    @property
+    def width(self) -> int:
+        return max(12, self._width or shutil.get_terminal_size((100, 24)).columns)
 
     def s(self, text: str, *styles: str) -> str:
         """Wrap *text* in *styles* when color is on and text is non-empty."""
@@ -93,36 +99,53 @@ class UI:
     # -- structural ---------------------------------------------------------
 
     def rule(self, char: str = "─", width: int = 60) -> str:
-        return self.s(char * width, DIM)
+        return self.s(char * min(width, self.width), DIM)
 
     def kv(self, label: str, value: str) -> str:
         return f"{self.s(pad(label, 11), CYAN, BOLD)} {value}"
 
     def section(self, title: str) -> str:
-        tail = "─" * max(0, 50 - display_width(title))
-        return self.s(f"── {title} {tail}", DIM)
+        width = min(50, self.width)
+        label = f"── {title} "
+        if display_width(label) > width:
+            return self.s(truncate(label, width), DIM)
+        return self.s(label + "─" * (width - display_width(label)), DIM)
 
     def table(
         self, headers: list[str], rows: list[list[str]], cell_styles: list | None = None
     ) -> str:
-        """Aligned table; ``cell_styles[i](text) -> str`` styles column i."""
+        """Aligned, terminal-width-aware table with display-width styling."""
         widths = [display_width(h) for h in headers]
         for row in rows:
-            for i, cell in enumerate(row):
+            for i, cell in enumerate(row[:len(headers)]):
                 widths[i] = max(widths[i], display_width(cell))
+        spacing = "  " if self.width >= 3 * len(headers) else " "
+        available = max(1, self.width - display_width(spacing) * (len(headers) - 1))
+        overflow = max(0, sum(widths) - available)
+        for i in range(len(widths) - 1, -1, -1):
+            floor = min(widths[i], max(1, display_width(headers[i])))
+            reduction = min(overflow, widths[i] - floor)
+            widths[i] -= reduction
+            overflow -= reduction
+        for i in range(len(widths) - 1, -1, -1):
+            reduction = min(overflow, widths[i] - 1)
+            widths[i] -= reduction
+            overflow -= reduction
+        shown_headers = [truncate(h, widths[i]) for i, h in enumerate(headers)]
         head = self.s(
-            "  ".join(pad(h, widths[i]) for i, h in enumerate(headers)), BOLD, DIM
+            spacing.join(pad(shown_headers[i], widths[i]) for i in range(len(headers))),
+            BOLD,
+            DIM,
         )
-        sep = self.s("  ".join("─" * w for w in widths), DIM)
+        sep = self.s(spacing.join("─" * w for w in widths), DIM)
         lines = [head, sep]
         for row in rows:
             cells = []
-            for i, cell in enumerate(row):
-                styled = cell
-                if cell_styles and cell_styles[i]:
-                    styled = cell_styles[i](cell)
+            for i, cell in enumerate(row[:len(headers)]):
+                shown = truncate(cell, widths[i])
+                styled = cell_styles[i](shown) if cell_styles and cell_styles[i] else shown
                 cells.append(pad(styled, widths[i]))
-            lines.append("  ".join(cells))
+            lines.append(spacing.join(cells))
         return "\n".join(lines)
 
     def status(self, text: str) -> str:
@@ -146,12 +169,15 @@ class UI:
         print(self.s(text, GREEN))
 
     def tool_call(self, name: str, args: str) -> None:
-        print(f"  {self.s('⚒', CYAN)} {self.s(name, CYAN, BOLD)} {self.s(args, DIM)}")
+        prefix = f"  ⚒ {name} "
+        detail = truncate(args, max(8, self.width - display_width(prefix)))
+        print(f"  {self.s('⚒', CYAN)} {self.s(name, CYAN, BOLD)} {self.s(detail, DIM)}")
 
     def tool_result(self, ok: bool, summary: str, elapsed: float | None) -> None:
         mark = self.s("✓", GREEN) if ok else self.s("✗", RED)
         tail = self.s(f" {elapsed:.1f}s", DIM) if elapsed is not None else ""
-        print(f"  {mark} {self.s(summary, GREEN if ok else RED)}{tail}")
+        label = truncate(summary, max(8, self.width - 8 - display_width(tail)))
+        print(f"  {mark} {self.s(label, GREEN if ok else RED)}{tail}")
 
     def error(self, msg: str) -> None:
         print(f"  {self.s('!', RED)} {self.s(msg, RED)}")
@@ -188,15 +214,17 @@ class UI:
 
     def banner(self, version: str, model: str, workspace: str) -> str:
         rows = [
-            f"lithe {version}",
-            f"model   {model}",
-            f"workdir {workspace}",
-            "/help 查看会话命令，/exit 退出",
+            f"lithe {version} · command agent",
+            f"◆ model      {model}",
+            f"⌂ workspace  {workspace}",
+            "/help 查看会话命令 · /exit 退出",
         ]
-        width = max(display_width(r) for r in rows) + 2
+        inner = max(8, self.width - 4)
+        rows = [truncate(row, inner - 2) for row in rows]
+        width = max(display_width(row) for row in rows) + 2
         top = "╭" + "─" * width + "╮"
         bot = "╰" + "─" * width + "╯"
-        body = "\n".join("│" + pad(" " + r, width) + "│" for r in rows)
+        body = "\n".join("│" + pad(" " + row, width) + "│" for row in rows)
         art = "\n".join((top, body, bot))
         return self.s(art, CYAN)