foxclaw 0.1.0 → 0.1.3

package/python/bench/concurrency.py

@@ -0,0 +1,103 @@
+"""
+M2 · 并发压测（数字产物）
+
+回答路线图 M2 的量化问题:
+  · 并行 fork-join 相对顺序,墙钟省多少?(latency)
+  · 共享库(ThoughtChain/ProcessManager/SystemBus/HMR)在多线程并发写下的吞吐,
+    以及 `database is locked` 计数(应为 0)。
+
+离线:不联网、LLM 用带固定延迟的 stub。
+用法:HF_HUB_OFFLINE=1 python bench/concurrency.py
+"""
+import asyncio
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import foxclaw.core.web_search as ws
+ws.needs_search = lambda q: False
+
+from foxclaw import Foxclaw
+from foxclaw.core.thought_chain import ThoughtNode
+
+SLEEP = 0.4
+PAR_TASK = "同时查今天的日程、分析本月理财、总结这篇论文"
+SEQ_TASK = "先查今天的日程然后分析本月理财然后总结这篇论文"
+
+
+def _slow(system, messages, max_tokens=2048, agent_id=""):
+    time.sleep(SLEEP)
+    return "已处理"
+
+
+def bench_latency(os_):
+    print("\n[1] 并行 fork-join vs 顺序（每个子任务 LLM stub 固定 " f"{SLEEP*1000:.0f}ms）")
+    r = asyncio.run(os_.supervisor.run_task(PAR_TASK))
+    par = r["plan"]["wall_ms"]
+    t0 = time.perf_counter()
+    asyncio.run(os_.supervisor.run_task(SEQ_TASK))
+    seq = (time.perf_counter() - t0) * 1000
+    print(f"    顺序墙钟 : {seq:8.0f} ms")
+    print(f"    并行墙钟 : {par:8.0f} ms")
+    print(f"    加速比   : {seq/par:8.2f}×   （3 子任务跨 3 个 Agent）")
+
+
+def bench_concurrency(os_, threads=12, per_thread=20):
+    print(f"\n[2] 共享库并发写压测（{threads} 线程 × {per_thread} 轮）")
+    tc, pm, bus, hmr = (os_.thought_chain, os_.process_manager,
+                        os_.system_bus, os_.hmr)
+    locked = {"n": 0}
+    errors = []
+    lk = threading.Lock()
+
+    def worker(k):
+        for i in range(per_thread):
+            try:
+                node = ThoughtNode.create(session_id=f"b{k}", agent_id="bench",
+                                          type="reasoning", content=f"n{k}_{i}", conf=0.9)
+                tc.add_node(node); tc.update_harness(node.id, "PASS")
+                p = pm.create(f"t{k}_{i}", agent_id=f"a{k}", schedule={"priority": 1})
+                pm.mark_running(p.process_id); pm.mark_completed(p.process_id)
+                bus.publish("bench.evt", {"k": k, "i": i})
+                hmr.ingest(f"记忆{k}_{i}", type="concept", agent_id=f"a{k}", title=f"m{k}_{i}")
+            except Exception as e:
+                msg = repr(e)
+                if "database is locked" in msg:
+                    with lk:
+                        locked["n"] += 1
+                with lk:
+                    errors.append(msg)
+
+    total = threads * per_thread
+    t0 = time.perf_counter()
+    ts = [threading.Thread(target=worker, args=(k,)) for k in range(threads)]
+    for t in ts: t.start()
+    for t in ts: t.join()
+    dur = time.perf_counter() - t0
+
+    with tc._conn() as c:
+        nodes = c.execute("SELECT COUNT(*) FROM thought_nodes WHERE agent_id='bench'"
+                          ).fetchone()[0]
+    print(f"    总写入组   : {total}  （每组 = 1 审计节点 + 1 进程流转 + 1 事件 + 1 记忆）")
+    print(f"    耗时       : {dur*1000:8.0f} ms   吞吐 {total/dur:8.0f} 组/s")
+    print(f"    审计落库   : {nodes} / {total}   {'✓ 不丢' if nodes >= total else '✗ 丢失'}")
+    print(f"    database is locked 次数 : {locked['n']}   {'✓' if locked['n']==0 else '✗'}")
+    print(f"    其它异常   : {len(errors)}   {'✓ 无' if not errors else errors[:1]}")
+
+
+def main():
+    os_ = Foxclaw(data_dir=tempfile.mkdtemp())
+    os_.router.complete = _slow
+    print("=" * 60)
+    print("Foxclaw · M2 并发压测")
+    print("=" * 60)
+    bench_latency(os_)
+    bench_concurrency(os_)
+    print("\n" + "=" * 60)
+
+
+if __name__ == "__main__":
+    main()

package/python/bench/e2e_real_models.py

@@ -0,0 +1,94 @@
+"""
+真实多模型 E2E 冒烟（非 stub）· 数字产物
+
+回答步骤 10「真实多模型 E2E」:逐个探测已配 Key 的 provider,各跑一条**真实**最小消息,
+验证「非 stub、非降级、有真实输出」,产出量化报告。
+
+opt-in:只对有真实 Key 的 provider 打真模型(要联网、会消耗额度);一个 Key 都没配则
+优雅跳过(exit 0)——CI/离线环境绝不误判失败。
+
+用法:
+  python bench/e2e_real_models.py            # 只测当前环境已配 Key 的 provider
+  FOXCLAW_E2E_SKIP_PROVIDER=google python ...  # 跳过某 provider(如无 SDK/额度)
+"""
+import os
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import foxclaw.core.web_search as ws  # noqa: E402
+ws.needs_search = lambda q: False
+
+from foxclaw.core.model_router import ModelRouter  # noqa: E402
+
+_SYS = "你是 Foxclaw 助手。"
+_MSG = [{"role": "user", "content": "请只回复两个字：你好"}]
+_MAX_TOKENS = 64
+_BAD_MARKERS = ("【未执行】", "【模型返回为空】", "【全部模型失败】", "【模型流式中断】", "STUB")
+
+
+def _smoke(provider: str) -> dict:
+    """对一个 provider 跑一条真实最小消息,返回观测结果。"""
+    t0 = time.perf_counter()
+    r = ModelRouter(provider=provider)
+    info = r.info()
+    if not info.get("client_ready"):
+        return {"provider": provider, "ok": False, "lat_ms": 0,
+                "output": "", "reason": "client 未就绪(SDK 缺失或无 Key): " +
+                                         (info.get("fallback_reason") or "未知")}
+    try:
+        out = r.complete(_SYS, _MSG, max_tokens=_MAX_TOKENS, agent_id="bench")
+        lat = (time.perf_counter() - t0) * 1000
+    except Exception as e:
+        return {"provider": provider, "ok": False, "lat_ms": (time.perf_counter() - t0) * 1000,
+                "output": "", "reason": f"调用异常: {type(e).__name__}: {e}"}
+
+    degraded = r.take_call_degraded()
+    bad = any(m in out for m in _BAD_MARKERS)
+    ok = bool(out) and not degraded and not bad
+    reason = ""
+    if degraded:
+        reason = "本次调用降级(degraded)"
+    elif bad:
+        reason = "输出含降级/失败文案"
+    return {"provider": provider, "ok": ok, "lat_ms": lat, "output": out, "reason": reason}
+
+
+def main():
+    skip = {s.strip().lower() for s in os.environ.get("FOXCLAW_E2E_SKIP_PROVIDER", "").split(",")
+            if s.strip()}
+    configured = [p["provider"] for p in ModelRouter.available_providers()
+                  if p["configured"] and p["provider"] not in skip]
+
+    print("=" * 64)
+    print("Foxclaw · 真实多模型 E2E 冒烟(非 stub)")
+    print("=" * 64)
+
+    if not configured:
+        print("未检测到任何已配置 Key 的 provider(见 .env.example)。")
+        print("结论: 跳过(无真实模型可测)——离线/无额度环境属预期,非失败。")
+        print("=" * 64)
+        return 0
+
+    print(f"检测到 {len(configured)} 个 provider: {', '.join(configured)}\n")
+    n_ok = 0
+    for p in configured:
+        r = _smoke(p)
+        mark = "✓" if r["ok"] else "✗"
+        n_ok += 1 if r["ok"] else 0
+        sample = (r["output"].strip().replace("\n", " ")[:36]) if r["output"] else "(空)"
+        print(f"[{mark}] {p:12s}  {r['lat_ms']:7.0f} ms  → {sample}")
+        if r["reason"]:
+            print(f"     原因: {r['reason']}")
+
+    print("\n" + "=" * 64)
+    print(f"结论: {n_ok}/{len(configured)} 个真实模型冒烟通过 — "
+          f"{'✓ 多模型真实链路可用' if n_ok == len(configured) else '✗ 有 provider 未通过(见上)'}")
+    print("=" * 64)
+    return 0 if n_ok == len(configured) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/python/bench/llm_retry_test.py

@@ -0,0 +1,241 @@
+"""
+bench/llm_retry_test.py
+C 阶段 _retry_llm helper 单元测试。
+
+覆盖:
+  1. 正常调用 1 次成功
+  2. 429 抛 1 次后成功
+  3. 429 抛 max_retries 次后 raise
+  4. 非 retryable 异常立即 raise
+  5. Retry-After header 优先于 backoff
+  6. 5xx 也 retry
+  7. ConnectionError / Timeout retry
+  8. 指数退避 (backoff 1→2→4) + max_delay 上限
+  9. openai RateLimitError (name 含 RateLimit) 也 retry
+"""
+import os, sys, time
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'vendor'))
+from hkc.hkc_kde.extractor import Extractor
+
+
+class FakeResponse:
+    def __init__(self, headers=None):
+        self.headers = headers or {}
+
+
+class Fake429Error(Exception):
+    def __init__(self, msg="rate limited", retry_after=None):
+        super().__init__(msg)
+        self.status_code = 429
+        self.headers = {"Retry-After": str(retry_after)} if retry_after else {}
+
+
+class Fake5xxError(Exception):
+    def __init__(self, msg="server error", status=500):
+        super().__init__(msg)
+        self.status_code = status
+
+
+class FakeTimeoutError(TimeoutError):
+    def __init__(self, msg="timed out"):
+        super().__init__(msg)
+        self.status_code = None
+
+
+class FakeConnError(ConnectionError):
+    pass
+
+
+class FakeRateLimitName(Exception):
+    """模拟 openai.RateLimitError(type name 含 'RateLimit',无 status_code)"""
+    def __init__(self, msg="rate"):
+        super().__init__(msg)
+
+
+class FakeValueError(Exception):
+    """非 retryable"""
+    def __init__(self, msg="bad request"):
+        super().__init__(msg)
+        self.status_code = 400
+
+
+ext = Extractor(provider="mock", model="mock-model")
+
+
+def make_func(side_effects):
+    """side_effects: 异常类或值,依次抛出,最后返回 'ok' 或 raise"""
+    call_count = [0]
+    sleeps = []
+
+    def _func(*args, **kwargs):
+        i = call_count[0]
+        call_count[0] += 1
+        if i < len(side_effects):
+            item = side_effects[i]
+            if isinstance(item, Exception):
+                raise item
+            return item
+        return "ok"
+
+    return _func, call_count, sleeps
+
+
+def patch_sleep():
+    """monkey-patch time.sleep 不真睡,记录时长"""
+    import hkc.hkc_kde.extractor as ex
+    original = ex.time.sleep
+    sleeps = []
+    def fake_sleep(s):
+        sleeps.append(s)
+    ex.time.sleep = fake_sleep
+    return ex, original, sleeps
+
+
+def restore_sleep(ex, original):
+    ex.time.sleep = original
+
+
+def t1_ok():
+    """1. 正常调用 1 次成功"""
+    func, calls, _ = make_func(["ok"])
+    r = ext._retry_llm(func, max_retries=3, base_delay=0.01)
+    assert r == "ok" and calls[0] == 1
+    print("  1. ok 1 次成功: PASS")
+
+
+def t2_429_retry_success():
+    """2. 429 抛 1 次后成功"""
+    func, calls, _ = make_func([Fake429Error(), "ok"])
+    ex, original, sleeps = patch_sleep()
+    try:
+        r = ext._retry_llm(func, max_retries=3, base_delay=0.01, max_delay=0.1)
+        assert r == "ok" and calls[0] == 2
+        assert len(sleeps) == 1 and sleeps[0] == 0.01
+        print("  2. 429 1 次后成功 + sleep 0.01: PASS")
+    finally:
+        restore_sleep(ex, original)
+
+
+def t3_429_exhaust():
+    """3. 429 抛 max_retries+1 次后 raise"""
+    func, calls, _ = make_func([Fake429Error()] * 5)
+    ex, original, sleeps = patch_sleep()
+    try:
+        try:
+            ext._retry_llm(func, max_retries=3, base_delay=0.001, max_delay=0.01)
+            assert False, "应该 raise"
+        except Fake429Error:
+            pass
+        assert calls[0] == 4
+        assert len(sleeps) == 3
+        print("  3. 429 4 次后 raise (1+3 retry): PASS, calls={}, sleeps={}".format(calls[0], sleeps))
+    finally:
+        restore_sleep(ex, original)
+
+
+def t4_non_retryable():
+    """4. 非 retryable (400) 立即 raise"""
+    func, calls, _ = make_func([FakeValueError()])
+    ex, original, sleeps = patch_sleep()
+    try:
+        try:
+            ext._retry_llm(func, max_retries=3, base_delay=0.01)
+            assert False, "应该 raise"
+        except FakeValueError:
+            pass
+        assert calls[0] == 1
+        assert len(sleeps) == 0
+        print("  4. 400 立即 raise 不 sleep: PASS")
+    finally:
+        restore_sleep(ex, original)
+
+
+def t5_retry_after():
+    """5. Retry-After header 优先于 backoff"""
+    func, calls, _ = make_func([Fake429Error(retry_after=0.05), "ok"])
+    ex, original, sleeps = patch_sleep()
+    try:
+        r = ext._retry_llm(func, max_retries=3, base_delay=1.0, max_delay=10.0)
+        assert r == "ok"
+        assert len(sleeps) == 1
+        assert sleeps[0] == 0.05, f"expected 0.05, got {sleeps[0]}"
+        print("  5. Retry-After=0.05 优先 backoff=1.0: PASS, slept={}".format(sleeps))
+    finally:
+        restore_sleep(ex, original)
+
+
+def t6_5xx():
+    """6. 5xx (500) retry"""
+    func, calls, _ = make_func([Fake5xxError(status=500), Fake5xxError(status=503), "ok"])
+    ex, original, sleeps = patch_sleep()
+    try:
+        r = ext._retry_llm(func, max_retries=3, base_delay=0.01, max_delay=0.1)
+        assert r == "ok" and calls[0] == 3
+        assert sleeps == [0.01, 0.02]
+        print("  6. 5xx 500+503 后成功: PASS, sleeps={}".format(sleeps))
+    finally:
+        restore_sleep(ex, original)
+
+
+def t7_conn_timeout():
+    """7. ConnectionError / Timeout retry"""
+    for cls, name in [(FakeConnError, "ConnectionError"), (FakeTimeoutError, "Timeout")]:
+        func, calls, _ = make_func([cls(), "ok"])
+        ex, original, sleeps = patch_sleep()
+        try:
+            r = ext._retry_llm(func, max_retries=3, base_delay=0.01)
+            assert r == "ok" and calls[0] == 2
+            assert len(sleeps) == 1
+            print("  7. {} retry: PASS".format(name))
+        finally:
+            restore_sleep(ex, original)
+
+
+def t8_backoff():
+    """8. 指数退避 1→2→4 + max_delay 上限"""
+    func, calls, _ = make_func([Fake429Error()] * 4)
+    ex, original, sleeps = patch_sleep()
+    try:
+        try:
+            ext._retry_llm(func, max_retries=3, base_delay=1.0, max_delay=3.0)
+        except Fake429Error:
+            pass
+        assert sleeps == [1.0, 2.0, 3.0], f"expected [1,2,3], got {sleeps}"
+        print("  8. 退避 1→2→3 (max_delay cap): PASS, sleeps={}".format(sleeps))
+    finally:
+        restore_sleep(ex, original)
+
+
+def t9_rate_limit_name():
+    """9. type name 含 'RateLimit' (openai.RateLimitError 风格) 也 retry"""
+    func, calls, _ = make_func([FakeRateLimitName(), "ok"])
+    ex, original, sleeps = patch_sleep()
+    try:
+        r = ext._retry_llm(func, max_retries=3, base_delay=0.01)
+        assert r == "ok" and calls[0] == 2
+        print("  9. RateLimit class name → retry: PASS")
+    finally:
+        restore_sleep(ex, original)
+
+
+def main():
+    print("=" * 60)
+    print("C 阶段 _retry_llm helper 单元测试 (9 项)")
+    print("=" * 60)
+    t1_ok()
+    t2_429_retry_success()
+    t3_429_exhaust()
+    t4_non_retryable()
+    t5_retry_after()
+    t6_5xx()
+    t7_conn_timeout()
+    t8_backoff()
+    t9_rate_limit_name()
+    print("=" * 60)
+    print("全部 9 项 PASS")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

package/python/bench/load_test.py

@@ -0,0 +1,193 @@
+"""
+本地大并发压测（真实 uvicorn 服务）
+
+起一个真实的 uvicorn（Foxclaw，stub LLM / 离线），用 httpx 异步客户端打高并发
+`POST /api/task`，量:
+  · 吞吐(req/s)、延迟分位(p50/p90/p95/p99/max)、错误率;
+  · **负载下正确性**:每个请求拿到独立 session_id(无串味)、无 database is locked、无 5xx。
+
+这把 M2 加锁 + 顶层 contextvars 的并发修复放到**真实 HTTP 服务**下验证。
+纯本地、离线、零基建。用法:HF_HUB_OFFLINE=1 python bench/load_test.py [总请求数] [并发数]
+"""
+import asyncio
+import os
+import statistics
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+PORT = int(os.environ.get("FOXCLAW_BENCH_PORT", "8231"))
+BASE = f"http://127.0.0.1:{PORT}"
+
+TEMPLATES = [
+    "分析本月理财预算与收支",
+    "总结这篇论文的核心要点",
+    "安排明天上午的会议日程",
+    "整理并汇总这批资料",
+    "你能做什么",
+]
+
+
+def _pct(xs, p):
+    if not xs:
+        return 0.0
+    xs = sorted(xs)
+    k = max(0, min(len(xs) - 1, int(round((p / 100) * (len(xs) - 1)))))
+    return xs[k]
+
+
+def _start_server():
+    """在后台线程起真实 uvicorn。返回 (server, thread)。"""
+    import uvicorn
+    os.environ.setdefault("FOXCLAW_DATA_DIR", tempfile.mkdtemp())
+    os.environ["FOXCLAW_SHADOW_ROUNDS"] = "50"
+    for k in ("ANTHROPIC_API_KEY", "OPENAI_API_KEY", "DEEPSEEK_API_KEY",
+              "GOOGLE_API_KEY", "DASHSCOPE_API_KEY"):
+        os.environ.pop(k, None)
+    config = uvicorn.Config("foxclaw.api:app", host="127.0.0.1", port=PORT,
+                            log_level="warning", access_log=False)
+    server = uvicorn.Server(config)
+    th = threading.Thread(target=server.run, daemon=True)
+    th.start()
+    return server, th
+
+
+async def _wait_ready(timeout=120):
+    import httpx
+    t0 = time.time()
+    async with httpx.AsyncClient() as c:
+        while time.time() - t0 < timeout:
+            try:
+                r = await c.get(f"{BASE}/api/status", timeout=2)
+                if r.status_code == 200:
+                    return True
+            except Exception:
+                pass
+            await asyncio.sleep(0.3)
+    return False
+
+
+async def _run_load(total: int, concurrency: int):
+    import httpx
+    sem = asyncio.Semaphore(concurrency)
+    latencies, statuses, sessions, errors = [], [], [], []
+    lock = asyncio.Lock()
+
+    async def one(i: int):
+        task = f"{TEMPLATES[i % len(TEMPLATES)]}（REQ{i:05d}）"
+        async with sem:
+            t0 = time.perf_counter()
+            try:
+                async with httpx.AsyncClient(timeout=60) as c:
+                    r = await c.post(f"{BASE}/api/task",
+                                     json={"task": task, "agent_id": "supervisor"})
+                dt = (time.perf_counter() - t0) * 1000
+                async with lock:
+                    latencies.append(dt)
+                    statuses.append(r.status_code)
+                    if r.status_code == 200:
+                        body = r.json()
+                        sid = body.get("session_id")
+                        if sid:
+                            sessions.append(sid)
+                        if isinstance(body, dict) and body.get("error") == "主管处理失败":
+                            errors.append(body)
+            except Exception as e:
+                async with lock:
+                    errors.append(repr(e))
+
+    t0 = time.perf_counter()
+    await asyncio.gather(*[one(i) for i in range(total)])
+    wall = time.perf_counter() - t0
+    return {
+        "wall_s": wall, "throughput": total / wall if wall else 0,
+        "latencies": latencies, "statuses": statuses,
+        "sessions": sessions, "errors": errors,
+    }
+
+
+async def _server_log_has_locked():
+    """负载后查一次 /api/status 确认服务仍活;database is locked 会体现在 errors/5xx。"""
+    import httpx
+    try:
+        async with httpx.AsyncClient() as c:
+            r = await c.get(f"{BASE}/api/status", timeout=5)
+            return r.status_code == 200
+    except Exception:
+        return False
+
+
+async def main_async(total, concurrency):
+    print("=" * 62)
+    print(f"Foxclaw · 本地大并发压测  (总请求={total} 并发={concurrency})")
+    print("=" * 62)
+    ok = await _wait_ready()
+    if not ok:
+        print("✗ 服务未就绪"); return 1
+    print("服务就绪。先测单请求基线(concurrency=1)...")
+
+    base = await _run_load(10, 1)
+    base_lat = base["latencies"]
+    base_p50 = _pct(base_lat, 50)
+    base_tps = base["throughput"]
+    print(f"  单请求 p50={base_p50:.0f}ms  串行吞吐={base_tps:.1f} req/s\n")
+
+    print(f"开始并发加载(concurrency={concurrency})...\n")
+    res = await _run_load(total, concurrency)
+    lat, st = res["latencies"], res["statuses"]
+    n2xx = sum(1 for s in st if 200 <= s < 300)
+    n5xx = sum(1 for s in st if s >= 500)
+    healthy = await _server_log_has_locked()
+
+    print("【吞吐 / 延迟】")
+    print(f"  墙钟         : {res['wall_s']:.2f} s")
+    print(f"  吞吐         : {res['throughput']:.1f} req/s")
+    print(f"  延迟 p50/p90 : {_pct(lat,50):.0f} / {_pct(lat,90):.0f} ms")
+    print(f"  延迟 p95/p99 : {_pct(lat,95):.0f} / {_pct(lat,99):.0f} ms")
+    print(f"  延迟 max     : {max(lat):.0f} ms" if lat else "  无延迟样本")
+    ratio = _pct(lat, 50) / base_p50 if base_p50 else 0
+    speedup = base_tps and res["throughput"] / base_tps
+    print("\n【规模化分析】")
+    print(f"  单请求成本(串行 p50)   : {base_p50:.0f} ms")
+    print(f"  并发吞吐 / 串行吞吐     : {speedup:.2f}×  "
+          f"（>1 = 请求已部分并行;offload 到线程后嵌入计算并行）")
+    print(f"  并发下 p50 / 串行 p50   : {ratio:.1f}×  "
+          f"(< 并发数 {concurrency} 越多 → 并行度越高;=并发数则完全串行)")
+    print(f"  现状: /api/task 已 offload 到线程,harness 语义嵌入在锁外并行(torch 释放 GIL);")
+    print(f"        非线性加速的余量卡在 GIL(Python 侧串行)+ 本机核数。")
+    print(f"  进一步提速: ① uvicorn --workers N 多进程(需先做状态外置) ② 更轻的 embedding。")
+    print("\n【正确性 · 负载下】")
+    print(f"  2xx / 总数   : {n2xx}/{total}   5xx: {n5xx}   异常: {len(res['errors'])}")
+    uniq = len(set(res["sessions"]))
+    print(f"  session 唯一 : {uniq}/{len(res['sessions'])}  "
+          f"→ {'✓ 无串味(顶层并发隔离成立)' if uniq == len(res['sessions']) and uniq > 0 else '✗ 有会话碰撞'}")
+    print(f"  服务负载后仍健康: {'✓' if healthy else '✗'}")
+    if res["errors"]:
+        print(f"  异常样例: {res['errors'][:2]}")
+
+    passed = (n5xx == 0 and not res["errors"] and healthy
+              and uniq == len(res["sessions"]) and uniq > 0)
+    print("\n" + "=" * 62)
+    print("结论:", "✓ 高并发下吞吐可测、零错误、审计无串味" if passed else "✗ 存在问题(见上)")
+    print("=" * 62)
+    return 0 if passed else 1
+
+
+def main():
+    total = int(sys.argv[1]) if len(sys.argv) > 1 else 200
+    concurrency = int(sys.argv[2]) if len(sys.argv) > 2 else 32
+    server, th = _start_server()
+    try:
+        rc = asyncio.run(main_async(total, concurrency))
+    finally:
+        server.should_exit = True
+        th.join(timeout=10)
+    sys.exit(rc)
+
+
+if __name__ == "__main__":
+    main()