perf: 启动输出瘦身 + FC 能力探测缓存，修复测试套件失效

自用体验（同时以人类和被接入 AI 的视角）暴露出三个问题，一并处理：

1. 启动太吵：117 行 / 16983 字符的开屏，人还没开始用就先刷屏
   - 完整 ASCII 开机动画改为 --logo / --banner 按需召唤，默认两行紧凑标识
   - 21 行命令说明折叠成一行「/help 全部命令 · /quit 退出 · ...」，
     完整速查表挪进 /help（新增 show_quick_commands）
   - 插件/引擎/工具的逐条加载日志改走 vprint，由 --verbose / -v /
     XCLI_VERBOSE=1 召唤；工具加载汇总成一行
   - 日志控制台 handler 降到 WARNING（文件仍留全量 INFO），并静音
     httpx/httpcore/urllib3 等第三方心跳日志
   => 默认启动 10 行 / 475 字符，--verbose 仍可看到全部 36 行细节

2. 不支持 FC 的模型每次会话都白撞一发 500
   讯飞 xophunyuan7bmt 不支持 Function Calling，请求带 tools 字段必报
   500 Invalid Params，虽有降级重试兜底，但每个新会话都要先错一次。
   - 新增 xcli_core/fc_tools 能力缓存（按 base_url::model 落盘 .fc_support.json）
   - 降级重试成功后记住该模型不支持 FC，后续直接不发 tools
   - 降级也失败时不写缓存，避免把别的故障误判成 FC 问题
   - 新增 /fc [reset] 查看与清除缓存

3. diff 弹窗模式每次启动都要重新问一遍
   - 首次选择后经 config.json 持久化，新增 /diff [popup|inline] 随时切换

测试：
- 新增 tests/test_startup_and_fc.py（27 项，含假 HTTP 验证降级与缓存链路）
- 修复 tests/test_plugins.py 长期失效：插件入口类早已由 Plugin 改名 Liugin，
  8 处 fixture 未跟进导致 65 个用例直接 error；断言也未适配 ToolResult 返回值
  与「❌」错误前缀。改为 plugin_class() / as_text() / is_error() 语义判断。
- 全量：217 passed（此前 152 passed + 65 error + 27 failed）

tests/test_plugins.py

@@ -29,6 +29,29 @@ def load_module(name, path):
     return mod
 
 
+def plugin_class(mod):
+    """取插件入口类（项目里叫 Liugin，历史上叫 Plugin，两种都认）"""
+    cls = getattr(mod, "Liugin", None) or getattr(mod, "Plugin", None)
+    assert cls is not None, f"{mod.__name__}: 缺少 Plugin/Liugin 类"
+    return cls
+
+
+def as_text(result):
+    """插件返回值统一转文本（可能是 str，也可能是 ToolResult）"""
+    return result if isinstance(result, str) else str(result)
+
+
+ERROR_MARKERS = ("❌", "错误", "失败", "缺少", "不存在", "无效", "请提供", "用法")
+
+
+def is_error(result):
+    """判断插件返回是否表示失败（不依赖具体文案措辞）"""
+    success = getattr(result, "success", None)
+    if success is not None:
+        return not success
+    return any(m in as_text(result) for m in ERROR_MARKERS)
+
+
 # ══════════════════════════════════════
 #  插件加载测试
 # ══════════════════════════════════════
@@ -89,7 +112,7 @@ class TestCodeEditor:
     @pytest.fixture
     def editor(self):
         mod = load_module("code_editor", os.path.join(PLUGINS_DIR, "code_editor.py"))
-        return mod.Plugin()
+        return plugin_class(mod)()
 
     @pytest.fixture
     def tmp_file(self, tmp_path):
@@ -99,47 +122,47 @@ class TestCodeEditor:
 
     def test_read_range(self, editor, tmp_file):
         result = editor.handle(f"read_range {tmp_file} 1 2")
-        assert "hello" in result
-        assert "1 |" in result
+        assert "hello" in as_text(result)
+        assert "1 |" in as_text(result)
 
     def test_edit(self, editor, tmp_file):
         result = editor.handle(f"edit {tmp_file} print('hello') <<<>>> print('hi')")
-        assert "已编辑" in result
+        assert "已编辑" in as_text(result)
         content = open(tmp_file).read()
         assert "print('hi')" in content
 
     def test_edit_not_found(self, editor, tmp_file):
         result = editor.handle(f"edit {tmp_file} nonexistent_code <<<>>> new_code")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_create(self, editor, tmp_path):
         new_file = str(tmp_path / "new.py")
         result = editor.handle(f"create {new_file} import os")
-        assert "已创建" in result
+        assert "已创建" in as_text(result)
         assert os.path.exists(new_file)
 
     def test_diff_text(self, editor):
         result = editor.handle("diff_text old <<<>>> new")
-        assert "变更预览" in result
+        assert "变更预览" in as_text(result)
 
     def test_ast_info(self, editor, tmp_file):
         result = editor.handle(f"ast_info {tmp_file}")
-        assert "def hello" in result
-        assert "def world" in result
+        assert "def hello" in as_text(result)
+        assert "def world" in as_text(result)
 
     def test_stats(self, editor, tmp_path):
         result = editor.handle(f"stats {tmp_path}")
-        assert "代码统计" in result
-        assert "文件" in result
+        assert "代码统计" in as_text(result)
+        assert "文件" in as_text(result)
 
     def test_structure(self, editor, tmp_path):
         result = editor.handle(f"structure {tmp_path} 1")
-        assert "" in result
+        assert "" in as_text(result)
 
     def test_find(self, editor, tmp_path):
         (tmp_path / "a.py").write_text("x = 1\ny = 2\n")
         result = editor.handle(f"find {tmp_path} x *.py")
-        assert "x = 1" in result
+        assert "x = 1" in as_text(result)
 
 
 class TestGitTools:
@@ -148,11 +171,11 @@ class TestGitTools:
     @pytest.fixture
     def git(self):
         mod = load_module("git_tools", os.path.join(PLUGINS_DIR, "git_tools.py"))
-        return mod.Plugin()
+        return plugin_class(mod)()
 
     def test_status(self, git):
         result = git.handle("status")
-        assert "Git" in result or "干净" in result or "分支" in result
+        assert "Git" in as_text(result) or "干净" in as_text(result) or "分支" in as_text(result)
 
     def test_log(self, git):
         result = git.handle("log --oneline 3")
@@ -161,7 +184,7 @@ class TestGitTools:
 
     def test_branch(self, git):
         result = git.handle("branch")
-        assert "master" in result or "main" in result
+        assert "master" in as_text(result) or "main" in as_text(result)
 
 
 class TestCmdExecutor:
@@ -170,27 +193,27 @@ class TestCmdExecutor:
     @pytest.fixture
     def cmd(self):
         mod = load_module("cmd_executor", os.path.join(PLUGINS_DIR, "cmd_executor.py"))
-        return mod.Plugin()
+        return plugin_class(mod)()
 
     def test_echo(self, cmd):
         result = cmd.handle("run echo test_ok")
-        assert "test_ok" in result
+        assert "test_ok" in as_text(result)
 
     def test_python_version(self, cmd):
         result = cmd.handle("run python3 --version")
-        assert "Python" in result
+        assert "Python" in as_text(result)
 
     def test_blocked_command(self, cmd):
         result = cmd.handle("run rm -rf /")
-        assert "拦截" in result
+        assert "拦截" in as_text(result)
 
     def test_timeout(self, cmd):
         result = cmd.handle("run echo fast --timeout 5")
-        assert "fast" in result
+        assert "fast" in as_text(result)
 
     def test_empty_command(self, cmd):
         result = cmd.handle("run")
-        assert "错误" in result
+        assert is_error(result)
 
 
 class TestFileManager:
@@ -199,53 +222,53 @@ class TestFileManager:
     @pytest.fixture
     def fm(self):
         mod = load_module("file_manager", os.path.join(PLUGINS_DIR, "file_manager.py"))
-        return mod.Plugin()
+        return plugin_class(mod)()
 
     def test_list(self, fm, tmp_path):
         (tmp_path / "a.txt").write_text("hi")
         result = fm.handle(f"list {tmp_path}")
-        assert "a.txt" in result
+        assert "a.txt" in as_text(result)
 
     def test_read(self, fm, tmp_path):
         f = tmp_path / "test.txt"
         f.write_text("hello world")
         result = fm.handle(f"read {f}")
-        assert "hello world" in result
+        assert "hello world" in as_text(result)
 
     def test_write_and_read(self, fm, tmp_path):
         f = tmp_path / "new.txt"
         result = fm.handle(f"write {f} -c test_content")
-        assert "已写入" in result
+        assert "已写入" in as_text(result)
         result = fm.handle(f"read {f}")
-        assert "test_content" in result
+        assert "test_content" in as_text(result)
 
     def test_copy(self, fm, tmp_path):
         src = tmp_path / "src.txt"
         src.write_text("data")
         dst = tmp_path / "dst.txt"
         result = fm.handle(f"copy {src} {dst}")
-        assert "已复制" in result
+        assert "已复制" in as_text(result)
         assert dst.exists()
 
     def test_delete(self, fm, tmp_path):
         f = tmp_path / "del.txt"
         f.write_text("bye")
         result = fm.handle(f"delete {f}")
-        assert "已删除" in result
+        assert "已删除" in as_text(result)
         assert not f.exists()
 
     def test_mkdir(self, fm, tmp_path):
         d = tmp_path / "newdir"
         result = fm.handle(f"mkdir {d}")
-        assert "已创建" in result
+        assert "已创建" in as_text(result)
         assert d.is_dir()
 
     def test_info(self, fm, tmp_path):
         f = tmp_path / "info.txt"
         f.write_text("x")
         result = fm.handle(f"info {f}")
-        assert "路径" in result
-        assert "大小" in result
+        assert "路径" in as_text(result)
+        assert "大小" in as_text(result)
 
 
 class TestAutoEngineer:
@@ -254,23 +277,23 @@ class TestAutoEngineer:
     @pytest.fixture
     def eng(self):
         mod = load_module("auto_engineer", os.path.join(PLUGINS_DIR, "auto_engineer.py"))
-        return mod.Plugin()
+        return plugin_class(mod)()
 
     def test_metrics(self, eng, tmp_path):
         (tmp_path / "a.py").write_text("x = 1\n# comment\n\ny = 2\n")
         result = eng.handle(f"metrics {tmp_path}")
-        assert "代码指标" in result
-        assert "文件" in result
+        assert "代码指标" in as_text(result)
+        assert "文件" in as_text(result)
 
     def test_security_clean(self, eng, tmp_path):
         (tmp_path / "safe.py").write_text("x = 1\nprint(x)\n")
         result = eng.handle(f"security {tmp_path}")
-        assert "没有发现" in result or "风险" in result
+        assert "没有发现" in as_text(result) or "风险" in as_text(result)
 
     def test_security_risk(self, eng, tmp_path):
         (tmp_path / "risk.py").write_text('password = "secret123"\neval("1+1")\n')
         result = eng.handle(f"security {tmp_path}")
-        assert "风险" in result
+        assert "风险" in as_text(result)
 
     def test_complexity(self, eng, tmp_path):
         code = "def f():\n    if True:\n        if True:\n            if True:\n                pass\n"
@@ -292,34 +315,34 @@ class TestTaskManager:
 
     def test_add(self, tm):
         result = tm.handle("add 测试任务")
-        assert "已添加" in result
+        assert "已添加" in as_text(result)
 
     def test_list_empty(self, tm):
         result = tm.handle("list")
-        assert "没有任务" in result
+        assert "没有任务" in as_text(result)
 
     def test_add_and_list(self, tm):
         tm.handle("add 任务A")
         tm.handle("add 任务B")
         result = tm.handle("list")
-        assert "任务A" in result
-        assert "任务B" in result
+        assert "任务A" in as_text(result)
+        assert "任务B" in as_text(result)
 
     def test_complete(self, tm):
         tm.handle("add 任务X")
         result = tm.handle("complete 1")
-        assert "已更新" in result
+        assert "已更新" in as_text(result)
 
     def test_delete(self, tm):
         tm.handle("add 任务Y")
         result = tm.handle("delete 1")
-        assert "已删除" in result
+        assert "已删除" in as_text(result)
 
     def test_clear(self, tm):
         tm.handle("add A")
         tm.handle("complete 1")
         result = tm.handle("clear")
-        assert "已清除" in result
+        assert "已清除" in as_text(result)
 
 
 # ══════════════════════════════════════
@@ -332,19 +355,19 @@ class TestBrowserAuto:
     @pytest.fixture
     def browser(self):
         mod = load_module("browser_auto", os.path.join(PLUGINS_DIR, "browser_auto.py"))
-        return mod.Plugin()
+        return plugin_class(mod)()
 
     def test_status_stopped(self, browser):
         result = browser.handle("status")
-        assert "未运行" in result
+        assert "未运行" in as_text(result)
 
     def test_invalid_operation(self, browser):
         result = browser.handle("nonexistent")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_empty_args(self, browser):
         result = browser.handle("")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_tool_info(self, browser):
         info = browser.get_tool_info()
@@ -363,7 +386,7 @@ class TestGuiAuto:
     @pytest.fixture
     def gui(self):
         mod = load_module("gui_auto", os.path.join(PLUGINS_DIR, "gui_auto.py"))
-        return mod.Plugin()
+        return plugin_class(mod)()
 
     def test_tool_info(self, gui):
         info = gui.get_tool_info()
@@ -380,88 +403,88 @@ class TestGuiAuto:
     def test_convert_mcp_args(self, gui):
         args = {"operation": "click", "target": "确定"}
         result = gui.convert_mcp_args(args)
-        assert "click" in result
-        assert "确定" in result
+        assert "click" in as_text(result)
+        assert "确定" in as_text(result)
 
     def test_convert_mcp_args_xy(self, gui):
         args = {"operation": "click", "x": 100, "y": 200}
         result = gui.convert_mcp_args(args)
-        assert "--xy" in result
-        assert "100" in result
+        assert "--xy" in as_text(result)
+        assert "100" in as_text(result)
 
     def test_convert_mcp_args_snapshot(self, gui):
         args = {"operation": "snapshot", "depth": 3}
         result = gui.convert_mcp_args(args)
-        assert "snapshot" in result
-        assert "3" in result
+        assert "snapshot" in as_text(result)
+        assert "3" in as_text(result)
 
     def test_empty_args(self, gui):
         result = gui.handle("")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_invalid_operation(self, gui):
         result = gui.handle("nonexistent_op")
-        assert "不支持" in result
+        assert "不支持" in as_text(result)
 
     def test_click_no_args(self, gui):
         result = gui.handle("click")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_type_no_args(self, gui):
         result = gui.handle("type")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_type_missing_text(self, gui):
         result = gui.handle("type 按钮")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_find_no_args(self, gui):
         result = gui.handle("find")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_findall_no_args(self, gui):
         result = gui.handle("findall")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_info_no_args(self, gui):
         result = gui.handle("info")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_value_no_args(self, gui):
         result = gui.handle("value")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_tree_no_args(self, gui):
         result = gui.handle("tree")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_wait_no_args(self, gui):
         result = gui.handle("wait")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_exists_no_args(self, gui):
         result = gui.handle("exists")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_highlight_no_args(self, gui):
         result = gui.handle("highlight")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_state_no_args(self, gui):
         result = gui.handle("state")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_keys_no_args(self, gui):
         result = gui.handle("keys")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_focus_no_args(self, gui):
         result = gui.handle("focus")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_click_xy_format_error(self, gui):
         result = gui.handle("click --xy abc")
-        assert "错误" in result
+        assert is_error(result)
 
     def test_format_element_info(self, gui):
         el = {
@@ -472,9 +495,9 @@ class TestGuiAuto:
             "enabled": True, "focused": False
         }
         result = gui._format_element_info(el)
-        assert "测试按钮" in result
-        assert "Button" in result
-        assert "btn_ok" in result
+        assert "测试按钮" in as_text(result)
+        assert "Button" in as_text(result)
+        assert "btn_ok" in as_text(result)
 
     def test_format_element_info_detailed(self, gui):
         el = {
@@ -485,8 +508,8 @@ class TestGuiAuto:
                        "right": 200, "bottom": 25}
         }
         result = gui._format_element_info(el, detailed=True)
-        assert "输入框" in result
-        assert "hello" in result
+        assert "输入框" in as_text(result)
+        assert "hello" in as_text(result)
 
     def test_all_operations_route(self, gui):
         """所有操作都能正确路由"""
@@ -504,28 +527,28 @@ class TestSubAgent:
     @pytest.fixture
     def sa(self):
         mod = load_module("sub_agent", os.path.join(PLUGINS_DIR, "sub_agent.py"))
-        return mod.Plugin()
+        return plugin_class(mod)()
 
     def test_list_empty(self, sa):
         result = sa.handle("list")
-        assert "没有" in result
+        assert "没有" in as_text(result)
 
     def test_stats_empty(self, sa):
         result = sa.handle("stats")
-        assert "总数: 0" in result
+        assert "总数: 0" in as_text(result)
 
     def test_spawn(self, sa):
         result = sa.handle("spawn tester 测试任务")
-        assert "已创建" in result
-        assert "agent_tester" in result
+        assert "已创建" in as_text(result)
+        assert "agent_tester" in as_text(result)
 
     def test_spawn_and_list(self, sa):
         sa.handle("spawn a 任务A")
         sa.handle("spawn b 任务B")
         import time; time.sleep(0.1)
         result = sa.handle("list")
-        assert "agent_a" in result
-        assert "agent_b" in result
+        assert "agent_a" in as_text(result)
+        assert "agent_b" in as_text(result)
 
     def test_status(self, sa):
         sa.handle("spawn x 某任务")
@@ -533,24 +556,24 @@ class TestSubAgent:
         # 获取 agent ID
         agent_id = list(sa.agents.keys())[0]
         result = sa.handle(f"status {agent_id}")
-        assert "名称" in result
+        assert "名称" in as_text(result)
 
     def test_kill(self, sa):
         sa.handle("spawn y 要终止的任务")
         import time; time.sleep(0.1)
         agent_id = list(sa.agents.keys())[0]
         result = sa.handle(f"kill {agent_id}")
-        assert "已终止" in result
+        assert "已终止" in as_text(result)
 
     def test_clean(self, sa):
         sa.handle("spawn z 清理测试")
         import time; time.sleep(0.1)
         result = sa.handle("clean")
-        assert "已清理" in result
+        assert "已清理" in as_text(result)
 
     def test_invalid_agent(self, sa):
         result = sa.handle("status nonexistent")
-        assert "未找到" in result
+        assert "未找到" in as_text(result)
 
 
 # ══════════════════════════════════════

tests/test_startup_and_fc.py

@@ -0,0 +1,297 @@
+"""启动输出瘦身 + FC 能力探测缓存 回归测试
+
+覆盖两件事：
+1. 无 FC 能力的模型（如讯飞 xophunyuan7bmt）被 500 打回后会被记住，
+   之后不再每次白撞一发 500 试探。
+2. 启动输出从 117 行折叠到 10 行，详细日志改由 --verbose 召唤。
+"""
+import contextlib
+import io
+import json
+import os
+import sys
+import types
+
+import pytest
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+BASE_URL = "https://maas-api.cn-huabei-1.xf-yun.com/v2"
+MODEL = "xophunyuan7bmt"
+
+TOOL = {
+    "type": "function",
+    "function": {
+        "name": "read_file",
+        "description": "读文件",
+        "parameters": {"type": "object", "properties": {}},
+    },
+}
+
+OK_BODY = {"choices": [{"message": {"content": "好"}}], "usage": {"prompt_tokens": 12}}
+ERR_500 = {"error": {"message": "xunfei response error: sid: xxx msg: RequestParamsError:Invalid Params"}}
+
+
+@pytest.fixture
+def fc(tmp_path):
+    """把 FC 缓存文件隔离到临时目录，避免污染真实运行时缓存"""
+    from xcli_core import fc_tools
+
+    old_file, old_mem = fc_tools._FC_CACHE_FILE, fc_tools._fc_cache
+    fc_tools._FC_CACHE_FILE = str(tmp_path / ".fc_support.json")
+    fc_tools._fc_cache = None
+    try:
+        yield fc_tools
+    finally:
+        fc_tools._FC_CACHE_FILE, fc_tools._fc_cache = old_file, old_mem
+
+
+class FakeResp:
+    def __init__(self, code, payload):
+        self.status_code = code
+        self._payload = payload
+        self.text = json.dumps(payload, ensure_ascii=False)
+
+    def json(self):
+        return self._payload
+
+
+def make_engine(model=MODEL):
+    """不走 __init__（会读配置/连网），直接摆一个可用实例"""
+    import ai_engines.openai_engine as oe
+
+    eng = oe.OpenaiAI.__new__(oe.OpenaiAI)
+    eng.name = "openai"
+    eng.cli = None
+    eng.api_key = "k"
+    eng.base_url = BASE_URL
+    eng.model = model
+    eng.max_history = 10
+    eng.conversation_history = []
+    eng.shared_conversation_history = None
+    eng.last_prompt_tokens = None
+    eng.thinking_start_marker = "<think>"
+    eng.thinking_end_marker = "</think>"
+    return eng
+
+
+@pytest.fixture
+def http(monkeypatch):
+    """替换 openai_engine 里的 requests，记录每次请求体"""
+    import ai_engines.openai_engine as oe
+
+    calls = []
+
+    def install(responder):
+        def fake_post(url=None, json=None, headers=None, timeout=None, **kw):
+            calls.append(dict(json))
+            return responder(json)
+
+        monkeypatch.setattr(
+            oe, "requests",
+            types.SimpleNamespace(post=fake_post, exceptions=oe.requests.exceptions),
+        )
+        return calls
+
+    install.calls = calls
+    return install
+
+
+# ══════════════════════════════════════
+#  1. FC 能力探测缓存
+# ══════════════════════════════════════
+
+class TestFCCache:
+    def test_default_assume_supported(self, fc):
+        assert fc.supports_fc(BASE_URL, MODEL) is True
+
+    def test_mark_and_remember(self, fc):
+        assert fc.mark_fc_unsupported(BASE_URL, MODEL) is True
+        assert fc.supports_fc(BASE_URL, MODEL) is False
+
+    def test_repeat_mark_not_reported(self, fc):
+        fc.mark_fc_unsupported(BASE_URL, MODEL)
+        # 第二次返回 False，调用方据此不重复刷屏提示
+        assert fc.mark_fc_unsupported(BASE_URL, MODEL) is False
+
+    def test_persist_across_restart(self, fc):
+        fc.mark_fc_unsupported(BASE_URL, MODEL)
+        assert os.path.exists(fc._FC_CACHE_FILE)
+        fc._fc_cache = None  # 模拟进程重启
+        assert fc.supports_fc(BASE_URL, MODEL) is False
+
+    def test_other_model_unaffected(self, fc):
+        fc.mark_fc_unsupported(BASE_URL, MODEL)
+        assert fc.supports_fc(BASE_URL, "spark-4.0-ultra") is True
+
+    def test_trailing_slash_normalized(self, fc):
+        fc.mark_fc_unsupported(BASE_URL, MODEL)
+        assert fc.supports_fc(BASE_URL + "/", MODEL) is False
+
+    def test_get_cache_returns_copy(self, fc):
+        fc.mark_fc_unsupported(BASE_URL, MODEL)
+        snap = fc.get_fc_cache()
+        assert isinstance(snap, dict) and snap is not fc._fc_cache
+
+    def test_reset(self, fc):
+        fc.mark_fc_unsupported(BASE_URL, MODEL)
+        assert fc.reset_fc_cache() == 1
+        assert fc.supports_fc(BASE_URL, MODEL) is True
+
+    def test_reset_single_entry(self, fc):
+        fc.mark_fc_unsupported(BASE_URL, MODEL)
+        fc.mark_fc_unsupported(BASE_URL, "other")
+        assert fc.reset_fc_cache(BASE_URL, MODEL) == 1
+        assert fc.supports_fc(BASE_URL, MODEL) is True
+        assert fc.supports_fc(BASE_URL, "other") is False
+
+    def test_corrupted_file_does_not_crash(self, fc):
+        with open(fc._FC_CACHE_FILE, "w", encoding="utf-8") as f:
+            f.write("{ not json")
+        fc._fc_cache = None
+        assert fc.supports_fc(BASE_URL, MODEL) is True
+
+
+# ══════════════════════════════════════
+#  2. openai 引擎接线（假 HTTP，不动真实接口）
+# ══════════════════════════════════════
+
+class TestOpenAIDegrade:
+    def test_first_call_degrades_and_caches(self, fc, http):
+        calls = http(lambda body: FakeResp(500, ERR_500) if "tools" in body else FakeResp(200, OK_BODY))
+
+        reply = make_engine().generate_response("说'好'", tools=[TOOL])
+
+        assert len(calls) == 2, f"应为 带tools→500 + 降级重试，实际 {len(calls)} 次"
+        assert "tools" in calls[0]
+        assert "tools" not in calls[1] and "tool_choice" not in calls[1]
+        assert reply == "好"
+        assert fc.supports_fc(BASE_URL, MODEL) is False, "降级成功后应记住该模型不支持 FC"
+
+    def test_second_call_skips_probe(self, fc, http):
+        fc.mark_fc_unsupported(BASE_URL, MODEL)
+        calls = http(lambda body: FakeResp(500, ERR_500) if "tools" in body else FakeResp(200, OK_BODY))
+
+        reply = make_engine().generate_response("再说一次", tools=[TOOL])
+
+        assert len(calls) == 1, f"已知不支持 FC 时不该再撞 500，实际 {len(calls)} 次"
+        assert "tools" not in calls[0]
+        assert reply == "好"
+
+    def test_unmarked_model_still_sends_tools(self, fc, http):
+        calls = http(lambda body: FakeResp(200, OK_BODY))
+
+        make_engine(model="gpt-4o").generate_response("hi", tools=[TOOL])
+
+        assert len(calls) == 1 and "tools" in calls[0]
+
+    def test_tools_payload_is_pure_official_format(self, fc, http):
+        calls = http(lambda body: FakeResp(200, OK_BODY))
+
+        make_engine(model="gpt-4o").generate_response("hi", tools=[TOOL])
+
+        tool = calls[0]["tools"][0]
+        assert tool.get("type") == "function"
+        assert set(tool.keys()) == {"type", "function"}
+        assert calls[0].get("tool_choice") == "auto"
+
+    def test_failed_degrade_does_not_cache(self, fc, http):
+        http(lambda body: FakeResp(500, ERR_500))
+
+        reply = make_engine().generate_response("hi", tools=[TOOL])
+
+        assert fc.supports_fc(BASE_URL, MODEL) is True, "降级也失败说明不是 FC 的锅，不能误判"
+        assert "API 调用失败" in str(reply)
+
+
+# ══════════════════════════════════════
+#  3. 启动输出瘦身
+# ══════════════════════════════════════
+
+def _read(*parts):
+    with open(os.path.join(PROJECT_ROOT, *parts), encoding="utf-8") as f:
+        return f.read()
+
+
+class TestStartupSlim:
+    def test_no_21_line_help_dump(self):
+        src = _read("xcli_core", "cli_core.py")
+        run_body = src.split("    def run(self):", 1)[1].split("    def _get_code_editor_plugin", 1)[0]
+        assert run_body.count("输入 '/") == 0, "启动不该再逐条打印命令说明"
+        assert "/help 全部命令" in run_body
+
+    def test_logo_is_opt_in(self):
+        src = _read("xcli_core", "cli_core.py")
+        assert "'--logo' in sys.argv" in src
+        assert "--banner" in src
+
+    def test_quick_commands_moved_into_help(self):
+        from xcli_core import cli_display
+
+        names = [n for n in dir(cli_display) if n.endswith("Mixin")]
+        assert names, "cli_display 里应有 Mixin 类"
+        cls = getattr(cli_display, names[0])
+        assert hasattr(cls, "show_quick_commands")
+
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            cls.show_quick_commands(cls.__new__(cls))
+        out = buf.getvalue()
+
+        assert "/fc" in out and "/diff" in out, "速查表要覆盖新命令"
+        assert 18 <= len(out.strip().splitlines()) <= 26
+
+    def test_diff_mode_remembered(self):
+        src = _read("xcli_core", "cli_core.py")
+        assert "set_system_config('diff_popup_mode'" in src
+        assert "if saved is not None:" in src, "存过就不该再问第二次"
+
+    def test_new_commands_registered(self):
+        src = _read("xcli_core", "cli_core.py")
+        assert "user_input.startswith('/diff')" in src
+        assert "user_input.startswith('/fc')" in src
+
+
+# ══════════════════════════════════════
+#  4. 启动噪音折叠到 --verbose
+# ══════════════════════════════════════
+
+class TestVerboseGate:
+    def test_loading_chatter_is_gated(self):
+        base_src = _read("xcli_core", "cli_base.py")
+        utm_src = _read("unified_tool_manager.py")
+        assert 'vprint(f"{Fore.GREEN}已注册插件命令' in base_src
+        assert 'vprint(f"{Fore.GREEN}已加载AI引擎' in base_src
+        assert 'vprint(f"{Fore.GREEN}已加载 Skill' in utm_src
+        assert "已加载 {len(self._tools)} 个工具" in utm_src, "工具加载应汇总成一行"
+
+    @pytest.mark.parametrize("argv,env,expected", [
+        (["ai_cli.py"], None, False),
+        (["ai_cli.py", "--verbose"], None, True),
+        (["ai_cli.py", "-v"], None, True),
+        (["ai_cli.py"], "1", True),
+        (["ai_cli.py"], "0", False),
+    ])
+    def test_is_verbose(self, monkeypatch, argv, env, expected):
+        from xcli_core import verbose as vb
+
+        monkeypatch.setattr(sys, "argv", argv)
+        if env is None:
+            monkeypatch.delenv("XCLI_VERBOSE", raising=False)
+        else:
+            monkeypatch.setenv("XCLI_VERBOSE", env)
+        assert vb.is_verbose() is expected
+
+    def test_vprint_silent_by_default(self, monkeypatch, capsys):
+        from xcli_core import verbose as vb
+
+        monkeypatch.setattr(sys, "argv", ["ai_cli.py"])
+        monkeypatch.delenv("XCLI_VERBOSE", raising=False)
+        vb.vprint("should not appear")
+        assert capsys.readouterr().out == ""
+
+        monkeypatch.setattr(sys, "argv", ["ai_cli.py", "-v"])
+        vb.vprint("should appear")
+        assert "should appear" in capsys.readouterr().out