@baimingtao/lbs-agent 1.5.0 → 1.6.0

package/bin/lbs.js

@@ -96,14 +96,11 @@ function gradient(text) {
   return out;
 }
 
-// ── Banner — 极简留白 ─────────────────────────────────────────
+// ── Banner — 单行品牌 ─────────────────────────────────────────
 
 function printBanner() {
   console.log();
-  console.log('        ' + paint('✦', C.pink));
-  console.log();
-  console.log('    ' + gradient('LBS Agent'));
-  console.log('      ' + paint('Autonomous AI Runtime', C.subtle));
+  console.log('  ' + gradient('LBS Agent') + '  ' + paint('Autonomous AI Runtime', C.subtle));
   console.log();
 }
 // ── 初始化检查 ─────────────────────────────────────────────────

package/interfaces/cli/_impl/cli_theme.py

@@ -1,11 +1,9 @@
-"""LBS CLI Theme — Aurora Pink 现代终端设计系统。
+"""LBS CLI Terminal Design System.
 
-设计原则:
-  留白 > 密集
-  符号 > 字符画
-  渐变 > 纯色
-
-对标: Claude Code, Gemini CLI, Warp Terminal, Charm BubbleTea
+原则:
+  终端 = Canvas, 不是 stdout
+  所有输出走 Layout, 有版心、间距、层级
+  一套图标, 一种节奏
 """
 
 from __future__ import annotations
@@ -13,6 +11,33 @@ from __future__ import annotations
 import os
 import sys
 
+# ── 版心 ───────────────────────────────────────────────────────
+
+MARGIN = 2        # 左缩进
+MAX_W  = 110      # 内容宽度上限
+
+def _term_width() -> int:
+    try:
+        import shutil
+        return shutil.get_terminal_size().columns
+    except Exception:
+        return 80
+
+def content_width() -> int:
+    return min(_term_width() - MARGIN * 2, MAX_W)
+
+def pad(text: str, level: int = 0) -> str:
+    """给每行加左缩进。level=0 用 MARGIN, 更深层级递加。"""
+    indent = " " * (MARGIN + level * 2)
+    lines = text.split("\n")
+    return "\n".join(indent + ln if ln.strip() else ln for ln in lines)
+
+def out(text: str = "", level: int = 0) -> None:
+    """统一输出 — 所有 CLI 输出的唯一出口。"""
+    if text == "":
+        print()
+    else:
+        print(pad(text, level))
 
 # ── 色彩 ───────────────────────────────────────────────────────
 
@@ -22,212 +47,167 @@ class C:
     DIM     = "\033[2m"
     ITALIC  = "\033[3m"
 
-    # Aurora Pink 渐变 (Pink → Purple → Blue)
-    PINK    = "\033[38;2;255;79;164m"       # #FF4FA4
-    PINK_L  = "\033[38;2;255;167;213m"      # #FFA7D5
-    PURPLE  = "\033[38;2;194;107;255m"      # #C26BFF
-    BLUE    = "\033[38;2;110;139;255m"      # #6E8BFF
-
-    # Mint (Web 端品牌色)
-    MINT    = "\033[38;2;152;216;200m"      # #98D8C8
-    MINT_D  = "\033[38;2;111;196;176m"      # #6FC4B0
-
-    # 状态
-    OK      = "\033[38;2;62;229;138m"       # #3EE58A
-    WARN    = "\033[38;2;255;179;71m"       # #FFB347
-    ERR     = "\033[38;2;255;107;129m"      # #FF6B81
-    INFO    = "\033[38;2;101;168;255m"      # #65A8FF
-
-    # 文字
-    TEXT    = "\033[38;2;235;235;245m"      # #EBEBF5 (正文)
-    SUBTLE  = "\033[38;2;138;138;150m"      # #8A8A96 (辅助)
-    FAINT   = "\033[38;2;90;90;102m"        # #5A5A66 (最弱)
-
-
-def _ok() -> bool:
+    PINK    = "\033[38;2;255;79;164m"
+    PINK_L  = "\033[38;2;255;167;213m"
+    PURPLE  = "\033[38;2;194;107;255m"
+    BLUE    = "\033[38;2;110;139;255m"
+    MINT    = "\033[38;2;111;196;176m"
+    MINT_L  = "\033[38;2;152;216;200m"
+    OK      = "\033[38;2;62;229;138m"
+    WARN    = "\033[38;2;255;179;71m"
+    ERR     = "\033[38;2;255;107;129m"
+    TEXT    = "\033[38;2;235;235;245m"
+    SUBTLE  = "\033[38;2;138;138;150m"
+    FAINT   = "\033[38;2;90;90;102m"
+
+
+def _color_ok() -> bool:
     if os.environ.get("NO_COLOR"):
         return False
     if os.environ.get("TERM") == "dumb":
         return False
     return sys.stdout.isatty()
 
-
 def p(text: str, *codes: str) -> str:
-    """上色"""
-    if not _ok():
+    if not _color_ok():
         return text
     return "".join(codes) + text + C.RESET
 
+def dim(t: str) -> str:
+    return p(t, C.SUBTLE)
 
-def dim(text: str) -> str:
-    return p(text, C.SUBTLE)
-
-
-def faint(text: str) -> str:
-    return p(text, C.FAINT)
+def faint(t: str) -> str:
+    return p(t, C.FAINT)
 
+def pink(t: str) -> str:
+    return p(t, C.PINK)
 
-def pink(text: str) -> str:
-    return p(text, C.PINK)
+def purple(t: str) -> str:
+    return p(t, C.PURPLE)
 
+def mint(t: str) -> str:
+    return p(t, C.MINT)
 
-def purple(text: str) -> str:
-    return p(text, C.PURPLE)
+def ok(t: str) -> str:
+    return p(t, C.OK)
 
+def err(t: str) -> str:
+    return p(t, C.ERR)
 
-def mint(text: str) -> str:
-    return p(text, C.MINT_D)
+def bold(t: str) -> str:
+    return p(t, C.BOLD)
 
-
-def ok(text: str) -> str:
-    return p(text, C.OK)
-
-
-def err(text: str) -> str:
-    return p(text, C.ERR)
-
-
-# ── 组件 ───────────────────────────────────────────────────────
-
-def gradient_text(text: str) -> str:
-    """Pink → Purple → Blue 逐字符渐变。"""
-    if not _ok():
+def gradient(text: str) -> str:
+    """Pink → Purple → Blue 渐变"""
+    if not _color_ok():
         return text
-    colors = [C.PINK, C.PINK_L, "\033[38;2;255;127;184m",
-              "\033[38;2;224;119;220m", C.PURPLE,
-              "\033[38;2;160;123;240m", C.BLUE]
+    stops = [
+        "\033[38;2;255;79;164m",
+        "\033[38;2;224;119;220m",
+        "\033[38;2;194;107;255m",
+        "\033[38;2;160;123;240m",
+        "\033[38;2;110;139;255m",
+    ]
     n = len(text)
     result = []
     for i, ch in enumerate(text):
         if ch == " ":
             result.append(ch)
             continue
-        idx = min(int(i / max(n, 1) * len(colors)), len(colors) - 1)
-        result.append(colors[idx] + ch + C.RESET)
+        idx = min(int(i / max(n, 1) * len(stops)), len(stops) - 1)
+        result.append(stops[idx] + ch + C.RESET)
     return "".join(result)
 
 
-def header() -> str:
-    """启动 header — 极简留白风格。"""
+# ── 统一图标体系 ───────────────────────────────────────────────
+#
+# 唯一一套符号, 不混用:
+#   ✦  品牌/模型
+#   ◐  Agent
+#   ◇  Session
+#   ▸  工具
+#   ✓  成功
+#   ✕  失败
+#   ❯  输入
+#   ·  分隔
+#
+
+
+# ── 组件 ───────────────────────────────────────────────────────
+
+def render_banner(version: str = "") -> str:
+    """极简 Header — 品牌名一行, 副标题一行, 结束。"""
     lines = [
         "",
-        f"        {p('✦', C.PINK)}",
-        "",
-        f"    {gradient_text('LBS Agent')}",
-        f"      {dim('Autonomous AI Runtime')}",
+        f"{gradient('LBS Agent')}" + (f"  {faint(version)}" if version else ""),
+        faint("Autonomous AI Runtime"),
         "",
     ]
     return "\n".join(lines)
 
-
-def session_card(rows: list[tuple[str, str]]) -> str:
-    """Session 信息卡 — 上下布局，图标 + label + value。"""
-    icons = {
-        "session":  "◇",
-        "workspace": "▸",
-        "agent":    "◐",
-        "model":    "✦",
-        "provider": "☁",
-        "memory":   "◈",
-        "runtime":  "⚙",
-        "turns":    "⟩",
-        "elapsed":  "⏱",
-    }
-    lines = []
-    for label, value in rows:
-        icon = icons.get(label, "·")
-        lines.append(f"  {p(icon, C.PURPLE)}  {dim(f'{label:11}')} {value}")
-    return "\n".join(lines)
-
-
-def separator(width: int = 52) -> str:
-    """分隔线 — 最弱色"""
-    return p("─" * width, C.FAINT)
-
-
-def prompt_symbol() -> str:
-    """输入提示符"""
-    return p("❯", C.PINK)
-
-
-def footer() -> str:
-    """底部快捷键栏"""
-    keys = [
-        ("↵", "Send"),
-        ("↑↓", "History"),
-        ("Tab", "Complete"),
-        ("/help", "Commands"),
-        ("Ctrl+C", "Exit"),
-    ]
-    parts = []
-    for key, label in keys:
-        parts.append(f"{p(key, C.PURPLE)} {faint(label)}")
-    return faint("  ") + faint("  ·  ".join(parts))
-
-
-def usage_line(seconds: float, iterations: int, tools: int) -> str:
-    """用量条"""
-    parts = [
-        p(f"{seconds:.1f}s", C.MINT_D),
-        faint(f"iter {iterations}"),
-        faint(f"tools {tools}"),
-    ]
-    return "  " + faint(" · ").join(parts)
-
-
-def result_text(content: str) -> str:
-    """最终结果"""
-    return p(content, C.TEXT)
-
-
-def error_text(content: str) -> str:
-    """错误"""
-    return p(f"✕ {content}", C.ERR)
-
-
-def agent_tag(name: str) -> str:
-    """Agent 标签"""
-    return p(f"◐ {name}", C.PURPLE)
-
-
-def model_tag(model: str) -> str:
-    """模型标签"""
-    return p(f"✦ {model}", C.PINK)
-
-
-def react_header(agent_display: str, model_chain: list[str], tools: list[str]) -> str:
-    """ReAct 任务头 — 极简留白"""
+def render_session_line(agent: str, model: str = "", provider: str = "", session_id: str = "") -> str:
+    """Session 信息压成一行。"""
+    parts = [f"{p('◐', C.PURPLE)} {pink(agent)}"]
+    if model:
+        parts.append(f"{p('✦', C.PINK)} {pink(model)}")
+    if provider:
+        parts.append(f"{faint(provider)}")
+    if session_id:
+        parts.append(faint(session_id[:12]))
+    return faint("  ·  ").join(parts)
+
+def render_prompt() -> str:
+    """输入提示符。"""
+    return f"{p('❯', C.PINK)} "
+
+def render_footer() -> str:
+    """快捷键栏 — 一行, 最弱色。"""
+    keys = [("↵", "send"), ("/help", "commands"), ("Ctrl+C", "exit")]
+    return faint("  ") + faint("  ·  ").join(
+        f"{p(k, C.SUBTLE)} {faint(label)}" for k, label in keys
+    )
+
+def render_react_header(agent: str, model_chain: list[str], tools: list[str]) -> str:
+    """ReAct 任务头 — 无边框, 纯留白。"""
+    lines = ["", f"  {p('◐', C.PURPLE)} {bold(agent)}"]
     model_str = faint(" → ").join(pink(m) for m in model_chain)
-    tools_str = faint(", ").join(mint(t) for t in tools)
-    return "\n".join([
-        separator(),
-        f"  {agent_tag(agent_display)}",
-        f"  {model_str}",
-        f"  {faint('tools')} {tools_str}" if tools_str else "",
-        separator(),
-    ])
-
-
-def react_iter(iteration: int) -> str:
-    """迭代标记"""
-    return f"\n  {p('⟡', C.PINK)} {p(f'iter {iteration}', C.BOLD, C.PINK)}"
-
-
-def thinking_block(content: str) -> str:
-    """思考块"""
-    return p(content, C.ITALIC, C.MINT_D)
+    lines.append(f"    {model_str}")
+    if tools:
+        lines.append(f"    {faint(', ').join(mint(t) for t in tools)}")
+    lines.append("")
+    return "\n".join(lines)
 
+def render_iter(iteration: int, max_iter: int = 0) -> str:
+    """迭代标记。"""
+    suffix = faint(f"/{max_iter}") if max_iter else ""
+    return f"  {p('✦', C.PINK)} {p(f'iter {iteration}', C.BOLD)}{suffix}"
 
-def tool_card(name: str, status: str, duration: str = "") -> str:
-    """工具调用卡片"""
-    status_color = C.OK if status == "ok" else C.ERR
-    icon = "✓" if status == "ok" else "✕"
-    dur = f"  {faint(duration)}" if duration else ""
-    return f"  {p(icon, status_color)} {faint(name)}{dur}"
+def render_thinking(content: str) -> str:
+    """思考块 — 薄荷绿斜体。"""
+    return f"  {p(content, C.ITALIC, C.MINT)}"
 
+def render_tool_call(name: str, args_preview: str = "") -> str:
+    """工具调用。"""
+    suffix = faint(f"({args_preview})") if args_preview else ""
+    return f"  {p('▸', C.PURPLE)} {mint(name)}{suffix}"
 
-def timeline_item(timestamp: str, label: str, success: bool = True) -> str:
-    """时间线条目"""
+def render_tool_result(name: str, success: bool, preview: str = "") -> str:
+    """工具结果。"""
     icon = "✓" if success else "✕"
-    color = C.OK if success else C.ERR
-    return f"  {faint(timestamp)}  {p(icon, color)} {dim(label)}"
+    color_fn = ok if success else err
+    suffix = f"  {faint(preview)}" if preview else ""
+    return f"  {color_fn(icon)} {faint(name)}{suffix}"
+
+def render_result(agent: str, success: bool, iterations: int, tools: int, duration: float, error: str = "") -> str:
+    """最终结果摘要 — 两行, 无框。"""
+    icon = ok("✓") if success else err("✕")
+    parts = [faint(f"iter {iterations}"), faint(f"tools {tools}"), mint(f"{duration:.1f}s")]
+    lines = [
+        "",
+        f"  {icon} {bold(agent)}",
+        f"    {faint(' · ').join(parts)}",
+    ]
+    if error:
+        lines.append(f"  {err(error[:200])}")
+    lines.append("")
+    return "\n".join(lines)

package/interfaces/cli/_impl/commands/chat_repl.py

@@ -1,6 +1,7 @@
-"""LBS Agent REPL — Aurora Terminal v2。
+"""LBS Agent REPL — Terminal Product v3。
 
-极简留白，符号驱动，渐变品牌。
+终端 = Canvas, 不是 stdout。
+所有输出走 TDS (Terminal Design System)。
 """
 from __future__ import annotations
 
@@ -13,11 +14,9 @@ from application.container import AgentSystemContainer
 from config.config import AppConfig
 from interfaces.cli._impl.commands.common import project_root
 from interfaces.cli._impl.cli_theme import (
-    C, p, dim, faint, pink, purple, mint, ok, err,
-    gradient_text, header, session_card, separator,
-    prompt_symbol, footer, usage_line, result_text,
-    error_text, agent_tag, model_tag, react_header,
-    react_iter, thinking_block, tool_card, timeline_item,
+    C, p, dim, faint, pink, purple, mint, ok, err, bold,
+    gradient, out, pad, render_banner, render_session_line,
+    render_prompt, render_footer, render_result,
 )
 
 
@@ -46,34 +45,33 @@ def _resolve_agent(config: AppConfig) -> str:
 
 
 def _print_banner(state: ChatState) -> None:
-    """启动 — 极简留白"""
+    """极简启动 — 版心内, 大留白"""
     print()
-    print(header())
-
-    rows = [
-        ("session",   faint(state.session_id) if state.session_id else faint("(unsaved)")),
-        ("agent",     agent_tag(state.agent_name)),
-        ("model",     model_tag(state.model_name) if state.model_name else faint("(default)")),
-        ("provider",  purple(state.provider_name) if state.provider_name else faint("(default)")),
-        ("turns",     faint(str(state.turn_count))),
-    ]
-    print(session_card(rows))
+    print(pad(gradient("LBS Agent")))
+    print(pad(faint("Autonomous AI Runtime")))
+    print()
+    # session 信息一行
+    info = render_session_line(
+        agent=state.agent_name,
+        model=state.model_name,
+        provider=state.provider_name,
+        session_id=state.session_id,
+    )
+    print(pad(info))
     print()
-    print(separator())
-    print(f"  {faint('Ask anything...')}")
-    print(separator())
+    print(pad(render_footer()))
     print()
 
 
 def _print_turn_header(state: ChatState) -> None:
-    """输入提示符 — 只有 ❯"""
+    """输入提示符 — 版心内, 无横线"""
     print()
-    print(f"  {prompt_symbol()} ", end="", flush=True)
+    print(pad(render_prompt()), end="", flush=True)
 
 
 def _print_help() -> None:
     print()
-    print(f"  {gradient_text('Commands')}")
+    out(gradient("Commands"))
     print()
     cmds = [
         ("/help",    "显示帮助"),
@@ -86,7 +84,7 @@ def _print_help() -> None:
         ("/clear",   "清屏"),
     ]
     for cmd, desc in cmds:
-        print(f"    {pink(cmd.ljust(12))} {faint(desc)}")
+        out(f"{pink(cmd.ljust(12))} {faint(desc)}", level=1)
     print()
 
 
@@ -94,8 +92,8 @@ def _cmd_list_agents(state: ChatState) -> None:
     agents = state.container.config.agents.agents
     print()
     for name, a in agents.items():
-        current = f"  {ok('← current')}" if name == state.agent_name else ""
-        print(f"  {agent_tag(name)} {faint(a.display_name)}{current}")
+        current = f"  {ok('←')}" if name == state.agent_name else ""
+        out(f"{p('◐', C.PURPLE)} {pink(name)} {faint(a.display_name)}{current}")
     print()
 
 
@@ -103,21 +101,20 @@ def _cmd_list_models(state: ChatState) -> None:
     config = state.container.config
     provider_name = state.provider_name or config.models.default_provider
     if provider_name not in config.models.providers:
-        msg = f"无 provider '{provider_name}'"
-        print(f"  {error_text(msg)}")
+        print(f"  {err(f'无 provider {provider_name!r}')}")
         return
     prov = config.models.providers[provider_name]
     print()
-    print(f"  {faint('provider')} {purple(provider_name)}")
+    out(f"{faint('provider')} {purple(provider_name)}")
     for m in prov.models:
         marker = f"  {ok('←')}" if m == state.model_name else ""
-        print(f"    {model_tag(m)}{marker}")
+        out(f"{p('✦', C.PINK)} {pink(m)}{marker}", level=1)
     print()
 
 
 def _cmd_history(state: ChatState, n: int = 5) -> None:
     if not state.session_id:
-        print(f"  {faint('无 session')}")
+        out(faint("无 session"))
         return
     try:
         messages = list(state.session_service.session_store.load_session_messages(state.session_id))
@@ -129,26 +126,24 @@ def _cmd_history(state: ChatState, n: int = 5) -> None:
                 recent.append((role, content))
         print()
         for role, content in recent:
-            rc = C.PINK if role == "user" else C.MINT_D
-            print(f"    {p(role.ljust(9), rc)} {faint(content)}")
+            rc = C.PINK if role == "user" else C.MINT
+            out(f"{p(role.ljust(9), rc)} {faint(content)}", level=1)
         print()
     except Exception as e:
-        msg = f"读取失败: {e}"
-        print(f"  {error_text(msg)}")
+        out(err(f"读取失败: {e}"))
 
 
 def _cmd_status(state: ChatState) -> None:
     elapsed = int(time.time() - state.started_at)
-    rows = [
-        ("session",  faint(state.session_id) if state.session_id else faint("(unsaved)")),
-        ("agent",    agent_tag(state.agent_name)),
-        ("model",    model_tag(state.model_name) if state.model_name else faint("(default)")),
-        ("provider", purple(state.provider_name) if state.provider_name else faint("(default)")),
-        ("turns",    faint(str(state.turn_count))),
-        ("elapsed",  faint(f"{elapsed}s")),
-    ]
+    info = render_session_line(
+        agent=state.agent_name,
+        model=state.model_name,
+        provider=state.provider_name,
+        session_id=state.session_id,
+    )
     print()
-    print(session_card(rows))
+    out(info)
+    out(faint(f"turns {state.turn_count} · {elapsed}s"))
     print()
 
 
@@ -165,14 +160,14 @@ def _handle_command(state: ChatState, line: str) -> bool:
         state.session_id = ""
         state.turn_count = 0
         state.started_at = time.time()
-        print(f"  {ok('◇')} {faint('new session')}")
+        out(f"{ok('◇')} {faint('new session')}")
     elif cmd == "/session":
         if arg:
             state.session_id = arg
-            print(f"  {ok('◇')} {faint('switched to')} {pink(arg)}")
+            out(f"{ok('◇')} {faint('→')} {pink(arg)}")
         else:
             sid = state.session_id or "(none)"
-            print(f"  {faint('session:')} {sid}")
+            out(f"{faint('session')} {sid}")
     elif cmd == "/status":
         _cmd_status(state)
     elif cmd == "/agent":
@@ -182,16 +177,15 @@ def _handle_command(state: ChatState, line: str) -> bool:
             agents = state.container.config.agents.agents
             if arg in agents:
                 state.agent_name = arg
-                print(f"  {ok('◇')} {faint('agent')} {agent_tag(arg)}")
+                out(f"{ok('◇')} {faint('→')} {p('◐', C.PURPLE)} {pink(arg)}")
             else:
-                msg = f"无 agent '{arg}'"
-                print(f"  {error_text(msg)}")
+                out(err(f"无 agent '{arg}'"))
     elif cmd == "/model":
         if not arg:
             _cmd_list_models(state)
         else:
             state.model_name = arg
-            print(f"  {ok('◇')} {faint('model')} {model_tag(arg)}")
+            out(f"{ok('◇')} {faint('→')} {p('✦', C.PINK)} {pink(arg)}")
     elif cmd == "/clear":
         print("\033[2J\033[H", end="")
     elif cmd == "/history":
@@ -199,16 +193,15 @@ def _handle_command(state: ChatState, line: str) -> bool:
             n = int(arg) if arg else 5
             _cmd_history(state, n)
         except ValueError:
-            print(f"  {error_text('/history [n] — n 须为整数')}")
+            out(err("/history [n] — n 须为整数"))
     elif cmd == "/save":
-        print(f"  {faint('session 每次 turn 自动保存')}")
+        out(faint("session 每次 turn 自动保存"))
     else:
-        print(f"  {error_text(f'未知命令: {cmd}')}")
+        out(err(f"未知命令: {cmd}"))
     return True
 
 
 def _run_turn(state: ChatState, user_input: str) -> None:
-    """跑一轮对话"""
     t0 = time.time()
     try:
         result = state.orchestrator.run_agent_sync(
@@ -220,21 +213,25 @@ def _run_turn(state: ChatState, user_input: str) -> None:
         elapsed = time.time() - t0
         if result.success:
             content = (result.content or "").strip()
-            print(f"\n{result_text(content)}")
+            print()
+            for line in content.split("\n"):
+                out(p(line, C.TEXT))
         else:
             e = result.error or "(无错误信息)"
-            print(f"\n  {error_text(e[:300])}")
-        print(usage_line(elapsed, result.iterations, result.total_tool_calls))
+            out(err(e[:300]))
+        # 用量 — 缩进, 最弱色
+        print()
+        out(faint(f"  {elapsed:.1f}s · iter {result.iterations} · tools {result.total_tool_calls}"))
         if not state.session_id:
             sid = result.session_id if hasattr(result, "session_id") and result.session_id else ""
             state.session_id = sid or f"chat-{int(state.started_at)}"
     except KeyboardInterrupt:
-        print(f"\n  {p('⏸', C.WARN)} {faint('已中断')}")
+        print()
+        out(f"{p('⏸', C.WARN)} {faint('已中断')}")
     except Exception as e:
         elapsed = time.time() - t0
-        msg = f"{type(e).__name__}: {str(e)[:200]}"
-        print(f"\n  {error_text(msg)}")
-        print(f"  {faint(f'{elapsed:.1f}s')}")
+        out(err(f"{type(e).__name__}: {str(e)[:200]}"))
+        out(faint(f"  {elapsed:.1f}s"))
 
 
 def cmd_chat(
@@ -245,7 +242,6 @@ def cmd_chat(
     query: str = "",
     session_id: str = "",
 ) -> int:
-    """进入 chat REPL 或单次 query。"""
     container = AgentSystemContainer(config=config, project_root=project_root)
 
     if not agent_name:
@@ -253,7 +249,7 @@ def cmd_chat(
 
     if agent_name not in config.agents.agents:
         msg = f"Agent '{agent_name}' 不存在"
-        print(f"  {error_text(msg)}")
+        out(err(msg))
         return 1
 
     state = ChatState(
@@ -275,8 +271,6 @@ def cmd_chat(
 
     # REPL
     _print_banner(state)
-    print(footer())
-    print()
 
     while True:
         try:
@@ -299,5 +293,5 @@ def cmd_chat(
             state.turn_count += 1
             _run_turn(state, line)
 
-    print(f"\n  {ok('◇')} {faint('Session saved. Bye.')}")
+    out(f"{ok('◇')} {faint('Session saved. Bye.')}")
     return 0

package/interfaces/cli/_impl/commands/run_agent.py

@@ -78,20 +78,18 @@ def cmd_run_agent(config: AppConfig, agent_name: str, task: str) -> None:
         except Exception as e:
             print(f"  [WARN] session save failed: {e}")
 
-        from runtime.orchestration.display import green, red, faint, pink, bold, color, Colors
-        sep = color("─" * 52, Colors.FAINT)
+        from runtime.orchestration.display import green, red, faint, pink, mint, bold
         icon = green("✓") if result.success else red("✕")
-        print(f"\n{sep}")
+        print()
         print(f"  {icon} {bold(result.agent_name)}")
         parts = [
             faint(f"iter {result.iterations}"),
             faint(f"tools {result.total_tool_calls}"),
-            color(f"{result.duration_seconds:.1f}s", Colors.MINT_D),
+            mint(f"{result.duration_seconds:.1f}s"),
         ]
-        print("  " + faint(" · ").join(parts))
+        print(f"    {faint(' · ').join(parts)}")
         if result.error:
             print(f"  {red(result.error[:200])}")
-        print(sep)
         print()
         if result.content:
             print(result.content)
@@ -100,10 +98,9 @@ def cmd_run_agent(config: AppConfig, agent_name: str, task: str) -> None:
         print()
 
         if result.steps:
-            print(f"  {faint('trace')}")
             for step in result.steps:
                 tools = ", ".join(t.name for t in step.tool_execs) if step.tool_execs else "-"
-                print(f"    {faint(f'{step.iteration:02d}')} {pink('·')} {faint(tools)}")
+                print(f"  {faint(f'{step.iteration:02d}')} {pink('·')} {faint(tools)}")
             print()
     finally:
         container.shutdown()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baimingtao/lbs-agent",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "publishConfig": {
     "access": "public"
   },

package/runtime/orchestration/loop/main_loop.py

@@ -252,19 +252,18 @@ class AgentLoop:
 
         logger.info("[%s] loop started (%s): %s", self.config.name, mode, task[:100])
         if self.config.report_progress:
-            from runtime.orchestration.display import pink, purple, mint, faint, bold, color, Colors
-            sep = color("─" * 52, Colors.FAINT)
-            self._print(f"\n{sep}")
+            from runtime.orchestration.display import pink, purple, mint, faint, bold
             agent_label = self.config.display_name or self.config.name
+            self._print("")
             self._print(f"  {purple('◐')} {bold(agent_label)}")
             chain = [self.config.model] + self.config.fallback_models
             model_str = faint(" → ").join(pink(m) for m in chain)
-            self._print(f"  {model_str}")
+            self._print(f"    {model_str}")
             tools_list = self.config.tools or []
             if tools_list:
                 tools_str = faint(", ").join(mint(t) for t in tools_list)
-                self._print(f"  {faint('tools')} {tools_str}")
-            self._print(f"{sep}")
+                self._print(f"    {tools_str}")
+            self._print("")
 
         return tools_schema
 
@@ -2000,20 +1999,19 @@ class AgentLoop:
             compression_results=list(self.compression_results),
         )
 
-        from runtime.orchestration.display import green, red, faint, pink, purple, mint, color, Colors, bold
-        sep = color("─" * 52, Colors.FAINT)
-        self._print(f"\n{sep}")
+        from runtime.orchestration.display import green, red, faint, mint, bold
         icon = green("✓") if success else red("✕")
+        self._print("")
         self._print(f"  {icon} {bold(self.config.name)}")
         parts = [
             faint(f"iter {self.current_iteration}"),
             faint(f"tools {self._tool_call_count}"),
-            color(f"{duration:.1f}s", Colors.MINT_D),
+            mint(f"{duration:.1f}s"),
         ]
-        self._print("  " + faint(" · ").join(parts))
+        self._print(f"    {faint(' · ').join(parts)}")
         if error:
             self._print(f"  {red(error[:200])}")
-        self._print(f"{sep}\n")
+        self._print("")
 
         logger.info(
             "[%s] loop finished: success=%s iterations=%d tools=%d duration=%.1fs",