openclaw-diag-cli 0.1.3 → 0.2.1

package/diag/03_configuration.py

@@ -85,7 +85,6 @@ def emit_config(out: output.Output, data: list, obj, prefix: str = "") -> None:
 def main() -> int:
     parser = cli.build_common_parser(
         description="模块 3：采集 OpenClaw 配置（含敏感字段脱敏）",
-        prog="03_configuration",
     )
     args = parser.parse_args()
 
@@ -95,6 +94,10 @@ def main() -> int:
     config_path = args.config
     if not os.path.isfile(config_path):
         out.item(f"配置文件未找到: {config_path}")
+        out.line("  下一步：")
+        out.line("    1) 确认 OpenClaw 已经初始化（运行过 `openclaw` 即会生成配置）")
+        out.line("    2) 用 OPENCLAW_CONFIG=/path/to/openclaw.json 或 --config 指向正确路径")
+        out.line("    3) 在容器/远端诊断时，用 OPENCLAW_HOME=/path 整体覆盖")
         out.evidence(config_path, "<文件缺失>")
         out.set_data("config_path", config_path)
         out.set_data("found", False)

package/diag/04_gateway.py

@@ -11,7 +11,6 @@ import sys
 from collections import defaultdict
 from datetime import datetime
 from pathlib import Path
-from typing import List, Optional
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
@@ -146,11 +145,20 @@ def section_restart_events(out: output.Output) -> None:
 
 def section_model_api(out: output.Output, args) -> None:
     if not os.path.isfile(args.config):
+        out.item("模型 API: 配置文件未找到")
+        out.set_data("model_api_status", {
+            "found": False, "reason": "config_not_found", "checked": args.config,
+        })
         return
     try:
         with open(args.config) as f:
             cfg = json.load(f)
-    except Exception:
+    except (OSError, json.JSONDecodeError) as e:
+        out.item(f"模型 API: 配置读取失败 ({type(e).__name__})")
+        out.set_data("model_api_status", {
+            "found": False, "reason": "config_unreadable",
+            "checked": args.config, "error": str(e)[:200],
+        })
         return
     models = cfg.get("models", {}) or {}
     all_cfgs = {}
@@ -290,8 +298,12 @@ def section_ws_lifecycle(out: output.Output, app_log: str) -> None:
                 else:
                     continue
                 events.append((ts_dt, ts_str, account, kind, msg))
-    except OSError:
-        out.item("Channel WS: 读取应用日志失败")
+    except OSError as e:
+        out.item(f"Channel WS: 读取应用日志失败 ({type(e).__name__})")
+        out.set_data("ws_summary_status", {
+            "found": False, "reason": "log_unreadable",
+            "checked": app_log, "error": str(e)[:200],
+        })
         return
 
     if not events and not expired:
@@ -564,7 +576,12 @@ def section_gateway_errors(out: output.Output, app_log: str) -> None:
                     continue
                 kind, code, reason = r
                 events.append((ts, kind, code, reason or "(no reason)"))
-    except OSError:
+    except OSError as e:
+        out.item(f"Gateway 错误码: 读取应用日志失败 ({type(e).__name__})")
+        out.set_data("gateway_errors_status", {
+            "found": False, "reason": "log_unreadable",
+            "checked": app_log, "error": str(e)[:200],
+        })
         return
 
     if not events:
@@ -614,7 +631,6 @@ def section_gateway_errors(out: output.Output, app_log: str) -> None:
 def main() -> int:
     parser = cli.build_common_parser(
         description="模块 4：Gateway 状态采集",
-        prog="04_gateway",
     )
     args = parser.parse_args()
 
@@ -622,6 +638,7 @@ def main() -> int:
     out.section("模块 4：Gateway 状态")
 
     port = 18789
+    port_source = "default"
     if os.path.isfile(args.config):
         try:
             with open(args.config) as f:
@@ -629,8 +646,13 @@ def main() -> int:
             cp = cfg.get("gateway", {}).get("port")
             if cp:
                 port = int(cp)
-        except Exception:
-            pass
+                port_source = "config"
+        except (OSError, json.JSONDecodeError, ValueError) as e:
+            out.set_data("port_source_status", {
+                "found": False, "reason": "config_unreadable",
+                "checked": args.config, "error": str(e)[:200],
+            })
+    out.set_data("port_source", port_source)
 
     section_process_port(out, args, port)
     section_restart_events(out)

package/diag/05_recent_errors.py

@@ -79,21 +79,25 @@ def render_log_line(line: str, max_len: int = 300) -> str:
         return line
 
 
-def collect_error_lines(log_files: List[str]) -> List[str]:
+def collect_error_lines(log_files: List[str]):
+    """Returns (matched_lines, unreadable_files). One unreadable file does not
+    abort the whole scan, but we tell the caller which paths failed."""
     out: List[str] = []
+    unreadable: List[dict] = []
     for lf in log_files:
         try:
             with open(lf, errors="replace") as f:
                 for ln in f:
                     if _ERR_RE.search(ln):
                         out.append(ln.rstrip("\n"))
-        except OSError:
-            continue
-    return out
+        except OSError as e:
+            unreadable.append({"path": lf, "error": f"{type(e).__name__}: {e}"})
+    return out, unreadable
 
 
-def collect_api_errors(log_files: List[str]) -> List[str]:
+def collect_api_errors(log_files: List[str]):
     out: List[str] = []
+    unreadable: List[dict] = []
     for lf in log_files:
         try:
             with open(lf, errors="replace") as f:
@@ -107,9 +111,9 @@ def collect_api_errors(log_files: List[str]) -> List[str]:
                     if _API_EXCLUDE_TXT_RE.search(ln):
                         continue
                     out.append(ln.rstrip("\n"))
-        except OSError:
-            continue
-    return out
+        except OSError as e:
+            unreadable.append({"path": lf, "error": f"{type(e).__name__}: {e}"})
+    return out, unreadable
 
 
 def journalctl_errors() -> str:
@@ -152,17 +156,21 @@ def tool_errors_from_session(session_path: str):
                 msg = obj.get("message", {}) or {}
                 if msg.get("isError"):
                     counts[msg.get("toolName", "unknown")] += 1
-            except Exception:
-                pass
+            except (json.JSONDecodeError, ValueError):
+                # Expected: session.jsonl can have malformed lines from
+                # interrupted writes; skip and keep counting.
+                continue
     except OSError:
-        pass
+        # Session file disappeared between glob() and open(). Caller already
+        # falls back to "no recent session"; reporting per-file unreadable
+        # would mostly add noise here.
+        return counts
     return counts
 
 
 def main() -> int:
     parser = cli.build_common_parser(
         description="模块 5：采集近期错误日志",
-        prog="05_recent_errors",
     )
     args = parser.parse_args()
 
@@ -187,8 +195,10 @@ def main() -> int:
     out.line("")
 
     if logs:
-        err_lines = collect_error_lines(logs)
+        err_lines, err_unreadable = collect_error_lines(logs)
         out.set_data("app_error_count", len(err_lines))
+        if err_unreadable:
+            out.set_data("app_log_unreadable", err_unreadable)
         if err_lines:
             out.item(f"应用日志 ERROR 级别: {len(err_lines)} 条 — Gateway 运行时报错，包括工具失败、模型异常等")
             rendered = []
@@ -202,7 +212,7 @@ def main() -> int:
         else:
             out.item("应用日志 ERROR 级别: 0 条 — Gateway 运行时报错")
 
-        api_lines = collect_api_errors(logs)
+        api_lines, _api_unreadable = collect_api_errors(logs)
         out.set_data("api_error_count", len(api_lines))
         if api_lines:
             out.item(f"模型 API HTTP 错误: {len(api_lines)} 条 ")

package/diag/06_cron_jobs.py

@@ -13,11 +13,12 @@ import sys
 import time
 from collections import Counter, deque
 from pathlib import Path
-from typing import Optional
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
-from ocdiag import cli, output, paths
+from ocdiag import cli, output
+from ocdiag.timeutil import fmt_age, fmt_ts
+from ocdiag.tokens import fmt_tokens, percentile
 
 try:
     from croniter import croniter  # type: ignore
@@ -26,15 +27,6 @@ except ImportError:
     HAS_CRONITER = False
 
 
-def fmt_ts(ms):
-    if not ms:
-        return "?"
-    try:
-        return datetime.datetime.fromtimestamp(ms / 1000).strftime("%Y-%m-%d %H:%M:%S")
-    except Exception:
-        return str(ms)
-
-
 def fmt_duration(ms):
     if ms is None:
         return "?"
@@ -46,24 +38,6 @@ def fmt_duration(ms):
     return f"{s/3600:.1f}h"
 
 
-def fmt_age(ms_delta):
-    s = abs(ms_delta) / 1000
-    if s < 60:
-        return f"{s:.0f}秒"
-    if s < 3600:
-        return f"{s/60:.0f}分钟"
-    if s < 86400:
-        return f"{s/3600:.1f}小时"
-    return f"{s/86400:.1f}天"
-
-
-def percentile(sorted_list, p):
-    if not sorted_list:
-        return None
-    k = max(0, min(len(sorted_list) - 1, int(len(sorted_list) * p)))
-    return sorted_list[k]
-
-
 def format_schedule(sched):
     k = sched.get("kind", "?")
     if k == "cron":
@@ -121,16 +95,6 @@ def load_runs(runs_dir, jid):
     return out
 
 
-def fmt_k(n):
-    if n is None:
-        return "?"
-    if n >= 1_000_000:
-        return f"{n/1_000_000:.1f}M"
-    if n >= 1000:
-        return f"{n/1000:.1f}K"
-    return str(n)
-
-
 def extract_usage(r):
     u = r.get("usage")
     if not u and isinstance(r.get("result"), dict):
@@ -463,7 +427,7 @@ def section_jobs(out: output.Output, jobs_file: str, state_file: str, runs_dir:
                 cost_sum += cost
                 has_cost = True
         if has_usage:
-            line = f"      tokens(最近{len(recent)}次): in={fmt_k(input_sum)} out={fmt_k(output_sum)}"
+            line = f"      tokens(最近{len(recent)}次): in={fmt_tokens(input_sum)} out={fmt_tokens(output_sum)}"
             if has_cost:
                 line += f" | cost=${cost_sum:.4f}"
             out.item(line)
@@ -671,7 +635,6 @@ def section_system_crontab(out: output.Output) -> None:
 def main() -> int:
     parser = cli.build_common_parser(
         description="模块 6：定时任务采集",
-        prog="06_cron_jobs",
     )
     args = parser.parse_args()
 

package/diag/07_performance.py

@@ -7,7 +7,6 @@ import glob
 import json
 import os
 import sys
-import tempfile
 from collections import defaultdict
 from datetime import datetime, timezone, timedelta
 from pathlib import Path
@@ -15,45 +14,13 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
 from ocdiag import cli, output
+from ocdiag.timeutil import parse_msg_ts, parse_obj_ts
+from ocdiag.tokens import fmt_tokens, pct
 
 
 NORMAL_STOPS = {"stop", "end_turn", "toolUse", "tool_calls", ""}
 
 
-def parse_obj_ts(ts_str):
-    if not ts_str:
-        return None
-    try:
-        return datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
-    except Exception:
-        return None
-
-
-def parse_msg_ts(ms):
-    if ms is None:
-        return None
-    try:
-        return datetime.fromtimestamp(int(ms) / 1000, tz=timezone.utc)
-    except Exception:
-        return None
-
-
-def pct(sorted_vals, p):
-    if not sorted_vals:
-        return 0.0
-    n = len(sorted_vals)
-    idx = min(n - 1, int(n * p))
-    return sorted_vals[idx]
-
-
-def fmt_tokens(n):
-    if n >= 1_000_000:
-        return f"{n/1_000_000:.1f}M"
-    if n >= 1_000:
-        return f"{n/1_000:.1f}K"
-    return str(n)
-
-
 def fmt_args(tool_name, tc_args, max_len=100):
     if isinstance(tc_args, str):
         try:
@@ -432,11 +399,18 @@ def render(out: output.Output, data, file_count):
     else:
         for i, (sec, val, hint) in enumerate(bottleneck_items):
             out.item(f"#{i+1}: {sec}（P95={val:.1f}s, {hint}）")
+    out.set_data("bottleneck", {
+        "model_p95": round(model_p95, 3),
+        "tool_p95": round(tool_p95, 3),
+        "model_top": model_top,
+        "tool_top": tool_top,
+    })
 
     out.subsection("模型性能")
     out.item(f"数据来源: 最近 {file_count} 个 session 文件")
     out.line("")
     model_stats = data["model_stats"]
+    models_payload = {}
     if not model_stats:
         out.item("最近 Session 中未发现模型使用数据")
     else:
@@ -481,9 +455,29 @@ def render(out: output.Output, data, file_count):
             stops_str = " ".join(f"{k}:{v}" for k, v in sorted(stops.items(), key=lambda x: -x[1]))
             out.item(f"  stopReasons: {stops_str}" if stops_str else "  stopReasons: (none)")
             out.line("")
+            models_payload[model_key] = {
+                "calls": calls,
+                "p50_s": round(p50, 3),
+                "p95_s": round(p95, 3),
+                "max_s": round(mx, 3),
+                "throughput_tok_s": (
+                    None if s["output"] == 0 or total_dur <= 0
+                    else round(s["output"] / total_dur, 1)
+                ),
+                "input_tokens": s["input"],
+                "output_tokens": s["output"],
+                "cache_read_tokens": s["cache_read"],
+                "cache_write_tokens": s["cache_write"],
+                "cost_usd": round(s["cost"], 6),
+                "success_rate_pct": round(success, 1),
+                "stop_reasons": dict(stops),
+            }
+    out.set_data("models", models_payload)
+    out.set_data("session_files_analyzed", file_count)
 
     out.subsection("工具性能（Top 10 by 调用量）")
     timed_tools = {n: s for n, s in data["tool_stats"].items() if s["durations"]}
+    tools_payload = {}
     if not timed_tools:
         out.item("（无工具调用数据）")
     else:
@@ -491,8 +485,11 @@ def render(out: output.Output, data, file_count):
         for name, s in ranked:
             durs = sorted(s["durations"])
             calls = s["calls"]
+            p50 = pct(durs, 0.50)
+            p95 = pct(durs, 0.95)
+            mx = durs[-1]
             err_rate = (s["errors"] / calls * 100) if calls else 0.0
-            dur_str = f"P50={pct(durs,0.50):.3f}s P95={pct(durs,0.95):.3f}s Max={durs[-1]:.3f}s"
+            dur_str = f"P50={p50:.3f}s P95={p95:.3f}s Max={mx:.3f}s"
             out.item(f"{name}: {calls} 次 | {dur_str} | 错误 {err_rate:.0f}%")
             timed = [r for r in s["records"] if r["dur"] is not None]
             timed.sort(key=lambda r: r["dur"], reverse=True)
@@ -511,6 +508,15 @@ def render(out: output.Output, data, file_count):
                 tail = f", {r['err_brief']}" if r["err_brief"] else ""
                 out.item(f"  失败: {args} (error, {dur_txt}{tail})")
                 err_shown += 1
+            tools_payload[name] = {
+                "calls": calls,
+                "errors": s["errors"],
+                "error_rate_pct": round(err_rate, 1),
+                "p50_s": round(p50, 3),
+                "p95_s": round(p95, 3),
+                "max_s": round(mx, 3),
+            }
+    out.set_data("tools", tools_payload)
 
     out.subsection("慢调用 Top 20")
     slow = sorted(data["slow_calls_top"], key=lambda x: x[0], reverse=True)
@@ -529,12 +535,17 @@ def render(out: output.Output, data, file_count):
     else:
         for i, entry in enumerate(top20, 1):
             out.item(f"[{i}] {entry[2]}")
+    out.set_data("slow_calls_top20", [
+        {"duration_s": round(e[0], 3), "kind": e[1], "summary": e[2]}
+        for e in top20
+    ])
 
     out.subsection("异常 stopReason — 模型非正常结束（如 error、中断）")
     abnormal_stops = data["abnormal_stops"]
     out.item(f"共 {len(abnormal_stops)} 条" + ("（无异常）" if not abnormal_stops else ""))
     for s in abnormal_stops[:20]:
         out.item(s)
+    out.set_data("abnormal_stops", abnormal_stops)
 
     out.subsection("模型 API 错误分布")
     api_err_total = sum(data["api_error_stats"].values())
@@ -548,9 +559,16 @@ def render(out: output.Output, data, file_count):
             out.item("分布:")
             for cat, n in sorted(data["api_error_stats"].items(), key=lambda kv: -kv[1]):
                 out.item(f"  {cat}: {n}")
+    out.set_data("api_errors", {
+        "total_calls": api_total,
+        "error_count": api_err_total,
+        "error_rate_pct": round(api_err_total / api_total * 100, 2) if api_total else 0.0,
+        "by_category": dict(data["api_error_stats"]),
+    })
 
     out.subsection("端到端消息延迟（user 发送 → assistant 最终响应）")
     e2e = data["e2e_latencies"]
+    e2e_payload = {"count": 0}
     if not e2e:
         out.item("（数据不足，未发现 user→assistant 配对）")
     else:
@@ -573,10 +591,19 @@ def render(out: output.Output, data, file_count):
             n = bucket_counts[lbl]
             pct_v = (n / total * 100) if total else 0.0
             out.item(f"  {lbl}: {n} ({pct_v:.1f}%)")
+        e2e_payload = {
+            "count": total,
+            "p50_s": round(p50, 3),
+            "p95_s": round(p95, 3),
+            "max_s": round(mx, 3),
+            "buckets": dict(bucket_counts),
+        }
+    out.set_data("e2e_latency", e2e_payload)
 
     out.subsection("延迟 vs 上下文大小")
     ctx_buckets_def = data["ctx_buckets_def"]
     ctx_durs = data["ctx_bucket_durs"]
+    ctx_payload = {}
     if not any(ctx_durs.get(l) for l, _ in ctx_buckets_def):
         out.item("（数据不足）")
     else:
@@ -585,13 +612,21 @@ def render(out: output.Output, data, file_count):
             durs = sorted(ctx_durs.get(b_label, []))
             if not durs:
                 out.line(f"    {b_label:<14} {0:>8} {'-':>10} {'-':>10}")
+                ctx_payload[b_label] = {"count": 0, "p50_s": None, "p95_s": None}
                 continue
             p50 = pct(durs, 0.50)
             p95 = pct(durs, 0.95)
             out.line(f"    {b_label:<14} {len(durs):>8} {p50:>9.1f}s {p95:>9.1f}s")
+            ctx_payload[b_label] = {
+                "count": len(durs),
+                "p50_s": round(p50, 3),
+                "p95_s": round(p95, 3),
+            }
+    out.set_data("ctx_buckets", ctx_payload)
 
     out.subsection("每日趋势（最近 7 天）")
     daily_stats = data["daily_stats"]
+    daily_payload = []
     if not daily_stats:
         out.item("（数据不足）")
     else:
@@ -602,12 +637,22 @@ def render(out: output.Output, data, file_count):
             d = daily_stats.get(d_key)
             if not d or d["calls"] == 0:
                 out.line(f"    {d_key:<10} {0:>8} {'-':>10} {'-':>14}")
+                daily_payload.append({"date": d_key, "calls": 0,
+                                       "p50_s": None, "output_tokens": 0})
                 continue
             durs = sorted(d["durs"])
             p50 = pct(durs, 0.50) if durs else 0.0
             out.line(f"    {d_key:<10} {d['calls']:>8} {p50:>9.1f}s {fmt_tokens(d['output']):>14}")
+            daily_payload.append({
+                "date": d_key,
+                "calls": d["calls"],
+                "p50_s": round(p50, 3),
+                "output_tokens": d["output"],
+            })
+    out.set_data("daily_trend", daily_payload)
 
     out.subsection("Cache 命中率")
+    cache_payload = {"total_calls": data["cache_total_calls"]}
     if data["cache_total_calls"] == 0:
         out.item("（无数据）")
     else:
@@ -622,17 +667,34 @@ def render(out: output.Output, data, file_count):
             f"cache_write: {fmt_tokens(data['cache_sum_cache_write'])}"
         )
         denom = data["cache_sum_input"] + data["cache_sum_cache_read"]
+        ratio_pct = None
         if denom > 0:
             ratio = data["cache_sum_cache_read"] / denom * 100
+            ratio_pct = round(ratio, 3)
             out.item(
                 f"上下文 cache 占比: cacheRead/(input+cacheRead) = "
                 f"{ratio:.3f}% ({fmt_tokens(data['cache_sum_cache_read'])}/{fmt_tokens(denom)})"
             )
+        cache_payload = {
+            "total_calls": data["cache_total_calls"],
+            "calls_with_cache_read": data["cache_calls_with_cache"],
+            "hit_rate_pct": round(hit_pct, 2),
+            "input_tokens": data["cache_sum_input"],
+            "cache_read_tokens": data["cache_sum_cache_read"],
+            "cache_write_tokens": data["cache_sum_cache_write"],
+            "ctx_cache_ratio_pct": ratio_pct,
+        }
+    out.set_data("cache_hit_rate", cache_payload)
 
     out.subsection("工具错误明细")
     tool_stats = data["tool_stats"]
     err_total = sum(s["errors"] for s in tool_stats.values())
     call_total = sum(s["calls"] for s in tool_stats.values())
+    tool_errors_payload = {
+        "total_errors": err_total,
+        "total_calls": call_total,
+        "by_tool": {},
+    }
     if err_total == 0:
         out.item(f"共 0 次错误 (总调用 {call_total} 次中)")
     else:
@@ -642,13 +704,22 @@ def render(out: output.Output, data, file_count):
             if s["errors"] == 0:
                 continue
             out.line(f"    {name} ({s['errors']}次):")
+            samples = []
             for r in s["error_records"][:3]:
                 ts_label = r["ts"].strftime("%Y-%m-%d %H:%M:%S") if r["ts"] else "?"
                 brief = r["err_brief"] or "(无错误内容)"
                 out.line(f"      {ts_label} | {brief[:100]}")
+                samples.append({"ts": ts_label, "brief": brief[:200]})
+            tool_errors_payload["by_tool"][name] = {
+                "errors": s["errors"],
+                "calls": s["calls"],
+                "samples": samples,
+            }
+    out.set_data("tool_errors", tool_errors_payload)
 
     out.subsection("Session 消耗 Top 5")
     session_stats = data["session_stats"]
+    session_top_payload = []
     if not session_stats:
         out.item("（无数据）")
     else:
@@ -657,12 +728,18 @@ def render(out: output.Output, data, file_count):
         for sid, ss in ranked:
             out.line(f"    {sid:<40} {ss['calls']:>8} "
                      f"{fmt_tokens(ss['tokens']):>10} {ss['duration']:>11.0f}s")
+            session_top_payload.append({
+                "session": sid,
+                "calls": ss["calls"],
+                "tokens": ss["tokens"],
+                "duration_s": round(ss["duration"], 1),
+            })
+    out.set_data("session_top5", session_top_payload)
 
 
 def main() -> int:
     parser = cli.build_common_parser(
         description="模块 7：模型与性能数据",
-        prog="07_performance",
     )
     args = parser.parse_args()
     out = output.init("performance", json_mode=args.json, no_color=args.no_color)
@@ -675,11 +752,6 @@ def main() -> int:
 
     data = analyze_sessions(session_files)
     render(out, data, len(session_files))
-
-    if args.json:
-        out.set_data("model_count", len(data["model_stats"]))
-        out.set_data("session_files_analyzed", len(session_files))
-        out.set_data("e2e_latency_count", len(data["e2e_latencies"]))
     return out.done()
 
 

package/diag/08_sessions.py

@@ -10,69 +10,18 @@ import re
 import sys
 import time
 from collections import defaultdict
-from datetime import datetime, timezone
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
 from ocdiag import cli, output
+from ocdiag.timeutil import fmt_duration, parse_msg_ts, parse_obj_ts
+from ocdiag.tokens import fmt_tokens, human_size, pct
 
 
 NORMAL_STOPS = {"stop", "end_turn", "toolUse", "tool_calls", ""}
 
 
-def parse_obj_ts(ts_str):
-    if not ts_str:
-        return None
-    try:
-        return datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
-    except Exception:
-        return None
-
-
-def parse_msg_ts(ms):
-    if ms is None:
-        return None
-    try:
-        return datetime.fromtimestamp(int(ms) / 1000, tz=timezone.utc)
-    except Exception:
-        return None
-
-
-def human_size(b):
-    if b < 1024:
-        return f"{b}B"
-    if b < 1048576:
-        return f"{b/1024:.1f}KB"
-    if b < 1073741824:
-        return f"{b/1048576:.1f}MB"
-    return f"{b/1073741824:.1f}GB"
-
-
-def fmt_tokens(n):
-    if n >= 1_000_000:
-        return f"{n/1_000_000:.1f}M"
-    if n >= 1_000:
-        return f"{n/1_000:.1f}K"
-    return str(n)
-
-
-def fmt_duration(sec):
-    if sec < 60:
-        return f"{sec:.0f}s"
-    if sec < 3600:
-        return f"{sec/60:.1f}m"
-    return f"{sec/3600:.1f}h"
-
-
-def pct(sorted_vals, p):
-    if not sorted_vals:
-        return 0.0
-    n = len(sorted_vals)
-    idx = min(n - 1, int(n * p))
-    return sorted_vals[idx]
-
-
 def build_id_to_key_map(agent_dir):
     sess_json = os.path.join(agent_dir, "sessions", "sessions.json")
     id_to_key = {}
@@ -502,7 +451,6 @@ def stuck_dimension(out: output.Output, log_dir: str) -> None:
 def main() -> int:
     parser = cli.build_common_parser(
         description="模块 8：Session 数据采集 + Stuck 探测",
-        prog="08_sessions",
     )
     args = parser.parse_args()
     out = output.init("sessions", json_mode=args.json, no_color=args.no_color)