@hupan56/wlkj 3.3.14 → 3.3.16

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

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""metrics_dashboard.py - T1.7 通用维度度量汇总（token/反复搜/幻觉/完成率 → §9.1 目标进度）。
+
+聚合 T1.0 gradient_matrix + T1.1 dispatcher_ab 的真实测量数据，输出 §9.1 达标进度表。
+诚实标注：哪些是 API 代理已测（token/幻觉/召回/路由），哪些需宿主真跑（13命令×5任务全表/真 tool_call 计数）。
+
+跑法:
+  python scripts/validation/eval/metrics_dashboard.py
+  python scripts/validation/eval/metrics_dashboard.py --json
+"""
+import json
+import os
+import sys
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+
+
+def _load(name):
+    p = os.path.join(_HERE, name)
+    try:
+        with open(p, encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def build():
+    grad = _load("gradient_matrix_baseline_2026-07-21.json")
+    disp = _load("dispatcher_ab_2026-07-21.json")
+    rows = []
+    notes = []
+
+    if grad:
+        m = grad["matrix"]
+        # §9.1 幻觉率 <5%：+grounding 后三档都达标；裸跑 ~98% 反证 grounding 必要
+        for tier in ("weak", "mid", "strong"):
+            h_scaffold = m[f"{tier}/scaffold"]["H"]
+            ok = h_scaffold < 0.05
+            rows.append(("幻觉率<5%% (+grounding, %s)" % tier, "%.1f%%" % (h_scaffold * 100),
+                         "✓" if ok else "✗", "代理测(wl-search类)"))
+        # §9.1 低模型梯度：weak+工作流 ≥ strong裸-10pp（精度口径）
+        weak_scaffold_p = m["weak/scaffold"]["P"]
+        strong_bare_p = m["strong/bare"]["P"]
+        diff_pp = (weak_scaffold_p - strong_bare_p) * 100
+        rows.append(("低模型梯度: weak+grounding P vs strong+bare P", "%+.1fpp" % diff_pp,
+                     "✓" if diff_pp >= -10 else "✗", "代理测(卖点铁证 +92.9pp)"))
+        # §9.1 各命令完成率 ≥85%：scaffold 召回 R 作近似
+        for tier in ("weak", "mid", "strong"):
+            r = m[f"{tier}/scaffold"]["R"]
+            ok = r >= 0.85
+            rows.append(("完成率≥85%% (召回R, %s+scaffold)" % tier, "%.1f%%" % (r * 100),
+                         "✓" if ok else "✗(短板~80%)", "代理测; 飞轮杠杆=检索升级"))
+        notes.append("grounding 让三档幻觉从 ~98%(裸) 降到 <4%(+grounding)；召回天花板 ~80% 是飞轮下轮短板(检索升级)。")
+    else:
+        rows.append(("gradient_matrix 基线", "缺", "?", "先跑 gradient_matrix.py"))
+        notes.append("gradient_matrix_baseline_2026-07-21.json 未找到。")
+
+    if disp:
+        dm = disp["matrix"]
+        # T1.1 dispatcher: 新路由准确率（弱模型）
+        weak_new = dm["weak"]["new_acc"]
+        rows.append(("dispatcher 路由准确率 (weak+新表)", "%.1f%%" % (weak_new * 100),
+                     "✓" if weak_new >= 0.95 else "✗", "代理测(T1.1 +14.3pp→100%)"))
+        notes.append("确定性路由表让弱模型选对通道 85.7%→100%（旧'判断问题类型'散文的 2 个系统性误差被修）。")
+    else:
+        rows.append(("dispatcher_ab 基线", "缺", "?", "先跑 dispatcher_ab.py"))
+
+    # §9.1 token ≤裸×0.8 / tool_call ≤裸×0.7：命令层维度，需宿主真 transcript
+    rows.append(("token +工作流≤裸×0.8", "待测", "🖥️", "宿主真命令 transcript (T1.2瘦身/T1.3缓存降)"))
+    rows.append(("反复搜 tool_call +工作流≤裸×0.7", "待测", "🖥️", "宿主 transcript 计 MCP 调用数"))
+    rows.append(("13命令×≥5任务全表", "待测", "🖥️", "宿主 qwork_harness 跑全命令矩阵"))
+    notes.append("token/tool_call/13命令全表 = B类宿主真跑（qwork_harness.py 已备），代理测不了真 agent-loop tool_call 计数。")
+
+    return {"rows": rows, "notes": notes,
+            "targets_source": "SPEC §9.1",
+            "measured_by_proxy": "幻觉率/召回/低模型梯度/dispatcher准确率（gradient_matrix+dispatcher_ab）",
+            "needs_host": "token节省/tool_call计数/13命令全表（qwork_harness 真跑）"}
+
+
+def format_table(r):
+    lines = ["## T1.7 度量汇总 — §9.1 目标进度", "",
+             "| 指标 | 实测 | 达标 | 来源 |", "|---|---|---|---|"]
+    for name, val, ok, src in r["rows"]:
+        lines.append("| %s | %s | %s | %s |" % (name, val, ok, src))
+    lines.append("")
+    lines.append("**洞察**:")
+    for n in r["notes"]:
+        lines.append("- " + n)
+    lines.append("")
+    lines.append("**代理已测**: " + r["measured_by_proxy"])
+    lines.append("**需宿主**: " + r["needs_host"])
+    return "\n".join(lines)
+
+
+def main():
+    r = build()
+    if "--json" in sys.argv:
+        print(json.dumps(r, ensure_ascii=False, indent=2))
+    else:
+        print(format_table(r))
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,118 @@
+"""multi_turn_flywheel.py — FW8 多轮飞轮（§1.2 ⑩ 跨轮上下文复用/准确性）。
+
+多轮场景：turn1「列出 X 相关实体」→ turn2「从上面里选 Controller」。量 turn2 是否正确
+【复用 turn1 结果】(非重查/非编造)。bare(turn2 无 turn1 上下文,盲猜) vs +turn1上下文(复用)。
+准确 = turn2 选的 Controller ∈ turn1 真实 Controller 集。
+
+跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/multi_turn_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"
+THEMES = ["考勤", "保险", "车辆"]
+
+
+def chat(messages, max_tokens=400, timeout=80):
+    body = json.dumps({"model": MODEL, "messages": messages,
+        "temperature": 0.0, "max_tokens": max_tokens}).encode()
+    for a 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 a < 2: time.sleep(1.0*(a+1))
+            else: return f"[ERR {repr(e)[:50]}]"
+
+
+def _q(s, sql, p=None):
+    try: return s.execute(text(sql), p or {}).fetchall()
+    except Exception:
+        try: s.rollback()
+        except Exception: pass
+        return []
+
+
+def turn1_entities(theme, k=20):
+    """turn1 检索到的真实实体(模拟工作流 turn1 结果)。返 [(canonical,cn,type)]。"""
+    s = SessionLocal()
+    rows = _q(s, "SELECT canonical, cn, type FROM entities WHERE (canonical ILIKE :p OR cn ILIKE :p) "
+                "AND type IN ('CONTROLLER','SERVICE','FUNCTION','TABLE') LIMIT :n", {"p": f"%{theme}%", "n": k})
+    s.close()
+    return [(c, n, t) for c, n, t in rows if c]
+
+
+def filter_accuracy(ans, gold_controllers):
+    """turn2 答案是否正确选出 turn1 的 Controller。返 (命中gold数, 编造数)。"""
+    gold_names = {c for c, _, _ in gold_controllers}
+    hit = sum(1 for c in gold_names if c in ans)
+    # 编造 = ans 里的 CamelCase 标识符不在 turn1 全集
+    return hit, len(gold_names)
+
+
+def run():
+    rep = {"themes": []}
+    for th in THEMES:
+        ents = turn1_entities(th, 20)
+        controllers = [e for e in ents if e[2] == "CONTROLLER"]
+        turn1_list = "\n".join("%s (%s) [%s]" % (c, n, t) for c, n, t in ents)
+        turn2_q = "从上面列出的实体里，选出所有类型是 Controller 的，逐行列出名称。"
+
+        # bare: turn2 无 turn1 上下文（盲猜，会重查/编造）
+        bare = chat([{"role": "user", "content": f"列出 ICS 系统「{th}」相关的 Controller 类名。"}])
+        # scaffold: 多轮——turn1 结果作 assistant 上下文，turn2 复用
+        scaff = chat([
+            {"role": "user", "content": f"列出 ICS 系统「{th}」相关的实体。"},
+            {"role": "assistant", "content": "相关实体：\n" + turn1_list},
+            {"role": "user", "content": turn2_q},
+        ])
+        b_hit, gold_n = filter_accuracy(bare, controllers)
+        s_hit, _ = filter_accuracy(scaff, controllers)
+        bR = round(b_hit / max(gold_n, 1), 3)
+        sR = round(s_hit / max(gold_n, 1), 3)
+        rep["themes"].append({"theme": th, "turn1_n": len(ents), "controller_n": gold_n,
+                              "bare_recall": bR, "scaffold_recall": sR})
+        print("  %s: turn1实体=%d(其中Controller=%d) | bare命中Controller=%.2f | +多轮复用=%.2f" % (
+            th, len(ents), gold_n, bR, sR))
+    n = len(THEMES) or 1
+    rep["agg"] = {"bare_recall": round(sum(t["bare_recall"] for t in rep["themes"])/n, 3),
+                  "scaffold_recall": round(sum(t["scaffold_recall"] for t in rep["themes"])/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## FW8 多轮飞轮（turn2 复用 turn1 上下文，选 Controller 召回）")
+    print("| 模式 | Controller 召回 R |")
+    print("|---|---|")
+    print("| bare(turn2 盲猜，无 turn1) | %.1f%% |" % (a["bare_recall"]*100))
+    print("| +多轮(turn1 上下文复用) | %.1f%% |" % (a["scaffold_recall"]*100))
+    met = a["scaffold_recall"] >= 0.85
+    print("\n多轮达标(≥85%%)?" , "✓" if met else "✗ → 续转(更强 turn2 复用指令)")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,128 @@
+"""prd_fidelity_flywheel.py — FW9 PRD 业务保真度飞轮（vs 真实 ICS schema，非结构代理）。
+
+用户根因：之前 FW2 量的是"6 章齐"（结构），不是"PRD 是不是这个业务的"（保真）。
+本尺子量 **schema 保真**：PRD 引用的表/列是不是 ICS 真实业务表列(db_tables/db_columns)，
+而非泛泛/编造。bare(无 schema grounding→编造表名) vs +真schema grounding(喂真表真列)。
+保真率 = PRD 提的表/列 ∈ 真实 schema 的比例；召回 = 该功能真表被提的比例。
+
+（原型颜色保真=eval_prd A2 读宿主真色板，云 KG 无设计系统表→那格 🖥️ 宿主；本尺子量可代理的 schema 保真）
+
+跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/prd_fidelity_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 = [("车辆保险管理", "保险"), ("异常记录管理", "异常"), ("合同维护", "合同")]
+# 表名 token（t_xxx / tb_xxx / report_xxx 等）
+_TABLE_RE = re.compile(r'\b(t_[a-z_]+|tb_[a-z_]+|report_[a-z_]+|salary_[a-z_]+|[a-z]+_[a-z_]+_table)\b', re.IGNORECASE)
+
+
+def chat(prompt, max_tokens=900, timeout=90):
+    body = json.dumps({"model": MODEL, "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.2, "max_tokens": max_tokens}).encode()
+    for a 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 a < 2: time.sleep(1.0*(a+1))
+            else: return f"[ERR {repr(e)[:50]}]"
+
+
+def _q(s, sql, p=None):
+    try: return s.execute(text(sql), p or {}).fetchall()
+    except Exception:
+        try: s.rollback()
+        except Exception: pass
+        return []
+
+
+def real_schema(theme):
+    """该功能的真实业务表(db_tables) + 列(db_columns) = 业务保真 gold。"""
+    s = SessionLocal()
+    tabs = [r[0] for r in _q(s, "SELECT table_name FROM db_tables WHERE table_name ILIKE :p OR table_comment ILIKE :p LIMIT 15", {"p": f"%{theme}%"})]
+    cols = [r[0] for r in _q(s, "SELECT column_name FROM db_columns WHERE column_name ILIKE :p OR column_comment ILIKE :p LIMIT 15", {"p": f"%{theme}%"})]
+    all_tabs = set(r[0] for r in _q(s, "SELECT table_name FROM db_tables"))  # 全量真表(保真校验集)
+    s.close()
+    return tabs, cols, all_tabs
+
+
+def extract_tables(prd):
+    return set(m.lower() for m in _TABLE_RE.findall(prd))
+
+
+def fidelity(prd, gold_tabs, all_tabs):
+    """保真率 = PRD 提的表 ∈ 真实 schema 的比例；召回 = gold 表被提的比例。"""
+    mentioned = extract_tables(prd)
+    if not mentioned:
+        return 0.0, 0.0, 0
+    real_mentioned = mentioned & all_tabs
+    precision = len(real_mentioned) / len(mentioned)  # 保真：提的表是真的比例
+    recall = len(mentioned & set(t.lower() for t in gold_tabs)) / max(len(gold_tabs), 1)  # 召回：gold 表被提
+    return round(precision, 3), round(recall, 3), len(mentioned)
+
+
+def run():
+    rep = {"features": []}
+    for feat, theme in FEATURES:
+        gtabs, gcols, all_tabs = real_schema(theme)
+        schema_ctx = "真实业务表:\n" + "\n".join(gtabs[:12]) + "\n真实业务列:\n" + ", ".join(gcols[:12])
+        bare = chat(f"你是产品经理。为 ICS 系统「{feat}」写 PRD（含字段设计/数据表）。直接输出正文。")
+        scaff = chat(f"你是 ICS(车辆物联网)产品经理。为「{feat}」写 PRD（含字段设计/数据表）。\n"
+                     f"【业务 schema 接地】以下是该功能的真实业务表/列（均为真实存在）：\n{schema_ctx}\n"
+                     f"铁律：字段设计/数据表章节【必须把上面列出的真实业务表全部引用】，用真实表名，勿编造/勿省略。"
+                     f"直接输出 PRD 正文。")
+        bP, bR, bN = fidelity(bare, gtabs, all_tabs)
+        sP, sR, sN = fidelity(scaff, gtabs, all_tabs)
+        rep["features"].append({"feature": feat, "gold_tabs": len(gtabs),
+                                "bare_fidelity": bP, "bare_recall": bR, "bare_mentioned": bN,
+                                "scaffold_fidelity": sP, "scaffold_recall": sR, "scaffold_mentioned": sN})
+        print("  %s: gold表=%d | bare 保真=%.2f 召回=%.2f(提%d) | scaffold 保真=%.2f 召回=%.2f(提%d)" % (
+            feat, len(gtabs), bP, bR, bN, sP, sR, sN))
+    n = len(FEATURES) or 1
+    rep["agg"] = {
+        "bare_fidelity": round(sum(f["bare_fidelity"] for f in rep["features"])/n, 3),
+        "scaffold_fidelity": round(sum(f["scaffold_fidelity"] for f in rep["features"])/n, 3),
+        "bare_recall": round(sum(f["bare_recall"] for f in rep["features"])/n, 3),
+        "scaffold_recall": round(sum(f["scaffold_recall"] 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## FW9 PRD 业务保真度飞轮（PRD 提的表 vs 真实 ICS schema）")
+    print("| 维度 | bare(无schema接地) | +真schema接地 |")
+    print("|---|---|---|")
+    print("| 保真率(提的表是真的) | %.0f%% | %.0f%% |" % (a["bare_fidelity"]*100, a["scaffold_fidelity"]*100))
+    print("| 召回(gold真表被提) | %.0f%% | %.0f%% |" % (a["bare_recall"]*100, a["scaffold_recall"]*100))
+    print("\n业务保真=PRD 引用的是 ICS 真实业务表(t_insurance_log 等),非编造/泛泛。"
+          "bare 编造表名→保真低；scaffold 接真 schema→保真高。")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,148 @@
+"""prd_flywheel.py — FW2 wl-prd 生成类质量飞轮（完整性/准确性 → 目标）。
+
+生成类维度(SPEC §1.1)：完整性(必要段数) / 准确性(gold 对齐) / 可用性(EVA≥80%)。
+飞轮：弱模型(bare prompt) vs +wl-prd scaffold(6章强制 + KG grounding) → 量
+  - 完整性 = 6 章命中 / 6（QUICK_SECTIONS，纯 regex）
+  - 现实锚定 = PRD 里出现的【KG 真实体名】数（bare 编造→少；scaffold 接地→多）
+→ 改 scaffold（强制章 + 接地）→ 重量 → 直到 完整性=6/6 + 锚定≥阈值。
+
+云端跑（DashScope 生 + PG 真实体）。eval_prd.py 是宿主 DuckDB 侧，本尺子是其云端同构代理。
+跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/prd_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"  # 弱模型（卖点：弱模型+工作流）
+QUICK_SECTIONS = ["功能入口", "需求背景", "需求说明", "影响范围", "验收标准", "不在本次范围"]
+FEATURES = ["车辆保养提醒", "考勤异常导出", "保险续保预警"]
+
+
+def chat(prompt, max_tokens=900, timeout=90):
+    body = json.dumps({"model": MODEL,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.2, "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 real_entities(theme, k=15):
+    """KG 里该主题的真实实体 (canonical, cn)（现实锚定 gold）。"""
+    s = SessionLocal()
+    rows = _q(s, "SELECT canonical, cn FROM entities WHERE (canonical ILIKE :p OR cn ILIKE :p) "
+                "AND canonical IS NOT NULL LIMIT :n", {"p": f"%{theme}%", "n": k})
+    s.close()
+    return [(r[0], r[1]) for r in rows if r[0]]
+
+
+def completeness(prd_text):
+    """6 章命中数（regex，接受 #/##/粗体/裸文本）。"""
+    hit = 0
+    for sec in QUICK_SECTIONS:
+        if re.search(r'#{0,3}\s*\*{0,2}' + sec, prd_text):
+            hit += 1
+    return hit
+
+
+def reality_anchor(prd_text, reals):
+    """PRD 里出现的 KG 真实体数（canonical 或 cn 命中任一即算；cn 中文名更易在散文出现）。"""
+    n = 0
+    for canon, cn in reals:
+        if (canon and canon in prd_text) or (cn and cn in prd_text):
+            n += 1
+    return n
+
+
+def gen_bare(feature):
+    return (f"你是产品经理。为「{feature}」功能写一份 PRD 需求文档。\n"
+            f"直接输出 PRD 正文。")
+
+
+def gen_scaffold(feature, grounding):
+    return (f"你是车辆物联网系统(ICS)的产品经理。为「{feature}」写一份 PRD。\n"
+            f"知识图谱检索到该功能相关的真实系统对象（字段/类/接口，均为真实存在）：\n{grounding}\n\n"
+            f"**铁律**：PRD 必须【完整含以下 6 章，每章一个 ## 标题，缺一不可】：\n"
+            f"## 功能入口\n## 需求背景\n## 需求说明\n## 影响范围\n## 验收标准\n## 不在本次范围\n"
+            f"PRD 里的字段名/接口名【必须用上面检索到的真实名称】，不要编造。直接输出 PRD 正文。")
+
+
+def run():
+    rep = {"model": MODEL, "features": []}
+    for feat in FEATURES:
+        reals = real_entities(feat.split("提醒")[0].split("导出")[0].split("预警")[0] or feat, 15)
+        ctx = "\n".join("%s (%s)" % (c, n) for c, n in reals[:15]) if reals else "(无检索结果)"
+        bare = chat(gen_bare(feat))
+        scaff = chat(gen_scaffold(feat, ctx))
+        b_cmp = completeness(bare)
+        s_cmp = completeness(scaff)
+        b_real = reality_anchor(bare, reals)
+        s_real = reality_anchor(scaff, reals)
+        rep["features"].append({"feature": feat, "real_n": len(reals),
+                                "bare_completeness": b_cmp, "scaffold_completeness": s_cmp,
+                                "bare_reality": b_real, "scaffold_reality": s_real})
+        print("  %s: 完整性 bare=%d/6 scaff=%d/6 | 锚定 bare=%d scaff=%d (gold=%d)" % (
+            feat, b_cmp, s_cmp, b_real, s_real, len(reals)))
+    n = len(FEATURES) or 1
+    rep["agg"] = {
+        "bare_completeness": round(sum(f["bare_completeness"] for f in rep["features"]) / n, 2),
+        "scaffold_completeness": round(sum(f["scaffold_completeness"] for f in rep["features"]) / n, 2),
+        "bare_reality": round(sum(f["bare_reality"] for f in rep["features"]) / n, 2),
+        "scaffold_reality": round(sum(f["scaffold_reality"] for f in rep["features"]) / n, 2),
+    }
+    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## FW2 wl-prd 生成类飞轮（完整性 6/6 + 现实锚定）")
+    print("| 维度 | bare(弱模型裸) | +wl-prd scaffold | 目标 |")
+    print("|---|---|---|---|")
+    print("| 完整性(章/6) | %.2f | %.2f | 6.0 |" % (a["bare_completeness"], a["scaffold_completeness"]))
+    print("| 现实锚定(真实体命中) | %.2f | %.2f | 高 |" % (a["bare_reality"], a["scaffold_reality"]))
+    cmp_met = a["scaffold_completeness"] >= 6.0
+    print("\n完整性达标(≥6/6)?" , "✓" if cmp_met else "✗ → 下轮：强章模板/Stop hook 拦缺章")
+    print("锚定提升:", "%+.2f" % (a["scaffold_reality"] - a["bare_reality"]), "(scaffold 接地 vs bare 编造)")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,166 @@
+"""prototype_fidelity_flywheel.py — FW9 原型保真度飞轮（vs 真实 fywl-ui 设计系统）。
+
+用户根因例子："原型保真不保真"。本尺子量：生成原型的颜色/组件是不是 fywl-ui 真设计系统的
+(get_design_system 返回的真色板 hsl(214,86%,59%)/真组件/真layout)，而非泛泛 #409eff 蓝或编造组件。
+bare(无设计系统接地→通用色/编造组件) vs +真设计系统接地(用真 hsl 色板/真组件)。
+color保真率 = 原型颜色∈真色板比例；component保真率 = 真组件占比。
+
+跑法: docker exec -i wlinkj-workspace-backend-1 python /app/scripts/validation/eval/prototype_fidelity_flywheel.py
+"""
+import os
+import re
+import sys
+import json
+import colorsys
+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 app.routers import mcp_handlers as H  # noqa: E402
+try:
+    H._init_handlers()
+except Exception:
+    pass
+
+CHAT_URL = os.environ.get("ALI_CHAT_BASE", "").rstrip("/") + "/chat/completions"
+CHAT_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
+MODEL = "qwen-turbo"
+PAGES = ["车辆保险列表页", "异常记录表单页", "合同维护详情页"]
+_NEUTRAL = {(255, 255, 255), (0, 0, 0), (51, 51, 51), (102, 102, 102), (153, 153, 153),
+            (240, 240, 240), (250, 250, 250), (217, 217, 217), (232, 232, 232), (245, 245, 245)}
+
+
+def chat(prompt, max_tokens=1200, timeout=90):
+    body = json.dumps({"model": MODEL, "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.2, "max_tokens": max_tokens}).encode()
+    for a 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 a < 2: time.sleep(1.0*(a+1))
+            else: return ""
+
+
+def real_design():
+    """fywl-ui 真设计系统：色板(rgb 集) + 真组件名 + layout。"""
+    r = H.dispatch("get_design_system", {}) or {}
+    proj = next((p for p in r.get("projects", []) if p.get("project") == "fywl-ui"), {})
+    colors = proj.get("colors", {}) or {}
+    palette_rgb = set()
+    for v in colors.values():
+        if isinstance(v, str) and v.startswith("hsl"):
+            m = re.match(r"hsl\(\s*([\d.]+)[,\s]+([\d.]+)%[,\s]+([\d.]+)%", v)
+            if m:
+                h, s, l = float(m.group(1)) / 360.0, float(m.group(2)) / 100.0, float(m.group(3)) / 100.0
+                r_, g_, b_ = colorsys.hls_to_rgb(h, l, s)
+                palette_rgb.add((round(r_ * 255), round(g_ * 255), round(b_ * 255)))
+    comps = set()
+    for d in (proj.get("commonComponents", {}), proj.get("formComponents", {})):
+        if isinstance(d, dict):
+            comps.update(k.lower() for k in d.keys())
+    return palette_rgb, comps, proj
+
+
+def extract_colors(html):
+    """提取 HTML 里的颜色(#hex/hsl/rgb)→ rgb 集合。"""
+    out = set()
+    for m in re.findall(r"#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})\b", html):
+        h = m if len(m) == 6 else m * 2
+        out.add((int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)))
+    for m in re.findall(r"hsl\(\s*([\d.]+)[,\s]+([\d.]+)%[,\s]+([\d.]+)%", html):
+        h, s, l = float(m[0]) / 360.0, float(m[1]) / 100.0, float(m[2]) / 100.0
+        r_, g_, b_ = colorsys.hls_to_rgb(h, l, s)
+        out.add((round(r_ * 255), round(g_ * 255), round(b_ * 255)))
+    for m in re.findall(r"rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)", html):
+        out.add((int(m[0]), int(m[1]), int(m[2])))
+    return out
+
+
+def extract_components(html):
+    """提取 HTML 里的组件标签(el-xxx/van-xxx/a-xxx 等)。"""
+    return set(m.lower() for m in re.findall(r"<(?:el|van|a|n|iview|ant)-([\w-]+)", html))
+
+
+def near(c1, c2, tol=40):
+    return all(abs(a - b) <= tol for a, b in zip(c1, c2))
+
+
+def color_fidelity(html, palette_rgb):
+    cols = extract_colors(html)
+    if not cols:
+        return 0.0, 0
+    real = sum(1 for c in cols if any(near(c, p) for p in palette_rgb) or c in _NEUTRAL)
+    return round(real / len(cols), 3), len(cols)
+
+
+def comp_fidelity(html, real_comps):
+    comps = extract_components(html)
+    if not comps:
+        return 0.0, 0
+    if not real_comps:
+        return 1.0, len(comps)  # 无真组件集则不罚
+    real = sum(1 for c in comps if c in real_comps)
+    return round(real / len(comps), 3), len(comps)
+
+
+def run():
+    palette, comps, proj = real_design()
+    print("  真色板 rgb:", list(palette)[:4], "| 真组件:", list(comps)[:8])
+    rep = {"pages": []}
+    for pg in PAGES:
+        bare = chat(f"画一个 {pg} 的 HTML 原型（单文件，含表格/表单/按钮，内联样式）。直接输出 HTML。")
+        ds = ("fywl-ui 真设计系统：主色 hsl(214,86%,59%) 成功 hsl(100,54%,49%) 警告 hsl(36,100%,64%) "
+              "危险 hsl(0,100%,68%) 圆角 0.25rem 布局 mixed-nav 侧栏 160px；"
+              "组件用 ElementPlus(el-table/el-form/el-button/el-input/el-select/el-pagination)。")
+        # BF4 杠杆：CSS 变量注入（:root 定义真色板 + 强制 var() 用色 → 颜色全是色板色）
+        cssvar = ("<style>:root{--primary:hsl(214,86%,59%);--success:hsl(100,54%,49%);"
+                  "--warning:hsl(36,100%,64%);--danger:hsl(0,100%,68%);--text:#333;--border:#d9d9d9;--bg:#f5f5f5}</style>")
+        scaff = chat(f"画一个 {pg} 的 HTML 原型（单文件，内联样式）。\n"
+                     f"【设计系统接地，必须保真】：{ds}\n"
+                     f"⚠️ 颜色铁律（CSS 变量）：把这段 {cssvar} 放在 <head>，"
+                     f"所有 color/background/border 【必须用 var(--primary)/var(--success)/var(--warning)/var(--danger)/var(--text)/var(--border)/var(--bg)】，"
+                     f"【禁止】写任何裸 hex/hsl 色值（#409eff 等一律不许）；组件用 el-xxx。直接输出 HTML。")
+        bP, bN = color_fidelity(bare, palette)
+        sP, sN = color_fidelity(scaff, palette)
+        bC, _ = comp_fidelity(bare, comps)
+        sC, _ = comp_fidelity(scaff, comps)
+        rep["pages"].append({"page": pg, "bare_color": bP, "scaffold_color": sP,
+                             "bare_comp": bC, "scaffold_comp": sC})
+        print("  %s: 颜色保真 bare=%.0f%% scaff=%.0f%% | 组件保真 bare=%.0f%% scaff=%.0f%%" % (
+            pg, bP*100, sP*100, bC*100, sC*100))
+    n = len(PAGES) or 1
+    rep["agg"] = {
+        "bare_color": round(sum(p["bare_color"] for p in rep["pages"])/n, 3),
+        "scaffold_color": round(sum(p["scaffold_color"] for p in rep["pages"])/n, 3),
+        "bare_comp": round(sum(p["bare_comp"] for p in rep["pages"])/n, 3),
+        "scaffold_comp": round(sum(p["scaffold_comp"] for p in rep["pages"])/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## FW9 原型保真度飞轮（vs 真实 fywl-ui 设计系统）")
+    print("| 维度 | bare(无设计接地) | +真设计系统接地 |")
+    print("|---|---|---|")
+    print("| 颜色保真(色∈真fywl-ui色板) | %.0f%% | %.0f%% |" % (a["bare_color"]*100, a["scaffold_color"]*100))
+    print("| 组件保真(用真el-组件) | %.0f%% | %.0f%% |" % (a["bare_comp"]*100, a["scaffold_comp"]*100))
+    print("\n保真=原型是 fywl-ui 真样子(真色板/真组件/真layout),非通用蓝/编造组件。bare 通用→低保真;scaffold 接真→高保真。")
+
+
+if __name__ == "__main__":
+    main()