@hupan56/wlkj 3.3.13 → 3.3.15

package/templates/qoder/scripts/validation/eval/code_flywheel.py

@@ -1,150 +1,150 @@
-"""code_flywheel.py — FW3 wl-code 变更类精准度飞轮（改对实体 / 误改率）。
-
-变更类维度(SPEC §1.1)：正确性(过测试)/安全(gate_check)/精准(改对文件-误改率)。
-本尺子量【精准】：给功能加改动，模型列"该改的代码实体"，量
-  - 精准 P = 列出的实体 ∈ KG 真实体的比例（bare 编造→低 P=误改率高；scaffold 接地→高 P）
-  - 召回 R = gold 实体被列出比例
-bare vs +get_impact grounding scaffold。安全(gate)/正确性(过测试)是执行流→🖥️。
-
-跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/code_flywheel.py
-"""
-import os
-import re
-import sys
-import json
-import time
-import urllib.request
-import urllib.error
-
-for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
-    if os.path.isdir(_p) and _p not in sys.path:
-        sys.path.insert(0, _p)
-
-from sqlalchemy import text  # noqa: E402
-from app.db import SessionLocal  # noqa: E402
-
-CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
-CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
-MODEL = "qwen-turbo"
-FEATURES = [("车辆保养提醒", "车辆"), ("考勤异常导出", "考勤"), ("保险续保预警", "保险")]
-_LINE_CLEAN = re.compile(r"^[\-\*\d\.\)、\s]+")
-_CODE_TOK = re.compile(r"[A-Za-z_][\w./\-:]{2,}")
-
-
-def chat(prompt, max_tokens=500, timeout=80):
-    body = json.dumps({"model": MODEL,
-        "messages": [{"role": "user", "content": prompt}],
-        "temperature": 0.0, "max_tokens": max_tokens}).encode()
-    for attempt in range(3):
-        try:
-            req = urllib.request.Request(CHAT_URL, data=body,
-                headers={"Authorization": f"Bearer {CHAT_KEY}", "Content-Type": "application/json"})
-            return json.loads(urllib.request.urlopen(req, timeout=timeout).read())["choices"][0]["message"]["content"]
-        except (urllib.error.URLError, TimeoutError, OSError, KeyError) as e:
-            if attempt < 2:
-                time.sleep(1.0 * (attempt + 1))
-            else:
-                return f"[ERR {repr(e)[:60]}]"
-
-
-def _q(s, sql, params=None):
-    try:
-        return s.execute(text(sql), params or {}).fetchall()
-    except Exception:
-        try:
-            s.rollback()
-        except Exception:
-            pass
-        return []
-
-
-def load_universe_and_gold():
-    """UNI=所有真实体名(canonical+cn, 精度校验); GOLD=每主题的真实体(召回校验)。"""
-    s = SessionLocal()
-    rows = _q(s, "SELECT canonical, cn FROM entities WHERE canonical IS NOT NULL")
-    UNI = set()
-    for c, n in rows:
-        if c:
-            UNI.add(c.strip())
-        if n:
-            UNI.add(n.strip())
-    GOLD = {}
-    for feat, theme in FEATURES:
-        rs = _q(s, "SELECT canonical, cn FROM entities WHERE (canonical ILIKE :p OR cn ILIKE :p) "
-                   "AND type IN ('CONTROLLER','SERVICE','FUNCTION','COLUMN','TABLE') LIMIT 20", {"p": f"%{theme}%"})
-        GOLD[feat] = [(c, n) for c, n in rs if c]
-    s.close()
-    return UNI, GOLD
-
-
-def extract_names(ans):
-    cands = set()
-    for line in ans.splitlines():
-        line = _LINE_CLEAN.sub("", line).strip()
-        if line and len(line) <= 60:
-            m = _CODE_TOK.findall(line)
-            if m:
-                cands.add(m[0])
-    return cands
-
-
-def score(ans, gold, UNI):
-    cands = extract_names(ans)
-    real = {x for x in cands if x in UNI}
-    precision = (len(real) / len(cands)) if cands else 0.0
-    hit = 0
-    for c, n in gold:
-        if (c and c in ans) or (n and n in ans):
-            hit += 1
-    recall = (hit / len(gold)) if gold else 0.0
-    return round(precision, 3), round(recall, 3), len(cands)
-
-
-def run():
-    UNI, GOLD = load_universe_and_gold()
-    rep = {"features": []}
-    for feat, theme in FEATURES:
-        gold = GOLD[feat]
-        gold_ctx = "\n".join("%s (%s)" % (c, n) for c, n in gold) or "(无)"
-        bare = chat("你是开发。要在车辆物联网系统(ICS)给「%s」加功能。\n"
-                    "逐行列出【需要修改的代码文件/Java类/方法名】，每行一个，只列确信真实存在的，不要编造。" % feat)
-        scaff = chat("你是开发。要在车辆物联网系统(ICS)给「%s」加功能。\n"
-                     "get_impact 检索到该功能相关的真实代码实体（均真实存在）：\n%s\n\n"
-                     "请把以上检索结果里的实体【尽量全部逐行列出】，每行一个，直接用检索结果里的名称，"
-                     "不要自行筛选/合并/省略，不要编造。检索到几个就列几个。" % (feat, gold_ctx))
-        bP, bR, bN = score(bare, gold, UNI)
-        sP, sR, sN = score(scaff, gold, UNI)
-        rep["features"].append({"feature": feat, "gold_n": len(gold),
-                                "bare_P": bP, "bare_R": bR, "scaffold_P": sP, "scaffold_R": sR})
-        print("  %s: gold=%d | bare P=%.2f R=%.2f | scaffold P=%.2f R=%.2f" % (
-            feat, len(gold), bP, bR, sP, sR))
-    n = len(FEATURES) or 1
-    rep["agg"] = {
-        "bare_P": round(sum(f["bare_P"] for f in rep["features"]) / n, 3),
-        "scaffold_P": round(sum(f["scaffold_P"] for f in rep["features"]) / n, 3),
-        "bare_R": round(sum(f["bare_R"] for f in rep["features"]) / n, 3),
-        "scaffold_R": round(sum(f["scaffold_R"] for f in rep["features"]) / n, 3),
-    }
-    return rep
-
-
-def main():
-    import argparse
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-    r = run()
-    a = r["agg"]
-    if args.json:
-        print(json.dumps(r, ensure_ascii=False, indent=2))
-        return
-    print("\n## FW3 wl-code 变更类精准飞轮（改对实体 P / 召回 R）")
-    print("| 维度 | bare(弱模型裸) | +get_impact scaffold |")
-    print("|---|---|---|")
-    print("| 精准 P(改对·反误改) | %.1f%% | %.1f%% |" % (a["bare_P"] * 100, a["scaffold_P"] * 100))
-    print("| 召回 R(改全) | %.1f%% | %.1f%% |" % (a["bare_R"] * 100, a["scaffold_R"] * 100))
-    print("\n安全(gate_check 前置)/正确性(过测试) = 执行流维度 → 🖥️ 宿主 wl-code 真跑")
-
-
-if __name__ == "__main__":
-    main()
+"""code_flywheel.py — FW3 wl-code 变更类精准度飞轮（改对实体 / 误改率）。
+
+变更类维度(SPEC §1.1)：正确性(过测试)/安全(gate_check)/精准(改对文件-误改率)。
+本尺子量【精准】：给功能加改动，模型列"该改的代码实体"，量
+  - 精准 P = 列出的实体 ∈ KG 真实体的比例（bare 编造→低 P=误改率高；scaffold 接地→高 P）
+  - 召回 R = gold 实体被列出比例
+bare vs +get_impact grounding scaffold。安全(gate)/正确性(过测试)是执行流→🖥️。
+
+跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/code_flywheel.py
+"""
+import os
+import re
+import sys
+import json
+import time
+import urllib.request
+import urllib.error
+
+for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
+    if os.path.isdir(_p) and _p not in sys.path:
+        sys.path.insert(0, _p)
+
+from sqlalchemy import text  # noqa: E402
+from app.db import SessionLocal  # noqa: E402
+
+CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
+CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
+MODEL = "qwen-turbo"
+FEATURES = [("车辆保养提醒", "车辆"), ("考勤异常导出", "考勤"), ("保险续保预警", "保险")]
+_LINE_CLEAN = re.compile(r"^[\-\*\d\.\)、\s]+")
+_CODE_TOK = re.compile(r"[A-Za-z_][\w./\-:]{2,}")
+
+
+def chat(prompt, max_tokens=500, timeout=80):
+    body = json.dumps({"model": MODEL,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.0, "max_tokens": max_tokens}).encode()
+    for attempt in range(3):
+        try:
+            req = urllib.request.Request(CHAT_URL, data=body,
+                headers={"Authorization": f"Bearer {CHAT_KEY}", "Content-Type": "application/json"})
+            return json.loads(urllib.request.urlopen(req, timeout=timeout).read())["choices"][0]["message"]["content"]
+        except (urllib.error.URLError, TimeoutError, OSError, KeyError) as e:
+            if attempt < 2:
+                time.sleep(1.0 * (attempt + 1))
+            else:
+                return f"[ERR {repr(e)[:60]}]"
+
+
+def _q(s, sql, params=None):
+    try:
+        return s.execute(text(sql), params or {}).fetchall()
+    except Exception:
+        try:
+            s.rollback()
+        except Exception:
+            pass
+        return []
+
+
+def load_universe_and_gold():
+    """UNI=所有真实体名(canonical+cn, 精度校验); GOLD=每主题的真实体(召回校验)。"""
+    s = SessionLocal()
+    rows = _q(s, "SELECT canonical, cn FROM entities WHERE canonical IS NOT NULL")
+    UNI = set()
+    for c, n in rows:
+        if c:
+            UNI.add(c.strip())
+        if n:
+            UNI.add(n.strip())
+    GOLD = {}
+    for feat, theme in FEATURES:
+        rs = _q(s, "SELECT canonical, cn FROM entities WHERE (canonical ILIKE :p OR cn ILIKE :p) "
+                   "AND type IN ('CONTROLLER','SERVICE','FUNCTION','COLUMN','TABLE') LIMIT 20", {"p": f"%{theme}%"})
+        GOLD[feat] = [(c, n) for c, n in rs if c]
+    s.close()
+    return UNI, GOLD
+
+
+def extract_names(ans):
+    cands = set()
+    for line in ans.splitlines():
+        line = _LINE_CLEAN.sub("", line).strip()
+        if line and len(line) <= 60:
+            m = _CODE_TOK.findall(line)
+            if m:
+                cands.add(m[0])
+    return cands
+
+
+def score(ans, gold, UNI):
+    cands = extract_names(ans)
+    real = {x for x in cands if x in UNI}
+    precision = (len(real) / len(cands)) if cands else 0.0
+    hit = 0
+    for c, n in gold:
+        if (c and c in ans) or (n and n in ans):
+            hit += 1
+    recall = (hit / len(gold)) if gold else 0.0
+    return round(precision, 3), round(recall, 3), len(cands)
+
+
+def run():
+    UNI, GOLD = load_universe_and_gold()
+    rep = {"features": []}
+    for feat, theme in FEATURES:
+        gold = GOLD[feat]
+        gold_ctx = "\n".join("%s (%s)" % (c, n) for c, n in gold) or "(无)"
+        bare = chat("你是开发。要在车辆物联网系统(ICS)给「%s」加功能。\n"
+                    "逐行列出【需要修改的代码文件/Java类/方法名】，每行一个，只列确信真实存在的，不要编造。" % feat)
+        scaff = chat("你是开发。要在车辆物联网系统(ICS)给「%s」加功能。\n"
+                     "get_impact 检索到该功能相关的真实代码实体（均真实存在）：\n%s\n\n"
+                     "请把以上检索结果里的实体【尽量全部逐行列出】，每行一个，直接用检索结果里的名称，"
+                     "不要自行筛选/合并/省略，不要编造。检索到几个就列几个。" % (feat, gold_ctx))
+        bP, bR, bN = score(bare, gold, UNI)
+        sP, sR, sN = score(scaff, gold, UNI)
+        rep["features"].append({"feature": feat, "gold_n": len(gold),
+                                "bare_P": bP, "bare_R": bR, "scaffold_P": sP, "scaffold_R": sR})
+        print("  %s: gold=%d | bare P=%.2f R=%.2f | scaffold P=%.2f R=%.2f" % (
+            feat, len(gold), bP, bR, sP, sR))
+    n = len(FEATURES) or 1
+    rep["agg"] = {
+        "bare_P": round(sum(f["bare_P"] for f in rep["features"]) / n, 3),
+        "scaffold_P": round(sum(f["scaffold_P"] for f in rep["features"]) / n, 3),
+        "bare_R": round(sum(f["bare_R"] for f in rep["features"]) / n, 3),
+        "scaffold_R": round(sum(f["scaffold_R"] for f in rep["features"]) / n, 3),
+    }
+    return rep
+
+
+def main():
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--json", action="store_true")
+    args = ap.parse_args()
+    r = run()
+    a = r["agg"]
+    if args.json:
+        print(json.dumps(r, ensure_ascii=False, indent=2))
+        return
+    print("\n## FW3 wl-code 变更类精准飞轮（改对实体 P / 召回 R）")
+    print("| 维度 | bare(弱模型裸) | +get_impact scaffold |")
+    print("|---|---|---|")
+    print("| 精准 P(改对·反误改) | %.1f%% | %.1f%% |" % (a["bare_P"] * 100, a["scaffold_P"] * 100))
+    print("| 召回 R(改全) | %.1f%% | %.1f%% |" % (a["bare_R"] * 100, a["scaffold_R"] * 100))
+    print("\n安全(gate_check 前置)/正确性(过测试) = 执行流维度 → 🖥️ 宿主 wl-code 真跑")
+
+
+if __name__ == "__main__":
+    main()

package/templates/qoder/scripts/validation/eval/dispatcher_ab.py

@@ -1,156 +1,156 @@
-"""dispatcher_ab.py — T1.1 mode dispatcher A/B（飞轮：量→改→重测）。
-
-证"确定性路由表"比"判断问题类型"散文更能让【弱模型】选对检索通道（零猜测）。
-给 {弱/中/强} 模型喂【旧路由 / 新路由】+ 14 条 gold 查询，量选通道准确率。
-
-跑法（容器内）：
-  docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/dispatcher_ab.py
-"""
-import os
-import sys
-import json
-import time
-import urllib.request
-import urllib.error
-
-for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
-    if os.path.isdir(_p) and _p not in sys.path:
-        sys.path.insert(0, _p)
-
-CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
-CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
-MODELS = {"weak": "qwen-turbo", "mid": "qwen-plus", "strong": "qwen-max"}
-CHANNELS = ["get_impact", "db", "coverage_matrix", "ask_corpus", "context_pack", "search_code", "rag_search"]
-
-# 14 条 gold 查询（7 通道 × 2），覆盖确定性路由表的每个信号
-GOLD = [
-    ("改 handleExport 影响谁", "get_impact"),
-    ("波及范围分析 vehicleNo 字段", "get_impact"),
-    ("t_asset 表结构", "db"),
-    ("status 字段有哪些枚举值", "db"),
-    ("哪些功能没测试", "coverage_matrix"),
-    ("测试覆盖盲区在哪", "coverage_matrix"),
-    ("资产管理的业务流程是什么", "ask_corpus"),
-    ("这个功能整体怎么运转", "ask_corpus"),
-    ("盘点考勤有哪些代码和字段", "context_pack"),
-    ("一次取全车辆管理的代码和API", "context_pack"),
-    ("handleExport 在哪定义", "search_code"),
-    ("AppWorkCalendarController 在哪", "search_code"),
-    ("车辆保养", "rag_search"),
-    ("保险异常筛选", "rag_search"),
-]
-
-# 旧路由（"判断问题类型" 散文，原 wl-search 第一步）
-SPEC_OLD = """本命令有 3 路检索，按问题类型选最合适的一路（不是无脑 search_code）：
-- "车辆保养"相关的代码/字段/API（语义找相关）→ rag_search 语义召回
-- "业务流程是什么/整体怎么运转"（全局问答）→ ask_corpus GraphRAG 问答
-- "handleExport 这个符号在哪定义/调用"（精确符号）→ search_code 关键词
-- "XX怎么实现的"（一次取全代码+API+字段）→ context_pack
-- "改 XX 影响谁" → get_impact
-顺序铁律：理解/盘点类先 rag_search；整体流程再补 ask_corpus；精确符号才 search_code。
-（注：数据库表结构/字段/枚举 → 先 list_envs 问环境；哪些没测/覆盖盲区 → coverage_matrix）"""
-
-# 新路由（确定性首匹配表，T1.1 改后）
-SPEC_NEW = """按顺序匹配第一个命中的信号，第一个命中决定通道，不要"判断问题类型"，按表查：
-1. 含"影响谁/改XX影响/波及" → get_impact
-2. 含"表结构/字段/枚举/真实数据/查库" → db（先 list_envs 问环境）
-3. 含"哪些没测/覆盖/盲区/测试矩阵" → coverage_matrix
-4. 含"业务流程/整体怎么运转/是干嘛的" → ask_corpus（再叠 rag_search）
-5. 含"盘点/有哪些代码/一次取全" → context_pack
-6. 精确符号（camelCase/下划线/路径，如 handleExport、/asset） → search_code
-7. 以上都没命中（默认） → rag_search（语义召回最全）"""
-
-
-def chat(model, prompt, max_tokens=40, timeout=60):
-    body = json.dumps({
-        "model": model,
-        "messages": [{"role": "user", "content": prompt}],
-        "temperature": 0.0,
-        "max_tokens": max_tokens,
-    }).encode()
-    for attempt in range(3):
-        try:
-            req = urllib.request.Request(CHAT_URL, data=body,
-                headers={"Authorization": f"Bearer {CHAT_KEY}", "Content-Type": "application/json"})
-            resp = urllib.request.urlopen(req, timeout=timeout)
-            return json.loads(resp.read())["choices"][0]["message"]["content"].strip()
-        except (urllib.error.URLError, TimeoutError, OSError, KeyError) as e:
-            if attempt < 2:
-                time.sleep(1.0 * (attempt + 1))
-            else:
-                return f"[ERR {repr(e)[:60]}]"
-
-
-def _norm(ans):
-    """从短答里抽出通道名（模型可能带解释/引号/中文）。"""
-    a = ans.lower()
-    for ch in CHANNELS:
-        if ch in a:
-            return ch
-    # 容错：db 写成 list_envs / 数据库
-    if "list_envs" in a or "数据库" in ans or "查库" in ans:
-        return "db"
-    return "__none__"
-
-
-def run_spec(model, spec, spec_name, verbose=True):
-    correct = 0
-    details = []
-    for query, gold in GOLD:
-        prompt = (f"你是搜索命令 /wl-search 的路由器。严格根据下面的【路由规则】判断这条查询该用哪个检索通道。\n\n"
-                  f"【路由规则】\n{spec}\n\n"
-                  f"【查询】{query}\n\n"
-                  f"只输出一个通道名，从这些里选: {', '.join(CHANNELS)}。不要解释。")
-        ans = chat(model, prompt)
-        got = _norm(ans)
-        ok = (got == gold)
-        correct += int(ok)
-        details.append({"q": query, "gold": gold, "got": got, "ok": ok, "raw": ans[:30]})
-        if verbose:
-            print(f"    [{spec_name}] {query[:18]:<20} gold={gold:<16} got={got:<16} {'✓' if ok else '✗ '+ans[:25]}")
-    acc = correct / len(GOLD)
-    return {"acc": round(acc, 3), "correct": correct, "n": len(GOLD), "details": details}
-
-
-def run(verbose=True):
-    res = {"models": MODELS, "n": len(GOLD), "matrix": {}}
-    for tier, model in MODELS.items():
-        old = run_spec(model, SPEC_OLD, "old", verbose)
-        new = run_spec(model, SPEC_NEW, "new", verbose)
-        res["matrix"][tier] = {"old_acc": old["acc"], "new_acc": new["acc"],
-                               "gain_pp": round((new["acc"] - old["acc"]) * 100, 1)}
-        print(f"  >> {tier}({model}): old={old['acc']:.2f} new={new['acc']:.2f} "
-              f"gain={res['matrix'][tier]['gain_pp']:+.1f}pp")
-    return res
-
-
-def format_table(res):
-    m = res["matrix"]
-    lines = ["## T1.1 dispatcher A/B（选对通道准确率：旧'判断问题类型' vs 新'确定性表'）", "",
-             "| 模型档 | 旧路由 acc | 新路由 acc | 增益 |",
-             "|---|---|---|---|"]
-    for tier in MODELS:
-        c = m[tier]
-        lines.append(f"| {tier}({MODELS[tier]}) | {c['old_acc']:.1%} | {c['new_acc']:.1%} | {c['gain_pp']:+.1f}pp |")
-    lines.append("")
-    weak_gain = m["weak"]["gain_pp"]
-    weak_new_vs_strong_old = (m["weak"]["new_acc"] - m["strong"]["old_acc"]) * 100
-    lines.append(f"- 弱模型增益: **{weak_gain:+.1f}pp**（确定性表让弱模型选对更多）")
-    lines.append(f"- 弱模型+新路由 vs 强模型+旧路由: **{weak_new_vs_strong_old:+.1f}pp**（>0=弱模型借确定性表追上/反超）")
-    return "\n".join(lines)
-
-
-def main():
-    import argparse
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-    res = run()
-    if args.json:
-        print(json.dumps(res, ensure_ascii=False, indent=2))
-    else:
-        print("\n" + format_table(res))
-
-
-if __name__ == "__main__":
-    main()
+"""dispatcher_ab.py — T1.1 mode dispatcher A/B（飞轮：量→改→重测）。
+
+证"确定性路由表"比"判断问题类型"散文更能让【弱模型】选对检索通道（零猜测）。
+给 {弱/中/强} 模型喂【旧路由 / 新路由】+ 14 条 gold 查询，量选通道准确率。
+
+跑法（容器内）：
+  docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/dispatcher_ab.py
+"""
+import os
+import sys
+import json
+import time
+import urllib.request
+import urllib.error
+
+for _p in ("/app", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))):
+    if os.path.isdir(_p) and _p not in sys.path:
+        sys.path.insert(0, _p)
+
+CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
+CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
+MODELS = {"weak": "qwen-turbo", "mid": "qwen-plus", "strong": "qwen-max"}
+CHANNELS = ["get_impact", "db", "coverage_matrix", "ask_corpus", "context_pack", "search_code", "rag_search"]
+
+# 14 条 gold 查询（7 通道 × 2），覆盖确定性路由表的每个信号
+GOLD = [
+    ("改 handleExport 影响谁", "get_impact"),
+    ("波及范围分析 vehicleNo 字段", "get_impact"),
+    ("t_asset 表结构", "db"),
+    ("status 字段有哪些枚举值", "db"),
+    ("哪些功能没测试", "coverage_matrix"),
+    ("测试覆盖盲区在哪", "coverage_matrix"),
+    ("资产管理的业务流程是什么", "ask_corpus"),
+    ("这个功能整体怎么运转", "ask_corpus"),
+    ("盘点考勤有哪些代码和字段", "context_pack"),
+    ("一次取全车辆管理的代码和API", "context_pack"),
+    ("handleExport 在哪定义", "search_code"),
+    ("AppWorkCalendarController 在哪", "search_code"),
+    ("车辆保养", "rag_search"),
+    ("保险异常筛选", "rag_search"),
+]
+
+# 旧路由（"判断问题类型" 散文，原 wl-search 第一步）
+SPEC_OLD = """本命令有 3 路检索，按问题类型选最合适的一路（不是无脑 search_code）：
+- "车辆保养"相关的代码/字段/API（语义找相关）→ rag_search 语义召回
+- "业务流程是什么/整体怎么运转"（全局问答）→ ask_corpus GraphRAG 问答
+- "handleExport 这个符号在哪定义/调用"（精确符号）→ search_code 关键词
+- "XX怎么实现的"（一次取全代码+API+字段）→ context_pack
+- "改 XX 影响谁" → get_impact
+顺序铁律：理解/盘点类先 rag_search；整体流程再补 ask_corpus；精确符号才 search_code。
+（注：数据库表结构/字段/枚举 → 先 list_envs 问环境；哪些没测/覆盖盲区 → coverage_matrix）"""
+
+# 新路由（确定性首匹配表，T1.1 改后）
+SPEC_NEW = """按顺序匹配第一个命中的信号，第一个命中决定通道，不要"判断问题类型"，按表查：
+1. 含"影响谁/改XX影响/波及" → get_impact
+2. 含"表结构/字段/枚举/真实数据/查库" → db（先 list_envs 问环境）
+3. 含"哪些没测/覆盖/盲区/测试矩阵" → coverage_matrix
+4. 含"业务流程/整体怎么运转/是干嘛的" → ask_corpus（再叠 rag_search）
+5. 含"盘点/有哪些代码/一次取全" → context_pack
+6. 精确符号（camelCase/下划线/路径，如 handleExport、/asset） → search_code
+7. 以上都没命中（默认） → rag_search（语义召回最全）"""
+
+
+def chat(model, prompt, max_tokens=40, timeout=60):
+    body = json.dumps({
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.0,
+        "max_tokens": max_tokens,
+    }).encode()
+    for attempt in range(3):
+        try:
+            req = urllib.request.Request(CHAT_URL, data=body,
+                headers={"Authorization": f"Bearer {CHAT_KEY}", "Content-Type": "application/json"})
+            resp = urllib.request.urlopen(req, timeout=timeout)
+            return json.loads(resp.read())["choices"][0]["message"]["content"].strip()
+        except (urllib.error.URLError, TimeoutError, OSError, KeyError) as e:
+            if attempt < 2:
+                time.sleep(1.0 * (attempt + 1))
+            else:
+                return f"[ERR {repr(e)[:60]}]"
+
+
+def _norm(ans):
+    """从短答里抽出通道名（模型可能带解释/引号/中文）。"""
+    a = ans.lower()
+    for ch in CHANNELS:
+        if ch in a:
+            return ch
+    # 容错：db 写成 list_envs / 数据库
+    if "list_envs" in a or "数据库" in ans or "查库" in ans:
+        return "db"
+    return "__none__"
+
+
+def run_spec(model, spec, spec_name, verbose=True):
+    correct = 0
+    details = []
+    for query, gold in GOLD:
+        prompt = (f"你是搜索命令 /wl-search 的路由器。严格根据下面的【路由规则】判断这条查询该用哪个检索通道。\n\n"
+                  f"【路由规则】\n{spec}\n\n"
+                  f"【查询】{query}\n\n"
+                  f"只输出一个通道名，从这些里选: {', '.join(CHANNELS)}。不要解释。")
+        ans = chat(model, prompt)
+        got = _norm(ans)
+        ok = (got == gold)
+        correct += int(ok)
+        details.append({"q": query, "gold": gold, "got": got, "ok": ok, "raw": ans[:30]})
+        if verbose:
+            print(f"    [{spec_name}] {query[:18]:<20} gold={gold:<16} got={got:<16} {'✓' if ok else '✗ '+ans[:25]}")
+    acc = correct / len(GOLD)
+    return {"acc": round(acc, 3), "correct": correct, "n": len(GOLD), "details": details}
+
+
+def run(verbose=True):
+    res = {"models": MODELS, "n": len(GOLD), "matrix": {}}
+    for tier, model in MODELS.items():
+        old = run_spec(model, SPEC_OLD, "old", verbose)
+        new = run_spec(model, SPEC_NEW, "new", verbose)
+        res["matrix"][tier] = {"old_acc": old["acc"], "new_acc": new["acc"],
+                               "gain_pp": round((new["acc"] - old["acc"]) * 100, 1)}
+        print(f"  >> {tier}({model}): old={old['acc']:.2f} new={new['acc']:.2f} "
+              f"gain={res['matrix'][tier]['gain_pp']:+.1f}pp")
+    return res
+
+
+def format_table(res):
+    m = res["matrix"]
+    lines = ["## T1.1 dispatcher A/B（选对通道准确率：旧'判断问题类型' vs 新'确定性表'）", "",
+             "| 模型档 | 旧路由 acc | 新路由 acc | 增益 |",
+             "|---|---|---|---|"]
+    for tier in MODELS:
+        c = m[tier]
+        lines.append(f"| {tier}({MODELS[tier]}) | {c['old_acc']:.1%} | {c['new_acc']:.1%} | {c['gain_pp']:+.1f}pp |")
+    lines.append("")
+    weak_gain = m["weak"]["gain_pp"]
+    weak_new_vs_strong_old = (m["weak"]["new_acc"] - m["strong"]["old_acc"]) * 100
+    lines.append(f"- 弱模型增益: **{weak_gain:+.1f}pp**（确定性表让弱模型选对更多）")
+    lines.append(f"- 弱模型+新路由 vs 强模型+旧路由: **{weak_new_vs_strong_old:+.1f}pp**（>0=弱模型借确定性表追上/反超）")
+    return "\n".join(lines)
+
+
+def main():
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--json", action="store_true")
+    args = ap.parse_args()
+    res = run()
+    if args.json:
+        print(json.dumps(res, ensure_ascii=False, indent=2))
+    else:
+        print("\n" + format_table(res))
+
+
+if __name__ == "__main__":
+    main()