guanlan-src/scripts/windscada_serve.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""windscada serve (M7c): 交互后端 — 工作台(全场)+分台页, 全部带时间窗.
设计: ①台页只渲染"有问题的系统"的证据图(分册两型: A=判据线+摆幅标注, B=本台vs全场四分位带), 无问题不出图;
②台内交互查询: 任一契约通道×时间窗×聚合 即时出图; ③工作台: 系统分类问题(全系统)+故障统计梳理+SOP控制策略;
④时间窗: 月度类数据真窗; 判级类(变桨/偏航/蓄能=近90日, 曲线=2025H2判别窗)固定窗如实标注.
端口 8033. 判级=筛查级/候选, P级归综合报告线."""
import sys as _sys, pathlib as _plb
_sys.path.insert(0, str(_plb.Path(__file__).resolve().parents[1]))
from src import paths as P
import sys, json, pathlib, re, threading, urllib.parse, collections
import hashlib, time
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))     # 安装根入 sys.path (先于 src.* 导入)
from src import paths as _P                                              # 路径唯一真源 (与 cwd 无关)
import numpy as np, pandas as pd
import math

def _jclean(o):
    """NaN/Inf → null (非法 JSON 防线; pd.DataFrame 会把 None 变 NaN)."""
    if isinstance(o, float) and (math.isnan(o) or math.isinf(o)): return None
    if isinstance(o, dict): return {k: _jclean(v) for k, v in o.items()}
    if isinstance(o, (list, tuple)): return [_jclean(x) for x in o]
    return o

# ── 客户交付脱敏 (2026-08-28 demo 门禁逮出 7 处特征频率 + 21 处判据门槛上屏) ──
# 规则来自 memory client-deliverable-hide-core-parameters: 判据名与实测值可见, 数值门槛与特征频率隐去。
# 分级而非一刀切 — 一刀切会把业主必须知道的口径也糊掉:
#   脱  特征频率 (134.9Hz 是我们解出来的轴承几何, 属核心参数)
#   脱  判据门槛 (≥40kW / |z|≥3 / ≥2.5× — 我们的判别阈值)
#   留  时间口径 (≥1h 段 / ≥3 天 — 业主要据此理解统计范围)
#   留  物理常数 (Cp ≤ 0.593 贝兹极限 — 公开知识, 不是我们的)
#   留  台数与占比 (≥2 个系统报警 — 业主自己数得出来)
# 内部模式: WINDSCADA_INTERNAL=1
import os as _os
INTERNAL = _os.environ.get('WINDSCADA_INTERNAL', '') == '1'
# ★ Hz 后不能用 \b: 中文属于 \w, "597Hz线" 里 z 与 线 之间没有词边界 ⇒ \b 不成立, 实测漏脱 WTG05 的 597Hz。
# ★ 前瞻也不能用 \w: 中文同属 \w, "HS_gen测点274Hz" 里 274 前是"点" ⇒ 断言失败漏脱。
# 只需排除数字与小数点 (防止把 1274 截成 274)。
_RE_HZ = re.compile(r'(?<![\d.])\d+(?:\.\d+)?\s*(?=Hz)')
_KEEP_UNIT = ('h', '小时', '天', '日', '月', '年', '台', '次', '条', '起', '个')
# ★ 判据符号前缀: |z|≥3 / σ≥2 / ×≥2.5 这类无单位阈值必须脱 —
#   否则会被"无单位小整数=计数口径"那条规则放行 (实测 |z|≥3 漏脱)。
_RE_THR = re.compile(r'([≥≤])\s*(\d+(?:\.\d+)?)\s*([a-zA-Z%℃×/·²]*)')
_CRIT_MARK = ('z', 'σ', '×', '倍', 'dev', 'resid', '选择性', '峰', '结构度', 'ratio')


def _redact_text(t):
    if INTERNAL or not isinstance(t, str) or not t:
        return t
    if '0.593' in t or '贝兹' in t or 'Betz' in t:      # 物理常数不动
        return _RE_HZ.sub('▪▪', t)
    t = _RE_HZ.sub('▪▪', t)

    def _th(m):
        sign, num, unit = m.group(1), m.group(2), m.group(3) or ''
        pre = t[max(0, m.start() - 8):m.start()]
        if any(c in pre for c in _CRIT_MARK):          # |z|≥3 / ×≥2.5 = 判据阈值, 必脱
            return f'{sign}▪{unit}'
        if unit in _KEEP_UNIT or (not unit and float(num) <= 10 and float(num) == int(float(num))):
            return m.group(0)          # 时间/计数口径保留 (≥1h段 / ≥2 个系统)
        return f'{sign}▪{unit}'
    return _RE_THR.sub(_th, t)


def _redact(o):
    if INTERNAL:
        return o
    if isinstance(o, str):
        return _redact_text(o)
    if isinstance(o, dict):
        return {k: _redact(v) for k, v in o.items()}
    if isinstance(o, list):
        return [_redact(v) for v in o]
    return o


# ── 语言投影 (2026-08-31) ────────────────────────────────────────────
# 诊断: 骨架页 HTML 里**一个中文字都没有** (实测 0 字符), 内容全部由 JS 从 API 拉取,
#       而 API 不认 lang —— 所以"英文版"拿到的一直是中文数据。此前三轮翻译 HTML 源码,
#       改的是一个没有内容的文件, 这是英文残留反复修不好的真正原因。
# 修法: 在 API 唯一出口 _jdump 上做文本层投影。**不带 lang 时原样返回**, 中文版行为零变化。
_REQ = threading.local()
try:
    from src.ontology import codes as _codes
except Exception:                                  # 码表缺失不应让服务起不来
    _codes = None


def _lang_of():
    return getattr(_REQ, 'lang', '') or ''


def _enum_fallback(field, value, lang):
    """枚举值映射不出码时的回落 —— **走翻译, 不留中文**。

    根因 (2026-08-31 实测): `part` 这类字段被当成枚举, 但它在工单里其实是**现场手写的
    自由文本** ('齿轮箱高速轴' / 'IGBT、直流保险' / '(振动线未收录)' / '无')。码表只有 18 条,
    覆盖不了; 而 normalize 失败时原实现**原样返回中文**, 于是英文页上直接显示中文。
    把这些硬塞进码表是错的 —— 它们不是枚举语义, 是描述。正确做法是让它们走翻译层。
    查不到才留原文 (不猜译)。
    """
    if lang == 'zh' or not isinstance(value, str) or not value.strip():
        return value
    try:
        from windscada import en_text as _et
    except Exception:
        return value
    for scope in (field, 'part', None):
        try:
            en, _src = _et.lookup(value, scope) if scope else _et.lookup(value)
        except Exception:
            en = None
        if en:
            return en
    return value


# ★这些字段 **不翻译** —— 它们是 JS 的判别值与查表键, 不是给人读的文案。
#   翻了会静默劈叉: 页面上看不出错, 但整段内容消失或整片颜色变灰。
#   2026-09-02 线上实测 (用户逮「有问题的看不见? 只有 good」):
#     · st 被翻成 Alarm  → `rows.filter(r=>r.st==='报警')` 零命中 → **报警 12 台整表不渲染**,
#       而柱状条读的是 sysdist (**键**没被翻) 仍显示 "Alarm 12" ⇒ 数字与明细自相矛盾。
#     · ostate 被翻成 Good/Excellent → `C[c.ostate]` (C 是中文键) 全部 MISS
#       → 融合矩阵**每一格颜色都退成灰**。
#   判据: 凡是 JS 里 `X[obj.字段]` 查中文键表、或 `obj.字段==='中文'` 比较的字段, 一律进本表。
#   显示层 (ui_en.value_script) 负责把渲染出来的中文文本换成英文, 所以人看到的仍是英文。
#   tests/test_keep_zh_discriminators.py 扫源码断言本表齐全, 防以后加字段漏登记。
_KEEP_ZH = frozenset((
    'st', 'ostate', 'wlevel', '状态', '设备状态', '证据状态', '部件', 'liveness',
    'loc',      # 模型本地/云端档位: `v.loc==='本地'` 决定"数据不出本地"这句能不能说
    # ★第三类判别用法, 本闸的扫描器 (tests/test_keep_zh_discriminators.py) 抓不到:
    #   不是比较也不是查表, 而是拼进 URL 路径当 ID (`/problem/${t}/${encodeURIComponent(x)}`)。
    #   syss 被翻成 'Yaw' 后, 浮层请求 sys=Yaw 永远查不到烤的是 sys=偏航 的快照键,
    #   点开必是"本窗无记录"——页面不报错, 数据静默消失, 和 st/ostate 那两类同一后果不同机制。
    #   2026-09-03 用户实测逮出 (Watch list → 系统名链接)。显示文字仍由 sysName(x) 客户端译。
    'syss',
))

# ★按**值**豁免 —— 给 `k` 这种一名多用的字段用。
#   `k` 在告警排行里是显示串 (`"7122 偏航液压油位低"`, 要翻),
#   在控制状态与部件配色里是枚举键 (`'停机'` / `'齿轮箱'`, 不能翻)。
#   键名分不开两者, 只能按值。2026-09-02 实测: 我先把 'k' 整个放进 _KEEP_ZH,
#   结果**报警名全部不再翻译** —— 修一个洞挖一个洞, 按值豁免才收得住边界。
#   来源: JS 里 CO / LOSSPLAIN 两张中文键表的键 + `x.k==='停机'` 比较。
_KEEP_ZH_VALS = frozenset((
    '齿轮箱', '发电机', '主轴承', '变桨叶片', '偏航', '测风', '其他',            # CO 配色键
    '限电·绑定', '限电命令·未绑定', '停机(调度令)', '停机', '正常发电', '低风待机',  # LOSSPLAIN 键
))


def _proj(o, lang):
    """把 `key_zh`/`key_en` 投影成裸 `key`。

    英文侧取不到 `_en` 时写 `[translation pending]` 而**不回落中文** ——
    回落会让缺口永远不被发现, 正是英文版残留三轮没被逮住的机制。
    """
    if isinstance(o, list):
        return [_proj(x, lang) for x in o]
    if not isinstance(o, dict):
        return o
    suf = '_' + lang
    other = '_zh' if lang == 'en' else '_en'
    # ★裸 `zh` / `en` 成对 (framework.py 的 SYSTEMS/RECORDS/stages 就是这个写法)。
    #   它们不带下划线, 走不到下面的后缀规则; 而末尾"残留中文一律写 [translation pending]"
    #   的兜底会把 zh 打成 pending —— **旁边的 en 明明就是对的**。实测 145 处 pending
    #   里的大多数是这一种。消费端 JS 读的是 `.zh`, 所以英文版把 en 的值投影到 zh 上。
    if lang != 'zh' and isinstance(o, dict) and 'zh' in o and 'en' in o:
        o = dict(o, zh=o['en'])
    # ★只有 k_en **有值**时才让裸 k 让位 (2026-09-01 parity 闸逮)。
    #   原来无条件让位: 上游给了 action_en=None, 裸 action 就被顶成 None ——
    #   页面上显示 "None", 比留中文糟得多。空的语言副本等于没给, 不该覆盖原值。
    out = {}
    source_fields = {'name', '步骤', '故障', '排查', '原因', '处置', 'check'}
    originals = {key: o.get(key + '_zh', o.get(key)) for key in source_fields} if lang == 'en' else {}
    originals = {key: value for key, value in originals.items() if isinstance(value, str) and _CJK.search(value)}
    langed = {k[:-len(suf)] for k in o if k.endswith(suf) and o[k] not in (None, '', [])}
    for k, v in o.items():
        if k == '_original':
            out[k] = dict(v) if isinstance(v, dict) else v
            continue
        if k.endswith(other):                      # 另一语言的副本不出 API
            continue
        if k.endswith(suf):
            if v not in (None, '', []):
                out[k[:-len(suf)]] = _proj(v, lang)
            continue
        if k in langed:                            # 已有 key_<lang>, 裸 key 让位
            continue
        v2 = _proj(v, lang)
        if k in _KEEP_ZH or (isinstance(v2, str) and v2 in _KEEP_ZH_VALS):
            out[k] = v2                            # 判别值/查表键: 原样留中文 (见 _KEEP_ZH 注释)
            continue
        # 枚举层先查码表 — 这些值有确定译名, 不该退化成 [translation pending]。
        # 列表型枚举 (如 facets) 逐项查。
        if lang != 'zh' and _codes is not None and k in _codes.CODES:
            if isinstance(v2, str):
                c = _codes.normalize(k, v2)
                if c:
                    v2 = _codes.label(k, c, lang)
                else:
                    v2 = _enum_fallback(k, v2, lang)
            elif isinstance(v2, list):
                v2 = [(_codes.label(k, _codes.normalize(k, x), lang)
                       if isinstance(x, str) and _codes.normalize(k, x) else x) for x in v2]
        # 单数字段名对应复数码表 (facet ← facets) 也走一遍
        elif lang != 'zh' and _codes is not None and k.rstrip('s') in _codes.CODES:
            f = k.rstrip('s')
            if isinstance(v2, str):
                c = _codes.normalize(f, v2)
                if c:
                    v2 = _codes.label(f, c, lang)
            elif isinstance(v2, list):
                v2 = [(_codes.label(f, _codes.normalize(f, x), lang)
                       if isinstance(x, str) and _codes.normalize(f, x) else x) for x in v2]
        # ★这里原来只判 isinstance(v2, str) —— **字符串列表整个绕过了英文投影**。
        #   _proj 递归进 list, 但 _proj(str) 原样返回, 所以 ["偏航","变桨"] 这种
        #   一路穿到 API。实测漏掉 5 条路径 (parts[] / syss[] / srcs[] /
        #   open_items[] / blind[]), 是英文页数据层残留中文的唯一来源。
        if lang == 'en':
            # Action counts use display labels as dictionary keys, so _en_deep
            # cannot reach them. Only this display map uses the established
            # work-order action glossary; all other dictionary/URL IDs stay put.
            if k == '动作统计' and isinstance(v2, dict):
                from src.windscada.maint.workorder_en import ACTION
                v2 = {ACTION.get(action) or action: count for action, count in v2.items()}
            v2 = _en_deep(v2, k)
        out[k] = v2
    for key, original in originals.items():
        if key in out and out[key] != original:
            out.setdefault('_original', {})[key] = original
    return out



def _en_deep(v, field='', _depth=0):
    """对字符串与**字符串列表/嵌套列表**一律走 _data_text_en。

    只对 str 生效的旧写法会让 list-of-str 静默穿透 —— 这类漏法的特征是
    "抽查单值全对, 页面上却成片中文", 因为漏的是容器不是值。
    """
    if isinstance(v, str):
        return _data_text_en(v, field) if _CJK.search(v) else v
    if isinstance(v, list) and _depth < 4:
        return [_en_deep(x, field, _depth + 1) for x in v]
    return v


_DATA_EN_CACHE = {}
_DATA_EN_MISS = set()     # 查不到的原文集合 (与命中缓存分开: 未命中的返回值随请求模式而异)


def _data_text_en(v, field=''):
    """数据层中文文本 → 英文。取不到才写 [translation pending]。

    ★为什么要有这一层: 原实现是"残留中文一律 [translation pending]" —— 干净但过于绝对。
    实测 /api/fleet 一次就打出 **2199 处** pending, 而其中大量是厂商报警名、工单原文、
    部件名、判级词, 这些在本项目里**已经有译源**: 厂商中英对照表 3834 条、IPC 部件表
    2113 条、枚举码表、工单名构词表。不查就直接标 pending, 等于把已有的资产扔掉,
    还让英文页看起来像没做完。

    查不到仍写 pending —— **不猜译**。这条不能松: 猜译出来的厂商报警名会误导现场。
    """
    if v in _DATA_EN_CACHE:
        return _DATA_EN_CACHE[v]
    if v in _DATA_EN_MISS:
        return v if getattr(_REQ, 'keep_orig', False) else '[translation pending]'
    out = None
    # ⓪⁻ 数据层**整串**直译表 (融合面盲区/未决项长文)。放在最前: 这些是整段人写的
    #     分析结论, 走模板反解或分层词表都只会碎成片段。
    try:
        from src.windscada import data_tpl_en as _tplN
        out = getattr(_tplN, 'NOTES', {}).get(v)
        if out is None:
            from src.windscada.en_text import standard_term
            out = standard_term(v)
        if out is None:
            out = getattr(_tplN, 'RECORD_EN', {}).get(v)
    except Exception:
        out = None
    if out is not None:
        _DATA_EN_CACHE[v] = out
        return out
    # ⓪ 「码 + 中文描述」→ 本体 AlarmCode 的权威 name_en (查表, 不翻译)
    try:
        from src.windscada import en_text as _et0
        out = _et0.alarm_en(v)
    except Exception:
        out = None
    if out is not None:
        _DATA_EN_CACHE[v] = out
        return out
    # ① 服务端拼串走**模板反解** (精确, 非翻译): 抽数字得形态 → 查英文模板 → 数字按序填回
    try:
        from src.windscada import data_tpl_en as _tpl
        out = _tpl.render(v)
    except ValueError as e:
        print('[_data_text_en] 模板占位符对不上, 已跳过不填: %s' % e, file=sys.stderr)
        out = None
    except Exception:
        out = None
    if out is not None:
        _DATA_EN_CACHE[v] = out
        return out
    try:
        from src.windscada import en_text as _et
        # ① 分层查表 (厂商报警 → IPC 部件 → 枚举/文案)
        for sc in ('fault', 'part', 'ui', None):
            hit, _src = _et.lookup(v, sc) if sc else _et.lookup(v)
            if hit:
                out = hit
                break
        # ② 部件自由文本解析 (复合名/带注解/多部件连写)
        if out is None:
            out = _et.part_en(v)
    except Exception:
        pass
    # ②b 词表直查 —— 部件名/判级词/系统名作为**独立字段**出现时 (fus.表[].部件 / .振动结论 /
    #     rel.表[].部件), 既不是模板串也不在 en_text 分层表里, 而 data_tpl_en 的
    #     CHAN/GRADE2/SYSTEM_EN 早就登记了同一批词 (供模板内部用)。不查就整片留中文
    #     (2026-09-03 实逮 fus.表 328 字)。**同一批词只因出现位置不同就译不出, 是接线漏不是词条漏。**
    if out is None:
        try:
            from src.windscada import data_tpl_en as _t2
            out = _t2.CHAN.get(v) or _t2.SYSTEM_EN.get(v)
            if out is None:
                g = _t2.GRADE2.get(v) or _t2.GRADE.get(v)
                if g:                              # 判级词在表里是小写短语 (模板内嵌用), 独立成字段要首字母大写
                    out = g[0].upper() + g[1:]
        except Exception:
            pass
    if out is None:
        try:
            from src.windscada.maint import workname_en as _wn
            # ★只用 work_name_en (逐段都命中才拼, 命不中返回 None), **不用 category_en**。
            #   category_en 是正则归类兜底: 它对看不懂的文本也会给出一个"像样"的答案。
            #   实测它把化验样注记译成 work item:
            #     '末样2025-01-09 (距振动现窗>12月, stale: 只作检测链回测)'
            #        → 'Condition monitoring — work item'   ← 错, 那不是工单
            #     '末样2026-07-13: 华标判正常(NB/T宽限); 重点值…'
            #        → 'Generator — work item'              ← 错且误导
            #   我在本函数的说明里写了"不猜译"然后把猜译器接了进来。
            #   **看得懂就译, 看不懂就标 pending —— pending 是诚实的, 猜译不是。**
            out = _wn.work_name_en(v)
        except Exception:
            pass
    if out:
        _DATA_EN_CACHE[v] = out
        return out
    # 查不到: 经典页写 [translation pending] (显示层再藏); v2 (keep=1) **留原文** —— 前端按原文
    # 标注为"手册原文", 不丢信息也不冒充英文。命中与未命中分开缓存, 两种模式互不污染。
    _DATA_EN_MISS.add(v)
    return v if getattr(_REQ, 'keep_orig', False) else '[translation pending]'


def maint_framework_view():
    """运维管理体系三维骨架 —— **唯一实现** (在线 API 与快照预烤共用)。

    ★同 dq_findings_view 的教训: 这段原来也是两份, 在线那份我接了 unmapped_top 的
    英文化, 预烤那份没有 ⇒ 在线干净、快照里还是中文, 而上云的是快照。
    抽出来一次, 消掉这类"改了一半"的可能。
    """
    import json as _j, pathlib as _p
    from src.windscada.maint import framework as _fw
    db = _j.loads(_P.objects_json().read_text(encoding='utf-8'))
    wo = [(v.get('props') or {}) for k, v in db.items() if k.startswith('workorder/')]
    r = dict(systems=_fw.system_load(wo)['rows'], tiers=_fw.systems_by_tier(),
             stages=_fw.stage_matrix(), records=_fw.RECORDS,
             gaps=_fw.capability_gaps(wo), coverage=_fw.coverage(wo))
    # unmapped_top = **未映射到系统码的现场手写部件名**, 不是枚举, 码表投影对它无效。
    # 走 part_en 自由文本解析; 空值在这个语境下写 "(not recorded)" 而非破折号。
    lang = _lang_of()
    if lang and lang != 'zh' and (r.get('gaps') or {}).get('unmapped_top'):
        try:
            from src.windscada import en_text as _et
            out = []
            for it in r['gaps']['unmapped_top']:
                if isinstance(it, (list, tuple)) and len(it) == 2:
                    e = _et.part_en(it[0]) or it[0]
                    out.append(['(not recorded)' if e == '\u2014' else e, it[1]])
                else:
                    out.append(it)
            r['gaps'] = dict(r['gaps'], unmapped_top=out)
        except Exception as e:
            print('[maint_framework_view] unmapped_top 英文化失败: %s' % e, file=sys.stderr)
    return r


def dq_findings_view():
    """数据可信度 finding 行 —— **唯一实现**。

    ★2026-08-31: 这段原来存在两份 —— 一份在 /api/dq_findings 处理分支, 一份在快照的
    `_dq()` 预烤闭包里。我给 API 那份补了 sensitivity / age_basis 等字段, 预烤那份没动
    ⇒ **在线看得到, 快照里没有**。而上云交付的恰恰是快照。
    同型教训已在 memory `library-gate-not-wired-to-production`: 落库不等于接上生产路径。
    这里直接消掉重复: 两边都调本函数。
    """
    import json as _j, pathlib as _p
    db = _j.loads(_P.objects_json().read_text(encoding='utf-8'))
    KEEP = ('finding/data_quality/', 'finding/caliber/',
            'finding/system_coverage/', 'finding/tier_trend/')
    rows = []
    for k, o in db.items():
        if not k.startswith(KEEP) or not isinstance(o, dict):
            continue
        p2 = o.get('props') or {}
        rows.append(dict(
            id=k, kind=k.split('/')[1],
            name=p2.get('name_zh') or p2.get('name'),
            name_zh=p2.get('name_zh') or p2.get('name'),
            name_en=p2.get('name_en'),
            grade=p2.get('grade'), claim_window=p2.get('claim_window'),
            evidence=p2.get('evidence_zh') or p2.get('evidence') or [],
            evidence_zh=p2.get('evidence_zh') or [],
            evidence_en=p2.get('evidence_en') or [],
            caveat=p2.get('caveat'), caveat_en=p2.get('caveat_en'),
            impact=p2.get('discriminator_zh') or p2.get('disposition_zh')
                   or p2.get('implication_zh') or p2.get('corrected_comparison_zh'),
            impact_en=p2.get('discriminator_en') or p2.get('disposition_en')
                   or p2.get('implication_en') or p2.get('corrected_comparison_en'),
            got_wrong=p2.get('what_i_got_wrong_zh'),
            got_wrong_en=p2.get('what_i_got_wrong_en'),
            quality_flag=p2.get('quality_flag_zh'), quality_flag_en=p2.get('quality_flag_en'),
            robust=p2.get('robust_zh'), robust_en=p2.get('robust_en'),
            basis=p2.get('basis_zh'), basis_en=p2.get('basis_en'),
            sensitivity=(p2.get('sensitivity') or {}).get('note_zh'),
            sensitivity_en=(p2.get('sensitivity') or {}).get('note_en'),
            age_basis=p2.get('age_basis_zh'), age_basis_en=p2.get('age_basis_en'),
        ))
    rows.sort(key=lambda x: (x['kind'] != 'data_quality', x['id']))
    r = dict(rows=rows, n=len(rows))
    if not rows:
        # ★2026-09-18 用户令("页面只能基于输入数据重算")之后实逮: 清过产物再重算的机器上
        #   `objects.json` 里 **0 条 finding/* 对象** ⇒ 本页只是"空", 不说原因就等于让人以为
        #   "系统自查没问题"。这四族的生成端确实不在重算链上(见族表 guanlan/ontology 说明),
        #   所以如实写清, 并明确"不用旧版产出补"。
        r['note'] = ('本体对象库里没有 finding/* 对象 (四族: data_quality / caliber / system_coverage / '
                     'tier_trend) ⇒ 本页**如实为空**, 不是"自查无发现"。这些 finding 的生成端不在重算链上'
                     '(唯一写方 scripts/ingest_ops_2025.py 的输入 data/raw/工作库 不在现场数据里), '
                     '运行期不从交付包补齐(用户令 2026-09-17); 要出件须研发补生成端。')
    return r


def _en_page(page):
    """lang=en 时把页面文案换成英文。**中文版不经过这里** (lang 空 → 直接返回原页)。

    用的是 ui_en 的**整条短语表**, 不是 i18n_en 的逐词词表 —— 后者会产出
    "Verification 状态机" 这类混杂串 (已实测作废)。缺条目由 ui_en.audit 报出,
    不静默留在页面上。
    """
    lang = _lang_of()
    if not lang or lang == 'zh':
        return page
    try:
        from src.windscada import ui_en
        page = ui_en.apply(page)
        # ★译后语法闸: 保护规则一松一紧都能把 JS 译坏, 而症状是**空白骨架页** ——
        #   此时"可见中文=0", 自查全绿。必须用外部解析器判, 不能靠数引号。
        for _m in re.finditer(r'<script[^>]*>(.*?)</script>', page, re.S):
            _code = _m.group(1)
            if _code.strip() and 'application/json' not in _m.group(0):
                ui_en.check_js(_code, label='英文页内联脚本')
        # 数据值 (报警/定论/工单…) 既做比较又要显示。比较照旧用中文, 显示层在 render
        # 之后替换文本节点 —— 只碰显示不碰逻辑, 所以判断不会失效。
        return page.replace('</body>', ui_en.value_script() + '</body>') \
            if '</body>' in page else page + ui_en.value_script()
    except Exception as e:
        # ★退回中文页比给个坏页安全, 但**必须响亮** —— 静默退回会让"英文版没做完"
        #   看起来像"英文版做完了只是有中文残留"。守护步骤失败必须可见。
        print('[_en_page] 🔴 英文化失败, 已退回中文页: %s: %s' % (type(e).__name__, e),
              file=sys.stderr)
        return page


def _jdump(obj, **kw):
    o = _redact(_jclean(obj))
    lang = _lang_of()
    if lang and lang != 'zh':                      # 中文版走这行以外的路径, 一字不动
        o = _proj(o, lang)
    return json.dumps(o, allow_nan=False, **kw)


def _gap_page(path: str, missing: 'pathlib.Path | None' = None, what: str = '这一块') -> str:
    r"""产物缺失时的兜底页 (2026-09-17 现场问题驱动)。

    原来 `/static/…`、`/turbines/…` 取不到文件就回一个裸 `404` 文本 —— 浏览器里表现为**一块空白**,
    用户看到的现象是"这个板块没有信息", 而不是"缺件"。最典型的就是总览页那个
    `<iframe src="/static/index.html">`(全场状态总览页)。

    ★2026-09-19 更新 (用户令「所有的计算均要形成观澜的源代码」): 该页**已有生成端** ——
    `scripts/windscada_overview_build.py`（用组件同一个快照烘焙器从重算产物生成), 重算链第 ⑦b 步会跑它,
    所以现在"不在位"只意味着**还没重算**, 不再是"包内没有生成端"。本页说明文字已据此改写。

    现在改成结构化说明: 缺哪一件、它归哪条产物线、**怎么补**、去哪儿看全局状态。
    口径与 CMS 的"无产物"页一致 (docs §11.4: 无产物时必须还能打开页面, 且要写明缺件与补齐办法)。
    """
    import html as _h
    rel = ''
    try:
        rel = pathlib.Path(missing).relative_to(pathlib.Path(_P.ROOT)).as_posix() if missing else ''
    except Exception:
        rel = str(missing or '')
    return ('<!doctype html><meta charset="utf-8"><title>产物不在位</title>'
            '<style>body{font:14px/1.7 system-ui,"Microsoft YaHei",sans-serif;color:#183548;background:#f2f6f8;'
            'margin:0;display:flex;align-items:center;justify-content:center;min-height:100vh}'
            '.b{background:#fff;border:1px solid #d4e3e7;border-radius:10px;padding:22px 26px;max-width:800px;'
            'box-shadow:0 6px 20px rgba(14,74,87,.08)}h1{font-size:17px;margin:0 0 10px}'
            'code{background:#eef4f6;border-radius:4px;padding:1px 5px}.s{color:#667f8e;font-size:13px}'
            'a{color:#087f89}li{margin:3px 0}</style>'
            f'<div class="b"><h1>{_h.escape(what)}的数据产物不在位</h1>'
            f'<p class="s">请求路径 <code>{_h.escape(path)}</code></p>'
            + (f'<p>缺的是 <code>{_h.escape(rel)}</code>（属 <code>outputs/&lt;场站&gt;/</code> 下的产物）。</p>'
               if rel else '')
            + '<p>两种情形分开补:</p><ul>'
            '<li><b>有生成端的产物</b>（alarms / workorders / temp_monthly / 振动窗索引谱 / '
            '<code>windscada/index.html</code> …）: 放好 '
            '<code>data/raw/&lt;场站&gt;/</code> 后跑 <code>python scripts/rebuild_all.py</code>, '
            '或点运维控制台的「数据重算」。</li>'
            '<li><b>仍缺生成端的那几族</b>（如 <code>sop/</code>、<code>paradigm_r1/</code> 里的人工底稿、'
            '<code>windcms/</code> 的厂家报告转录）: 按用户令 2026-09-19「所有的计算均要形成观澜的源代码」'
            '正在逐族补（清单见 <code>docs/源代码化清单_v0.1.md</code>）; 在此之前页面如实显示缺件, '
            '且按用户令 2026-09-17 <b>运行期不从交付包补齐</b>。'
            '（2026-09-19 已补上生成端的: 变桨面 <code>pitch/**</code> ← <code>scripts/pitch_face_build.py</code>; '
            '振动在升/闭环 <code>m5_cms_tcm/component_history.json</code>、三层基线 <code>baseline_38.json</code> '
            '← <code>scripts/component_history_build.py</code> / <code>scripts/baseline_38_build.py</code>; '
            '事实契约 <code>guanlan/**</code> ← 重算台账生成 claim; '
            '发布层 <code>ontology/release_r1|r2</code> ← <code>scripts/ontology_release_build.py</code>。）</li></ul>'
            '<p class="s">逐件来源见 <code>outputs/&lt;场站&gt;/_provenance.json</code>；'
            '缺口清单见 <code>docs/系统设计说明.md</code> §7 与 docs/重算缺口与补件清单_v0.1.md。</p>'
            '<p><a href="/v2" target="_top">← 返回工作台</a> · '
            '<a href="http://127.0.0.1:28084/ops" target="_top">运维控制台 · 数据重算</a> · '
            '<a href="http://127.0.0.1:28084/healthz" target="_top">全部模块状态</a></p></div>')

from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
from src.windscada.config import farm
from src.windscada import taxonomy
from src.windscada.subsys import temp_nbm, hydraulic, yaw as yawmod, pitch as pitchmod
from src.windscada.perf import availability
from src.windscada import i18n

CFG = farm(); ST = pathlib.Path(CFG['store'])
_CJK = re.compile(r'[\u4e00-\u9fff]')


def vibcms_results():
    """windcms 评估报告 → 结果层转录 (2026-08-28 用户令: 生接改融合·只显示结果·模型与计算隐藏).
    取最新一期报告md; '融合级(模型)/CMS红黄'两列=模型输出, 不出结果层; 分析功能留独立cms.

    ★2026-09-18 用户令"页面只能基于输入数据重算、不许用旧版产出补"之后实逮: 清过产物再重算的机器上
    `windcms/` 里没有 `报告_CMS振动状态评估报告_*.md`, 于是 `sorted(glob)[-1]` 抛
    **IndexError: list index out of range**, 页面看到的是"windcms 报告解析失败: list index out of range"
    —— 与 `ProductsMissing` 的教训同一个病: **缺产物被报成了程序坏了**。现在按缺产物如实回结构化的
    `no_report`, 并写清它由谁生成。★2026-09-19 再修: 报告步的生成端(`scripts/windcms.py report`)与它的
    上游(`rudong_model_run.py`/`rudong_fusion_run.py`)都已随包并上链, 缺件只剩"还没重算到那一步"这一个原因,
    故这里再附一句"重算是否正在跑"(读 run/ops_job.json), 免得把"正在跑"读成"系统坏了"。
    """
    reps = sorted(ST.parent.glob('windcms/报告_CMS振动状态评估报告_*.md'))
    if not reps:
        # ★2026-09-19 修: 原话还写着"本包六层链的 model_run/fusion 两步脚本未随包" —— 那两步已在
        #   2026-09-19 按口径重建并上链(scripts/rudong_model_run.py / rudong_fusion_run.py), 话说反了。
        #   真实原因只有两种: ① 重算还没走到 ④b 的报告步(清过产物后这一步要跑很久); ② windcms 产物被清且未重算。
        try:
            from src import opsjob as _oj
            _run = (' ' + _oj.running_text()) if _oj.running_text() else ''
        except Exception:
            _run = ''
        return dict(date=None, overall='', action=[], grades=[], diff=dict(only_cms=[], only_handoff=[]),
                    no_report=True,
                    note_zh='本机没有 CMS 振动状态评估报告 (由重算链 ④b 的 report 步生成: '
                            'python scripts/windcms.py report)。如实为空, 不用旧版产出补。' + _run,
                    err='无产物: windcms/报告_CMS振动状态评估报告_*.md 不在位')
    try:
        rp = reps[-1]
        md = rp.read_text(encoding='utf-8')       # 不写 encoding 会按系统 locale(cp936) 读 → 中文报告乱码
        date = rp.stem.rsplit('_', 1)[-1]
        overall = ''
        if '### 3.1' in md:
            seg = md.split('### 3.1')[1].split('###')[0]
            overall = next((l.strip() for l in seg.splitlines() if l.strip().startswith('全场')), '')
        def _tab(sec):
            return [[c.strip() for c in l.strip('|').split('|')] for l in sec.splitlines() if l.startswith('| WTG')]
        action = _tab(md.split('### 3.2')[1].split('## ')[0]) if '### 3.2' in md else []
        grades = []
        if '## 附录 A' in md:
            for r in _tab(md.split('## 附录 A')[1]):
                # 列: 机组/前/后/齿/发/综合/融合级(模型·隐)/CMS红黄(隐)/行动
                grades.append(dict(t=r[0], 主轴承前=r[1], 主轴承后=r[2], 齿轮箱=r[3], 发电机=r[4],
                                   综合=r[5], 行动=r[8] if len(r) > 8 else ''))
        # 与融合矩阵(handoff 定谳链)口径差异台
        from src.windscada.subsys import fusion as _f
        ft, _ = _f.fusion_table()
        hset = {r.turbine for _, r in ft.iterrows() if _f.verdict_class(str(r.振动结论))[1] in ('bad', 'warn')}
        cset = {r[0] for r in action}
        diff = dict(only_cms=sorted(cset - hset), only_handoff=sorted(hset - cset))
        # ★2026-09-19: 把**这个窗真实覆盖的日期区间**一并回给页面。原来只回 date(出件日) 与表格,
        #   页面上看不到"数据从哪天到哪天" ⇒ 用户拿 2026-03~04 的导出却只看到 4 月的谱时,
        #   无法判断是"数据没呈现"还是"源件本身就那么点"(实测源件最早只到 2026-03-16, 逐台更晚)。
        _span, _win = '', ''
        try:
            from src.windcms import config as _wcfg, data as _wdata
            _w2 = _wcfg.farm(str(CFG.get('key') or 'rudong'))
            _span = _wdata.span_text(_w2) or ''
            _win = ','.join(_wdata.windows(_w2))
        except Exception:
            _span = _win = ''
        return dict(date=date, overall=overall, action=action, grades=grades, diff=diff,
                    时间范围=_span, 窗=_win)
    except Exception as e:
        return dict(error=f'windcms 报告解析失败: {e}')  # 响亮, 不静默空表

LOCK = threading.Lock()
_CACHE = {}


# ── 产物指纹 → **运行中自动重载** (2026-09-16 用户令: "重算后的产物可即时用于页面呈现") ──────
# 背景 (实测): _load() 把产物**一次性**读进内存, 之后只在启动时读一次 ⇒ 重算完成后页面仍显示旧数,
# 必须重启组件服务才更新。判定依据: 改产物后 /detail/api/fleet 等仍回旧值, 重启组件后才变。
# 做法: 取"页面取数依赖的产物文件"的 (路径, mtime_ns, size) 摘要当指纹; _load() 前比一次
# (带 TTL, 免得每请求都 stat 一遍), 指纹变了就重载 ⇒ 重算产物**不再需要重启服务**。
# 也提供 /api/reload 显式重载 (运维控制台重算结束后可点一下)。
_STAMP_TTL = 2.0          # 秒: 指纹有效期 (stat ~150 个文件 ≈ 1~3 ms, 不值得每请求都做)
_STAMP = {'val': None, 'at': 0.0}


def _product_files():
    """页面取数依赖的产物文件清单 (顺序稳定: 供指纹; 只列**产物**, 不含 reference/ 随包契约)。

    覆盖 _load() 直读的件 + 它经 taxonomy/temp_nbm/hydraulic/fusion 间接读的件:
      windscada/*.parquet|csv|json  · ontology/*.json  · pitch/*.parquet
      m5_cms_tcm/{handoff_vibration_v2,component_history,baseline_38}.json  · windcms/报告_CMS*.md
    """
    try:
        from src.windcms.config import cms_out as _cms_out     # 与写侧同一解析口 (WINDCMS_OUT)
        _cms_dir = _cms_out()
    except Exception:
        _cms_dir = _P.cms()
    pats = ((ST, ('*.parquet', '*.csv', '*.json')),
            (_P.ont(), ('*.json',)),
            (_P.pitch(), ('*.parquet',)),
            (_P.m5(), ('handoff_vibration_v2.json', 'component_history.json', 'baseline_38.json')),
            (_cms_dir, ('报告_CMS振动状态评估报告_*.md',)))
    files = []
    for d, ps in pats:
        for pat in ps:
            files.extend(sorted(d.glob(pat)))
    return files


def products_stamp(force=False):
    """产物指纹 (sha1 前 16 位)。force=True 时忽略 TTL 立即重算。"""
    now = time.time()
    if not force and _STAMP['val'] is not None and (now - _STAMP['at']) < _STAMP_TTL:
        return _STAMP['val']
    h = hashlib.sha1()
    for p in _product_files():
        try:
            st = p.stat()
            h.update(f'{_P.rel(p)}|{st.st_mtime_ns}|{st.st_size}\n'.encode('utf-8'))
        except OSError:
            h.update(f'{_P.rel(p)}|MISSING\n'.encode('utf-8'))
    _STAMP.update(val=h.hexdigest()[:16], at=now)
    return _STAMP['val']


class ProductsMissing(RuntimeError):
    """产物缺失 (outputs/<场>/… 被清空或尚未生成)。

    2026-09-11 人工检查空状态时逮: 原来 `temp_monthly.parquet` 一缺, `_load()` 直接抛 FileNotFoundError,
    外层处理器把它当**未知异常**回 500 + traceback —— 人看到的是"服务器错误", 分不清"没算产物"还是"程序坏了"。
    现在这类缺失单独成类, 由请求层回**结构化的无数据**(HTTP 200 + err=no_products), 与 `adhoc_query` 的
    `no_source` 一致。真 bug 仍然照旧 500 并带 traceback (不静默)。"""

    def __init__(self, name, path):
        super().__init__(f'产物缺失: {name} (期望 {path})')
        self.what, self.path = name, path


def reload_products(reason=''):
    """显式清缓存 (下一次请求重载)。返回清前的指纹, 供日志/接口回显。"""
    with LOCK:
        old = _CACHE.get('__stamp')
        _CACHE.clear()
    print(f'[reload] 清产物缓存 ({reason or "手动"}) 旧指纹={old}', flush=True)
    return old


def _load():
    with LOCK:
        stamp = products_stamp()
        if _CACHE.get('__loaded'):
            if _CACHE.get('__stamp') == stamp:
                return
            # 产物变了 (典型: 刚跑完重算) → 重载。**先建后换**: 下面任何一步抛异常都不会破坏旧缓存,
            # 请求照旧能用旧数 (降级但不空白), 同时日志留痕。
            print(f'[reload] 产物指纹变化 {_CACHE.get("__stamp")} → {stamp}, 重载', flush=True)
        tmp = {}
        try:
            for key, name in (('tm', 'temp_monthly.parquet'), ('al', 'alarms.parquet'),
                              ('lm', 'loss_monthly.parquet'), ('bins', 'powercurve_bins.parquet'),
                              ('pcd', 'powercurve_dev.parquet')):
                f = ST / name
                if not f.exists():
                    raise ProductsMissing(name, f)
                tmp[key] = pd.read_parquet(f)
            tmp['al']['month'] = tmp['al']['t_on'].dt.to_period('M').astype(str)
            tmp['pcd'] = tmp['pcd'].set_index('turbine')
            for key, name in (('duty', 'duty_monthly.parquet'),):
                f = ST / name
                tmp[key] = pd.read_parquet(f) if f.exists() else None
            try:
                tmp['sysmx'] = taxonomy.system_matrix()
                tmp['treg'] = temp_nbm.registry()
                tmp['treg'] = tmp['treg'][0] if isinstance(tmp['treg'], tuple) else tmp['treg']
                tmp['hyd'], _ = hydraulic.registry()
                tmp['hyd'] = tmp['hyd'].set_index('turbine')
            except FileNotFoundError as e:            # 这些派生件同样在产物仓里; 缺了就按"无产物"处理
                raise ProductsMissing(getattr(e, 'filename', '派生产物'), getattr(e, 'filename', ST))
            zp = _P.pitch() / 'pitch_zero_monthly.parquet'
            tmp['zero'] = pd.read_parquet(zp) if zp.exists() else None
            tmp['__stamp'] = stamp
            tmp['__loaded'] = True
            _CACHE.update(tmp)                        # 原子提交: 失败时不留下半截缓存
        except Exception:
            if _CACHE.get('__loaded'):
                print('[reload] 重载失败 → 继续用上一份缓存 (页面不会空白, 但数是旧的; 看上面的异常)', flush=True)
            raise

WINDOWS = ['近30日', '近90日', '2026年', '2026H1', '2025H2', '全程']
def _month_end(m):
    """'YYYY-MM' → 该月最后一天 'YYYY-MM-DD'。"""
    import calendar
    y, mo = int(m[:4]), int(m[-2:])
    return f'{m}-{calendar.monthrange(y, mo)[1]:02d}'

def months_of(win):
    """窗 → 覆盖到的月份列表（月度类数据按此过滤）。"""
    _load()
    all_m = sorted(_CACHE['tm'].month.unique())
    if win == '全程': return all_m
    if win == '2025H2': return [m for m in all_m if '2025-07' <= m <= '2025-12']
    if win == '2026H1': return [m for m in all_m if '2026-01' <= m <= '2026-06']
    if win == '2026年': return [m for m in all_m if m >= '2026-01']
    import re as _re
    if _re.fullmatch(r'\d{4}-\d{2}', win):        # 单月窗 (2026-08-27 用户令: 按月份过滤和选择)
        return [m for m in all_m if m == win]
    m2 = _re.fullmatch(r'(\d{4}-\d{2})~(\d{4}-\d{2})', win)
    if m2:                                          # 月区间窗 "2025-04~2025-10"
        return [m for m in all_m if m2.group(1) <= m <= m2.group(2)]
    m3 = _re.fullmatch(r'(\d{4}-\d{2}-\d{2})~(\d{4}-\d{2}-\d{2})', win)
    if m3:                                          # ★自定义起止（含）→ 相交的月 (用户令 2026-09-21)
        a, b = sorted((m3.group(1), m3.group(2)))
        return [m for m in all_m if _month_end(m) >= a and f'{m}-01' <= b]
    n = 1 if win == '近30日' else 3
    return all_m[-n:]

def win_range(win):
    """窗 → (起, 止) 日期串，**含两端**（用户令 2026-09-21：时间窗支持自定义起止日期）。

    预设/逐月/月区间窗一律落到"该窗覆盖月的月首/月末"，于是与 `months_of()` 同口径；
    日区间窗原样返回。日粒度件（停机事件/报警/日粒度判据）用它做**含端**过滤。
    """
    import re as _re
    if win:
        if _re.fullmatch(r'\d{4}-\d{2}-\d{2}~\d{4}-\d{2}-\d{2}', win):
            a, b = win.split('~')
            return (a, b) if a <= b else (b, a)
        if _re.fullmatch(r'\d{4}-\d{2}', win):
            return (f'{win}-01', _month_end(win))
        m2 = _re.fullmatch(r'(\d{4}-\d{2})~(\d{4}-\d{2})', win)
        if m2:
            return (f'{m2.group(1)}-01', _month_end(m2.group(2)))
        if win == '2025H2':
            return ('2025-07-01', '2025-12-31')
        if win == '2026H1':
            return ('2026-01-01', '2026-06-30')
    ms = months_of(win)
    if not ms:
        return ('0001-01-01', '9999-12-31')
    return (f'{ms[0]}-01', _month_end(ms[-1]))

def in_win(ts, win):
    """按窗过滤**有日粒度**的时间列（含两端）。月度列请用 `months_of()`（闰月/跨月取整不同）。"""
    import pandas as pd
    a, b = win_range(win)
    t = pd.to_datetime(ts, errors='coerce')
    return (t >= pd.Timestamp(a)) & (t <= pd.Timestamp(b) + pd.Timedelta(days=1) - pd.Timedelta(seconds=1))

def span_of(win):
    """窗 → 计算层用的 (起, 止) 元组（含）；判级/曲线等按窗重算的口子都吃这个。"""
    return win_range(win)


# ── 按窗重算：后台算 + 缓存（用户令 2026-09-21）─────────────────────────────────
# 判级矩阵 ≈25 s/窗、七镜头 ≈9~44 s/窗 —— 直接同步算会把 HTTP 请求挂几十秒（远端还要过网关，
# 长请求有被掐的风险）。所以统一口径：**缓存命中即回；未命中就起后台线程，本次先回 pending，
# 页面轮询再取**。同一窗只算一次；算完常驻内存（进程内）。
import threading as _thr

_WIN_CACHE: dict = {'sysmx': {}, 'curves': {}, 'm9': {}}
_WIN_BUSY: dict = {'sysmx': set(), 'curves': set(), 'm9': set()}
_WIN_ERR: dict = {'sysmx': {}, 'curves': {}, 'm9': {}}
_WIN_LOCK = _thr.Lock()
# ★重活**串行**（2026-09-21 服务器实逮）: 预热与请求各自起线程 ⇒ 同时跑两个按窗重算（各几百 MB 级
#   中间帧），小内存机器上进程被系统杀掉（日志停在"按窗重算启动"两行、随后网关 503）。
#   现在全部重活排队执行：峰值 = 1 份中间帧。
_HEAVY_LOCK = _thr.Lock()


def _mem_mb():
    """本进程可用内存（MB）；拿不到就返回 None（不因为这些诊断信息把重算搞挂）。"""
    try:
        import ctypes

        class _MS(ctypes.Structure):
            _fields_ = [('dwLength', ctypes.c_ulong), ('dwMemoryLoad', ctypes.c_ulong),
                        ('ullTotalPhys', ctypes.c_ulonglong), ('ullAvailPhys', ctypes.c_ulonglong),
                        ('ullTotalPageFile', ctypes.c_ulonglong), ('ullAvailPageFile', ctypes.c_ulonglong),
                        ('ullTotalVirtual', ctypes.c_ulonglong), ('ullAvailVirtual', ctypes.c_ulonglong),
                        ('ullAvailExtendedVirtual', ctypes.c_ulonglong)]
        st = _MS()
        st.dwLength = ctypes.sizeof(_MS)
        ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(st))
        return int(st.ullAvailPhys // (1024 * 1024))
    except Exception:
        return None


def _win_key(win):
    a, b = span_of(win)
    return f'{a}~{b}'


def _win_get(kind, win, fn):
    """→ 值 或 None（None = 正在算/刚起算）。失败**记名**（`_WIN_ERR`）而不是静默当"没数据"。"""
    key = _win_key(win)
    with _WIN_LOCK:
        if key in _WIN_CACHE[kind]:
            return _WIN_CACHE[kind][key]
        if key not in _WIN_BUSY[kind]:
            _WIN_BUSY[kind].add(key)

            def _run():
                try:
                    with _HEAVY_LOCK:                       # 重活串行: 同一时刻只算一份
                        m0 = _mem_mb()
                        print(f'[win] {kind} 按窗重算开算 {key}（可用内存 {m0} MB）', flush=True)
                        v = fn()
                        print(f'[win] {kind} 按窗重算完成 {key}（可用内存 {_mem_mb()} MB）', flush=True)
                except Exception as e:                      # 守护失败必响亮
                    _WIN_ERR[kind][key] = f'{type(e).__name__}: {e}'[:200]
                    print(f'[win] {kind} 按窗重算失败 {key}: {_WIN_ERR[kind][key]}', flush=True)
                    v = None
                with _WIN_LOCK:
                    if v is not None:
                        _WIN_CACHE[kind][key] = v
                    _WIN_BUSY[kind].discard(key)
            _thr.Thread(target=_run, name=f'win-{kind}-{key}', daemon=True).start()
            print(f'[win] {kind} 按窗重算启动 {key}（首次约数十秒，页面会先出 pending）', flush=True)
        return None


def _win_wait(kind, win, timeout=120.0):
    """等某窗的按窗重算落地（预热用）。超时/失败返回 None，绝不抛。"""
    import time as _t
    key = _win_key(win)
    t0 = _t.time()
    while _t.time() - t0 < timeout:
        with _WIN_LOCK:
            if key in _WIN_CACHE[kind]:
                return _WIN_CACHE[kind][key]
        if key in _WIN_ERR[kind]:
            return None
        _t.sleep(1.0)
    return None


def sysmx_of(win):
    """→ (判级矩阵, pending)。`pending=True` 时返回的是"另一口径"的旧矩阵，页面必须如实标注。"""
    from src.windscada import taxonomy
    m = _win_get('sysmx', win, lambda: taxonomy.system_matrix(CFG, span=span_of(win)))
    if m is None:
        return _CACHE['sysmx'], True
    return m, False


def curves_of(win):
    """→ (七镜头分箱件 或 None, pending)。按窗重算（干净窗就是正式产物本身）。"""
    from src.windscada.perf import curves as _cv
    a, b = span_of(win)
    if (a, b) == (_cv.WIN[0], '2025-12-31'):     # 与正式产物的判别窗一致 ⇒ 直接用产物, 不重算
        import pandas as _pd
        return _pd.read_parquet(ST / 'curve_lenses.parquet'), False
    st = _win_get('curves', win, lambda: _cv.build_store(CFG, span=(a, b), write=False))
    return st, st is None


def m9_of(win):
    """→ (控制参数一致性, pending)。按窗重算（走窄仓 ≈5 s/窗）；干净窗直接用正式产物。"""
    from src.windscada.perf import control as _cm
    a, b = span_of(win)
    if (a, b) == (_cm.WIN[0], '2025-12-31'):
        return _cm.registry(CFG), False
    v = _win_get('m9', win, lambda: _cm.registry(CFG, span=(a, b)))
    if v is None:
        return _cm.registry(CFG), True          # 未就位: 先给上一口径, 页面按 pending 标注
    return v, False

TS = {'报警': 0, '危险': 0, '良好': 1, '不可判': 2, '优秀': 3}

# ---------- 图规格 (分册两型) ----------
def fig_temp(t, ch, win):
    tm = _CACHE['tm']; ms = months_of(win)
    g = tm[tm.channel == ch]
    piv = g.pivot_table(index='month', columns='turbine', values='med').reindex(ms)
    if t not in piv.columns or piv[t].dropna().empty: return None
    nm = i18n.ch_cn(ch, with_tag=False)
    return dict(kind='band', title=f'{t} {nm} 月度 (发电态P>500kW)', unit='℃', months=ms,
                self=[None if v != v else round(v, 2) for v in piv[t]],
                med=[None if v != v else round(v, 2) for v in piv.median(axis=1)],
                q1=[None if v != v else round(v, 2) for v in piv.quantile(.25, axis=1)],
                q3=[None if v != v else round(v, 2) for v in piv.quantile(.75, axis=1)],
                note='灰带=全场四分位区间, 深线=全场中位, 红线=本台')

def fig_duty(t, ch, title, unit, win, thresholds=None):
    d = _CACHE['duty']
    if d is None: return None
    ms = months_of(win)
    g = d[d.channel == ch]
    piv = g.pivot_table(index='month', columns='turbine', values='val').reindex(ms)
    if t not in piv.columns or piv[t].dropna().empty: return None
    return dict(kind='band', title=f'{t} {title}', unit=unit, months=ms,
                self=[None if v != v else round(v, 2) for v in piv[t]],
                med=[None if v != v else round(v, 2) for v in piv.median(axis=1)],
                q1=[None if v != v else round(v, 2) for v in piv.quantile(.25, axis=1)],
                q3=[None if v != v else round(v, 2) for v in piv.quantile(.75, axis=1)],
                thresholds=thresholds or [], note='灰带=全场四分位区间')

def fig_alarm_bars(t, codes, title, win):
    al = _CACHE['al']; ms = months_of(win)
    g = al[(al.turbine == t) & (al.code.isin(codes)) & (al.month.isin(ms))]
    if not len(g): return None
    cnt = g.groupby('month').size().reindex(ms).fillna(0)
    return dict(kind='bars', title=f'{t} {title} 月度条数', unit='条', months=ms,
                vals=[int(v) for v in cnt], note='窗内合计 %d 条' % int(cnt.sum()))

def fig_curve(t):
    b = _CACHE['bins']; g = b[b.turbine == t].sort_values('bin')
    if not len(g): return None
    dv = _CACHE['pcd'].loc[t]
    return dict(kind='xy', title=f'{t} 功率曲线 vs fleet中位 [固定判别窗 2025-H2, 机舱风口径]', unit='kW',
                x=[float(x) for x in g['bin']], self=[round(float(v), 1) for v in g.p],
                med=[round(float(v), 1) for v in g.fleet_p], xlab='风速 m/s',
                note=f"偏差 {dv.dev_w:+.1%} · 风速计偏置 {dv.ws_bias:+.2f} m/s · {dv['判别']}")

def fig_zero(t, win):
    z = _CACHE['zero']
    if z is None: return None
    tt = t.replace('WTG', '')
    g = z[(z.turbine.astype(str).str.contains(tt)) | (z.turbine == t)] if 'turbine' in z.columns else None
    if g is None or not len(g): return None
    ms = months_of(win)
    mcol = [c for c in g.columns if 'month' in c.lower() or '月' in c]
    if not mcol: return None
    g = g[g[mcol[0]].astype(str).isin(ms)]
    # 只画零位偏差本身 (样本数量纲不同, 混画会把判据线压扁 → 移入图注)
    n_med = int(g['n_rows'].median()) if 'n_rows' in g.columns and len(g) else 0
    return dict(kind='multiline', title=f'{t} 桨叶零位偏差 月度', unit='°', months=[str(x) for x in g[mcol[0]]],
                series=[dict(name='零位偏差', vals=[round(float(v), 3) if v == v else None for v in g['zero_dev']])],
                thresholds=[dict(v=0.6, label='报警 0.6°'), dict(v=-0.6, label='')],
                note=f'判据: 变桨分册 §3.2 (报警门 ±0.6°); 月样本中位 {n_med} 行')

SYS_ALARM = {'偏航': yawmod.FAM, '变桨': {'蓄能缸检': ['3411', '3412', '3413'], '泵/过热': ['7106', '7100'], '油位/滤芯': ['7101', '7103', '7104']}}

SYS_CODES = {
    '变桨': ['3130', '3145', '3173', '3224', '3225', '3411', '3412', '3413', '3418', '7100', '7101', '7102', '7103', '7104', '7106', '9306', '9309'],
    '偏航': ['10100', '10104', '10105', '10113', '10125', '10201', '10400', '10401', '7122', '1012'],
    '齿轮箱': ['4101', '4102', '4103'],
    '变流器': ['13902', '13905', '19024', '19170', '19285', '20000', '63036'],
    '主控与传感网': ['8108', '8110', '8171', '8184', '8185', '8186', '8187', '63209', '63004'],
}

def fig_sys_alarms(t, sysname, win):
    """该台该系统报警族 月度条数 (与工单处理史并读)."""
    codes = SYS_CODES.get(sysname)
    if not codes: return None
    ms = months_of(win)
    al = _CACHE['al']
    g = al[(al.turbine == t) & (al.code.isin(codes)) & (al.month.isin(ms))]
    if not len(g): return None
    v = g.groupby('month').size().reindex(ms).fillna(0)
    top = g.groupby('code').size().sort_values(ascending=False).head(3)
    note = '窗内合计 %d 条; top: ' % len(g) + '; '.join(f'{c} {i18n.alarm_label(c)[:12]}×{n}' for c, n in top.items())
    return dict(kind='bars', title=f'{t} {sysname}系统 报警月度条数', unit='条', months=ms,
                vals=[int(x) for x in v], note=note)


def turbine_problems(t, win):
    """有问题的系统 → 证据图 (分册式); 无问题不出."""
    _load()
    sysd = _CACHE['sysmx'][t]
    treg = _CACHE['treg']
    out = []
    for s in taxonomy.SYSTEMS:
        st = sysd[s]['状态']
        if st == '优秀': continue
        figs = []
        # 温度证据
        for _, r in treg[(treg.turbine == t)].iterrows():
            ch = r['channel']
            nm = ch.replace('tmp_wtc_', '').replace('_mean', '').replace('_max', '')
            if taxonomy.TEMP2SYS.get(nm) == s and str(r['判']) != '—':
                f = fig_temp(t, ch, win)
                if f: f['title'] = f"{t} {i18n.ch_cn(ch, with_tag=False)} — {r['判']} ({r['dev_K']:+.1f}K)"; figs.append(f)
        # 系统专属证据
        if s == '变桨':
            hv = _CACHE['hyd'].loc[t]
            if hv['判'] != '—':
                f = fig_duty(t, 'HydPress_band', '变桨液压10min摆幅 月度', 'bar', win,
                             thresholds=[dict(v=52, label='正常充压滞环≈52bar')])
                if f: f['title'] = f"{t} 蓄能行为 — {hv['判']}"; figs.append(f)
            for nm, codes in SYS_ALARM['变桨'].items():
                f = fig_alarm_bars(t, codes, f'变桨{nm}报警', win)
                if f: figs.append(f)
            f = fig_zero(t, win)
            if f: figs.append(f)
        if s == '偏航':
            yrow_d = dict(zip(['D1润滑不可能', 'D2过热', 'D2变流器警告', 'D2解缆', 'D3制动液压错误', 'D3油位低', 'D4偏航失败', 'D4风传感'], [0]*8))
            f = fig_duty(t, 'dot_wtc_YawLubPu_timeon', '偏航润滑泵运行时长 月度', '秒/日', win)
            if f: figs.append(f)
            for nm, codes in yawmod.FAM.items():
                f = fig_alarm_bars(t, codes, '偏航·' + nm.lstrip('D1234'), win)
                if f: figs.append(f)
        if s in ('主轴承', '齿轮箱', '发电机'):
            vf = vib_scalar_fig(t, s)
            if vf: figs.append(vf)
            # 振动驱动的问题 (taxonomy 振动映射) → 配套分析曲线: 部件双端温度 + 主轴承柱塞 duty
            if '振动:' in sysd[s]['依据']:
                vib_chs = {'主轴承': ['tmp_wtc_MBearGTm_mean', 'tmp_wtc_MBearHTm_mean'],
                           '发电机': ['tmp_wtc_GenBeRTm_mean', 'tmp_wtc_GenBeGTm_mean'],
                           '齿轮箱': ['tmp_wtc_IMSGenTm_mean', 'tmp_wtc_HSGenTmp_mean']}[s]
                for ch in vib_chs:
                    f = fig_temp(t, ch, win)
                    if f: f['note'] = (f.get('note') or '') + ' ｜ 振动判级交叉轴: 温度=同机制果侧观测(观测面≠源数)'; figs.append(f)
                if s == '主轴承':
                    f = fig_duty(t, 'din_wtc_MBLubPis_timeon', '主轴承润滑柱塞运行时长 月度 (因侧执行链)', '秒/日', win)
                    if f: f['note'] = (f.get('note') or '') + ' ｜ 29#签名: 单次时长塌→回升→2026-07单月突变(泵打不满)'; figs.append(f)
                # 振动摘要配传动链图形 (2026-08-28 用户令: 关联图形填入) — comp=依据里的部件短语, sev=结论级
                _why = sysd[s]['依据']
                _m = re.search(r'振动: ([^ ]+) ([^ (]+)', _why)
                _comp, _lv = (_m.group(1), _m.group(2)) if _m else (s, '')
                _sev = 'var(--bad)' if any(k in _lv for k in ('定论', '报警')) else ('var(--warn)' if '预警' in _lv else 'var(--ok)')
                figs.append(dict(kind='vib', title=f'{t} {s} 振动分析摘要',
                                 comp=_comp, sev=_sev,
                                 text=_why + ' ｜ 谱级深潜与逐窗趋势 → 振动融合板块·振动分析入口 (windcms)'))
            if '配对差' in sysd[s]['依据']:
                pair_chs = {'主轴承': ['tmp_wtc_MBearHTm_mean', 'tmp_wtc_MBearGTm_mean'],
                            '发电机': ['tmp_wtc_GenBeGTm_mean', 'tmp_wtc_GenBeRTm_mean']}.get(s, [])
                for ch in pair_chs:
                    f = fig_temp(t, ch, win)
                    if f: figs.append(f)
            if '润滑' in sysd[s]['依据']:
                ch = {'主轴承': 'din_wtc_MBLubPis_timeon', '齿轮箱': 'din_wtc_GBLubPis_timeon', '发电机': 'dot_wtc_GenLubPu_timeon'}[s]
                f = fig_duty(t, ch, f'{s}润滑 月度', '秒/日', win)
                if f: figs.append(f)
        if s == '主控与传感网':
            if '测风' in sysd[s]['依据'] or '风速计' in sysd[s]['依据']:
                f = fig_alarm_bars(t, yawmod.FAM['D4风传感'], '风传感故障报警', win)
                if f: figs.append(f)
            if '曲线判风速计' in sysd[s]['依据'] or '风速计偏置' in sysd[s]['依据']:
                f = fig_curve(t)
                if f: figs.append(f)
        # ★每个问题配: 该系统报警月度图 + 工单处理史 (用户令)
        try:
            from src.windscada.subsys import workorder as womod
            hist = womod.history(t, s)
        except Exception as e:
            hist = dict(n=0, rows=[], note=f'工单不可用 {e}'[:60], 动作统计={}, 窗='')
        af = fig_sys_alarms(t, s, win)
        if af: figs.append(af)
        # 排版 (2026-08-28 用户令"排版更合理"): ①同标题图去重 (配对差/温度证据两处会重复挂同一通道)
        # ②按阅读顺序排 — 结论定位(传动链) → 证据强度(振动标量) → 时序(温度/润滑/报警) → 曲线
        seen, uniq = set(), []
        for _f in figs:
            k = (_f.get('kind'), _f.get('title'))
            if k in seen: continue
            seen.add(k); uniq.append(_f)
        _ORD = {'vib': 0, 'vibbar': 1, 'band': 2, 'line': 3, 'bar': 4, 'xy': 5, 'text': 6}
        figs = sorted(uniq, key=lambda x: _ORD.get(x.get('kind'), 9))
        out.append(dict(sys=s, 状态=st, 依据=i18n.humanize(sysd[s]['依据']), figs=figs, orders=hist))
    dv = _CACHE['pcd'].loc[t] if t in _CACHE['pcd'].index else None
    if dv is not None and abs(dv.dev_w) > 0.03:
        f = fig_curve(t)
        out.append(dict(sys='功率曲线', 状态='报警' if 'A类' in str(dv['判别']) else '良好',
                        依据=f"偏差 {dv.dev_w:+.1%}, 风速计偏置 {dv.ws_bias:+.2f} m/s → {dv['判别']}", figs=[f] if f else []))
    out.sort(key=lambda x: TS.get(x['状态'], 9))
    return out

LENSES = [('wsb', 'grd_wtc_ActPower_mean', 'L1 功率曲线 (风速-功率)', '风速 m/s (机舱风)', 'kW'),
          ('wsb', 'cp', 'L6 风能利用系数 Cp (风速-Cp)', '风速 m/s', 'Cp'),
          ('wsb', 'lam', 'L5 叶尖速比 λ (风速-λ)', '风速 m/s', 'λ'),
          ('grb', 'tq', 'L4 转矩-转速 (发电机侧)', '发电机转速 rpm', 'kNm'),
          ('pwb', 'tur_wtc_PitcPosA_mean', 'L2 功率-桨距 (控制律/削峰)', '功率 kW', '°'),
          ('pwb', 'tur_wtc_GenRpm_mean', 'L3 功率-发电机转速 (饱和点)', '功率 kW', 'rpm'),
          ('pwb', 'p3', 'L2b 三叶桨距极差 (集距/不平衡)', '功率 kW', '°'),
          ('pwb', 'ratio', 'L7 转速比 gen/rot (传动链)', '功率 kW', '—')]

def curve_view(win='2025H2'):
    """特性曲线多镜头 (SOP §4.6c): fleet 中位+四分位带 + 过绝对锚的离群台曲线.

    ★2026-09-21 用户令「发电性能随时间窗变化」: 七镜头**按所选时间窗重算**（首次后台算，先回 pending），
    7 张月度时序图按所选窗的月份过滤。原口径（2025H2 干净判别窗）仍可作为窗之一被选中，
    选到它时直接用正式产物，不重算。
    """
    import pandas as pd
    from src.windscada.perf import curves as cv
    a, b = span_of(win)
    ms = months_of(win)
    store, pending = curves_of(win)
    if pending:
        return dict(building=True, win=win, span=[a, b], months=ms,
                    note=f'正在按所选时间窗 {a} ~ {b} 重算七镜头曲线（首次约 10~45 秒），完成后自动刷新。'
                         f'期间下方月度时序图已按所选窗过滤，可直接看。')
    wlabel = f'{a} ~ {b}'
    figs = []
    for xc, yc, title, xlab, unit in LENSES:
        r = cv.lens(xc, yc, store_df=store, win_label=wlabel)
        if not r: continue
        outs = sorted(r['离群'].items(), key=lambda kv: -abs(kv[1]['z']))[:3]
        a = r['anchor']
        series = [dict(name='全场中位', vals=r['fleet'])]
        series += [dict(name=f"{t.replace('WTG','')}# {v['resid']:+.4g}{a['单位']}", vals=r['per_t'][t]) for t, v in outs]
        figs.append(dict(kind='multiline', title=title, unit=unit, months=[f"{x:g}" for x in r['x']],
                         series=series, xlab=xlab,
                         note=(f"显著门 |残差|≥{a['门']}{a['单位']} ({a['说明']}) ∧ |z|≥3 → 离群 "
                               f"{'/'.join(t.replace('WTG','')+'#' for t,_ in outs) if outs else '无'}"
                               f" ｜ 灰域=全场四分位, 逐档中位聚合, 已剥限电(只正常发电态)"
                               f" ｜ 样本 {r['n_total']:,} 个10min点 / {r['n_turbines']} 台 / 最小档 {r['n_min_bin']:,}"
                               f" ｜ 窗 {r['win']} (随所选窗)"),
                         band=dict(q1=r['q1'], q3=r['q3'])))
        # 残差视图 (§4.6c④ per机必算同型残差): 绝对量尺度上四分位带只有几个像素, 残差面才看得见
        if outs:
            rs = [dict(name=f"{t.replace('WTG','')}# {v['resid']:+.4g}{a['单位']}",
                       vals=[None if (r['per_t'][t][i] is None or r['fleet'][i] is None) else round(r['per_t'][t][i] - r['fleet'][i], 4)
                             for i in range(len(r['x']))]) for t, v in outs]
            q1d = [round(r['q1'][i] - r['fleet'][i], 4) for i in range(len(r['x']))]
            q3d = [round(r['q3'][i] - r['fleet'][i], 4) for i in range(len(r['x']))]
            figs.append(dict(kind='multiline', title=title.split(' (')[0] + ' · 同型机群残差 (本台−全场中位)', unit=unit,
                             months=[f"{x:g}" for x in r['x']], series=rs, xlab=xlab,
                             thresholds=[dict(v=a['门'], label=f"显著门 +{a['门']}{a['单位']}"), dict(v=-a['门'], label='')],
                             band=dict(q1=q1d, q3=q3d),
                             note=(f"虚线=物理绝对锚 ±{a['门']}{a['单位']} ({a['说明']}); 灰域=全场四分位残差带; 出带且过锚才算离群"
                                   f" ｜ 样本 {r['n_total']:,} 点 / {r['n_turbines']} 台 ｜ 窗 {r['win']}")))
    # ---- 时序件: 控制参数月度 (M9b) + 偏航动态月度 (M12) ----
    def _ts(path, val, title, unit, xlab, picks=None, note='', thr=None):
        f = ST / path
        if not f.exists(): return None
        d = pd.read_parquet(f)
        if val not in d.columns: return None
        piv = d.pivot_table(index='month', columns='turbine', values=val)
        # ★2026-09-21 用户令: 月度时序图按**所选时间窗**的月份过滤（月度件无法按日切，如实写"按月取整"）
        if ms:
            piv = piv.reindex([m for m in [str(x) for x in piv.index] if m in set(ms)])
        if not len(piv): return None
        msx = [str(x) for x in piv.index]
        med = piv.median(axis=1)
        dev = (piv.sub(med, axis=0)).abs().mean()
        picks = picks or list(dev.sort_values(ascending=False).head(3).index)
        series = [dict(name='全场中位', vals=[None if v != v else round(float(v), 3) for v in med])]
        series += [dict(name=t.replace('WTG', '') + '#', vals=[None if v != v else round(float(v), 3) for v in piv[t]])
                   for t in picks if t in piv.columns]
        # 样本量与窗随图走 (2026-08-28 门禁 F1): 7 张时序图原来只有结论没有依据规模,
        # 违反第一性原理②"Sample size declared"。逐月×台的非空格数即样本量。
        _n = int(piv.notna().to_numpy().sum())
        _nt = int(piv.shape[1])
        note2 = (note + f" ｜ 样本 {_n:,} 个月×台 / {_nt} 台 / {len(msx)} 个月"
                        f" ｜ 窗 {msx[0]}~{msx[-1]} (月度聚合, 随所选窗·按月取整)") if msx else note
        return dict(kind='multiline', title=title, unit=unit, months=msx, series=series, xlab=xlab,
                    note=note2, thresholds=thr or [],
                    band=dict(q1=[None if v != v else round(float(v), 3) for v in piv.quantile(0.25, axis=1)],
                              q3=[None if v != v else round(float(v), 3) for v in piv.quantile(0.75, axis=1)]))
    for args in (
        ('control_monthly.parquet', 'p_cap', '时序① 满发功率封顶 月度 (取每月高位稳定值; 阶跃=配置变更)', 'kW', '月', None,
         '灰域=全场四分位; 参数级分组见发电性能页 (4175/4200/4225 三组); 阶跃=配置变更, 平移=工况'),
        ('control_monthly.parquet', 'w_cap', '时序② 转速封顶 月度 (取每月高位稳定值)', 'rpm', '月', None, '两轴独立分组 (1672/1680)'),
        ('control_monthly.parquet', 'pitch_rated', '时序③ 额定段桨距角 月度 (标定漂移)', '°', '月',
         ['WTG03', 'WTG34', 'WTG19'], '离群台=桨距调度同档差 top3'),
        ('yaw_dynamic_monthly.parquet', 'err_sd', '时序④ 对风散布 σ 月度 (原始, 未清洗)', '°', '月',
         ['WTG08', 'WTG16', 'WTG04'], '三台19个月全程高 → 非发作型; 清洗后降至5-7°, 判为机舱位置通道拖偏(A类数据质量)非对风故障'),
        ('yaw_dynamic_monthly.parquet', 'travel_day', '时序⑤ 偏航行程 月度 (抗采样物理量)', '°/日', '月', None,
         '行程=活动量代理, 非真磨损量; 与状态位次数互核'),
        ('yaw_dynamic_monthly.parquet', 'twist_span', '时序⑥ 扭缆角月跨度 (ScYawPos 累计位置)', '°', '月', None, '解缆动作后回零'),
        ('yaw_dynamic_monthly.parquet', 'pump_med', '时序⑦ 偏航泵压 月度 (小站泵压)', 'bar', '月', None, '全场极齐 → 无泵压异常'),
    ):
        f = _ts(*args)
        if f: figs.append(f)
    return dict(figs=figs, physics=cv.physics_check(),
                note=('镜头口径 (SOP §4.6c): X轴优先功率(直测干净量); 机舱风 self-ref → 只判形状/相对, '
                      '绝对达成率须现场测风; per机异常必算同型机群残差(禁眼估); 工况段筛选=剔除0kW与低转速混合态档'))


_VIBSENS = {'主轴承': ['Main_bearing_front', 'Main_bearing_rear'],
            '齿轮箱': ['Gear_planet', 'Gear_IMS', 'Gear_HS_rotor_side', 'Gear_HS_generator_side'],
            '发电机': ['Generator_DE', 'Generator_NDE']}
_SENS_CN = {'Main_bearing_front': '主轴承前', 'Main_bearing_rear': '主轴承后', 'Gear_planet': '行星级',
            'Gear_IMS': '中间轴', 'Gear_HS_rotor_side': '高速轴转子侧', 'Gear_HS_generator_side': '高速轴发电机侧',
            'Generator_DE': '发电机DE', 'Generator_NDE': '发电机NDE'}
_VIBMET = [('Peak', '冲击峰值'), ('Kurtosis', '峭度'), ('Rms_Vel', '速度有效值'), ('iso_rms', 'ISO烈度')]
_VIBC = {}


def vib_scalar_fig(t, sysname):
    """TCM 标量: 本台 vs 全场中位 (按测点×指标) + 六窗趋势. 数据=振动线 m5_cms_tcm 产物, 本页只转录不判级."""
    import pandas as _pd
    if 'z' not in _VIBC:
        base = _P.m5()
        try:
            _VIBC['z'] = _pd.read_parquet(base / 'fleet_scalar_z.parquet')
            _VIBC['tr'] = _pd.read_parquet(base / 'scalar_trend_6win.parquet')
        except Exception:
            _VIBC['z'] = _VIBC['tr'] = None
    z, tr = _VIBC['z'], _VIBC['tr']
    if z is None: return None
    sens = _VIBSENS.get(sysname, [])
    if not sens: return None
    g = z[(z.turbine == t) & (z.sensor.isin(sens)) & (z.meas.isin([m for m, _ in _VIBMET]))]
    if not len(g): return None
    # 取最高功率档 (载荷高处信噪比最好); 该档缺则退最近档
    order = sorted(g.bin.unique())
    gb = g[g.bin == order[-1]]
    rows = []
    for sn in sens:
        for mk, mcn in _VIBMET:
            r = gb[(gb.sensor == sn) & (gb.meas == mk)]
            if not len(r): continue
            r = r.iloc[0]
            tv = None
            if tr is not None:
                q = tr[(tr.turbine == t) & (tr.sensor == sn) & (tr.metric == mk)]
                if len(q): tv = float(q.iloc[0]['ratio'])
            rows.append(dict(测点=_SENS_CN.get(sn, sn), 指标=mcn, 本台=round(float(r.val), 3),
                             全场中位=round(float(r.fleet_med), 3), z=round(float(r.z), 2),
                             倍中位=round(float(r.val) / float(r.fleet_med), 2) if r.fleet_med else None,
                             六窗比=round(tv, 2) if tv else None))
    if not rows: return None
    return dict(kind='vibbar', size='L', title=f'{t} {sysname} 振动标量 · 本台 vs 全场 ({str(order[-1]).replace("WPS-ActivePower ", "功率 ").rstrip(",")} kW 档)',
                rows=rows, note='数据=TCM 六窗标量 (振动线 m5_cms_tcm 产物转录); z=fleet 稳健离群度, 六窗比=末窗/首窗 (>1 上升)')


def single_problem(t, sys, win):
    """只回该台该系统这一个问题 (用户令: 点开就是一个问题, 其他不带出来)."""
    return [p for p in turbine_problems(t, win) if p['sys'] == sys]


def fleet_view(win):
    _load()
    ms = months_of(win)
    # ★2026-09-21 用户令「判级也按所选时间窗重算」: 判级矩阵按窗算（后台+缓存，首次 pending）。
    sysmx, sysmx_pending = sysmx_of(win)
    # ① 系统分类问题 (全系统)
    systems, sysdist = {}, {}
    for s in taxonomy.SYSTEMS:
        rows = [dict(t=t, st=sysmx[t][s]['状态'], why=i18n.humanize(sysmx[t][s]['依据']))
                for t in CFG['turbines'] if sysmx[t][s]['状态'] in ('报警', '不可判')]   # 良好不出 (用户令: 只显示有问题的)
        rows.sort(key=lambda r: TS.get(r['st'], 9))
        systems[s] = rows
        # 全场分布 (系统入口卡用: rows 只含问题台, 不能当全场分母 — 会显示"共12台")
        from collections import Counter as _C
        sysdist[s] = dict(_C(sysmx[t][s]['状态'] for t in CFG['turbines']))
        # 良好台清单单列 (系统详情页第三档)
        systems[s + '·良好'] = [dict(t=t, st='良好', why=i18n.humanize(sysmx[t][s]['依据']))
                                for t in CFG['turbines'] if sysmx[t][s]['状态'] == '良好']
    # ①b 关注清单: ≥2 系统报警 (逐台独立台页)
    watch = []
    for t in CFG['turbines']:
        al_sys = [x for x in taxonomy.SYSTEMS if sysmx[t][x]['状态'] == '报警']
        if len(al_sys) >= 2:
            watch.append(dict(t=t, n=len(al_sys), syss=al_sys,
                              # ★不截断: 截到 70 字会把依据切成半句, 而模板反解要完整形态
                              #   ⇒ 英文侧整条落回中文 (2026-09-03 实逮, 总览 7 卡 4 张中文)。
                              #   显示长度归前端 CSS 管。
                              why='；'.join(f"{x}: {i18n.humanize(sysmx[t][x]['依据'])}" for x in al_sys)))
    watch.sort(key=lambda r: -r['n'])
    n_alarm_t = sum(1 for t in CFG['turbines'] if any(sysmx[t][x]['状态'] == '报警' for x in taxonomy.SYSTEMS))
    # ② 故障统计梳理 (真时间窗)
    al = _CACHE['al']; a = al[al.month.isin(ms)]
    top_txt = a.groupby(['code', 'text']).agg(n=('code', 'size'), dur_h=('dur_s', lambda x: x.sum() / 3600)).reset_index()
    pareto_n = top_txt.sort_values('n', ascending=False).head(12)
    pareto_d = top_txt.sort_values('dur_h', ascending=False).head(12)
    monthly = a.groupby('month').size().reindex(ms).fillna(0)
    per_t = a.groupby('turbine').size().sort_values(ascending=False).head(10)
    # 经典故障分析: 条数与时长必须配对看 (2026-08-28)。两个独立排行榜分不出
    # "高频短时(信号抖动或重复触发)" 与 "低频长时(硬故障)" — 处置方向相反, 混在一起会误派工。
    # 第三维=影响台数, 分离"单台刷屏"与"全场批次共性"。
    # 残月识别 (2026-08-28 审核逮): 2026-07 只有 6 天数据(覆盖 19.4%), 却被当整月
    # 并进"2026年"的占比与月度趋势 → 末柱"下降"是假象。占比类分母也因此不完整。
    import calendar as _cal
    _lmc = _CACHE['lm']; _lmc = _lmc[_lmc.month.astype(str).isin(ms)]
    _cov = {}
    for _mm in ms:
        _sub = _lmc[_lmc.month.astype(str) == _mm]
        if not len(_sub):
            _cov[_mm] = 0.0; continue
        _y, _mo = int(_mm[:4]), int(_mm[-2:])
        _cal_h = _cal.monthrange(_y, _mo)[1] * 24
        _cov[_mm] = round(float(_sub['rows_'].sum() / 6 / max(_sub['turbine'].nunique(), 1) / _cal_h), 3)
    _nt = a.groupby(['code', 'text'])['turbine'].nunique().rename('nt')
    _med = a.groupby(['code', 'text'])['dur_s'].median().rename('med_s')
    qd = top_txt.set_index(['code', 'text']).join([_nt, _med]).reset_index()
    qd = qd.sort_values('n', ascending=False).head(30)
    faults = dict(
        pareto_n=[dict(k=f"{r.code} {i18n.alarm_label(r.code, r.text)[:18]}", v=int(r.n)) for _, r in pareto_n.iterrows()],
        pareto_d=[dict(k=f"{r.code} {i18n.alarm_label(r.code, r.text)[:18]}", v=round(float(r.dur_h), 1)) for _, r in pareto_d.iterrows()],
        monthly=dict(months=ms, vals=[int(v) for v in monthly],
                     cov=[_cov.get(x, 0.0) for x in ms],
                     per_day=[round(float(monthly[x]) / max(_cov.get(x, 0.0) * _cal.monthrange(int(x[:4]), int(x[-2:]))[1], 1e-9), 1)
                              if _cov.get(x, 0) > 0.02 else None for x in ms]),
        cov=_cov, cov_min=min(_cov.values()) if _cov else 1.0,
        partial=[x for x in ms if _cov.get(x, 1) < 0.5],
        quad=[dict(code=str(r.code), k=i18n.alarm_label(r.code, r.text)[:20], n=int(r.n),
                   h=round(float(r.dur_h), 1), nt=int(r.nt), med=round(float(r.med_s), 1))
              for _, r in qd.iterrows()],
        n_codes=int(len(top_txt)),
        per_t=[dict(k=k, v=int(v)) for k, v in per_t.items()], total=int(len(a)))
    # ③ SOP 控制策略
    lm = _CACHE['lm']; l = lm[lm.month.astype(str).isin(ms)]
    hrs = l.groupby('state')['rows_'].sum() / 6
    loss = l.groupby('state')['loss'].sum() / 1000
    hrs_tot = max(hrs.sum(), 1)
    stop_h = hrs.get('停机', 0) + hrs.get('停机(调度令)', 0)
    disp_h = hrs.get('停机(调度令)', 0)
    lw_h = hrs.get('低风待机', 0)
    # 口径与 availability.summary 单源一致: 1 − 停机/(总 − 调度令 − 低风待机)
    avail = 1 - (stop_h - disp_h) / max(hrs_tot - disp_h - lw_h, 1)
    pcd = _CACHE['pcd']
    # 能量账闭合 (2026-08-28 经典分析): 四行工况表看不出"电量流向"。
    # 理论可发 = 实际上网 + Σ各态损失; 过物理上限核 (不可超 38台×4.0MW×窗时长)。
    _act = l.groupby('state')['act'].sum() / 1000
    _wf = [dict(k=str(k), loss=round(float(loss.get(k, 0)), 0), act=round(float(_act.get(k, 0)), 0),
                h=round(float(hrs.get(k, 0)), 0)) for k in hrs.index]
    _A = float(_act.sum()); _L = float(loss.sum())
    _cap = len(CFG['turbines']) * 4.0 * float(hrs_tot) / max(len(CFG['turbines']), 1)
    # 逐月能量 (2026-08-28 报表端口): 汇报要环比与趋势, 全窗聚合给不出。
    # 残月覆盖率一并带出 — 报表里拿残月和整月比环比会读反 (故障月度图已踩过一次)。
    _em = []
    for _mm in ms:
        _sub = l[l.month.astype(str) == _mm]
        if not len(_sub):
            continue
        _a1 = float(_sub['act'].sum()) / 1000
        _l1 = float(_sub['loss'].sum()) / 1000
        _em.append(dict(m=_mm, act=round(_a1, 0), loss=round(_l1, 0), theo=round(_a1 + _l1, 0),
                        loss_pct=round(_l1 / max(_a1 + _l1, 1) * 100, 1),
                        cov=_cov.get(_mm, 1.0),
                        eflh=round(_a1 / max(len(CFG['turbines']) * 4.0, 1), 0)))
    energy = dict(monthly=_em, act=round(_A, 0), loss=round(_L, 0), theo=round(_A + _L, 0),
                  loss_pct=round(_L / max(_A + _L, 1) * 100, 1),
                  eflh=round(_A / max(len(CFG['turbines']) * 4.0, 1), 0),
                  cap=round(_cap, 0), cap_ok=bool(_A + _L < _cap),
                  items=sorted(_wf, key=lambda r: -r['loss']))
    control = dict(
        energy=energy,
        states=[dict(k=k, h=round(float(v), 0), pct=round(float(v / hrs_tot * 100), 1), loss=round(float(loss.get(k, 0)), 0)) for k, v in hrs.items()],
        avail=round(float(avail * 100), 1),
        curve=dict(sigma=round(float(pcd.dev_w.std() * 100), 2),
                   cands=[dict(t=i, dev=round(float(r.dev_w * 100), 2), 判=r['判别']) for i, r in pcd.iterrows() if r['判别'] != '—'],
                   note='固定判别窗 2025-H2'),
        anchors='限电命令面占比 2025≈0.197 → 2026≈0.769 (专项锚)')
    m8 = None
    try:
        from src.windscada.perf import faults as fmod
        if (ST / 'stop_events.parquet').exists():
            m8 = dict(mtbf=fmod.mtbf_summary(ms), stop_pareto=fmod.stop_pareto(ms), seasonal=fmod.seasonal())
    except Exception as e:
        m8 = dict(err=str(e)[:120])
    m9 = None
    try:
        from src.windscada.perf import control as cmod
        if (ST / 'control_profile.parquet').exists():
            m9, m9_pending = m9_of(win)          # ★按窗重算（用户令 2026-09-21）
    except Exception as e:
        m9 = dict(err=str(e)[:120])
        m9_pending = False
    try:
        from src.windscada.perf import reliability as relmod
        rel = relmod.overview(CFG, span=span_of(win))
    except Exception as e:
        rel = dict(err=str(e)[:120])
    try:
        from src.windscada.subsys import fusion as fusmod
        ftab, fmeta = fusmod.fusion_table(CFG, all_turbines=True)
        mrows, mheads = fusmod.matrix(CFG, ms)   # 整体时间窗: 矩阵现窗/记忆轨迹随全局窗选择器
        cap = fusmod.capability()
        ev, ev_bounds = fusmod.drivetrain_events(ms, CFG)
        lvcnt = {}
        for r in mrows:
            lv = r['振动']['level']; lvcnt[lv] = lvcnt.get(lv, 0) + 1
        fkpi = dict(定论=lvcnt.get('bad', 0), 预警=lvcnt.get('warn', 0), 候选观察=lvcnt.get('note', 0),
                    销案正常=lvcnt.get('ok', 0), 未列=lvcnt.get('unlisted', 0),
                    收录台=len(CFG['turbines']) - lvcnt.get('unlisted', 0), 全场=len(CFG['turbines']),
                    机制链=sum(1 for r in mrows if '机制链' in r['润滑'].get('note', '')),
                    系数=dict(wear=cap['classes'].get('wear_progressive', {}).get('coef'),
                            thermal=cap['classes'].get('thermal_acute', {}).get('coef'),
                            unknown=cap['classes'].get('unknown', {}).get('coef')))
        # 矩阵补 报警/工单 两列 (2026-08-28 用户令) — 报警=窗内真窗计数+族分布; 工单=历史台账(窗见列头)
        # 报警/工单两列只统计传动链三部件 (2026-08-28 用户令: 只说发电机/齿轮箱/主轴) —
        # 本矩阵每行是"该台传动链状态", 全场报警计数会把变桨/偏航/主控的量混进来 (316 条里绝大多数与传动链无关)
        _DT_PAT = '齿轮|齿箱|润滑油|油冷|滤芯|发电机|定子|绕组|滑环|主轴承|主轴|轴承'
        _a = _CACHE['al']; _aw = _a[_a.month.isin(ms)]
        _aw = _aw[_aw.text.str.contains(_DT_PAT, na=False)]
        _acnt = _aw.groupby('turbine').size()
        _arank = _acnt.rank(ascending=False, method='min')
        _FAM = [('齿轮箱', '齿轮|齿箱|润滑油|油冷|滤芯'), ('发电机', '发电机|定子|绕组|滑环'),
                ('主轴承', '主轴承|主轴')]
        try:
            from src.windscada.subsys import workorder as _wo
            _wod = _wo.load(CFG)
        except Exception:
            _wod = None
        for _r in mrows:
            _t = _r['turbine']; _g = _aw[_aw.turbine == _t]
            _fam, _taken = [], set()
            _CODEFAM = {'3225': '变桨叶片'}       # 文本为空的码走码号归族 (3225=变桨液压, 现场西门子资料对译表)
            for _nm, _pat in _FAM:
                _byc = _g.code.astype(str).map(_CODEFAM) == _nm
                _sub = _g[~_g.index.isin(_taken) & (_g.text.str.contains(_pat, na=False) | _byc)]
                _taken |= set(_sub.index)
                if len(_sub): _fam.append(dict(k=_nm, n=int(len(_sub))))
            _oth = len(_g) - sum(f['n'] for f in _fam)
            if _oth > 0: _fam.append(dict(k='其他', n=int(_oth)))
            # 刷屏闸: 单码占比过半 → 条数不代表"问题多"而是一个码在抖 (08# 4609/4918=93.7% 码3225 集中2026-01)
            _burst = None
            if len(_g):
                _bc = _g.groupby('code').size().sort_values(ascending=False)
                _share = float(_bc.iloc[0]) / len(_g)
                if _share >= 0.5:
                    _sub2 = _g[_g.code == _bc.index[0]]
                    _burst = dict(code=str(_bc.index[0]), share=round(_share, 3), n=int(_bc.iloc[0]),
                                  months=sorted({str(m)[:7] for m in _sub2.t_on.dt.to_period('M').astype(str)}),
                                  med_s=float(_sub2.dur_s.median()) if 'dur_s' in _sub2 else None)
            # 明细 (用户令"浮窗说明之前发生问题"): top 码 + 首末时间
            _top = []
            if len(_g):
                for (_c2, _tx), _sub3 in _g.groupby(['code', 'text']):
                    _top.append(dict(code=str(_c2), text=str(_tx)[:34], n=int(len(_sub3)),
                                     first=str(_sub3.t_on.min())[:10], last=str(_sub3.t_on.max())[:10]))
                _top.sort(key=lambda x: -x['n'])
            _r['报警'] = dict(n=int(_acnt.get(_t, 0)), rank=int(_arank.get(_t, 0)) if _t in _arank else None,
                             tot=len(CFG['turbines']), fam=_fam, burst=_burst, items=_top[:6])
            if _wod is not None and len(_wod):
                _w = _wod[_wod.turbine == _t]
                _wtxt = (_w.get('故障名称', '').astype(str) + ' ' + _w.get('故障位置二级', '').astype(str)
                         + ' ' + _w.get('维修对象', '').astype(str) + ' ' + _w.get('元器件名称', '').astype(str))
                _w = _w[_wtxt.str.contains(_DT_PAT, na=False)]
                _acts = _w['维修动作'].replace('', pd.NA).dropna().value_counts() if len(_w) else None
                _wi = []
                for _, _wr in _w.sort_values('t_report', ascending=False).head(6).iterrows():
                    _wi.append(dict(date=str(_wr.get('t_report'))[:10], name=str(_wr.get('故障名称') or '')[:30],
                                    act=str(_wr.get('维修动作') or ''), part=str(_wr.get('维修对象') or _wr.get('元器件名称') or '')[:14]))
                _r['工单'] = dict(n=int(len(_w)),
                                  acts=[dict(k=str(k), n=int(v)) for k, v in (_acts.head(3).items() if _acts is not None else [])],
                                  items=_wi,
                                  last=(lambda v: str(v.max())[:10] if len(v) else None)(_w.t_report.dropna()[_w.t_report.dropna().dt.year > 2000]) if len(_w) else None)
            else:
                _r['工单'] = dict(n=0, acts=[], last=None)
        _wyr = ''
        if _wod is not None and len(_wod):
            _tv = _wod.t_report.dropna()
            _tv = _tv[_tv.dt.year > 2000]        # 空日期落 1970 epoch, 剔除后再报窗 (否则列头写"1970~")
            if len(_tv): _wyr = f"{_tv.min():%Y}~{_tv.max():%Y}"
        mheads = dict(mheads, 报警=f"传动链三部件 · {ms[0]}~{ms[-1]}" if ms else '传动链三部件',
                      工单=f"传动链三部件 · 台账 {_wyr}" if _wyr else '台账不可用')
        # 决策链进度盘 (2026-08-28 用户问"这个到底能怎么用"): 原来只有 29# 一台的静态六格,
        # 是展示牌不是工作面 — 打开它做不了任何决定。改为对全部需跟踪台报"走到第几步、卡在哪、下一步做什么"。
        # 判定规则单源在此, 前端只渲染不判断。
        _CLOOP = {}
        try:
            _ch = json.loads((ST.parent / 'm5_cms_tcm' / 'component_history.json').read_text(encoding='utf-8'))
            for _k, _v in _ch.get('summary', {}).items():
                if _k.startswith('★换件闭环') and isinstance(_v, list):
                    for _r in _v:
                        _CLOOP[_r['turbine']] = _r
                if _k.startswith('★当前在升') and isinstance(_v, list):
                    for _r in _v:
                        _CLOOP.setdefault(_r['turbine'], {}).update(rising=_r)
        except Exception:
            pass
        _HIT = {'bad', 'warn', 'note'}
        # ★一台可能有多行 (29#/17# 各 2 行: 齿轮箱 + 主轴承)。用 {turbine: row} 直接建字典会被后一行覆盖,
        # 实测 29# 因此取到"齿轮箱二级行星内齿圈·监视"那行, 而它的决策链讲的是"主轴承+集中润滑泵·定论"
        # ⇒ 浮窗里部件、温度通道、油样全是另一个部件的 (memory: 画图须确认各维度来自同一个体)。
        _SEV = {'bad': 0, 'warn': 1, 'note': 2, 'stale': 3, 'ok': 4, 'unlisted': 5}
        _tbi = {}
        for _row in ftab.to_dict('records'):
            _k = _row['turbine']
            if _k not in _tbi or _SEV.get(_row.get('级'), 9) < _SEV.get(_tbi[_k].get('级'), 9):
                _tbi[_k] = _row
        board = []
        for _r in mrows:
            t = _r['turbine']
            srcs = [k for k in ('振动', '温度', '润滑', '油液') if (_r.get(k) or {}).get('level') in _HIT]
            lvl = (_r.get('振动') or {}).get('level')
            tb = _tbi.get(t, {})
            mech = ('机制链' in ((_r.get('润滑') or {}).get('note') or '')
                    or '机制链' in (tb.get('振动结论') or ''))
            n_wo = (_r.get('工单') or {}).get('n') or 0
            cl = _CLOOP.get(t) or {}
            closed = bool(cl.get('verdict') == '恢复')
            rising = cl.get('rising')
            if not (lvl in _HIT or (srcs and lvl != 'ok')):
                continue
            # 六步: done=已达 / open=未达 / unknown=数据不足不可判
            steps = [
                dict(k='证据', st='done' if srcs else 'open', v=f"{len(srcs)} 源", d='/'.join(srcs)),
                dict(k='机制', st='done' if mech else 'open',
                     v='已定性' if mech else '未定性', d='根因定到部件与失效模式'),
                dict(k='判级', st='done' if lvl in _HIT else 'open',
                     v=tb.get('证据状态') or lvl or '—', d=f"设备状态 {tb.get('设备状态') or '—'}"),
                dict(k='排期', st='done' if t == 'WTG29' else 'open',
                     v='情景A 2026-09' if t == 'WTG29' else '未排',
                     d='进检修排程沙盘 (风险×损失双轴)'),
                # ★这一列一律"不可判", 不是偷懒: 工单台账止 2024-11 而判级窗在 2026,
                # 台账里的历史工单不可能是针对本次问题的 ⇒ 用 n>0 判"已派工"会造出假的完成态。
                dict(k='动作', st='unknown',
                     v=(f"台账 {n_wo} 单" if n_wo else '台账无'),
                     d='工单台账 2020~2024-11, 25-26 现场未提供 — 历史单不对应本次问题, 须向现场核实'),
                # ★历史闭环不占本格: 05#/20# 2024~2025 换过齿轮箱且已验证恢复, 但本轮又有新的候选级证据,
                # 把历史闭环填进第六格会出现"验收已达而机制未定"的自相矛盾行。历史闭环走 hist_loop 单独标记。
                dict(k='验收', st='open', v='未验',
                     d='本轮动作执行后复测同一判据是否回落' + (
                        f" (该台 {cl.get('replace_date')} 有过一次闭环: {cl.get('component')} 降至 {cl.get('ratio')}×)" if closed else '')),
            ]
            _first = next((x for x in steps if x['st'] != 'done'), None)
            stuck = _first['k'] if _first else None
            stuck_kind = _first['st'] if _first else None
            NEXT = {'证据': '补测: 四源全为常态, 先确认监测面有效',
                    '机制': '定性: 现场/取样把根因定到部件与失效模式 — 机制不清则排期与动作都无依据',
                    '判级': '送审: 按 RV-1 触发相应审级',
                    '排期': '排程: 进沙盘比情景, 出建议窗口',
                    '动作': '核实: 向现场调取 2025~2026 工单 — 台账止于 2024-11, 系统无法判定是否已派工',
                    '验收': '复测: 动作已执行, 复测同一判据是否回落'}
            board.append(dict(t=t, lvl=lvl, ostate=tb.get('设备状态'), estate=tb.get('证据状态'),
                              part=tb.get('部件'), steps=steps, stuck=stuck, stuck_kind=stuck_kind,
                              next=NEXT.get(stuck, ''), done=sum(1 for x in steps if x['st'] == 'done'),
                              rising=rising, hist_loop=(cl if closed else None), srcs=srcs))
        _ORD = {'bad': 0, 'warn': 1, 'note': 2}
        board.sort(key=lambda r: (_ORD.get(r['lvl'], 3), -r['done']))
        _cl_rows = [v for v in _CLOOP.values() if v.get('verdict') == '恢复']
        fus = dict(链盘=dict(rows=board, closed=_cl_rows,
                            stuck=dict(collections.Counter(r['stuck'] for r in board if r['stuck'])),
                            wo_bound='工单台账 2020~2024-11 (现场未提供 25-26)'),
                   表=ftab.to_dict('records'),
                   矩阵=mrows, 列窗=mheads, kpi=fkpi,
                   事件=ev, 事件边界=ev_bounds,
                   能力=dict(classes=cap['classes'], blind=[str(b) for b in cap['blind']], loop=cap.get('loop', {})),
                   窗=dict(振动=fmeta.get('振动窗', '—'), SCADA=fmeta.get('SCADA窗', ''), 油样=fmeta.get('油样窗', '')),
                   色标=fmeta.get('色标', {}), 数据时点=fmeta.get('数据时点', ''), handoff日期=fmeta.get('handoff日期', ''),
                   证据窗末=fmeta.get('证据窗末', ''),
                   纪律=str(fmeta.get('纪律', '')), 盲区=[str(b) for b in fmeta.get('盲区', [])],
                   open_items=[str(o) for o in fmeta.get('open_items', [])], gap=fmeta.get('gap'))
    except Exception as e:
        fus = dict(err=str(e)[:160])
    kpi = dict(报警台=n_alarm_t, 关注台=len(watch), 全场=len(CFG['turbines']))
    return dict(win=win, months=ms, all_months=sorted(_CACHE['tm'].month.unique()),
                systems=systems, sysdist=sysdist, watch=watch, kpi=kpi, rel=rel, fus=fus, faults=faults, control=control, m8=m8, m9=m9,
                # ★2026-09-21: 判级轴现在**按所选窗重算**；首次是后台算，这一份仍是旧口径 ⇒ 如实标 pending
                sysmx_pending=bool(sysmx_pending),
                m9_pending=bool(m9_pending),
                win_pending=bool(sysmx_pending or m9_pending),
                sysmx_span=list(span_of(win)),
                note=('判级轴(变桨/偏航/蓄能/温度)按所选窗重算；曲线按所选窗重算；'
                      '故障统计/五态/温度月轨迹/停机台账=所选窗真窗'
                      + ('（⚠ 判级矩阵正在按窗重算，下面系统卡暂为上一份口径，稍后自动刷新）' if sysmx_pending else '')))

# ---------- 本体网页面 (ontology 的网页体现: 机制链/决策台/机制库/对象浏览器; 只读, 复用 MCP 纯函数) ----------
def ontology_view():
    from src.ontology import mcp_server as om
    d = om.db()
    from collections import Counter
    stats = dict(Counter(v['type'] for v in d.values()))
    mechs = [dict(id=o['id'], **{k: o['props'].get(k) for k in ('name', 'status', 'facets', 'source')},
                  affects=o.get('links', {}).get('affects', []))
             for o in d.values() if o['type'] == 'FailureMechanism']
    # 29# 机制链 (§2 规划补齐): 机制为中心的分层链
    ev = [dict(id=i, **{k: d[i]['props'].get(k) for k in ('facet', 'claim_window', 'summary', 'source')})
          for i in d['mechanism/WTG29/lub_starvation']['links']['evidencedBy']]
    chain29 = dict(
        mechanism=dict(id='mechanism/WTG29/lub_starvation', **d['mechanism/WTG29/lub_starvation']['props']),
        evidence=ev,
        verdict=dict(id='verdict/WTG29/TCM-16', **{k: d['verdict/WTG29/TCM-16']['props'].get(k)
                                                   for k in ('level', 'title', 'review_tier', 'claim_window')}),
        scenario=dict(id='scenario/WTG29/repair_scheduling_v1',
                      **{k: d['scenario/WTG29/repair_scheduling_v1']['props'].get(k)
                         for k in ('key_insight', 'recommendation', 'scenarios')}),
        action=dict(id='action/WTG29/repair_pump', **d['action/WTG29/repair_pump']['props']),
        acceptance=dict(id='acceptance/WTG29/state', **d.get('acceptance/WTG29/state', {}).get('props', {})),
        tree=dict(id='decision/WTG29/acceptance_tree', **d['decision/WTG29/acceptance_tree']['props']))
    decisions = [dict(id=o['id'], **{k: o['props'].get(k) for k in ('decided_by', 'when', 'decision', 'status', 'outcome')})
                 for o in d.values() if o['id'].startswith('decision/user') or o['id'].startswith('decision/pending')]
    roll = d.get('meta/roll_state', {}).get('props', {})
    constraints = ('C1 证据必带claim_window+观测面+源身份 · C2 判级必带审级+证据链接 · C3 独立源数按观测面去重禁按条数 · '
                   'C4 判读三分(支持|排除|不可判, 不可判≠阴性) · C5 状态措辞窗相关必带窗 · C6 动作必带可逆级(L3须审级)')
    weather = d.get('mwindow/rudong/climatology', {}).get('props', {}).get('monthly', {})
    return dict(stats=stats, constraints=constraints, mechanisms=mechs, chain29=chain29,
                decisions=decisions, roll=roll, weather=weather)


def ontology_list(otype, turbine, limit=60):
    from src.ontology import mcp_server as om
    return om.ont_query(type=otype or '', turbine=turbine or '', limit=int(limit)).get('data', [])


def ontology_obj(oid):
    from src.ontology import mcp_server as om
    r = om.ont_get(id=oid)
    lk = om.ont_links(id=oid).get('data', {})
    return dict(obj=r.get('data'), links=lk, err=r.get('error'))


# ---------- AI 问答 (P2 离线编排的网页入口; dsh + ontology MCP; 串行锁=一次一问, windcms五类错教训) ----------
CUR_WIN = ['2026年']          # 最近一次 fleet 查询的窗, 供报告助手复用
ASK = {'state': 'idle', 'q': '', 'model': '', 'answer': '', 'verify': None, 't0': 0, 'err': '',
       'step': '', 'steps': [], 'review': None, 'xrev': False, 'lang': 'zh'}
# step/steps: 推理进度 (229s 全程无反馈会被读成"给不出结果"); review: 另一模型的交叉审核结果
_ASK_STEP_KEY_EN = {
    '启动': 'Starting',
    '预取': 'Prefetch',
    '推理': 'Reasoning',
    '取证': 'Evidence retrieval',
    '成文': 'Drafting',
    '校闸': 'Grounding gate',
    '交叉审核': 'Cross-review',
    '完成': 'Done',
    '失败': 'Failed',
}


def _ask_step_text(k, d='', lang='zh'):
    k = '' if k is None else str(k)
    d = '' if d is None else str(d)
    if lang != 'en':
        return f'{k}· {d}' if d else k
    key = _ASK_STEP_KEY_EN.get(k, k)
    detail = d.strip()
    m = re.search(r'第\s*(\d+\s*/\s*\d+)\s*轮', detail)
    if m:
        detail = 'round ' + m.group(1).replace(' ', '')
    else:
        m = re.search(r'(\d{1,2})\s*一站式证据包', detail)
        if m:
            alias = 'focus unit'
            try:
                from src.windscada.deid import unitize_answer
                alias = unitize_answer(f"WTG{int(m.group(1)):02d}")
            except Exception:
                pass
            detail = f'{alias} evidence pack'
        elif '闭环' in detail and '证据' in detail:
            n = ''.join(re.findall(r'\d+', detail))
            detail = f'closure and trend evidence: {n} records' if n else 'closure and trend evidence'
        elif '全场' in detail and '判级' in detail:
            n = ''.join(re.findall(r'\d+', detail))
            detail = f'fleet ratings: {n} units' if n else 'fleet ratings'
        elif '换模型' in detail or '复核' in detail:
            detail = 'reviewing with another model'
        elif re.search(r'[\u3400-\u9fff\u3000-\u303f\uff00-\uffef]', detail):
            detail = ''
    if re.search(r'[\u3400-\u9fff\u3000-\u303f\uff00-\uffef]', key):
        key = 'Working'
    if re.search(r'[\u3400-\u9fff\u3000-\u303f\uff00-\uffef]', detail):
        detail = ''
    return f'{key} · {detail}' if detail else key

# 模型档位 (2026-08-28 用户裁: 去掉 qwen3:30b-a3b, 用 27B)。
# 每档标注适用场景与实测耗时 — 让人按"这个问题值不值得等"来选, 而不是凭型号大小猜。
ASK_MODELS = {'qwen3:8b': 'deploy/dsh/model.qwen8b.patch.yml',
              'qwen3.8:27b': 'deploy/dsh/model.qwen27b.patch.yml',
              # 2026-09-06 用户裁 "加档": 部署包写的是 "本机 Ollama 的 DeepSeek 模型", 机上实有 r1 14b/32b 却选不到.
              #   本地档一律走 fast_agent 快路径 (Ollama 直连), 不走 dsh, 故 patch 为 None; r1 不支持 tools 时快路径自动退化为预取直答 (见 fast_agent._chat).
              'deepseek-r1:14b': None, 'deepseek-r1:32b': None,
              'qwen3:30b-a3b': None,   # 2026-09-07: 8B 校闸未过的自动升档目标 (30B 参数 / 3B 激活, 单轮 ~20 s)
              'deepseek-v4-pro': None}
# ★这张表原来只有本地模型时代的三档, **不含实际部署的 deepseek-chat / kimi-fast /
#   qwen-plus** —— 于是 MODEL_SPEC[sel.value] 落空, v.warn 为空, 徽章就显示「零外发」。
#   云端模型对用户说"零外发"是**假保证**, 比时间写错严重得多 (2026-09-01 用户说"太慢"
#   时顺带查出来的)。补全 + 下面 mdlNote 的兜底改为"按外发处理", 宁可说重不可说轻。
MODEL_SPEC = {
    'qwen3:8b':        dict(nm='轻量 8B',  loc='本地', t='约 30 到 60 秒', use='默认档: 快速简答问答 (用户裁 2026-09-07)'),
    'qwen3.8:27b':     dict(nm='标准 27B', loc='本地', t='约 2 到 4 分钟', use='复杂问题档: 多台横向比对与机制推断 (用户裁 2026-09-07)'),
    'qwen3:30b-a3b':   dict(nm='快 30B (a3b)', loc='本地', t='约 20 到 60 秒', use='8B 校闸未过时的自动升档目标; 也可直接选'),
    'deepseek-r1:14b': dict(nm='本机 DeepSeek 14B', loc='本地', t='约 1 到 3 分钟', use='交叉审核审核档 (作答请优先 qwen 27B; 用户裁 2026-09-07)'),
    'deepseek-r1:32b': dict(nm='本机 DeepSeek 32B', loc='本地', t='约 3 到 8 分钟', use='备用: 更强更慢, 引用格式不稳 (约三成概率不出文)'),
    'deepseek-chat':   dict(nm='DeepSeek', loc='云端', t='约 3 到 10 秒',  use='默认档, 状态查询与机制推断',
                            warn='内容会外发到模型厂商, 场名与台号已去标识化'),
    'kimi-fast':       dict(nm='Kimi',     loc='云端', t='约 5 到 20 秒',  use='长文归纳',
                            warn='内容会外发到模型厂商, 场名与台号已去标识化'),
    'qwen-plus':       dict(nm='通义千问',  loc='云端', t='约 5 到 20 秒',  use='备用云端档',
                            warn='内容会外发到模型厂商, 场名与台号已去标识化'),
    'deepseek-v4-pro': dict(nm='云端 DS',  loc='云端', t='约 2 到 6 分钟', use='复杂推理与交叉审核',
                            warn='内容会外发到模型厂商, 场名与台号已去标识化'),
}


def _warm(model):
    # 预热+常驻: 空载请求把模型拉进内存并 keep_alive 30m (与 dsh 冷启并行, 消掉 18GB 级冷加载)
    try:
        import urllib.request
        urllib.request.urlopen(urllib.request.Request(
            'http://127.0.0.1:11434/api/generate', method='POST',
            data=json.dumps(dict(model=model, prompt='', keep_alive='30m')).encode(),
            headers={'Content-Type': 'application/json'}), timeout=120).read()
    except Exception:
        pass


def _ask_worker(q, model, lang='zh'):
    import subprocess, threading, time as _t
    out = _P.ont() / 'ask_last.out'
    try:
        if MODEL_SPEC.get(model, {}).get('loc') == '本地':   # 本地档 (qwen3 / deepseek-r1) 走直连快路径; 原按 'qwen' 前缀硬判, 加 r1 档后改按档表 loc
            # 本地模型走直连快路径 (fast_agent: ollama chat+tools 同进程, 砍 dsh/node/MCP 三层;
            # 实测 8b 116s→19s; 同一套工具与闸, 服务端强制双闸). deepseek 云端仍走 dsh 完整编排.
            threading.Thread(target=_warm, args=(model,), daemon=True).start()
            sys.path.insert(0, str(pathlib.Path('.').resolve()))
            sys.path.insert(0, str(pathlib.Path('scripts').resolve()))
            from src.ontology.fast_agent import answer_escalate as _fast   # 2026-09-07: 8B 拦了自动升 a3b 重答 (用户令)

            def _on_step(k, d=''):
                ASK['step'] = _ask_step_text(k, d, lang)
                ASK.setdefault('steps', []).append(ASK['step'])

            def _on_partial(txt):
                # 先快后准 (用户裁 2026-09-07): 30 s 内先出初答 (契约直出), 状态 partial, 前端继续轮询; 27B 出来后整段替换
                ASK.update(answer=txt, state='partial', partial=True)

            r = _fast(q, model, on_step=_on_step, lang=lang, on_partial=_on_partial)
            _esc = f" · 升档 {r['escalated_from']}→{r['model']}" if r.get('escalated_from') else ''
            ans = r['answer'] + f"\n\n({r['gate']} · {r['rounds']}轮 · 直连快路径{_esc})"
            out.write_text(ans, encoding='utf-8')     # 答案是中文: 缺 encoding 在中文 Windows 上按 GBK 写, 可能崩
            from ontology_p2_verify import verify as _v0
            ASK.update(answer=ans, verify=_v0(ans, lang=lang), partial=False, refined_from=r.get('escalated_from'))
            # 交叉审核: 换一个本地模型复核同一份证据 (同模型自审 = 自己给自己判卷)
            if ASK.get('xrev'):
                _on_step('交叉审核', '换模型复核中')
                from src.ontology.fast_agent import cross_review as _xr
                # 审核档 = DeepSeek r1:14b (用户裁 2026-09-07); 作答本身是 DeepSeek 时换 qwen 27B 审 —— 始终跨家族 (同家族自审 = 自己判卷)
                _rm = 'deepseek-r1:14b' if not model.startswith('deepseek') else 'qwen3.8:27b'
                ASK['review'] = _xr(q, r['answer'], r.get('facts') or [], model=_rm)
            ASK.update(state='done')
            return
        if False:
            q = '/no_think ' + q          # (快路径内已带 /no_think; dsh 路径仅 deepseek)
        cmd = ['deploy/dsh/dsh_run.sh', '--profile', 'headless',
               '--patch', 'deploy/dsh/headless.patch.ontology.yml']
        mp = ASK_MODELS.get(model)
        if mp:
            cmd += ['--patch', mp]
        if lang == 'en':
            cmd.append(q + ' Answer in English only. End every conclusion sentence with [object/id]. Finally run claim_check.')
        else:
            cmd.append(q + ' 每个结论句末尾用[对象id]标注来源。最后调用claim_check。')
        # 2026-09-16: 走 src.proc.run —— 本函数跑在 detail 服务进程里 (无可见控制台), 裸 spawn
        # 会让 Windows 给这条"云端档问答"新建可见控制台窗口 (本地档不走这里)。
        from src import proc as _proc
        r = _proc.run(cmd, capture_output=True, text=True, timeout=600)
        ans = r.stdout.strip() or ('(空输出) stderr: ' + r.stderr[-500:])
        out.write_text(ans, encoding='utf-8')
        sys.path.insert(0, str(pathlib.Path('scripts').resolve()))
        from ontology_p2_verify import verify as _v
        ASK.update(answer=ans, verify=_v(ans, lang=lang), state='done')
    except Exception as e:
        _msg = str(e)
        if 'Connection refused' in _msg or 'Errno 61' in _msg or '11434' in _msg:
            _msg = '本机模型未启动 (Ollama 127.0.0.1:11434 拒连); 离线版不转云, 请先启动 Ollama'   # 2026-09-07 真停实测: 原样抛 urlopen 错误给用户
        ASK.update(state='error', err=_msg[:300])


# ── 报告定制助手 (2026-08-28 用户令: 留一个互动交互窗, 报告按定制, 离线模型支持) ──
# 两件事: ①听懂"给集团看的月报, 重点讲设备问题"这类话 → 选出该放哪些块
#         ②基于**真实数字**写一段总结叙述 — 为图表补充文字结论, 供汇报使用。
# 防编造: 数字只许用下面这份摘要里的, 生成后过 grounding 闸复核, 越界即标注。
RPT_BLOCK_KEYS = ['kpi', 'water', 'emon', 'blame', 'ram', 'parts', 'attrib',
                  'pareto', 'quad', 'frate', 'units', 'chain', 'loop', 'plan', 'caliber']
RPT_SYS = ('你是风电场报告编排助手。根据用户要求做两件事, 严格按格式输出, 不要解释:\n'
           'BLOCKS: 用逗号分隔的块名 (只能从给定清单里选, 按报告顺序排)\n'
           'TEXT: 一段中文总结 (150~300 字, 可分 2~3 句一组)\n'
           '铁律: TEXT 里出现的每个数字都必须来自"可用数据"里, 不许自己算不许估计; '
           '没有依据的话就不写。不要写套话, 不要写"综上所述"。')


def rpt_compose(need, canvas, model='qwen3:8b'):
    import time as _t
    fl = fleet_view(CUR_WIN[0] if CUR_WIN else '2026年')
    E = (fl.get('control') or {}).get('energy') or {}
    R = fl.get('rel') or {}
    M = ((fl.get('m8') or {}).get('mtbf')) or {}
    F = fl.get('faults') or {}
    BD = ((fl.get('fus') or {}).get('链盘')) or {}
    facts = [
        f"统计期 {fl.get('win')}; 38 台 4.0MW",
        f"上网电量 {E.get('act')} MWh; 理论可发 {E.get('theo')}; 损失 {E.get('loss')} MWh; 损失率 {E.get('loss_pct')}%",
        f"等效满发 {E.get('eflh')} h; 时间可用率 {(fl.get('control') or {}).get('avail')}%",
        f"总停机 {R.get('总停机h')} h = 设备类 {R.get('设备类停机h')} + 外部类 {R.get('外部类停机h')}",
        f"平均停机间隔 {M.get('MTBF_h')} h; 停机 {M.get('停机事件数')} 起; 单次平均 {M.get('MDT_h')} h",
        f"报警 {F.get('total')} 条 / {F.get('n_codes')} 个码",
        f"需行动机组 {len(BD.get('rows') or [])} 台; 卡点 {BD.get('stuck')}",
        # 占比直接给出: 不给模型就得自己算, 算对了也会被接地闸判为"未接地数字"(实测 31.4/46.6)
        f"损失构成: " + '; '.join(
            f"{x['k']} {x['loss']} MWh (占损失 {round(x['loss'] / max(E.get('loss') or 1, 1) * 100, 1)}%)"
            for x in (E.get('items') or [])),
        f"停机 {R.get('总停机h')} h 中设备类占 {round((R.get('设备类停机h') or 0) / max(R.get('总停机h') or 1, 1) * 100, 1)}%",
        f"端到端闭环 {len(BD.get('closed') or [])} 例",
    ]
    prompt = (f"可用数据:\n" + '\n'.join('- ' + x for x in facts) +
              f"\n\n可选块 (只能从这里选): {', '.join(RPT_BLOCK_KEYS)}"
              f"\n块的含义: kpi=一级指标 water=能量瀑布 emon=逐月发电 blame=损失分账 ram=可靠性象限 "
              f"parts=部件停机 attrib=归因覆盖 pareto=故障帕累托 quad=故障四象限 frate=月度故障率 "
              f"units=重点机组 chain=决策链 loop=闭环实证 plan=下期建议 caliber=口径边界"
              f"\n\n当前画布: {', '.join(canvas) if canvas else '(空)'}"
              f"\n用户要求: {need}")
    import urllib.request as _ur      # 顶部只 import urllib.parse, urllib.request 需显式导入
    body = dict(model=model, messages=[dict(role='system', content=RPT_SYS),
                                       dict(role='user', content='/no_think ' + prompt)],
                stream=False, keep_alive='30m', options=dict(num_ctx=8192, num_predict=800))
    t0 = _t.time()
    try:
        req = _ur.Request('http://127.0.0.1:11434/api/chat', data=json.dumps(body).encode(),
                          headers={'Content-Type': 'application/json'})
        with _ur.urlopen(req, timeout=300) as r:
            txt = (json.loads(r.read())['message'].get('content') or '')
    except Exception as e:
        return dict(err=f'本地模型不可达: {str(e)[:120]}')
    txt = re.sub(r'<think>.*?</think>', '', txt, flags=re.S).strip()
    mb = re.search(r'BLOCKS\s*[:：]\s*(.+)', txt)
    mt = re.search(r'TEXT\s*[:：]\s*(.+)', txt, re.S)
    blocks = [b.strip() for b in re.split(r'[,，\s]+', mb.group(1))] if mb else []
    blocks = [b for b in blocks if b in RPT_BLOCK_KEYS]
    narrative = (mt.group(1).strip() if mt else '').strip()
    # 接地闸: 叙述里的数字必须在 facts 里出现 (同 fast_agent 的 grounding 口径)
    bad = []
    try:
        from src.windscada.audit import grounding as _gr
        ok, b = _gr(narrative, '\n'.join(facts))
        bad = (b or {}).get('numbers') or []
    except Exception:
        pass
    return dict(blocks=blocks, narrative=narrative, model=model,
                secs=round(_t.time() - t0, 1), ungrounded=bad, raw=txt[:900])


ASK_CAT_HINTS = {
    '设备类': '(设备状态类: 从本体的机组档案、对象查询与机制检索三条路取证)',
    '检修排程决策': '(检修排程类: 用 ont_scenario/ont_get 取排期沙盘与验收树; 建议级动作注明待人裁)',
    '损失分析': '(损失分析类: 用 ont_loss/ont_scenario 取证; 电量kWh为主, 金额必带电价区间0.391~0.85口径; 限电类损失≠设备责任)',
    '安全风险预测': '(风险预测类: 用 ont_risk/ont_mechanism_search 取证; 区分升级中/稳定高位/盲区, 未列≠正常, 不可判≠阴性)',
}


ASK_CAT_HINTS_EN = {
    '设备类': '(Equipment state: use unit profiles, object queries and mechanism search for evidence)',
    '检修排程决策': '(Maintenance scheduling: use scenarios and acceptance trees; mark advisory actions as pending human decision)',
    '损失分析': '(Loss analysis: use loss accounts and scenarios; energy in kWh/MWh, monetary value must carry the tariff-range caveat)',
    '安全风险预测': '(Risk prediction: distinguish escalating, stable-high and blind-spot cases; no listing is not proof of normality)',
}


def ask_start(q, model, cat='', xrev=False, lang='zh', display_q=''):
    import threading, time as _t
    if not q.strip():
        return dict(err='问题为空' if lang != 'en' else 'The question is empty')
    if ASK['state'] in ('running', 'partial'):   # partial = 初答已出、27B 复核中, 仍占槽
        return dict(err='已有问题在推理中 (串行锁, 一次一问)', state=ASK['state'])
    if model not in ASK_MODELS:
        return dict(err=f'未知模型 {model}; 可选 {list(ASK_MODELS)}')
    hints = ASK_CAT_HINTS_EN if lang == 'en' else ASK_CAT_HINTS
    q2 = (hints.get(cat, '') + ' ' + q).strip()
    if lang == 'en':
        try:
            from src.windscada.deid import ununitize_question
            q2 = ununitize_question(q2)
        except Exception as e:
            print('[ask] 代号反解失败: %s' % e, file=sys.stderr)
    ASK.update(state='running', q=display_q or q, model=model, answer='', verify=None, err='', t0=_t.time(),
               step='启动' if lang != 'en' else 'Starting', steps=[], review=None, lang=lang)
    ASK['xrev'] = bool(xrev)
    threading.Thread(target=_ask_worker, args=(q2, model, lang), daemon=True).start()
    return dict(state='running', model=model)


def ask_status():
    import time as _t
    d = dict(ASK)
    d['elapsed'] = int(_t.time() - ASK['t0']) if ASK['t0'] else 0
    return d


# ---------- 台内即时查询 ----------
_RAW_CACHE = {}
def adhoc_query(t, ch, win, agg):
    from src.windscada.data import load_10min, contracted_cols
    _load()
    key = t
    with LOCK:
        if key not in _RAW_CACHE:
            if len(_RAW_CACHE) > 6: _RAW_CACHE.clear()
            try:
                _RAW_CACHE[key] = load_10min(t, CFG, groups=['A.功率', 'A.风况', 'A.转速', 'A.状态', 'B.变桨', 'B.温度NBM', 'B.偏航', 'B.润滑液压'])
            except Exception as e:
                # 2026-09-11 场景① 逮: 原始件不在时这里原来直接把异常抛给 HTTP 处理器 → 前端拿到 500,
                # 面板只显示"服务器错误", 人看不出是"没放数据"还是"程序坏了"。改为**结构化的无数据**回答:
                # 与成功路径同一个形状 (kind/title/unit/months/series/note), 前端按正常渲染即可显示原因。
                src = CFG.get('src_10min')
                return dict(kind='multiline', title=f'{t} {i18n.ch_cn(ch)}', unit='', months=[], series=[],
                            err='no_source',
                            note=f'无原始件: 本机应在 {src}\\{t}.csv (即 data\\raw\\<场站名称>\\scada_10min\\)'
                                 f' — 放入后重跑 scripts\\rebuild_from_raw.py --scada')
    d = _RAW_CACHE[key]
    if ch not in d.columns: return dict(err=f'通道 {ch} 不在契约内')
    ms = months_of(win)
    dd = d[d.ts.dt.to_period('M').astype(str).isin(ms)]
    if agg == 'daily':
        g = dd.groupby(dd.ts.dt.date)[ch].median()
        xs = [str(x) for x in g.index]
    else:
        g = dd.groupby(dd.ts.dt.to_period('M').astype(str))[ch].median() if agg == 'med' else \
            dd.groupby([dd.ts.dt.to_period('M').astype(str), dd.ts.dt.date])[ch].sum().groupby(level=0).mean()
        xs = list(g.index)
    agg_cn = {'med': '月中位', 'sum': '月duty(秒/日)', 'daily': '逐日中位'}.get(agg, agg)
    fig = dict(kind='multiline', title=f'{t} {i18n.ch_cn(ch)} ({agg_cn}, {win})', unit='', months=xs,
               series=[dict(name=i18n.ch_cn(ch, with_tag=False), vals=[None if v != v else round(float(v), 3) for v in g])], note='台内即时查询')
    # fleet 带 (若月仓有)
    for store, col in ((_CACHE['tm'], 'med'), (_CACHE['duty'], 'val')):
        if store is None or agg == 'daily': continue
        gg = store[store.channel == ch]
        if len(gg):
            piv = gg.pivot_table(index='month', columns='turbine', values=col).reindex(xs)
            fig = dict(kind='band', title=fig['title'], unit='', months=xs,
                       self=[None if v != v else round(float(v), 3) for v in piv.get(t, pd.Series(index=xs, dtype=float))],
                       med=[None if v != v else round(float(v), 3) for v in piv.median(axis=1)],
                       q1=[None if v != v else round(float(v), 3) for v in piv.quantile(.25, axis=1)],
                       q3=[None if v != v else round(float(v), 3) for v in piv.quantile(.75, axis=1)], note='灰带=全场四分位 (月仓)')
            break
    return fig

def channel_list():
    from src.windscada.data import contract
    c = contract(CFG)
    out = {}
    for g, cols in c['groups'].items():
        out[g] = [dict(code=k, cn=i18n.ch_cn(k, with_tag=False) + ' · ' + k) for k, v in cols.items() if v['liveness'] == '活']
    return out

# ---------- HTML ----------
from src.windscada.design import CSS as BASE_CSS

CHART_JS = """
// 设备状态色 = 观澜语义色单源 (2026-08-28 用户裁: 观澜色块体系更好, 保留; windcms 那边改过来)
// 对照 windcms 现值见 design.py 的 --st-* (迁移期保留, 供振动线对齐用)
const C={'优秀':'var(--ok)','良好':'var(--info)','报警':'var(--warn)','危险':'var(--bad)','不可判':'var(--unknown)','监测不可用':'var(--unknown)','无监测':'var(--unknown)'};
// 传动链运动简图 (2026-08-28 用户令"纯图形": 弃方块标签, 用工程简图语言 —
// 轴=横线 · 齿轮=竖矩形(啮合处相切) · 轴承=剖面符号 · 行星级=齿圈+行星架 · 发电机=定子/转子;
// 只有命中部件着色并标名, 其余全灰 = 一眼看出"链条哪一环出问题")
const baBar=(pre,post,col)=>{
  const M=Math.max(pre,post,7), W=120, sc2=v=>Math.max(2,v/M*(W-4));
  return `<svg class="dt" viewBox="0 0 ${W} 26" style="width:${W}px;height:26px">
    <rect x="2" y="2" width="${sc2(pre).toFixed(1)}" height="9" rx="2" fill="var(--muted)" fill-opacity="0.55"/>
    <rect x="2" y="15" width="${sc2(post).toFixed(1)}" height="9" rx="2" fill="${col}" fill-opacity="0.9"/>
  </svg>`};
const esc=t=>String(t==null?'':t).replace(/&/g,'&amp;').replace(/"/g,'&quot;').replace(/</g,'&lt;');
// 温度偏差条: 0 为中线的双向条 (方向即符号, 长度即幅度, 色即判级) + 数字并存
const devBar=(ch,dev,vd,raw)=>{
  if(dev==null||dev===undefined) return `<span class="small">${esc(raw).slice(0,30)}</span>`;
  const M=6, W=104, mid=W/2, k=Math.max(-1,Math.min(1,dev/M)), bw=Math.abs(k)*(mid-8);
  // 只有真越档(|dev|>=3K)才上语义色, 其余淡灰 — 避免整列彩条抢注意力
  const strong = Math.abs(dev) >= 3;
  const col = !strong ? 'var(--muted)' : (/候选/.test(vd||'')?'var(--warn)':/记基线/.test(vd||'')?'var(--info)':/不可判|返服/.test(vd||'')?'var(--unknown)':'var(--muted)');
  const over=Math.abs(dev)>M;
  return `<div title="${esc(raw)}" style="display:flex;align-items:center;gap:7px">
    <svg class="dt" viewBox="0 0 ${W} 18" style="width:${W}px;height:18px;flex:none">
      <line x1="4" y1="9" x2="${W-4}" y2="9" stroke="var(--line)" stroke-width="1" stroke-opacity="0.7"/>
      <line x1="${mid}" y1="1" x2="${mid}" y2="17" stroke="var(--muted)" stroke-width="1" stroke-opacity="0.6"/>
      <rect x="${dev>=0?mid:mid-bw}" y="4" width="${Math.max(bw,1.5)}" height="10" rx="2" fill="${col}" fill-opacity="0.9"/>
      ${over?`<path d="M${dev>0?W-5:5},9 l${dev>0?-5:5},-4 v8 z" fill="${col}"/>`:''}
    </svg>
    <b class="small" style="font-variant-numeric:tabular-nums;color:${col}">${dev>0?'+':''}${dev}K</b></div>
    <div class="small" style="color:var(--muted);margin-top:1px">${esc(ch||'')}</div>`};
// 证据窗时间条: 固定 2026-01→09 轴, 块=claim 窗覆盖段 (跨行可比, 一眼看窗对不对得上)
const winBar=(spans,raw)=>{
  if(!spans||!spans.length) return `<span class="small" title="${esc(raw)}">未标窗</span>`;
  const T0=Date.parse('2026-01-01'), T1=Date.parse('2026-09-01'), W=118;
  const px=d=>{const v=Date.parse(d); return 3+Math.max(0,Math.min(1,(v-T0)/(T1-T0)))*(W-6)};
  const blocks=spans.map(([a,b])=>{const x1=px(a), x2=px(b);
    return `<rect x="${x1.toFixed(1)}" y="4" width="${Math.max(x2-x1,2.5).toFixed(1)}" height="10" rx="2" fill="var(--accent)" fill-opacity="0.8"/>`}).join('');
  return `<div title="${esc(raw)}"><svg class="dt" viewBox="0 0 ${W} 18" style="width:${W}px;height:18px">
    <rect x="3" y="4" width="${W-6}" height="10" rx="2" fill="var(--line)" fill-opacity="0.5"/>${blocks}</svg>
    <div class="small" style="color:var(--muted)">${spans.length} 个窗段</div></div>`};
// 油液时效胶囊: 绿=近共时可作现时判据 / 灰=stale 只作回测锚
const oilPill=(last,fresh,raw)=>`<div title="${esc(raw)}" style="display:flex;align-items:center;gap:6px">
  <i style="width:9px;height:9px;border-radius:50%;flex:none;background:${fresh?'var(--ok)':'var(--unknown)'}"></i>
  <span class="small" style="font-variant-numeric:tabular-nums">${last||'无样'}</span></div>
  <div class="small" style="color:var(--muted)">${last?(fresh?'近共时':'stale &gt;12 个月'):'—'}</div>`;
// 术语去黑话 (2026-08-28 用户令"翻译·审核黑话"): 内部判级词/口径缩写 → 现场话, 括注保留原词以便对账
const JARGON=[[/正样本/g,'健康对照台'],[/可降(?![级])/g,'可降级观察'],[/记基线观察/g,'记基线·下轮复核'],
  [/CLAIM窗|claim窗/g,'证据窗'],[/位次([0-9]+)[/]([0-9]+)/g,'全场第$1名(共$2台)'],[/未列 [(（]≠正常[^)）]*[)）]/g,'未收录 (≠已排除异常)'],
  [/温度候选[(]定向查[)]/g,'温度偏高·待定向排查'],[/最大偏/g,'偏差最大通道'],[/单次([0-9]+)s/g,'单次循环 $1 秒'],
  [/窗内无样/g,'本窗未取样'],[/仲裁输入/g,'待仲裁输入'],[/无新证/g,'本轮无新证据'],[/降观察/g,'降为观察'],
  [/弱同向新证/g,'弱同向新证据'],[/传感器项/g,'测量链(仪器)问题'],[/份样/g,' 份油样'],[/NBM/g,'基线模型(NBM)']];
// 表述规范单源 = windcms agent.py 的业主口径注解 (2026-08-28 用户令: 等级评价和表述一定要参照 windcms)。
// 规范原文: 状态等级打头(优秀=未见异常保持常规监视 / 良好=轻微偏离记录观察 / 报警=存在需现场核实或处置的异常 /
//   危险=异常严重建议尽快停机检查 / 不可判=数据不足或监测中断); 证据状态放括号里说可信度
//   (候选=待现场核实 / 准定论·预警=基本确认 / 候选·新发=新出现待核实 / 候选·记基线=已记为基线下窗观察 /
//    参考=仅记录 / INSUFFICIENT=数据不足 / 撤回=已取消)。
// ★不自造措辞: 之前我译的"待现场核实/观察即可"虽通顺但偏离了 windcms 词表, 已撤。
const ST_NOTE = {'优秀':'未见异常, 保持常规监视', '良好':'轻微偏离, 记录观察',
  '报警':'存在需现场核实或处置的异常', '危险':'异常严重, 建议尽快停机检查', '不可判':'数据不足或监测中断'};
const EV_NOTE = {'候选':'待现场核实', '准定论·预警':'基本确认', '候选·新发':'新出现待核实',
  '候选·记基线':'已记为基线, 下窗观察', '参考':'仅记录', 'INSUFFICIENT':'数据不足',
  '定论':'已定案', '正常':'未见异常', '撤回':'已取消'};
const plain = t => String(t || '');   // 判级词一律用 windcms 原词, 注解走 ST_NOTE/EV_NOTE
// 振动技术速记 → 人话 (2026-08-28 用户令: 黑话改掉)。只翻术语不动数字, 原文进悬停。
// 顺序敏感: 长词先于短词 (DE/NDE 要先于 DE), 否则会被短词切碎。
const VIBJARGON = [
  [/DE[/]NDE/g, '驱动端与非驱动端'], [/GenDE/g, '发电机驱动端'], [/GenNDE/g, '发电机非驱动端'],
  [/HS_gen2?/g, '高速轴发电机侧'], [/HS_rot/g, '高速轴转子侧'], [/IMS/g, '中间轴'],
  [/(?<![A-Za-z])NDE(?![A-Za-z])/g, '非驱动端'], [/(?<![A-Za-z])DE(?![A-Za-z])/g, '驱动端'],
  // 复合词先于单词: 原文"内圈BPFI"若先翻 BPFI 会变成"内圈内圈特征频率"
  [/内圈BPFI/g, '内圈特征频率'], [/外圈BPFO/g, '外圈特征频率'],
  [/BPFI/g, '内圈特征频率'], [/BPFO/g, '外圈特征频率'], [/FTF/g, '保持架特征频率'], [/BSF/g, '滚动体特征频率'],
  [/TD_1R/g, '时域单转指标'], [/Peak/g, '冲击峰值'], [/Rms/gi, '有效值'],
  [/([0-9]+(?:[.][0-9]+)?)[ ]*阶/g, '$1 倍轴频'], [/[(]o([0-9]+(?:[.][0-9]+)?)[)]/g, '(轴频 $1 倍)'],
  [/×p90/g, '×全场90分位'], [/×fleet/g, '×全场中位'],
  [/六窗/g, '六个观测窗'], [/([0-9])窗/g, '$1 个观测窗'],
  [/宽带/g, '宽频带总量'], [/台阶/g, '阶跃上升'], [/缓升/g, '缓慢上升'], [/回落/g, '回落至'],
  [/全净|六窗全净/g, '各窗均干净'], [/清洁/g, '干净'], [/回归/g, '回到常态'],
  // 替换文本本身不得含后续规则会再匹配的词 (原写'见族主台'会被下一条的 /族/ 二次替换)
  [/同族/g, '同批次共性 (见该批主台)'], [/族第([^ ]+)台/g, '同批次第$1台'], [/族/g, '批次共性组'],
  [/gain异常/g, '测点增益异常'], [/gain/g, '测点增益'],
  [/[(]销[)]/g, '(已销案)'], [/梯度/g, '沿链梯度最高点'],
  [/周期主导/g, '周期成分主导'], [/急性事件/g, '突发事件'], [/慢性/g, '长期'],
  [/主异常在/g, '主要异常位于'],
];
const vibPlain = t => { let x = String(t || ''); VIBJARGON.forEach(([a, b]) => x = x.replace(a, b)); return x; };
const zh=t=>{let x=String(t==null?'':t); JARGON.forEach(([a,b])=>x=x.replace(a,b)); return x};
// 族分布堆叠条 (报警列)
// 族分布条 (2026-08-28 用户逮"故障多少长度都一样"):
// 条总长 = 该台条数/全场最大 → 跨行可比 (原来段宽按台内占比算, 总和恒 100% 所以每行一样长, 量的信息全丢);
// 段内比例 = 族构成。总长封顶 118px, 最短 6px 保证可见。
const famBar=(fam,n,maxN)=>{
  if(!n) return `<span class="small" style="color:var(--muted)">窗内无报警</span>`;
  const CO={'齿轮箱':'#8A6D3B','发电机':'#4A6FA5','主轴承':'#2E7D6B','变桨叶片':'#4A6FA5','偏航':'#2E7D6B','测风':'#7C5295','其他':'#5A6470'};
  const W=118, w=Math.max(6, Math.round(n/Math.max(maxN||n,1)*W));
  return `<div title="${n} 条 · 全场最多 ${maxN||n} 条" style="display:flex;height:9px;border-radius:3px;overflow:hidden;width:${w}px">`
    +fam.map(f=>`<i title="${f.k} ${f.n}" style="width:${(f.n/n*100).toFixed(1)}%;background:${CO[f.k]||'#5A6470'}"></i>`).join('')
    +`</div><div class="small" style="color:var(--muted);margin-top:3px">${fam.slice(0,2).map(f=>f.k+' '+f.n).join(' · ')}</div>`};
const PART2SYS=p=>/主轴承|主轴/.test(p)?'主轴承':/齿轮|行星|中间|中速|高速/.test(p)?'齿轮箱':/发电机/.test(p)?'发电机':p;
// ────────────────────────────────────────────────────────────────────────
// 报表汇报端口 (2026-08-28 用户令: 按客户汇报管理要求做定制化报表端口, 一级显示, ontology 支持)
//
// 范式不是自创的 — 国内风电场上报集团的月度运行分析报告结构是固定的:
//   发电完成 → 设备运行 → 故障分析 → 限电情况 → 检修执行 → 重点机组 → 下期计划。
// 端口做三件事: ①选范式与周期 ②勾章节(定制化) ③选受众(决定脱敏级别)。
// "一级显示" = 顶部六个核心指标用大字直出, 明细下沉到章节; 领导只看第一屏也拿得到结论。
// 每个数字带口径与来源, 结论可回溯到本体对象 — 这是它区别于"手搓 PPT"的地方。
// ────────────────────────────────────────────────────────────────────────
// 报表画布 (2026-08-28 用户令: "像画布一样让客户选, 不是放太多信息")
//
// 改法: 从"满配 + 关掉不要的"翻成"空画布 + 挑要的"。前者默认给一大堆再让人做减法,
// 客户看到的是负担; 后者每加一块都是一次主动选择, 报告长度天然由客户控制。
// 组件粒度也从"章"降到"块" — 一张图/一张表就是一块, 挑的时候看得见自己在放什么。
// 范式(月报/周报/专题/年度) 退化为**预设组合**: 点一下把一组块填进画布, 之后照样能加减调序。
// 组件按主题分组 (2026-08-28 用户"交互界面设计一下"): 15 块平铺成两行时,
// 客户要在一堆同质按钮里找, 且原生 title 弹出会遮住旁边两个按钮 (截图逮)。
// 改为按报告的叙事顺序分五组, 说明走固定说明区不浮动。
const RPT_GROUPS = [['发电', 'gen'], ['可靠性', 'rel'], ['故障', 'flt'], ['机组', 'unit'], ['收尾', 'end']];
const RPT_BLOCKS = {
  kpi:    {g:'gen',  nm:'一级指标',     ic:'▦', d:'六个核心数: 上网电量 / 等效满发 / 可用率 / 损失率 / 停机间隔 / 需行动台'},
  water:  {g:'gen',  nm:'能量瀑布',     ic:'▤', d:'理论可发 → 逐段扣损 → 实际上网, 用于定位电量流向'},
  emon:   {g:'gen',  nm:'逐月发电表',   ic:'▥', d:'逐月上网 / 损失 / 损失率 / 等效满发, 含数据覆盖率'},
  blame:  {g:'gen',  nm:'损失责任分账', ic:'◧', d:'交易调度侧 / 设备侧 / 运行侧 三段占比 — 回答"谁的责任"'},
  ram:    {g:'rel',  nm:'可靠性象限',   ic:'◈', d:'MTBF × MDT 部件象限, 分出"频发易修"与"罕发难修", 处置方向相反'},
  parts:  {g:'rel',  nm:'部件停机表',   ic:'▤', d:'逐部件停机时长 / 事件数 / MTBF / MDT / 影响台数'},
  attrib: {g:'rel',  nm:'归因覆盖',     ic:'▬', d:'已归因 vs 无记录停机的占比 — 无记录不等于没有故障'},
  pareto: {g:'flt',  nm:'故障帕累托',   ic:'▮', d:'按条数降序 + 累计 80% 线, 找关键少数'},
  quad:   {g:'flt',  nm:'故障四象限',   ic:'◇', d:'条数 × 单次时长, 区分重复触发与实际停机 — 按条数排序会误定优先级'},
  frate:  {g:'flt',  nm:'月度故障率',   ic:'▪', d:'按天归一的日均条数, 数据不满月单独标注'},
  units:  {g:'unit', nm:'重点机组',     ic:'☰', d:'需跟踪台的部件 / 证据源 / 六步进度 / 卡在哪一步'},
  chain:  {g:'unit', nm:'决策链进度',   ic:'⛓', d:'证据→机制→判级→排期→动作→验收 六步的瓶颈分布'},
  loop:   {g:'unit', nm:'闭环实证',     ic:'✓', d:'检出 → 换件 → 复测回落的历史例证, 证明这条链是通的'},
  plan:   {g:'end',  nm:'下期建议',     ic:'✎', d:'由数据推出的行动项, 不是套话'},
  caliber:{g:'end',  nm:'口径与边界',   ic:'⚑', d:'统计期 / 残月 / 工单窗 / 判级性质 — 建议常驻, 没有边界的数字堆不能作汇报依据'},
  narr:   {g:'end',  nm:'运行总结',     ic:'✍', d:'本地模型基于实测数据生成的运行总结 — 为图表补充文字结论, 供汇报使用'},
};
const RPT_PRESETS = {
  month: {nm:'月度运行分析', blocks:['kpi','water','emon','blame','ram','pareto','units','plan','caliber']},
  week:  {nm:'周报',        blocks:['kpi','frate','units','plan','caliber']},
  topic: {nm:'设备专题',    blocks:['units','chain','ram','loop','caliber']},
  year:  {nm:'年度总结',    blocks:['kpi','water','emon','ram','loop','caliber']},
  blank: {nm:'空白画布',    blocks:[]},
};
function rptInit(){
  if(!window.RPTAUD) window.RPTAUD='in';
  // 默认空画布 (2026-08-28 用户令"都去掉, 只剩选项栏"): 打开只有选项栏, 一块都不预填。
  // 起手给几块仍是替客户做决定 — 画布的意思就是空着等人放东西。
  if(!window.RPTCANVAS) window.RPTCANVAS=[];
}
// 报告定制交互 (2026-08-28 用户令: 留一个互动交互窗, 报告按定制, 离线模型支持)。
// 模型做两件事: 按需求挑组件 + 据实测摘要写总结。数字全部来自后端摘要, 生成后过接地闸;
// 模型自己算的派生值(如占比求和)会被标出来让人核 — 算得对也要标, 因为核不了的数字不能进报告。
// ★下拉原来写死两个**本地**模型 (qwen3:8b / qwen3.8:27b), 而云端部署上一个都没配;
//   /api/rpt_compose 在云端的问答微服务里也不存在 (只有 ask / ask_status / ask_models)。
//   于是这个按钮在生产环境是死的: 点了拿回 404 的 {"err":"not found"}, 显示成 "not found"。
//   改为按**实际可用**填充: 有编排接口才启用, 模型清单与问答助手同源 (/api/ask_models)。
//   交付件不该摆一个点了就报错的按钮。
// ★不能叫 rptInit —— 上面 L1528 已经有一个同名函数 (初始化 RPTAUD / RPTCANVAS)。
//   函数声明后者覆盖前者, 于是 RPTAUD 永远初始化不了, 渲染直接 ReferenceError,
//   整个汇报定制面板消失。命名撞车只在运行时才炸, 语法闸看不见。
// ★模型下拉必须按**实际配了密钥的**填, 不能把 MODEL_SPEC 全列出来 ——
//   MODEL_SPEC 是"档位说明表"(含本地档), 不是"可用清单"。全列出来并默认选第一个
//   (qwen3:8b, 本地档) 的后果: 用户一提问就报「模型 qwen3:8b 未配置密钥」。
//   云主机 2 核 1GB, 本地模型本来就跑不起来。可用清单唯一来源 = /api/ask_models。
async function fillModels(selId){
  const sel=document.getElementById(selId); if(!sel) return {};
  let models={};
  try{ models=(await (await fetch('/api/ask_models')).json()).models||{} }catch(e){}
  const ks=Object.keys(models);
  sel.innerHTML = ks.length
    ? ks.map(k=>{const v=MODEL_SPEC[k]||{}; return `<option value="${k}">${v.nm||k}${v.loc?' · '+v.loc:''}${v.t?' · '+v.t:''}</option>`}).join('')
    : '<option value="">无可用模型</option>';
  return models;
}
async function askModelInit(){
  await fillModels('askm');
  if(typeof mdlNote==='function') mdlNote();
}
async function rptModelInit(){
  const sel=document.getElementById('rptmdl'), btn=document.getElementById('rptgo'),
        out=document.getElementById('rptout');
  if(!sel) return;
  let hasCompose=false;
  const models=await fillModels('rptmdl');
  // 编排已移植上云 (2026-09-01), 故改回**真探测** —— 拦截器已把 rpt_compose 放行到
  // 真网络, 探得到 200 就启用, 离线打开探不到就禁用并说明。
  try{ const r=await fetch('/api/rpt_compose?probe=1'); hasCompose = !!(r&&r.ok) }catch(e){ hasCompose=false }
  const ks=Object.keys(models);
  // ★这句原文是「本地模型…数据不出本地」—— 选 DeepSeek 时数据当然出本地。
  //   与徽章同一判据: 按选中档位的 loc 给话, 不写死。
  const hint=document.getElementById('rpthint');
  const syncHint=()=>{ if(!hint) return;
    const v=MODEL_SPEC[sel.value]||{};
    hint.innerHTML='模型依据需求选取组件, 并基于实测数据生成运行总结'
      + (v.loc==='本地' ? '; 数据不出本地'
         : '; <span style="color:var(--warn)">内容会外发到模型厂商</span>'); };
  sel.addEventListener('change', syncHint); syncHint();
  if(!hasCompose||!ks.length){
    if(btn){ btn.disabled=true; btn.style.opacity='.5'; btn.style.cursor='not-allowed' }
    if(out) out.innerHTML = !ks.length ? '本部署未配置任何模型密钥, 编排不可用'
                                       : '本部署未启用编排接口, 画布仍可手动拼装';
  }
}
async function rptCompose(){
  const need=(document.getElementById('rptneed')||{}).value||'';
  const mdl=(document.getElementById('rptmdl')||{}).value||'qwen3:8b';
  const out=document.getElementById('rptout');
  if(!need.trim()){ out.innerHTML='先输入报告要求'; return }
  const _sp=MODEL_SPEC[mdl]||{}, _loc=(_sp.loc==='本地');
  out.innerHTML='<span style="color:var(--accent)">模型编排中…</span> 挑组件 + 写总结'
    + (_loc ? ', 全程零外发' : ', <span style="color:var(--warn)">内容会外发到模型厂商</span>');
  let d;
  try{ d=await (await fetch(`/api/rpt_compose?need=${encodeURIComponent(need)}&canvas=${encodeURIComponent(RPTCANVAS.join(','))}&model=${encodeURIComponent(mdl)}`)).json(); }
  catch(e){ out.innerHTML=`<span style="color:var(--bad)">生成失败: ${e.message}</span>`; return }
  if(d.err){ out.innerHTML=`<span style="color:var(--bad)">${d.err}</span>`; return }
  window.RPTNARR={text:d.narrative, model:d.model, ungrounded:d.ungrounded||[]};
  const bl=(d.blocks||[]).filter(b=>RPT_BLOCKS[b]);
  if(bl.length) window.RPTCANVAS = (d.narrative? ['narr'] : []).concat(bl);
  else if(d.narrative && !RPTCANVAS.includes('narr')) RPTCANVAS.unshift('narr');
  out.innerHTML=`已按需求编排 <b>${bl.length}</b> 块${d.narrative?' + 一段运行总结':''} ·
    ${d.model} 用时 ${d.secs}s${(d.ungrounded||[]).length?` · <span style="color:var(--warn)">${d.ungrounded.length} 个数字待核</span>`:' · 数字全部接地'}`;
  render();
  setTimeout(()=>{const el=document.getElementById('rptout'); if(el&&!el.innerHTML) el.innerHTML='';},50);
}
function rptExport(fmt){
  // 导出走后端生成真 .docx/.xlsx: 图表块转成对应数据表, 信息不丢且可核对。
  // 上报版沿用界面同一套脱敏规则, 不需要导出后再手工处理。
  if(!RPTCANVAS.length){ alert('画布是空的 — 先从组件库选内容'); return }
  const n=(window.RPTNARR&&RPTNARR.text)?RPTNARR.text:'';
  const win=(window.D&&D.win)||'2026年';
  const url=`/api/rpt_export?fmt=${fmt}&blocks=${encodeURIComponent(RPTCANVAS.join(','))}`
    +`&aud=${RPTAUD}&win=${encodeURIComponent(win)}&narr=${encodeURIComponent(n.slice(0,4000))}`;
  const a=document.createElement('a'); a.href=url; a.download=''; document.body.appendChild(a); a.click(); a.remove();
}
function rptHint(k){
  // 固定说明区而非浮动 tooltip: 原生 title 弹出会盖住相邻按钮 (用户截图逮),
  // 且鼠标一移就消失, 读不完。放在组件库下方定位不动。
  const el=document.getElementById('rpthint'); if(!el) return;
  const v=k?RPT_BLOCKS[k]:null;
  el.innerHTML = v ? `<b style="color:var(--ink)">${v.ic} ${v.nm}</b> — ${v.d}`
    : '悬停查看组件说明 · 已选组件再次点击移出 · 右侧 ↑↓ 调整顺序';
}
function rptPreset(k){ window.RPTCANVAS=RPT_PRESETS[k].blocks.slice(); render(); }
function rptAdd(k){ if(!RPTCANVAS.includes(k)){ RPTCANVAS.push(k); render(); } }
function rptDel(k){ const i=RPTCANVAS.indexOf(k); if(i>=0){ RPTCANVAS.splice(i,1); render(); } }
function rptMove(k,dir){
  const i=RPTCANVAS.indexOf(k), j=i+dir;
  if(i<0||j<0||j>=RPTCANVAS.length) return;
  [RPTCANVAS[i],RPTCANVAS[j]]=[RPTCANVAS[j],RPTCANVAS[i]]; render();
}
function rptK(v,u,lab,note,cls){
  return `<div class="kpi ${cls||''}"><b>${v}<span> ${u}</span></b>
    <span>${lab}<br><span style="opacity:.8">${note||''}</span></span></div>`;
}

function rptBlock(k, d){
  const E=(d.control&&d.control.energy)||{}, em=E.monthly||[], R=(d.rel&&!d.rel.err)?d.rel:null,
        M=(d.m8&&!d.m8.err)?d.m8.mtbf:null, F=d.faults||{}, FU=d.fus||{}, BD=(FU.链盘)||{};
  const wrap=(t,b,src)=>`<div class="card mb"><h3>${t}</h3>${b}
    ${src?`<p class="small" style="color:var(--muted);margin-top:8px;padding-top:7px;border-top:1px solid var(--line-2)">口径: ${src}</p>`:''}</div>`;
  if(k==='kpi'){
    const last=em[em.length-1]||{}, prev=em[em.length-2]||{};
    const cmpOK=(last.cov||0)>=0.5 && (prev.cov||0)>=0.5;
    const dl=(a,b)=>b?((a-b)/b*100):0;
    return `<div class="kpis" style="margin-bottom:14px">
      ${rptK((E.act||0).toLocaleString(),'MWh','上网电量',`理论可发 ${(E.theo||0).toLocaleString()} ｜ ${cmpOK?`环比 ${dl(last.act,prev.act)>=0?'+':''}${dl(last.act,prev.act).toFixed(0)}%`:'环比不可比(末月不满)'}`)}
      ${rptK((E.eflh||0).toLocaleString(),'h','等效满发小时',`年化约 ${Math.round((E.eflh||0)/Math.max(em.filter(x=>x.cov>=0.5).length,1)*12).toLocaleString()} h`)}
      ${rptK(d.control&&d.control.avail,'%','时间可用率','不含调度令与低风待机',(d.control&&d.control.avail>=95)?'ok':'warn')}
      ${rptK(E.loss_pct,'%','损失率',`${(E.loss||0).toLocaleString()} MWh`,(E.loss_pct>=15)?'warn':'')}
      ${rptK(M?M.MTBF_h:'—','h','平均停机间隔',`停机 ${M?M.停机事件数:'—'} 起 · 单次均 ${M?M.MDT_h:'—'}h`)}
      ${rptK((BD.rows||[]).length,'台','需行动机组',`定论 ${(FU.kpi||{}).定论||0} · 预警 ${(FU.kpi||{}).预警||0} · 候选 ${(FU.kpi||{}).候选观察||0}`,(BD.rows||[]).length>20?'warn':'')}</div>`;
  }
  if(k==='water') return wrap('发电完成情况', waterfall(E)+
    `<p class="small" style="color:var(--muted);margin-top:6px">理论可发 ${(E.theo||0).toLocaleString()} = 上网 ${(E.act||0).toLocaleString()} + 损失 ${(E.loss||0).toLocaleString()} MWh (${E.loss_pct}%)
    ｜ <span title="不是物理判据: 正常数据下必然通过。它的作用是当损失被高估到不可能时(台账数字虚高曾把损失写成超过全停上限)立刻拦下">量级自检</span>: 理论 ${E.cap_ok?'低于':'≥'} 全额定上限 ${(E.cap||0).toLocaleString()} MWh ${E.cap_ok?'✔':'✗ 数字不可信'}</p>`,
    'SCADA 10min 工况态分解; 损失=同工况理论出力与实测之差。量级自检为防虚高的下限闸, 不是风资源判据');
  if(k==='emon') return wrap('逐月发电', em.length?`<table><tr><th>月</th><th class="num">上网 MWh</th><th class="num">损失 MWh</th><th class="num">损失率</th><th class="num">等效满发 h</th><th>覆盖</th></tr>
    ${em.map(x=>`<tr><td>${x.m}</td><td class="num">${x.act.toLocaleString()}</td><td class="num">${x.loss.toLocaleString()}</td><td class="num">${x.loss_pct}%</td><td class="num">${x.eflh}</td>
    <td class="small" style="color:${x.cov<0.5?'var(--warn)':'var(--muted)'}">${(x.cov*100).toFixed(0)}%${x.cov<0.5?' 不满月':''}</td></tr>`).join('')}</table>`:'—',
    '覆盖率<50% 的月不参与环比');
  if(k==='blame') return wrap('损失责任分账', blameBar(E)+
    `<p class="small" style="color:var(--muted);margin-top:8px">进设备考核的只有"故障与检修停机"; 限电属交易与调度侧。
    <br><b>限电不是"低风时段收到的空令"</b>: 限电·绑定时段平均出力 1.435 MW, 正常发电时段 1.412 MW, 比值 1.02 —
    风况相同而出力被压, 说明限电是真压制; 但"限电命令期·功率未被压制"那一档平均出力仅 0.724 MW(18% 额定), 确属低风时段收令。</p>`,
    '工况态分解 + 限电命令面绑定判别; 平均出力=实发÷台时, 用作风资源代理量');
  if(k==='ram') return R?wrap('可靠性 × 可维修性', ramChart(R.表)+
    `<p class="small" style="color:var(--muted);margin-top:6px">设备类 ${R.设备类停机h}h / 外部类 ${R.外部类停机h}h (电网·风况·运维操作不计设备可靠性)</p>`,
    'SCADA ≥1h 停机段, 不含调度令; 海上 MDT 含交通窗口'):'';
  if(k==='parts') return R?wrap('部件停机', `<table><tr><th>部件</th><th class="num">停机h</th><th class="num">事件</th><th class="num">MTBF h</th><th class="num">MDT h</th><th class="num">影响台</th></tr>
    ${R.表.slice(0,9).map(x=>`<tr><td class="small">${x.部件}${x.外部?' (外部)':''}</td><td class="num">${x.停机时长h}</td><td class="num">${x.事件数}</td>
    <td class="num">${x.MTBF_h||'—'}</td><td class="num">${x.MDT_h}</td><td class="num">${x.影响台数}</td></tr>`).join('')}</table>`,
    '归因=段起点±30min 首发码'):'';
  if(k==='attrib') return R?wrap('归因覆盖', attribBar(R.表,R.总停机h)+
    `<p class="small" style="color:var(--muted);margin-top:6px">"无记录停机"不是没有故障, 是没归上因。</p>`,''):'';
  if(k==='pareto') return wrap('故障帕累托', paretoChart(F.pareto_n||[],' 条',''), '报警事件表');
  if(k==='quad') return wrap('故障模式四象限', quadChart(F.quad||[])+
    `<p class="small" style="color:var(--muted);margin-top:6px">右下角报警码属重复触发, 不应按条数排定优先级。</p>`,'纵界=10min(一个SCADA采样格)');
  if(k==='frate') return wrap('月度故障率', rateChart(F.monthly||{months:[],vals:[]})+
    `<p class="small" style="color:var(--muted);margin-top:6px">柱高=日均条数, 不是月总数。</p>`,'不满月按天归一');
  if(k==='units'){
    const rows=(BD.rows||[]).slice(0,14);
    return wrap('重点机组与处置', `<p class="small" style="color:var(--muted);margin-bottom:8px">需跟踪 ${(BD.rows||[]).length} 台 / 38 ｜ 瓶颈 ${Object.entries(BD.stuck||{}).map(([a,b])=>`<b>${b} 台</b>卡在「${a}」`).join(' · ')}</p>
      <table><tr><th style="width:52px">机组</th><th style="width:64px">状态</th><th>部件与证据</th><th style="width:56px">进度</th><th style="width:62px">卡在</th></tr>
      ${rows.map(r=>`<tr><td><b>${r.t.replace('WTG','')}#</b></td><td>${chip(r.ostate||'—')}</td>
      <td class="small" style="color:var(--muted)">${r.part&&r.part.indexOf('未收录')<0?`<b style="color:var(--ink)">${r.part}</b> · `:''}${(r.srcs||[]).join('/')||'—'}${r.rising?` · <span style="color:var(--bad)">在升 ${r.rising.ratio}×</span>`:''}</td>
      <td class="num small">${r.done}/6</td><td class="small" style="color:var(--warn)">${r.stuck||'全通'}</td></tr>`).join('')}</table>`,
      '四源融合判级');
  }
  if(k==='chain') return wrap('决策链进度', `<p class="small" style="color:var(--muted)">六步: 证据 → 机制 → 判级 → 排期 → 动作 → 验收。
    当前 ${Object.entries(BD.stuck||{}).map(([a,b])=>`${b} 台卡在「${a}」`).join(', ')}。</p>`,
    '「动作」一列不可判 — ' + (BD.wo_bound||''));
  if(k==='loop'){
    const cl=BD.closed||[];
    return wrap('端到端闭环实证', `<table><tr><th>机组</th><th>部件</th><th>换件日期</th><th class="num">换前</th><th class="num">换后</th><th class="num">比值</th></tr>
      ${cl.map(x=>`<tr><td><b>${x.turbine.replace('WTG','')}#</b></td><td class="small">${x.component}</td><td class="small">${x.replace_date}</td>
      <td class="num">${x.pre}</td><td class="num">${x.post}</td><td class="num" style="color:var(--ok)"><b>${x.ratio}×</b></td></tr>`).join('')}</table>
      <p class="small" style="color:var(--muted);margin-top:6px">这几台正是算法当初的检出台 ⇒ 故障前能看见、换件后能看见恢复。</p>`,
      '振动标量前后对比');
  }
  if(k==='plan') return wrap('下期计划与建议', `<ol style="margin:0 0 0 20px;line-height:1.85">
    <li><b>补机制定性</b> — ${(BD.stuck||{}).机制||0} 台停在"判了级但根因未定", 是当前最大单一瓶颈</li>
    <li><b>回收 25~26 工单</b> — 台账止 2024-11, 本期检修执行与闭环无法自动判定</li>
    <li><b>油液采样节奏</b> — 四源里油液长期 stale, 只能作回测锚</li>
    <li><b>限电侧</b> — 损失六成在交易与调度侧, 设备侧改善空间有限</li></ol>`,
    '建议级 — 排期与动作须经审批');
  if(k==='narr'){
    const N=window.RPTNARR;
    if(!N||!N.text) return wrap('运行总结','<p class="small" style="color:var(--muted)">还没有生成 — 在上面的交互窗输入报告要求。</p>','');
    return wrap('运行总结', `<p style="line-height:1.9;margin:0">${N.text.replace(/</g,'&lt;').split(String.fromCharCode(10)).join('<br>')}</p>
      ${(N.ungrounded||[]).length?`<p class="small" style="color:var(--warn);margin-top:8px">
        ⚠ 以下数值由模型自行推算, 不在原始数据摘要中, 引用前须核对: ${N.ungrounded.join(' / ')}</p>`:''}`,
      `本地模型 ${N.model} 生成 · 数字取自系统实测摘要 · 接地闸${(N.ungrounded||[]).length?'报 '+N.ungrounded.length+' 处待核':'全通过'}`);
  }
  if(k==='caliber'){
    const part=(F.partial||[]);
    return wrap('口径与数据边界', `<ul style="margin:0 0 0 20px;line-height:1.85">
      <li><b>统计期</b> ${d.win}${part.length?` — ${part.join('/')} 数据不满月(覆盖 ${Math.round((F.cov_min||0)*100)}%), 月度已按天归一`:''}</li>
      <li><b>可用率与损失率分母不同</b> 可用率分母剔除低风待机与调度令(问"该发时能不能发"),
        损失率分母含全部时段(问"理论能发多少"); 同一低风时段在可用率里不计时间、在损失率里计入基数 —
        这是两个指标的设计差异不是错, 但两者不可直接相乘或互推。低风待机对损失的贡献仅 118 MWh(0.5%)</li>
      <li><b>停机</b> 可靠性口径 ≥1h 段, 电量账为逐条工况态 — 两个数都对, 不可相减</li>
      <li><b>工单</b> 台账 2020~2024-11, 本报告不对本期检修执行下结论</li>
      <li><b>判级</b> 由振动/温度/润滑/油液四源融合得出; 行动等级由综合报告出具</li>
      ${RPTAUD==='up'?'<li><b>脱敏</b> 上报版隐去判据门槛与特征频率</li>':''}</ul>`,'');
  }
  return '';
}

function renderReport(d){
  rptInit();
  const FU=d.fus||{};
  let h=`<div class="eyebrow">汇报定制 · 画布</div>`;
  // ── 画布控制条: 预设 / 组件库 / 受众 / 打印 ──
  h+=`<div class="card mb noprint">
    <div style="display:flex;gap:12px;align-items:center;flex-wrap:wrap;margin-bottom:10px">
      <span class="small" style="font-weight:600">预设</span>
      ${Object.entries(RPT_PRESETS).map(([k,v])=>`<button onclick="rptPreset('${k}')" style="cursor:pointer;padding:5px 13px;border-radius:15px;
        border:1px solid var(--line);background:var(--panel);color:var(--ink);font-size:12.5px">${v.nm}</button>`).join('')}
      <span style="flex:1"></span>
      <select onchange="window.RPTAUD=this.value;render()" style="padding:5px 9px;border:1px solid var(--line);border-radius:7px;background:var(--panel);color:var(--ink);font-size:12.5px">
        <option value="in"${RPTAUD==='in'?' selected':''}>场站内部 (全量)</option>
        <option value="up"${RPTAUD==='up'?' selected':''}>上报集团 (脱敏)</option></select>
      <button onclick="window.print()" style="cursor:pointer;padding:5px 13px;border-radius:7px;border:1px solid var(--accent);background:var(--panel);color:var(--accent);font-weight:600;font-size:12.5px">打印 / 存 PDF</button>
      <button onclick="rptExport('docx')" style="cursor:pointer;padding:5px 13px;border-radius:7px;border:1px solid var(--line);background:var(--panel);color:var(--ink);font-size:12.5px">导出 Word</button>
      <button onclick="rptExport('xlsx')" style="cursor:pointer;padding:5px 13px;border-radius:7px;border:1px solid var(--line);background:var(--panel);color:var(--ink);font-size:12.5px">导出 Excel</button>
      ${RPTAUD==='up'?'<span class="small" style="color:var(--warn);flex-basis:100%">上报版 — 判据门槛与特征频率已脱敏</span>':''}
    </div>
    <div class="small" style="font-weight:600;margin-bottom:7px">组件库
      <span style="font-weight:400;color:var(--muted)">点击加入报告, 再次点击移出 · 画布里已有 <b>${RPTCANVAS.length}</b> 块</span></div>
    <div style="display:grid;grid-template-columns:auto 1fr;gap:6px 12px;align-items:center">
      ${RPT_GROUPS.map(([gn,gk])=>`
        <div class="small" style="color:var(--muted);text-align:right;white-space:nowrap">${gn}</div>
        <div style="display:flex;gap:6px;flex-wrap:wrap">
          ${Object.entries(RPT_BLOCKS).filter(([,v])=>v.g===gk).map(([k,v])=>{const on=RPTCANVAS.includes(k);
            return `<button onmouseenter="rptHint('${k}')" onmouseleave="rptHint()" onfocus="rptHint('${k}')"
              onclick="rpt${on?'Del':'Add'}('${k}')" style="cursor:pointer;padding:5px 11px;border-radius:7px;
              border:1px solid ${on?'var(--accent)':'var(--line)'};background:${on?'var(--accent)':'var(--panel)'};
              color:${on?'#fff':'var(--ink)'};font-size:12.5px;opacity:${on?1:0.78}">${v.ic} ${v.nm}${on?' ✓':''}</button>`}).join('')}
        </div>`).join('')}
    </div>
    <div id="rpthint" class="small" style="color:var(--muted);margin-top:9px;padding-top:8px;border-top:1px solid var(--line-2);min-height:19px">
      悬停查看组件说明 · 已选组件再次点击移出 · 右侧 ↑↓ 调整顺序</div>
    <div style="margin-top:11px;padding-top:10px;border-top:1px solid var(--line-2)">
      <div class="small" style="font-weight:600;margin-bottom:6px">输入报告要求
        <span id="rpthint" style="font-weight:400;color:var(--muted)">模型依据需求选取组件, 并基于实测数据生成运行总结</span></div>
      <div style="display:flex;gap:8px;align-items:center;flex-wrap:wrap">
        <input id="rptneed" placeholder="例如: 上报集团月报, 侧重设备可靠性与重点机组"
          onkeydown="if(event.key==='Enter')rptCompose()"
          style="flex:1 1 300px;min-width:220px;padding:7px 12px;border:1px solid var(--line);border-radius:7px;background:var(--panel);color:var(--ink);font-size:13px">
        <select id="rptmdl" style="padding:7px 9px;border:1px solid var(--line);border-radius:7px;background:var(--panel);color:var(--ink);font-size:12.5px"></select>
        <button id="rptgo" onclick="rptCompose()" style="cursor:pointer;padding:7px 18px;border-radius:7px;border:1px solid var(--accent);background:var(--accent);color:#fff;font-weight:600;font-size:13px">生成</button>
      </div>
      <div id="rptout" class="small" style="color:var(--muted);margin-top:7px"></div></div></div>`;
  setTimeout(rptModelInit, 60);

  if(!RPTCANVAS.length)
    return h+`<div class="paper" style="text-align:center;padding:56px 40px">
      <div class="small" style="color:var(--muted)">文档预览窗 — 从上面的组件库点选内容, 此处显示报告预览</div></div>`;

  // 报表头卡撤 (2026-08-28 用户令): 场名与统计期页眉已有, 数据源列表与"结论可回溯"声明
  // 属口径块的内容 — 摆在报告最上面是重复且抢戏。打印时的抬头由下面这行轻量署名承担。

  // ── 文档预览窗 (2026-08-28 用户令: 生成的文档能预览才打印) ──
  // 画布内容包进"一页纸": 有抬头、有边界、有页脚, 所见即将打印出来的样子。
  const _asof=(FU.数据时点||'').slice(0,10);
  h+=`<div class="paper"><div class="paper-hd">
    <div><div class="paper-ti">如东海上风电场 · 运行分析报告</div>
      <div class="small" style="color:var(--muted);margin-top:3px">统计期 ${d.win} ｜ 38 × SWT-4.0-130${RPTAUD==='up'?' ｜ 上报版':''}</div></div>
    <div class="small" style="color:var(--muted);text-align:right">${RPTCANVAS.length} 个章节</div></div>`;
  RPTCANVAS.forEach((k,i)=>{
    const v=RPT_BLOCKS[k]; if(!v) return;
    // 控制条移到块**上方**独立一行 — 原来绝对定位压在卡右上角, 挡住 KPI 数字与图例 (用户截图逮)
    const bb=(t,fn,dis)=>`<button title="${t}" onclick="${fn}" ${dis?'disabled':''} style="cursor:pointer;padding:1px 8px;border-radius:5px;
      border:1px solid var(--line);background:transparent;color:var(--muted);font-size:11px;opacity:${dis?0.3:0.7}">${t}</button>`;
    h+=`<div class="noprint" style="display:flex;gap:3px;justify-content:flex-end;margin-bottom:-6px;position:relative;z-index:2">
        ${bb('↑',`rptMove('${k}',-1)`,i===0)}${bb('↓',`rptMove('${k}',1)`,i===RPTCANVAS.length-1)}${bb('×',`rptDel('${k}')`,false)}
      </div>${rptBlock(k,d)}`;
  });
  h+=`<div class="paper-ft">
    <span>数据源 SCADA 10min · 报警事件 · 工单台账 · CMS 振动 · 油液化验${_asof?` ｜ 出件 ${_asof}`:''}</span>
    <span>结论可回溯至本体对象${RPTAUD==='up'?' ｜ 判据门槛与特征频率已脱敏':''}</span></div></div>`;
  return h;
}

// 决策链浮窗 (2026-08-28 用户令: 29号点开应该是决策链的具体信息的浮窗)。
// 盘上一行只给"卡在哪", 点开给这一台的六步全貌: 每步达没达、依据是什么、为什么卡住。
// 29# 另有本体链(证据清单/机制/四情景/验收树), 其余台给四源证据明细。
function popChain(t){
  const BD=(D&&D.fus&&D.fus.链盘)||{}; const r=(BD.rows||[]).find(x=>x.t===t); if(!r) return;
  const STC={done:'var(--ok)',open:'var(--warn)',unknown:'var(--muted)'};
  const STT={done:'已达',open:'未达',unknown:'不可判'};
  const num='①②③④⑤⑥';
  // ★列宽按语言取。原来写死 44/52/96px, 是照**两个汉字**量的; 英文 "Verification" /
  //   "Not evaluable" 塞不下 ⇒ 标签被截成 "Mechanis"/"Scheduli"/"Verificati", chip 压到
  //   下一列上 (用户截图实逮)。中文页取原值, 一个像素不动。
  const EN=(typeof window!=='undefined'&&window.__EN), W=EN?[92,104,132]:[44,52,96];
  const steps=r.steps.map((x,i)=>{
    const cur=(x.k===r.stuck);
    return `<div style="display:flex;gap:10px;padding:9px 11px;border-radius:8px;margin-bottom:5px;align-items:flex-start;
      border:1px solid ${cur?STC[x.st]:'var(--line)'};background:${cur?'var(--bg)':'transparent'}">
      <div style="flex:none;width:20px;color:var(--muted);font-size:13px">${num[i]}</div>
      <div style="flex:none;width:${W[0]}px;font-weight:600;font-size:12.5px">${x.k}</div>
      <div style="flex:none;width:${W[1]}px"><span class="badge" style="border-color:${STC[x.st]};color:${STC[x.st]};white-space:nowrap">${STT[x.st]}</span></div>
      <div style="flex:none;width:${W[2]}px;font-size:12px">${x.v}</div>
      <div class="small" style="color:var(--muted);flex:1;line-height:1.5">${x.d}${cur?` <b style="color:${STC[x.st]}">← 卡在这里</b>`:''}</div></div>`;}).join('');
  // 与后端 _tbi 同口径: 多行台取最严重那行, 否则浮窗四源卡会指向另一个部件
  const SEV={bad:0,warn:1,note:2,stale:3,ok:4,unlisted:5};
  const F=(D&&D.fus)||{};
  const frow=(F.表||[]).filter(x=>x.turbine===t).sort((a,b)=>(SEV[a.级]??9)-(SEV[b.级]??9))[0];
  let mini='';
  if(frow){
    mini=`<div class="pop-mini">
      <div><b>振动结论</b><span class="badge" style="border-color:${LVC2(frow.级)};color:${LVC2(frow.级)}">${(frow.振动结论||'').slice(0,26)}</span>
        <div class="small" style="color:var(--muted);margin-top:4px">${frow.部件||''}</div></div>
      <div><b>证据窗</b>${winBar(frow.窗区间,frow.claim_window)}</div>
      <div><b>温度轴 (fleet相对)</b>${devBar(frow.温度通道,frow.温度dev,frow.温度判,frow.温度轴)}</div>
      <div><b>油液时效</b>${oilPill(frow.油末样,frow.油新鲜,frow.油样轴)}</div></div>`;
  }
  let ext='';
  const C=(typeof ONT!=='undefined'&&ONT)?ONT.chain29:null;
  if(t==='WTG29'&&C){
    const ev=(C.evidence||[]).map(e=>`<div class="small" style="color:var(--muted);padding:4px 0;border-bottom:1px solid var(--line-2)">
      <b style="color:var(--ink)">${e.facet||e.id||''}</b>
      <span style="color:var(--muted)"> 窗 ${e.claim_window||'—'}</span>
      <div style="line-height:1.55;margin-top:2px">${(e.summary||'').toString().slice(0,150)}</div></div>`).join('');
    const sc=(C.scenario&&C.scenario.scenarios)||[];
    ext=`<div style="margin-top:12px">
      <div class="small" style="font-weight:600;margin-bottom:5px">① 证据清单 · ${(C.evidence||[]).length} 条 / ${C.mechanism.independent_source_count} 个观测面</div>
      ${ev}
      <div class="small" style="color:var(--muted);margin-top:5px">四个观测面是<b>同一条机制链的四个面</b>, 不算四个独立源 — 加权时不可当多源印证。</div>
      <div class="small" style="font-weight:600;margin:12px 0 5px">② 机制 · ${C.mechanism.name||''}</div>
      <div class="small" style="color:var(--muted)">${C.mechanism.note||''}</div>
      <div class="small" style="font-weight:600;margin:12px 0 5px">④ 排期沙盘 · ${sc.length} 个情景</div>
      <table style="margin-top:2px"><tr><th>情景</th><th>窗</th><th>作业级</th><th>停机损失</th></tr>
      ${sc.map(x=>`<tr><td class="small"><b>${x.id}</b></td><td class="small">${x['修理窗']||'—'}</td>
        <td class="small" style="color:var(--muted)">${(x['作业级']||'').slice(0,20)}</td>
        <td class="small" style="color:var(--muted)">${((x['停机损失']||{})['电费口径']||'—').slice(0,22)}</td></tr>`).join('')}</table>
      <div class="small" style="font-weight:600;margin:12px 0 5px">⑥ 验收 · ${C.acceptance.state||'待执行'}</div>
      <div class="small" style="color:var(--muted);line-height:1.55">${(C.acceptance.note||'').slice(0,200)}</div></div>`;
  }
  document.body.insertAdjacentHTML('beforeend',
    `<div class="pop-mask" id="popm" onclick="if(event.target.id==='popm')closePop()"><div class="pop-box">
     <div class="pop-hd"><b>${t.replace('WTG','')}# 决策链</b>
       ${chip(r.ostate||'—')}<span class="small" style="color:var(--muted)">走到 ${r.done}/6 · 卡在「${r.stuck||'全通'}」</span>
       <span class="pop-x" onclick="closePop()">×</span></div>
     <div class="pop-bd">
       <p class="small" style="color:var(--muted);margin-bottom:10px">从发现异常到修完验收的六步。
         <b>下一步:</b> ${r.next||'—'}</p>
       ${steps}${mini}${ext}
       <div style="margin-top:12px;display:flex;gap:8px;flex-wrap:wrap">
         <a class="badge" href="/turbine/${t}">该台完整问题页 →</a></div>
     </div></div></div>`);
}
async function popPart(t,part){
  const sys=PART2SYS(part), win=(D&&D.win)||'2026年';
  document.body.insertAdjacentHTML('beforeend',
    `<div class="pop-mask" id="popm" onclick="if(event.target.id==='popm')closePop()"><div class="pop-box">
     <div class="pop-hd"><b>${t} · ${part}</b><span class="small" style="color:var(--muted)">载入中…</span>
     <span class="pop-x" onclick="closePop()">×</span></div><div class="pop-bd" id="popbd"></div></div></div>`);
  let figs=[], p0=null;
  try{ const r=await fetch(`/api/problem?t=${t}&sys=${encodeURIComponent(sys)}&win=${encodeURIComponent(win)}`);
       const d=await r.json(); p0=(d.problems||[])[0]; figs=(p0&&p0.figs)||[]; }catch(e){}
  const F=(D&&D.fus)||{}, frow=(F.表||[]).filter(x=>x.turbine===t&&PART2SYS(x.部件)===sys)[0];
  const curves=figs.filter(f=>f.kind!=='text'&&f.kind!=='vib');
  const mini=[];
  if(frow){
    mini.push(`<div><b>振动结论</b><span class="badge" style="border-color:${LVC2(frow.级)};color:${LVC2(frow.级)}">${frow.振动结论}</span>
      <div class="small" style="color:var(--muted);margin-top:4px">${frow.部件}</div></div>`);
    mini.push(`<div><b>证据窗</b>${winBar(frow.窗区间,frow.claim_window)}</div>`);
    mini.push(`<div><b>温度轴 (fleet相对)</b>${devBar(frow.温度通道,frow.温度dev,frow.温度判,frow.温度轴)}</div>`);
    mini.push(`<div><b>油液时效</b>${oilPill(frow.油末样,frow.油新鲜,frow.油样轴)}</div>`);
  }
  if(p0) mini.unshift(`<div><b>系统判级</b>${chip(p0['状态']||'—')}<div class="small" style="color:var(--muted);margin-top:4px">${(p0['依据']||'').slice(0,70)}</div></div>`);
  const hd=document.querySelector('#popm .pop-hd span.small');
  if(hd) hd.outerHTML=`<span class="small" style="color:var(--muted)">${sys} · 窗 ${win}</span>`;
  document.getElementById('popbd').innerHTML=
    `<div style="margin-bottom:10px">${dtChainStates({[part.replace(/[(（].*/,'')]:LVC2(p0&&p0['状态']==='报警'?'bad':'warn')},260,null)}</div>
     <div class="pop-mini">${mini.join('')}</div>`
    +(curves.length?curves.slice(0,2).map(f=>`<div style="margin-bottom:10px">${drawFig(f)}</div>`).join('')
                   :`<p class="small" style="color:var(--muted)">该部件在本窗无 SCADA 曲线 (振动谱级证据走 windcms)</p>`)
    +`<p class="small" style="margin-top:8px"><a class="tl" href="/problem/${t}/${encodeURIComponent(sys)}">完整问题页 (全部曲线与工单史) →</a>
      &nbsp;·&nbsp;<a class="tl" href="/turbine/${t}">本台总览 →</a></p>`;
}
// 三个场景各自独立提交与展示 (2026-08-28 用户令"都单独放在一个输入窗")。
// 原来共用一个输入框 + 一个结果区, 切场景就把上一个结果冲掉 —
// 而实际用法是"先查报警码怎么修, 顺手看这个系统的预防任务和故障树", 三者要并存对照。
if(!window.ASSTCACHE3) window.ASSTCACHE3={};
async function asstGo(mode){
  const m=mode||ASSTMODE;
  const out=document.getElementById('asstOut_'+m); if(!out) return;
  const el=document.getElementById('asstIn_'+m); const v=el?el.value.trim():'';
  out.innerHTML=`<div class="card"><p class="small">查询中…</p></div>`;
  const qs={fault:`kind=fault&code=${encodeURIComponent(v)}`,
            prev:`kind=prev&system=${encodeURIComponent(v||'齿轮箱')}`,
            tree:`kind=tree&system=${encodeURIComponent(v||'齿轮箱')}`}[m];
  let d;
  try{ d=await (await fetch('/api/ont_chain?'+qs)).json(); }
  catch(e){ out.innerHTML=`<div class="card"><p class="small" style="color:var(--bad)">查询失败: ${e.message}</p></div>`; return }
  out.innerHTML = (m==='fault' && d.data) ? faultCards(d.data)
    : (m==='tree' && d.data) ? treeCards(d.data)
    : `<div class="card"><pre class="small" style="white-space:pre-wrap;margin:0;line-height:1.75">${(d.text||'').replace(/</g,'&lt;')}</pre></div>`;
  window.ASSTCACHE3[m]=out.innerHTML;
}

function treeCards(x){
  // 故障树两层: 失效模式(果) ← causedBy ← 部件级原因(因); 条长=实证量, 步骤=手册原文
  const nodes = x.nodes || [];
  if(!nodes.length) return `<div class="card"><p class="small">该系统无失效模式记录</p></div>`;
  const maxE = Math.max(1, ...nodes.map(n => n.n_alarm + n.n_wo * 10));
  let h = `<div class="card mb"><h3>${x.system} 故障树 · ${nodes.length} 个失效模式</h3>
    <p class="small" style="color:var(--muted)">一层=系统×失效类(归纳自本场码表与工单) · 二层=手册排查方向归一+工单原因计数;
      条长按实证量(报警条数 + 工单×10), 因果来自手册与工单原文非推断, 树深两层不外推。</p></div>`;
  nodes.forEach(n => {
    const w = Math.max(3, (n.n_alarm + n.n_wo * 10) / maxE * 100);
    const col = n.n_wo >= 5 ? 'var(--bad)' : n.n_alarm >= 100 ? 'var(--warn)' : 'var(--info)';
    h += `<div class="card mb"><div style="display:flex;align-items:center;gap:12px;flex-wrap:wrap">
      <div style="flex:1;min-width:200px"><b>${n.name}</b>
        <div style="height:7px;border-radius:3px;background:${col};width:${w.toFixed(0)}%;margin-top:5px;max-width:100%"></div>
        <div class="small" style="color:var(--muted);margin-top:4px">本场报警 ${n.n_alarm} 条 · 工单 ${n.n_wo} 条${n.codes.length?` · 征兆码 ${n.codes.join(', ')}`:''}</div>
      </div></div>`;
    if(n.causes && n.causes.length){
      h += `<div style="margin-top:10px;padding-left:14px;border-left:2px dashed var(--line)">
        <div class="small" style="color:var(--muted);margin-bottom:6px">← 可能原因 (手册排查方向 + 工单实证)</div>
        <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(280px,1fr));gap:10px">`
        + n.causes.map(c => `<div style="border:1px solid var(--line);border-radius:8px;padding:10px 12px">
            <div><b class="small">${c.name}</b>
              <span class="small" style="color:var(--muted)"> 手册 ${c.n_ref} 次 · 工单 ${c.n_wo} 次 · 涉码 ${c.n_codes}</span></div>
            ${(c.steps||[]).map(st => `<div class="small" style="color:var(--muted);margin-top:5px;line-height:1.6">· ${st}</div>`).join('')}
          </div>`).join('') + `</div></div>`;
    } else {
      h += `<p class="small" style="color:var(--muted);margin-top:8px">(手册无该类排查条目 — 原因层待补)</p>`;
    }
    h += `</div>`;
  });
  return h;
}

function maintCards(md){
  // 数据维护面: 两层分开 (混在一起会让"机理被数据覆盖" — 更新频率与责任方完全不同)
  const rows = md.rows || [];
  if(md.error) return `<div class="card"><p class="small" style="color:var(--bad)">${md.error}</p></div>`;
  const LAYER = [['数据','随运营滚动 — 新数据到位后跑摄入, 本体与判级自动刷新','var(--accent)'],
                 ['机理','相对稳定 — 换厂商资料或现场反馈修正时才动; 它是判据的地基, 变更须过审','var(--warn)']];
  let h = `<div class="card mb"><h3>数据维护面 · ${rows.length} 个源</h3>
    <p class="small" style="color:var(--muted)">每个源给出: 当前覆盖 / 末次更新 / 约定位置 / 摄入命令 / 更新频率 / 责任方。
      要补数据就把新文件放到"约定位置"再跑"摄入命令"。</p></div>`;
  LAYER.forEach(([lv, note, col]) => {
    const rs = rows.filter(r => r.层 === lv);
    if(!rs.length) return;
    h += `<div class="card mb" style="border-left:3px solid ${col}"><h3>${lv}${LAYER_SFX} (${rs.length})</h3>
      <p class="small" style="color:var(--muted)">${note}</p>
      <table style="margin-top:10px"><tr><th style="width:20%">源</th><th style="width:22%">当前覆盖</th>
        <th style="width:14%">末次更新</th><th style="width:10%">频率</th><th style="width:10%">责任</th><th>补数据怎么做</th></tr>
      ${rs.map(r => `<tr>
        <td class="small"><b>${r.存在 ? '' : '✗ '}${r.名}</b></td>
        <td class="small" style="font-variant-numeric:tabular-nums">${r.覆盖}${r.条数 ? ` <span style="color:var(--muted)">(${r.条数.toLocaleString()} 条)</span>` : ''}</td>
        <td class="small" style="color:var(--muted)">${r.末次更新 || '—'}</td>
        <td class="small">${r.频率}</td><td class="small">${r.责任}</td>
        <td class="small"><div style="color:var(--muted)">放到: <code>${r.位置}</code></div>
          <div style="margin-top:3px">跑: <code>${r.摄入}</code></div>
          <div style="margin-top:3px;color:var(--muted)">${r.说明}</div></td></tr>`).join('')}</table></div>`;
  });
  return h;
}

function faultCards(x){
  // 抢修链结构化渲染: 码身份 → 失效模式 → 分步处置(卡片) → 历史工单 → 技术依据
  const sev = x.n_site>=1000?'var(--bad)':x.n_site>=100?'var(--warn)':'var(--muted)';
  let h=`<div class="card mb"><div style="display:flex;align-items:flex-start;gap:14px;flex-wrap:wrap">
    ${x.system?partGlyph(x.system,'var(--accent)'):''}
    <div style="flex:1;min-width:220px"><h3 style="margin:0">${x.code} · ${x.name}</h3>
      <p class="small" style="color:var(--muted);margin-top:5px">
        系统 ${x.system||'未归属'} · 本场 <b style="color:${sev}">${x.n_site}</b> 条${x.alarm_type?` · 告警类型 ${x.alarm_type}`:''}</p></div></div>`;
  if(x.failmodes&&x.failmodes.length)
    h+=`<div style="margin-top:10px"><b class="small" style="color:var(--muted)">指向的失效模式</b>
      ${x.failmodes.map(f=>`<div class="small" style="margin-top:5px">· ${f.name} <span style="color:var(--muted)">(该类本场报警 ${f.n_alarm} 条 / 工单 ${f.n_wo} 条)</span></div>`).join('')}</div>`;
  h+=`</div>`;
  if(x.steps&&x.steps.length){
    h+=`<div class="card mb"><h3>现场处置 ${x.steps.length} 步 <span class="small" style="font-weight:400;color:var(--muted)">(${x.wi_source||''})</span></h3>
      <p class="small" style="color:var(--muted)">节点部件=手册原文元件位号(确定); 判定规范=实机参数表(2024-10-21 导出)按物理量匹配的<b>候选判据</b>,
        非厂商绑定 — 现场以铭牌与图纸复核; 参数 ID 与告警码是不同命名空间, 未按同号关联。</p>
      <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:10px;margin-top:10px">`
      +x.steps.map(st=>`<div style="border:1px solid var(--line);border-left:3px solid var(--accent);border-radius:8px;padding:11px 13px">
        <div class="small" style="color:var(--accent);font-weight:600">第 ${st.序} 步${st.类别?` · ${st.类别}`:''}${st.qty?` · 量: ${st.qty}`:''}</div>
        <div style="margin-top:5px;line-height:1.65">${st.步骤}</div>
        ${(st.tags&&st.tags.length)?`<div class="small" style="margin-top:7px"><b style="color:var(--muted)">节点部件</b>
          ${st.tags.map(t=>`<code style="background:var(--panel-2);border:1px solid var(--line);border-radius:4px;padding:1px 6px;margin-right:5px">${t}</code>`).join('')}</div>`:''}
        ${(st.nodes&&st.nodes.length)?`<div class="small" style="margin-top:7px">
          <b style="color:var(--muted)">应检节点 · ${st.circuit||''} (手册此步未给位号 → 按回路构成展开, 逐点查)</b>
          <table style="margin-top:3px"><tr><th style="width:38%">节点</th><th>查什么</th></tr>
          ${st.nodes.map(n=>`<tr><td class="small">${n.name}</td><td class="small">${n.check}</td></tr>`).join('')}</table>
          ${(st.known_tags&&st.known_tags.length)?`<div style="color:var(--muted);margin-top:4px">该系统手册出现过的位号 (对图纸时参考):
            ${st.known_tags.map(k=>`<code style="margin-right:5px">${k.tag}</code>`).join('')}</div>`:''}
          </div>`:''}
        ${(st.specs&&st.specs.length)?`<div class="small" style="margin-top:7px"><b style="color:var(--muted)">判定规范 (实机参数表)</b>
          <table style="margin-top:3px"><tr><th style="width:64px">参数号</th><th>名称</th><th style="width:74px" class="num">整定值</th><th style="width:96px" class="num">允许范围</th></tr>
          ${st.specs.map(sp=>`<tr><td class="small">${sp.no}</td><td class="small">${sp.text}</td>
            <td class="num small">${sp.val!=null?sp.val+(sp.unit||''):'—'}</td>
            <td class="num small">${sp.lo!=null?`${sp.lo} ~ ${sp.hi}`:'—'}</td></tr>`).join('')}</table></div>`:''}
        ${(st.drawings&&st.drawings.length)?`<div class="small" style="margin-top:7px"><b style="color:var(--muted)">对应图纸</b>
          ${st.drawings.map(dw=>`<div style="color:var(--muted);margin-top:2px">· ${dw.name}</div>`).join('')}</div>`:''}
      </div>`).join('')
      +`</div></div>`;
  } else {
    h+=`<div class="card mb"><p class="small">本码无手册处置条目 (手册覆盖本场 161/322 码) — 需查图纸或联系厂商支持。</p></div>`;
  }
  if(x.workorders&&x.workorders.length)
    h+=`<div class="card mb"><h3>现场实际怎么修的 (${x.system} 历史工单 ${x.wo_total} 条, 台账 2020~2024)</h3>
      <table style="margin-top:8px"><tr><th style="width:92px">日期</th><th style="width:64px">机组</th><th>故障</th><th style="width:110px">处置</th></tr>
      ${x.workorders.map(w=>`<tr><td class="small">${w.date}</td><td class="small">${w.turbine.replace('WTG','')}#</td>
        <td class="small">${w.name}</td><td class="small">${w.action} ${w.part}</td></tr>`).join('')}</table>
      <p class="small" style="color:var(--muted);margin-top:6px">工单窗止 2024-11-21; 2025-26 现场未提供 ⇒ "0 条"是记录缺失非未修过。</p></div>`;
  // 技术依据卡撤 (2026-08-28 用户令): 按文件名关键词匹配出来的文档与本次故障常不相关
  // (液压压力偏高 → 推出"单叶片吊具培训资料"/"轮毂起吊图纸"), 列出来是噪音不是依据。
  // ont_doc_search API 保留, 需要时按码精确查, 不再在抢修链里自动铺开。
  return h;
}

async function ontChain(kind){
  const out=document.getElementById('ocOut'); if(!out) return;
  out.style.display='block'; out.textContent='查询中…';
  const qs={fault:()=>`kind=fault&code=${encodeURIComponent((document.getElementById('ocCode')||{}).value||'')}`,
            prev:()=>`kind=prev&system=${encodeURIComponent((document.getElementById('ocSys')||{}).value||'')}`,
            tree:()=>`kind=tree&system=${encodeURIComponent((document.getElementById('ocSys')||{}).value||'')}`,
            plan:()=>'kind=plan&top=12',
            doc:()=>`kind=doc&keyword=${encodeURIComponent((document.getElementById('ocDoc')||{}).value||'')}`}[kind];
  try{ const r=await fetch('/api/ont_chain?'+qs()); const d=await r.json();
       out.textContent=d.text||JSON.stringify(d); }
  catch(e){ out.textContent='查询失败: '+e.message }
}
function closePop(){const m=document.getElementById('popm'); if(m)m.remove()}
const LVC2=lv=>({bad:'var(--bad)',warn:'var(--warn)',ok:'var(--ok)',meta:'var(--muted)',note:'var(--info)'}[lv]||'var(--warn)');
document.addEventListener('keydown',e=>{if(e.key==='Escape')closePop()});
// 状态链条 (per 节点各自着色版; windcms 结果层用: 四部件等级一次性画在传动链上, 替代四列 chips)
const dtChainStates=(cmap,W,T2)=>{
  const w=W||208, Y=20, MU='var(--muted)', PN='var(--panel)', LN='var(--line)';
  const zone=(x,w2,dash)=>`<rect x="${x}" y="5" width="${w2}" height="30" rx="6" fill="var(--muted)" fill-opacity="0.13"
      stroke="${LN}" stroke-opacity="0.5" ${dash?'stroke-dasharray="3 2"':''}/>`;
  const node=(x,key,kind)=>{
    const col=cmap[key]||null, k=!!col, r=k?6.6:5;
    const teeth=kind==='g'?[0,90,180,270].map(a=>{const t=a*Math.PI/180;
      return `<line x1="${(x+Math.cos(t)*r).toFixed(1)}" y1="${(Y+Math.sin(t)*r).toFixed(1)}" x2="${(x+Math.cos(t)*(r+2.6)).toFixed(1)}" y2="${(Y+Math.sin(t)*(r+2.6)).toFixed(1)}" stroke="${col||MU}" stroke-width="${k?1.7:1.2}"/>`}).join(''):'';
    const core=`<circle cx="${x}" cy="${Y}" r="${r}" fill="${col||PN}" fill-opacity="${k?0.9:1}" stroke="${col||MU}" stroke-opacity="${k?1:0.8}" stroke-width="${k?2:1.3}"/>`
      +(kind==='b'?`<circle cx="${x}" cy="${Y}" r="${(r*0.4).toFixed(1)}" fill="${k?'#fff':MU}" fill-opacity="${k?0.85:0.7}"/>`:teeth);
    return (k&&T2)?`<g class="dt-hot" onclick="event.stopPropagation();popPart('${T2}','${key}')"><title>${key} — 点看曲线与四源微视图</title>
        <circle cx="${x}" cy="${Y}" r="${r+7}" fill="transparent"/>${core}</g>`:core};
  return `<svg class="dt" viewBox="0 0 320 40" style="display:block;width:${w}px;max-width:100%;height:auto">
  ${zone(28,74)}${zone(112,90,1)}${zone(212,96)}
  <line x1="20" y1="${Y}" x2="304" y2="${Y}" stroke="${LN}" stroke-width="3" stroke-linecap="round"/>
  <path d="M20,13 L11,4 M20,27 L11,36 M20,${Y} L9,${Y}" stroke="${MU}" stroke-width="1.6" fill="none"/>
  ${node(46,'主轴承前','b')}${node(88,'主轴承后','b')}
  ${node(133,'齿轮箱','g')}${node(157,'齿轮箱','g')}${node(181,'齿轮箱','g')}
  ${node(236,'发电机','b')}${node(282,'发电机','b')}
  </svg>`};
// 证据强度阶梯 (确诊4格/准定论3/候选2/参考1/INSUFFICIENT 0虚框) — 文字分级换成可比的阶梯
const evLadder=t=>{
  const T=String(t||''), n=/确诊/.test(T)?4:/准定论|定论/.test(T)?3:/候选/.test(T)?2:/参考/.test(T)?1:0;
  const col=n>=4?'var(--bad)':n===3?'var(--warn)':n===2?'var(--info)':n===1?'var(--muted)':'var(--unknown)';
  const cells=[0,1,2,3].map(i=>`<rect x="${2+i*15}" y="${12-i*3}" width="11" height="${6+i*3}" rx="1.5"
     fill="${i<n?col:'none'}" fill-opacity="0.9" stroke="${col}" stroke-opacity="${i<n?1:0.4}" stroke-width="1"
     ${i>=n?'stroke-dasharray="2 1.5"':''}/>`).join('');
  return `<div title="${esc(T)}" style="display:flex;align-items:center;gap:7px">
    <svg class="dt" viewBox="0 0 62 20" style="width:62px;height:20px;flex:none">${cells}</svg>
    <span class="small" style="color:${col}">${esc(T)}</span></div>`};
// 部件微缩符号 (矩阵/列表行内用): 与解剖图同一套图形语言的 24px 版 —
// 齿轮箱=行星轮系 · 发电机=定子转子 · 主轴承=滚子剖面 · 变桨=桨叶轴承 · 偏航=齿圈驱动
function partIcon(name, col){
  const c = col || 'currentColor', n = String(name || '');
  const W = 30, H = 26;
  // 尺寸走 inline style (全局 svg{width:100%} 会吃掉 width 属性 — 同一个坑第三次: dtSVG/台页/此处)
  const wrap = body => `<svg viewBox="0 0 ${W} ${H}" role="img" aria-label="${n}"
    style="width:${W}px;height:${H}px;min-width:${W}px;vertical-align:-6px;margin-right:6px;flex:none;display:inline-block"
    ><g fill="none" stroke="${c}" stroke-width="1.3">${body}</g></svg>`;
  if(/齿轮箱|行星|中间轴|中速|高速/.test(n))
    return wrap(`<circle cx="15" cy="13" r="10.5"/><circle cx="15" cy="13" r="3.4"/>
      <circle cx="15" cy="5.5" r="3"/><circle cx="8.5" cy="17" r="3"/><circle cx="21.5" cy="17" r="3"/>
      <path d="M15,13 L15,5.5 M15,13 L8.5,17 M15,13 L21.5,17" stroke-width="0.9" stroke-opacity="0.75"/>`);
  if(/发电机|定子|转子|DE|NDE/.test(n))
    return wrap(`<rect x="4" y="6" width="22" height="14" rx="2.5"/>
      <path d="M4,10 h22 M4,16 h22" stroke-opacity="0.45"/>
      <rect x="9" y="10" width="12" height="6" rx="1" fill="${c}" fill-opacity="0.18" stroke="none"/>
      <path d="M1,13 h3 M26,13 h3" stroke-width="1.6"/>`);
  if(/主轴承|主轴/.test(n)){
    // 前后两个轴承都画出来 (2026-08-28 用户令), 命中的那个着色加粗, 另一个留灰 —
    // 左=前(轮毂侧) 右=后(齿轮箱侧), 与传动链图同一朝向; 未指明前后则两个都着色
    const hasF = /前/.test(n), hasR = /后/.test(n), both = !hasF && !hasR;
    const brg = (x, on) => {
      const st = on ? c : 'var(--muted)', w = on ? 1.7 : 1.05, op = on ? 1 : 0.55;
      return `<g stroke="${st}" stroke-width="${w}" stroke-opacity="${op}">
        <rect x="${x}" y="5.5" width="16" height="4" rx="1"/><rect x="${x}" y="16.5" width="16" height="4" rx="1"/>
        <circle cx="${x + 4.5}" cy="13" r="2.3"/><circle cx="${x + 11.5}" cy="13" r="2.3"/></g>`;
    };
    return `<svg viewBox="0 0 46 26" role="img" aria-label="${n}"
      style="width:46px;height:26px;min-width:46px;vertical-align:-6px;margin-right:6px;flex:none;display:inline-block">
      <g fill="none"><path d="M2,13 h42" stroke="var(--muted)" stroke-width="2.2" stroke-opacity="0.35"/>
      ${brg(4, hasF || both)}${brg(26, hasR || both)}</g></svg>`;
  }
  if(/变桨|桨|叶片|叶根|轮毂/.test(n))
    return wrap(`<circle cx="15" cy="13" r="7.5"/><circle cx="15" cy="13" r="4"/>
      <path d="M15,5.5 q7,-3 11,1 M15,20.5 q7,3 11,-1 M7.5,13 q-6,0 -6.5,-4" stroke-width="1.1" stroke-opacity="0.8"/>`);
  if(/偏航|解缆|扭缆|对风/.test(n))
    return wrap(`<circle cx="15" cy="15" r="9"/><circle cx="15" cy="15" r="5.5" stroke-dasharray="2 2"/>
      ${[0,72,144,216,288].map(a=>{const r=(a-90)*Math.PI/180;
        return `<circle cx="${(15+Math.cos(r)*9).toFixed(1)}" cy="${(15+Math.sin(r)*9).toFixed(1)}" r="1.7"/>`}).join('')}`);
  if(/变流|变频|逆变/.test(n))
    return wrap(`<rect x="5" y="6" width="20" height="14" rx="2"/><path d="M11,10 l-3,4 h5 l-3,4" stroke-width="1.2"/>
      <path d="M18,10 v8 M21.5,10 v8" stroke-opacity="0.6"/>`);
  if(/塔架|塔筒|基础|法兰/.test(n))
    return wrap(`<path d="M11,4 h8 l3,17 h-14 z"/><path d="M9,14 h12" stroke-opacity="0.5"/>
      <path d="M5,21 h20" stroke-width="1.8"/>`);
  return wrap(`<circle cx="15" cy="13" r="8" stroke-dasharray="3 2.5"/>`);
}

// 部件小图 (按部件截取: 只画命中的那一段, 不画整条链; 比八节点链条形象 — 带座体/齿形/散热筋等外形特征)
function partGlyph(name, col, solid){
  // solid=true 仅用于报警/危险级 — 良好/优秀级用描边不填充, 否则密集表格里满屏深色块
  // (2026-08-28 用户逮'满屏黑化'; 对应 skill 原则: boldness 只花在一处, 其余安静)
  const c = col || 'currentColor', n = String(name || ''), MU = 'var(--muted)';
  const svg = (w, body) => `<svg viewBox="0 0 ${w} 38" role="img" aria-label="${n}"
    style="width:${w}px;height:38px;min-width:${w}px;vertical-align:-11px;flex:none;display:block">
    <g fill="none" stroke-linejoin="round">${body}</g></svg>`;

  if(/主轴承|主轴/.test(n)){
    const F = /前/.test(n), R = /后/.test(n), both = !F && !R;
    // 带座体的轴承: 座体梯形 + 外圈 + 滚子 + 内圈, 轴穿过
    const unit = (x, on) => {
      const st = on ? c : MU, w = on ? 1.7 : 1, op = on ? 1 : 0.5;
      return `<g stroke="${st}" stroke-width="${w}" stroke-opacity="${op}">
        <path d="M${x-2},32 h26 l-3,-8 h-20 z" fill="${on&&solid?c:'none'}" fill-opacity="${on&&solid?0.14:0}"/>
        <rect x="${x+1}" y="7" width="18" height="4" rx="1"/>
        <rect x="${x+1}" y="25" width="18" height="4" rx="1"/>
        <rect x="${x+1}" y="12.5" width="18" height="2.6" rx="0.8" stroke-opacity="${op*0.7}"/>
        <rect x="${x+1}" y="21" width="18" height="2.6" rx="0.8" stroke-opacity="${op*0.7}"/>
        <circle cx="${x+5}" cy="18" r="2.6"/><circle cx="${x+10}" cy="18" r="2.6"/><circle cx="${x+15}" cy="18" r="2.6"/></g>`;
    };
    return svg(96, `<path d="M2,18 h92" stroke="${MU}" stroke-width="3" stroke-opacity="0.3" stroke-linecap="round"/>
      ${unit(8, F||both)}${unit(56, R||both)}
      <text x="19" y="6" text-anchor="middle" font-size="8" fill="${F||both?c:MU}" stroke="none" opacity="${F||both?1:0.6}">前</text>
      <text x="67" y="6" text-anchor="middle" font-size="8" fill="${R||both?c:MU}" stroke="none" opacity="${R||both?1:0.6}">后</text>`);
  }

  if(/齿轮箱|行星|中间轴|中速|高速/.test(n)){
    const P = /行星/.test(n), M = /中间|中速/.test(n), H = /高速/.test(n), all = !P && !M && !H;
    const gear = (cx, cy, r, teeth, on) => {
      const st = on ? c : MU, sw = on ? 1.6 : 1, op = on ? 1 : 0.45;
      let t = '';
      for(let i=0;i<teeth;i++){const a=i*2*Math.PI/teeth;
        t += `<line x1="${(cx+Math.cos(a)*r).toFixed(1)}" y1="${(cy+Math.sin(a)*r).toFixed(1)}"
              x2="${(cx+Math.cos(a)*(r+2.4)).toFixed(1)}" y2="${(cy+Math.sin(a)*(r+2.4)).toFixed(1)}"/>`}
      return `<g stroke="${st}" stroke-width="${sw}" stroke-opacity="${op}"><circle cx="${cx}" cy="${cy}" r="${r}"/>${t}
        <circle cx="${cx}" cy="${cy}" r="${(r*0.3).toFixed(1)}"/></g>`;
    };
    return svg(104, `<path d="M3,10 h98 v22 q0,4 -4,4 h-90 q-4,0 -4,-4 z" stroke="${MU}" stroke-opacity="0.45" stroke-dasharray="3 2"/>
      ${gear(22, 21, 9, 12, P||all)}${gear(22, 21, 3.4, 0, P||all)}
      ${gear(55, 18, 7.5, 10, M||all)}${gear(80, 25, 5.5, 8, H||all)}
      <path d="M31,21 h16 M62,20 h11" stroke="${MU}" stroke-width="1.6" stroke-opacity="0.45"/>`);
  }

  if(/发电机|定子|转子|DE|NDE/.test(n)){
    const D = /(?<!N)DE/.test(n) && !/NDE/.test(n), ND = /NDE/.test(n), all = !D && !ND;
    const end = (x, on) => `<g stroke="${on?c:MU}" stroke-width="${on?1.7:1}" stroke-opacity="${on?1:0.5}">
      <rect x="${x}" y="12" width="9" height="14" rx="2"/><circle cx="${x+4.5}" cy="19" r="2.6"/></g>`;
    return svg(96, `<g stroke="${c}" stroke-width="1.3">
      <rect x="18" y="8" width="60" height="22" rx="3"/></g>
      <g stroke="${MU}" stroke-opacity="0.5" stroke-width="0.9">
        ${[26,34,42,50,58,66].map(x=>`<line x1="${x}" y1="8" x2="${x}" y2="30"/>`).join('')}</g>
      <rect x="30" y="14" width="36" height="10" rx="2" stroke="${c}" stroke-width="1.2" fill="${c}" fill-opacity="${solid?0.14:0.04}"/>
      <path d="M4,19 h14 M78,19 h14" stroke="${MU}" stroke-width="2.4" stroke-opacity="0.35" stroke-linecap="round"/>
      ${end(8, D||all)}${end(79, ND||all)}
      <text x="12" y="6" text-anchor="middle" font-size="8" fill="${D||all?c:MU}" stroke="none" opacity="${D||all?1:0.6}">DE</text>
      <text x="84" y="6" text-anchor="middle" font-size="8" fill="${ND||all?c:MU}" stroke="none" opacity="${ND||all?1:0.6}">NDE</text>`);
  }

  if(/变桨|桨|叶片|叶根|轮毂/.test(n))
    return svg(80, `<g stroke="${c}" stroke-width="1.5">
      <circle cx="26" cy="19" r="12"/><circle cx="26" cy="19" r="7"/>
      ${[0,120,240].map(a=>{const r=(a-90)*Math.PI/180;
        return `<circle cx="${(26+Math.cos(r)*9.6).toFixed(1)}" cy="${(19+Math.sin(r)*9.6).toFixed(1)}" r="2.2"/>`}).join('')}</g>
      <g stroke="${MU}" stroke-width="4" stroke-opacity="0.32" stroke-linecap="round">
        <path d="M38,19 q22,-3 36,-11"/><path d="M38,19 q22,3 36,11"/></g>`);

  if(/偏航|解缆|扭缆|对风/.test(n))
    return svg(80, `<g stroke="${c}" stroke-width="1.5"><circle cx="34" cy="21" r="13"/>
      ${Array.from({length:14},(_,i)=>{const a=i*2*Math.PI/14;
        return `<line x1="${(34+Math.cos(a)*13).toFixed(1)}" y1="${(21+Math.sin(a)*13).toFixed(1)}"
                x2="${(34+Math.cos(a)*15.6).toFixed(1)}" y2="${(21+Math.sin(a)*15.6).toFixed(1)}"/>`}).join('')}</g>
      <g stroke="${MU}" stroke-width="1.2" stroke-opacity="0.6">
        <circle cx="60" cy="14" r="5"/><circle cx="60" cy="28" r="5"/></g>
      <path d="M18,6 h32" stroke="${MU}" stroke-width="2" stroke-opacity="0.4"/>`);

  return svg(60, `<circle cx="30" cy="19" r="11" stroke="${MU}" stroke-dasharray="3 2.5" stroke-opacity="0.6"/>`);
}

// ══ 部件解剖图 (2026-08-28 用户令"部件UI图像化认真对待") ══
// 原则: 画机制不画名字 — 每张图展示该系统的介质/动力如何流经部件, 箭头带口径标注,
// 命中部件按状态着色; 一图一论点。与传动链简图分工: 传动链=链上哪一环, 解剖图=环内怎么坏的。
const ANAT_C = st => ({'报警':'var(--bad)','危险':'var(--bad)','预警':'var(--warn)','良好':'var(--info)',
                       '优秀':'var(--ok)','不可判':'var(--unknown)'}[st] || 'var(--muted)');

function anatMainBearing(hit, states){
  // 主轴承集中润滑链: 泵 →(管路)→ 分配器 →(柱塞往复=出脂计量)→ 前/后轴承
  // 画的是"脂怎么到轴承", 29# 的失效点在泵本体 (柱塞单次时长拖长=打不满)
  const c = k => ANAT_C((states||{})[k]);
  const on = k => (hit||'').includes(k);
  const hl = k => on(k) ? 'var(--bad)' : 'currentColor';
  return `<figure style="margin:0"><svg viewBox="0 0 660 210" role="img" width="660"
    aria-label="主轴承集中润滑链: 润滑泵经管路到分配器, 分配器柱塞往复把脂定量送到前后主轴承"
    style="max-width:100%;height:auto;display:block;margin:0 auto">
    <g fill="none" stroke="currentColor" stroke-width="1.4" font-family="inherit">
      <!-- 脂桶+泵 -->
      <rect x="18" y="60" width="54" height="66" rx="4" stroke="${hl('泵')}" stroke-width="${on('泵')?2.4:1.4}"/>
      <path d="M28,70 h34 M28,80 h34 M28,90 h34" stroke-opacity="0.35"/>
      <text x="45" y="142" text-anchor="middle" font-size="11" fill="currentColor" stroke="none">脂桶</text>
      <circle cx="104" cy="93" r="17" stroke="${hl('泵')}" stroke-width="${on('泵')?2.4:1.4}"/>
      <path d="M97,86 l14,7 -14,7 z" fill="${hl('泵')}" stroke="none"/>
      <text x="104" y="128" text-anchor="middle" font-size="11" fill="${hl('泵')}" stroke="none">润滑泵</text>
      ${on('泵') ? '<text x="104" y="62" text-anchor="middle" font-size="10" fill="var(--bad)" stroke="none">本体失效</text>' : ''}
      <!-- 管路 -->
      <path d="M121,93 h58" marker-end="url(#aH)"/>
      <text x="150" y="86" text-anchor="middle" font-size="10" fill="currentColor" stroke="none" stroke-opacity="0">主管路</text>
      <!-- 分配器 -->
      <rect x="182" y="66" width="66" height="54" rx="4" stroke="${hl('分配器')}"/>
      <path d="M196,80 v26 M215,80 v26 M234,80 v26" stroke-opacity="0.55"/>
      <text x="215" y="134" text-anchor="middle" font-size="11" fill="currentColor" stroke="none">分配器</text>
      <text x="215" y="60" text-anchor="middle" font-size="9.5" fill="currentColor" stroke="none" opacity="0.7">柱塞往复=出脂计量</text>
      <!-- 支路到前后轴承 -->
      <path d="M248,80 h48 q12,0 12,-12 v-14" marker-end="url(#aH)"/>
      <path d="M248,106 h48 q12,0 12,12 v14" marker-end="url(#aH)"/>
      <text x="286" y="70" text-anchor="middle" font-size="9.5" fill="currentColor" stroke="none" opacity="0.7">前支路</text>
      <text x="286" y="140" text-anchor="middle" font-size="9.5" fill="currentColor" stroke="none" opacity="0.7">后支路</text>
      <!-- 前后轴承 (剖面) -->
      ${[['主轴承前', 34], ['主轴承后', 132]].map(([k, y]) => `
        <g stroke="${c(k)}" stroke-width="${(states||{})[k]==='报警'?2.4:1.4}">
          <rect x="330" y="${y}" width="86" height="16" rx="2"/>
          <rect x="330" y="${y+28}" width="86" height="16" rx="2"/>
          <circle cx="352" cy="${y+22}" r="5"/><circle cx="373" cy="${y+22}" r="5"/><circle cx="394" cy="${y+22}" r="5"/>
        </g>
        <text x="373" y="${y+58}" text-anchor="middle" font-size="11" fill="${c(k)}" stroke="none">${k}</text>`).join('')}
      <!-- 主轴穿过 -->
      <path d="M300,105 h180" stroke-width="7" stroke-opacity="0.25" stroke-linecap="round"/>
      <!-- 观测面标注 -->
      <path d="M215,120 v42" stroke-dasharray="3 3" stroke-opacity="0.6"/>
      <text x="215" y="176" text-anchor="middle" font-size="10" fill="currentColor" stroke="none">因侧: 柱塞计数/单次时长</text>
      <path d="M373,${(states||{})['主轴承后']?'190':'190'} v-14" stroke-dasharray="3 3" stroke-opacity="0.6"/>
      <text x="470" y="176" text-anchor="middle" font-size="10" fill="currentColor" stroke="none">果侧: 轴承温度 · 振动冲击</text>
      <defs><marker id="aH" markerWidth="7" markerHeight="7" refX="6" refY="3.5" orient="auto">
        <polygon points="0,0 7,3.5 0,7" fill="currentColor"/></marker></defs>
    </g></svg>
    <figcaption class="small" style="color:var(--muted);margin-top:6px">
      脂路: 泵 → 主管路 → 分配器(柱塞定量) → 前/后支路 → 轴承。因侧看柱塞行为, 果侧看轴承温度与冲击 —
      两侧不是两个独立源, 是同一条机制链的两端。</figcaption></figure>`;
}

function anatGearbox(hit, states){
  // 齿轮箱: 一级行星 + 两级平行轴 + 润滑/冷却回路 (油从箱底经泵/滤/冷却器回喷淋)
  const c = k => ANAT_C((states||{})[k]);
  const on = k => (hit||'').includes(k);
  const hl = k => on(k) ? 'var(--bad)' : 'currentColor';
  return `<figure style="margin:0"><svg viewBox="0 0 660 250" role="img" width="660"
    aria-label="齿轮箱: 一级行星加两级平行轴传动, 下方为润滑油路(泵-滤芯-冷却器-喷淋)"
    style="max-width:100%;height:auto;display:block;margin:0 auto">
    <g fill="none" stroke="currentColor" stroke-width="1.4">
      <rect x="24" y="18" width="500" height="128" rx="8" stroke-dasharray="5 4" stroke-opacity="0.5"/>
      <text x="274" y="14" text-anchor="middle" font-size="10.5" fill="currentColor" stroke="none" opacity="0.7">齿轮箱壳体 (i=119.752)</text>
      <!-- 行星级 -->
      <g stroke="${hl('行星')}" stroke-width="${on('行星')?2.2:1.4}">
        <circle cx="98" cy="82" r="46"/><circle cx="98" cy="82" r="15"/>
        <circle cx="98" cy="46" r="14"/><circle cx="67" cy="100" r="14"/><circle cx="129" cy="100" r="14"/>
        <path d="M98,82 L98,46 M98,82 L67,100 M98,82 L129,100" stroke-width="1"/>
      </g>
      <text x="98" y="146" text-anchor="middle" font-size="11" fill="${hl('行星')}" stroke="none">一级行星</text>
      <path d="M144,82 h40" marker-end="url(#gH)"/>
      <text x="164" y="74" text-anchor="middle" font-size="9" fill="currentColor" stroke="none" opacity="0.7">中速</text>
      <!-- 平行轴两级 -->
      <g stroke="${hl('中间')}" stroke-width="${on('中间')?2.2:1.4}">
        <rect x="188" y="52" width="16" height="60" rx="3"/><rect x="188" y="26" width="16" height="26" rx="3"/></g>
      <text x="196" y="146" text-anchor="middle" font-size="11" fill="${hl('中间')}" stroke="none">中间轴</text>
      <g stroke="${hl('高速')}" stroke-width="${on('高速')?2.2:1.4}">
        <rect x="244" y="26" width="16" height="52" rx="3"/><rect x="244" y="78" width="16" height="30" rx="3"/></g>
      <text x="252" y="146" text-anchor="middle" font-size="11" fill="${hl('高速')}" stroke="none">高速轴</text>
      <path d="M268,93 h56" marker-end="url(#gH)"/>
      <text x="296" y="86" text-anchor="middle" font-size="9" fill="currentColor" stroke="none" opacity="0.7">→ 发电机</text>
      <!-- 油路 -->
      <path d="M60,146 v34 h420 v-34" stroke-opacity="0.8"/>
      <circle cx="180" cy="180" r="13" stroke="${hl('油泵')}"/><path d="M174,174 l12,6 -12,6 z" fill="${hl('油泵')}" stroke="none"/>
      <text x="180" y="208" text-anchor="middle" font-size="10" fill="currentColor" stroke="none">油泵</text>
      <rect x="242" y="168" width="26" height="24" rx="2" stroke="${hl('滤芯')}"/>
      <path d="M246,172 l18,16 M264,172 l-18,16" stroke-width="0.9" stroke-opacity="0.6"/>
      <text x="255" y="208" text-anchor="middle" font-size="10" fill="currentColor" stroke="none">滤芯</text>
      <rect x="322" y="166" width="40" height="28" rx="3" stroke="${hl('冷却')}"/>
      <path d="M330,170 v20 M340,170 v20 M350,170 v20" stroke-width="0.9" stroke-opacity="0.6"/>
      <text x="342" y="208" text-anchor="middle" font-size="10" fill="${hl('冷却')}" stroke="none">冷却器</text>
      <path d="M410,180 v-20" marker-end="url(#gH)"/>
      <text x="446" y="176" text-anchor="middle" font-size="10" fill="currentColor" stroke="none">喷淋回箱</text>
      <!-- 观测面 -->
      <text x="560" y="60" font-size="10" fill="currentColor" stroke="none">观测面:</text>
      <text x="560" y="78" font-size="10" fill="currentColor" stroke="none" opacity="0.8">· 振动 (各级测点)</text>
      <text x="560" y="94" font-size="10" fill="currentColor" stroke="none" opacity="0.8">· 轴承/油温 ΔT</text>
      <text x="560" y="110" font-size="10" fill="currentColor" stroke="none" opacity="0.8">· 滤芯压差码</text>
      <text x="560" y="126" font-size="10" fill="currentColor" stroke="none" opacity="0.8">· 油样铁谱</text>
      <defs><marker id="gH" markerWidth="7" markerHeight="7" refX="6" refY="3.5" orient="auto">
        <polygon points="0,0 7,3.5 0,7" fill="currentColor"/></marker></defs>
    </g></svg>
    <figcaption class="small" style="color:var(--muted);margin-top:6px">
      传动: 行星级(输入) → 中间轴 → 高速轴(输出)。油路: 箱底 → 泵 → 滤芯 → 冷却器 → 喷淋回箱 —
      过热类失效沿油路查(冷却/滤芯), 磨损类沿齿轮线查(振动/铁谱)。</figcaption></figure>`;
}

function anatPitch(hit, states){
  // 变桨: 蓄能器储压 → 比例阀 → 油缸推动变桨轴承 → 桨叶; 滑环供电与信号
  const c = k => ANAT_C((states||{})[k]);
  const on = k => (hit||'').includes(k);
  const hl = k => on(k) ? 'var(--bad)' : 'currentColor';
  return `<figure style="margin:0"><svg viewBox="0 0 660 230" role="img" width="660"
    aria-label="变桨系统: 蓄能器储压经比例阀推动油缸, 油缸驱动变桨轴承转动桨叶; 滑环传电与信号"
    style="max-width:100%;height:auto;display:block;margin:0 auto">
    <g fill="none" stroke="currentColor" stroke-width="1.4">
      <!-- 滑环 -->
      <g stroke="${hl('滑环')}"><rect x="20" y="86" width="30" height="50" rx="4"/>
        <path d="M20,96 h30 M20,110 h30 M20,124 h30" stroke-opacity="0.5"/></g>
      <text x="35" y="152" text-anchor="middle" font-size="10.5" fill="currentColor" stroke="none">滑环</text>
      <path d="M50,111 h34" marker-end="url(#pH)"/>
      <text x="67" y="104" text-anchor="middle" font-size="9" fill="currentColor" stroke="none" opacity="0.7">电/信号</text>
      <!-- 蓄能器 -->
      <g stroke="${hl('蓄能')}" stroke-width="${on('蓄能')?2.2:1.4}">
        <rect x="88" y="70" width="40" height="82" rx="20"/>
        <path d="M88,104 h40" stroke-dasharray="3 2"/></g>
      <text x="108" y="166" text-anchor="middle" font-size="10.5" fill="${hl('蓄能')}" stroke="none">蓄能器</text>
      <text x="108" y="62" text-anchor="middle" font-size="9" fill="currentColor" stroke="none" opacity="0.7">氮气预充</text>
      <path d="M128,111 h36" marker-end="url(#pH)"/>
      <!-- 比例阀 -->
      <g stroke="${hl('阀')}"><rect x="166" y="92" width="34" height="38" rx="3"/>
        <path d="M166,111 h34 M183,92 v38" stroke-opacity="0.5"/></g>
      <text x="183" y="146" text-anchor="middle" font-size="10.5" fill="currentColor" stroke="none">比例阀</text>
      <path d="M200,111 h34" marker-end="url(#pH)"/>
      <text x="217" y="104" text-anchor="middle" font-size="9" fill="currentColor" stroke="none" opacity="0.7">压力</text>
      <!-- 油缸 -->
      <g stroke="${hl('油缸')}" stroke-width="${on('油缸')?2.2:1.4}">
        <rect x="236" y="94" width="86" height="34" rx="3"/>
        <rect x="246" y="100" width="30" height="22" rx="2" fill="currentColor" fill-opacity="0.14"/>
        <path d="M276,111 h66"/></g>
      <text x="279" y="146" text-anchor="middle" font-size="10.5" fill="${hl('油缸')}" stroke="none">变桨油缸</text>
      <!-- 变桨轴承 + 桨叶 -->
      <g stroke="${hl('轴承')}" stroke-width="${on('轴承')?2.2:1.4}">
        <circle cx="392" cy="111" r="34"/><circle cx="392" cy="111" r="24"/>
        ${[0,120,240].map(a=>{const r=(a-90)*Math.PI/180;
          return `<circle cx="${(392+Math.cos(r)*29).toFixed(1)}" cy="${(111+Math.sin(r)*29).toFixed(1)}" r="3.4"/>`}).join('')}</g>
      <text x="392" y="164" text-anchor="middle" font-size="10.5" fill="${hl('轴承')}" stroke="none">变桨轴承</text>
      <path d="M426,111 q46,-4 74,-40" stroke-width="5" stroke-opacity="0.3" stroke-linecap="round"/>
      <path d="M426,111 q46,4 74,40" stroke-width="5" stroke-opacity="0.3" stroke-linecap="round"/>
      <text x="520" y="76" font-size="10.5" fill="currentColor" stroke="none">桨叶 A/B/C</text>
      <!-- 观测面 -->
      <path d="M108,152 v30 h284 v-18" stroke-dasharray="3 3" stroke-opacity="0.55"/>
      <text x="250" y="196" text-anchor="middle" font-size="10" fill="currentColor" stroke="none">
        观测: 蓄能带宽/停机泄压 · 桨距跟踪偏差 · 三叶零位一致性 · 轴承润滑脂</text>
      <defs><marker id="pH" markerWidth="7" markerHeight="7" refX="6" refY="3.5" orient="auto">
        <polygon points="0,0 7,3.5 0,7" fill="currentColor"/></marker></defs>
    </g></svg>
    <figcaption class="small" style="color:var(--muted);margin-top:6px">
      动力: 蓄能器储压 → 比例阀 → 油缸 → 变桨轴承 → 桨叶。压力侧失效看蓄能带宽与泄压率,
      执行侧看桨距跟踪偏差, 三叶不一致指向单支路。</figcaption></figure>`;
}

const ANAT = {'主轴承': anatMainBearing, '齿轮箱': anatGearbox, '变桨': anatPitch};

// 链条缩略版 (表格用: 列宽有限, 全剖面被挤成49px不可读) — 同一图形语言的 sparkline。
// 2026-08-28 用户"更清楚": 八个一样的圆点分不出段落 → 节点形状语义化 (轴承=双环 · 齿轮=带齿圆)
// + 三段分区底纹 (主轴 / 齿轮箱 / 发电机), 命中环放大填色+外发光, 仍零文字。
const dtMini=(comp,sev,W,T2)=>{
  const c=String(comp||''), w=W||208;
  const hit=n=>({'主轴承前':/主轴承[(（]前|主轴承前|主轴承[+＋]|主轴承(?![(（前后])/,'主轴承后':/主轴承[(（]后|主轴承后/,
    '行星':/行星|二级行星/,'中间':/中间轴|中速/,'高速':/高速轴|高速(?!.*发电)/,
    '发电机DE':/发电机DE|发电机[(（]|发电机(?!NDE)/,'发电机NDE':/发电机NDE|NDE/}[n].test(c));
  const gball=/齿轮箱/.test(c)&&!/行星|中间轴|中速|高速轴/.test(c);
  const on=n=>hit(n)||(gball&&['行星','中间','高速'].includes(n));
  const Y=20, MU='var(--muted)', PN='var(--panel)', LN='var(--line)';
  const zone=(x,w2,dash)=>`<rect x="${x}" y="5" width="${w2}" height="30" rx="6" fill="var(--muted)" fill-opacity="0.13"
      stroke="${dash&&gball?sev:LN}" stroke-opacity="${dash&&gball?0.9:0.5}" ${dash?'stroke-dasharray="3 2"':''}/>`;
  // 轴承节点 = 双环 (外圈+滚道); 齿轮节点 = 圆+四齿
  const node=(x,n,kind)=>{
    const k=on(n), col=k?sev:MU, r=k?7:5.4;
    const teeth=kind==='g'?[0,90,180,270].map(a=>{const t=a*Math.PI/180;
      return `<line x1="${(x+Math.cos(t)*r).toFixed(1)}" y1="${(Y+Math.sin(t)*r).toFixed(1)}" x2="${(x+Math.cos(t)*(r+2.6)).toFixed(1)}" y2="${(Y+Math.sin(t)*(r+2.6)).toFixed(1)}" stroke="${col}" stroke-width="${k?1.8:1.2}"/>`}).join(''):'';
    const core=(k?`<circle class="dt-halo" cx="${x}" cy="${Y}" r="${r+6}" fill="${sev}"/>`:'')
      +`<circle cx="${x}" cy="${Y}" r="${r}" fill="${k?sev:PN}" fill-opacity="${k?0.9:1}" stroke="${col}" stroke-opacity="${k?1:0.85}" stroke-width="${k?2.2:1.4}"/>`
      +(kind==='b'?`<circle cx="${x}" cy="${Y}" r="${(r*0.42).toFixed(1)}" fill="${k?'#fff':MU}" fill-opacity="${k?0.85:0.7}" stroke="none"/>`:teeth);
    return (k&&T2)?`<g class="dt-hot" onclick="event.stopPropagation();popPart('${T2}','${n}')"><title>${n} — 点看曲线与四源微视图</title>
        <circle cx="${x}" cy="${Y}" r="${r+7}" fill="transparent"/>${core}</g>`:core;
  };
  return `<svg class="dt" viewBox="0 0 320 40" style="display:block;width:${w}px;max-width:100%;height:auto">
  ${zone(28,74)}${zone(112,90,1)}${zone(212,96)}
  <line x1="20" y1="${Y}" x2="304" y2="${Y}" stroke="${LN}" stroke-width="3" stroke-linecap="round"/>
  <path d="M20,13 L11,4 M20,27 L11,36 M20,${Y} L9,${Y}" stroke="${MU}" stroke-width="1.6" fill="none"/>
  ${node(46,'主轴承前','b')}${node(88,'主轴承后','b')}
  ${node(133,'行星','g')}${node(157,'中间','g')}${node(181,'高速','g')}
  ${node(236,'发电机DE','b')}${node(282,'发电机NDE','b')}
  </svg>`};
const dtSVG=(comp,sev,W)=>{
  const c=String(comp||''), w=W||660;
  const hit=n=>({'主轴承前':/主轴承[(（]前|主轴承前|主轴承[+＋]|主轴承(?![(（前后])/,'主轴承后':/主轴承[(（]后|主轴承后/,
    '行星':/行星|二级行星/,'中间':/中间轴|中速/,'高速':/高速轴|高速(?!.*发电)/,
    '发电机DE':/发电机DE|发电机[(（]|发电机(?!NDE)/,'发电机NDE':/发电机NDE|NDE/}[n].test(c));
  const gball=/齿轮箱/.test(c)&&!/行星|中间轴|中速|高速轴/.test(c);
  const on=n=>hit(n)||(gball&&['行星','中间','高速'].includes(n));
  const LN='var(--line)', MU='var(--muted)', PN='var(--panel)';
  const K=660/w, FS=(11*K).toFixed(1), SW=(1.5*K).toFixed(2);   // 缩放补偿: 显示字号/线宽与图宽无关
  // 部件绘制器: 命中→光晕+sev描边加粗+标名; 未命中→灰描边无字 (纯图形: 只有出问题的那一环有字)
  const part=(n,label,lx,ly,body,halo)=>{
    const k=on(n), col=k?sev:MU;
    return (k&&halo?`<rect class="dt-halo" x="${halo[0]}" y="${halo[1]}" width="${halo[2]}" height="${halo[3]}" rx="8" fill="${sev}"/>`:'')
      +`<g stroke="${col}" stroke-width="${k?SW:0.9*K}" fill="${PN}" fill-opacity="1">${body}</g>`
      +(k?`<text x="${lx}" y="${ly}" text-anchor="middle" font-size="${FS}" font-weight="600" fill="${sev}">${label}</text>`:'');
  };
  // 轴承剖面符号 (上下外圈+滚子+内圈)
  const brg=(x,n,label,ly)=>part(n,label,x,ly,
    `<rect x="${x-17}" y="47" width="34" height="7" rx="1.5"/><rect x="${x-17}" y="96" width="34" height="7" rx="1.5"/>`+
    [-11,0,11].map(d=>`<circle cx="${x+d}" cy="60" r="4.2"/><circle cx="${x+d}" cy="90" r="4.2"/>`).join('')+
    `<rect x="${x-17}" y="66" width="34" height="4" rx="1"/><rect x="${x-17}" y="80" width="34" height="4" rx="1"/>`,[x-24,40,48,70]);
  // 齿轮 = 竖矩形 + 齿纹
  const gear=(x,cy,D,n,label,ly)=>part(n,label,x+6,ly,
    `<rect x="${x}" y="${cy-D/2}" width="13" height="${D}" rx="2"/>`+
    Array.from({length:Math.max(3,Math.round(D/9))},(_,i)=>{const yy=cy-D/2+4+i*(D-8)/Math.max(2,Math.round(D/9)-1);
      return `<line x1="${x}" y1="${yy}" x2="${x+13}" y2="${yy}" stroke-width="${0.7*K}" stroke-opacity="0.55"/>`}).join(''),[x-7,cy-D/2-7,27,D+14]);
  const shaft=(x1,x2,y,th)=>`<line x1="${x1}" y1="${y}" x2="${x2}" y2="${y}" stroke="${LN}" stroke-width="${th||9}" stroke-linecap="round"/>`;
  return `<svg class="dt" viewBox="0 0 660 150" style="display:block;width:${w}px;max-width:100%;height:auto;margin:6px auto">
  <!-- 轮毂+叶根 -->
  <g stroke="${MU}" fill="${PN}"><path d="M22,52 L48,62 L48,88 L22,98 Z" stroke-width="1"/>
    <line x1="22" y1="75" x2="6" y2="75" stroke-width="3"/><line x1="24" y1="60" x2="10" y2="34" stroke-width="3"/>
    <line x1="24" y1="90" x2="10" y2="116" stroke-width="3"/></g>
  ${shaft(46,206,75,12)}
  ${brg(88,'主轴承前','主轴承 前',126)}${brg(154,'主轴承后','主轴承 后',126)}
  <!-- 齿轮箱壳 -->
  <rect x="196" y="16" width="242" height="118" rx="7" fill="none"
        stroke="${gball?sev:LN}" stroke-width="${gball?1.6:1}" stroke-dasharray="4 3" stroke-opacity="${gball?0.9:0.6}"/>
  <!-- 一级行星: 齿圈(上下)+行星轮+太阳轮+行星架 -->
  ${part('行星','行星级',236,146,
    `<rect x="210" y="24" width="52" height="8" rx="2"/><rect x="210" y="118" width="52" height="8" rx="2"/>
     <rect x="228" y="38" width="14" height="26" rx="2"/><rect x="228" y="86" width="14" height="26" rx="2"/>
     <rect x="228" y="62" width="14" height="26" rx="2"/>
     <path d="M210,75 L228,51 M210,75 L228,99" stroke-width="${1.4*K}" fill="none"/>`,[203,17,66,116])}
  ${shaft(256,306,75,7)}
  <!-- 二级 中速→中间轴 (节点相切) -->
  ${gear(300,75,46,'中间','中间轴',146)}
  ${gear(300,37,30,'中间','',0)}
  ${shaft(306,352,37,6)}
  <!-- 三级 中间轴→高速轴 -->
  ${gear(348,37,50,'高速','高速轴',146)}
  ${gear(348,75,26,'高速','',0)}
  ${shaft(360,438,75,8)}
  <!-- 联轴器 -->
  <g stroke="${MU}" fill="${PN}"><rect x="438" y="62" width="6" height="26" rx="1"/><rect x="452" y="62" width="6" height="26" rx="1"/>
    <line x1="444" y1="75" x2="452" y2="75" stroke-width="2"/></g>
  <!-- 发电机: 壳+定子+转子+两端轴承 -->
  <rect x="462" y="34" width="184" height="82" rx="7" fill="none" stroke="${LN}" stroke-dasharray="4 3" stroke-opacity="0.6"/>
  <g stroke="${MU}" fill="${PN}"><rect x="486" y="42" width="136" height="12" rx="2"/><rect x="486" y="96" width="136" height="12" rx="2"/>
    <rect x="492" y="60" width="124" height="30" rx="3" fill-opacity="0.35"/></g>
  ${shaft(430,652,75,8)}
  ${part('发电机DE','发电机 DE',478,146,`<rect x="470" y="56" width="16" height="12" rx="2"/><rect x="470" y="82" width="16" height="12" rx="2"/>
     <circle cx="478" cy="64" r="3.4"/><circle cx="478" cy="86" r="3.4"/>`,[464,48,28,54])}
  ${part('发电机NDE','发电机 NDE',628,146,`<rect x="620" y="56" width="16" height="12" rx="2"/><rect x="620" y="82" width="16" height="12" rx="2"/>
     <circle cx="628" cy="64" r="3.4"/><circle cx="628" cy="86" r="3.4"/>`,[614,48,28,54])}
  </svg>`};

function chip(s){return `<span class="chip" style="--c:${C[s]||'#9aa4b0'}">${s}</span>`}
function sc(v,lo,hi,a,b){return hi>lo? a+(b-a)*(v-lo)/(hi-lo) : (a+b)/2}
// 图幅分级 (2026-08-28 用户令"根据系统和分类要合理大小"):
//   L=整行 (传动链/振动标量/功率曲线 — 需要横向空间, 但图身封顶 880/760 不随容器无限拉伸)
//   M=常规格 (月度趋势/计数条 — 两张并排可比)
const FIGW = {vib: 880, vibbar: 900, xy: 760, band: 620, bar: 620, line: 620};
const isL = f => f.size === 'L' || ['vib', 'vibbar', 'xy'].includes(f.kind);
const figWrap = (f, inner, note) => `<div class="card"${isL(f) ? ' style="grid-column:1/-1"' : ''}>
  <h3>${f.title || ''}</h3><div style="max-width:${FIGW[f.kind] || 620}px;margin:0 auto">${inner}</div>
  ${note ? `<p class="small" style="margin-top:6px;color:var(--muted)">${note}</p>` : ''}</div>`;

// 故障模式四象限 (经典可靠性分析)。x=发生条数(对数) y=单次中位时长(对数);
// 右下=高频短时(抖动/刷屏, 调参或屏蔽) 左上=低频长时(硬故障, 备件/检修)
// 右上=高频长时(重点治理) 左下=低频短时(本底)。点面积=影响台数, 分离单台刷屏与批次共性。
function quadChart(items){
  const it=(items||[]).filter(x=>x&&x.n>0&&x.med>0);
  if(it.length<3) return '<p class="small">窗内码数不足, 不作四象限</p>';
  const W=720,H=330,ML=58,MR=16,MB=44,MT=16;
  const lx=x=>Math.log10(x), xs=it.map(d=>lx(d.n)), ys=it.map(d=>lx(d.med));
  const x0=Math.min(...xs)-0.15,x1=Math.max(...xs)+0.15,y0=Math.min(...ys)-0.15,y1=Math.max(...ys)+0.15;
  const PX=v=>ML+(lx(v)-x0)/(x1-x0)*(W-ML-MR), PY=v=>H-MB-(lx(v)-y0)/(y1-y0)*(H-MT-MB);
  // 分界: 条数中位 与 单次时长 600s(10min, 一个SCADA采样格) — 时长界是物理刻度不是分位数
  const srt=[...it].map(d=>d.n).sort((a,b)=>a-b), nmid=srt[Math.floor(srt.length/2)];
  const cx=PX(nmid), cy=PY(600);
  const mt=Math.max(...it.map(d=>d.nt));
  const pts=it.map(d=>{
    const r=3+Math.sqrt(d.nt/mt)*7, hot=(d.n>=nmid&&d.med>=600);
    return `<circle cx="${PX(d.n).toFixed(1)}" cy="${PY(d.med).toFixed(1)}" r="${r.toFixed(1)}"
      fill="${hot?'var(--bad)':'var(--accent)'}" fill-opacity="0.5" stroke="${hot?'var(--bad)':'var(--accent)'}" stroke-width="1">
      <title>${d.code} ${d.k}\u000A${d.n} 条 · 单次中位 ${d.med}s · 累计 ${d.h}h · ${d.nt} 台</title></circle>`;}).join('');
  const lab=it.filter(d=>d.n>=nmid||d.med>=600).slice(0,8).map(d=>
    `<text x="${(PX(d.n)+9).toFixed(1)}" y="${(PY(d.med)+3).toFixed(1)}" font-size="9" fill="var(--muted)">${d.code}</text>`).join('');
  const qn=(x,y,t,sub)=>`<text x="${x}" y="${y}" font-size="10" fill="var(--muted)" opacity="0.85">${t}</text>
    <text x="${x}" y="${y+12}" font-size="8.5" fill="var(--muted)" opacity="0.6">${sub}</text>`;
  const tick=v=>v>=3600?(v/3600)+'h':(v>=60?(v/60)+'min':v+'s');
  const yt=[10,60,600,3600,36000].filter(v=>lx(v)>=y0&&lx(v)<=y1).map(v=>
    `<line x1="${ML}" y1="${PY(v).toFixed(1)}" x2="${W-MR}" y2="${PY(v).toFixed(1)}" stroke="var(--line)" stroke-opacity="0.4"/>
     <text x="${ML-6}" y="${(PY(v)+3).toFixed(1)}" font-size="9" fill="var(--muted)" text-anchor="end">${tick(v)}</text>`).join('');
  const xt=[1,10,100,1000,10000].filter(v=>lx(v)>=x0&&lx(v)<=x1).map(v=>
    `<text x="${PX(v).toFixed(1)}" y="${H-MB+14}" font-size="9" fill="var(--muted)" text-anchor="middle">${v}</text>`).join('');
  return `<svg class="dt" viewBox="0 0 ${W} ${H}" style="width:${W}px;max-width:100%;height:auto">
    ${yt}${xt}
    <line x1="${cx.toFixed(1)}" y1="${MT}" x2="${cx.toFixed(1)}" y2="${H-MB}" stroke="var(--muted)" stroke-dasharray="3 3" stroke-opacity="0.5"/>
    <line x1="${ML}" y1="${cy.toFixed(1)}" x2="${W-MR}" y2="${cy.toFixed(1)}" stroke="var(--muted)" stroke-dasharray="3 3" stroke-opacity="0.5"/>
    ${qn(ML+6,MT+12,'低频长时 · 硬故障','备件与检修窗')}
    ${qn(W-MR-96,MT+12,'高频长时 · 重点治理','优先派工')}
    ${qn(ML+6,H-MB-18,'低频短时 · 本底','不单独处置')}
    ${qn(W-MR-96,H-MB-18,'高频短时 · 重复触发','调整参数或屏蔽, 非硬件故障')}
    ${pts}${lab}
    <text x="${(ML+(W-MR-ML)/2).toFixed(1)}" y="${H-6}" font-size="9.5" fill="var(--muted)" text-anchor="middle">发生条数 (对数)</text>
    <text x="14" y="${(MT+(H-MB-MT)/2).toFixed(1)}" font-size="9.5" fill="var(--muted)" text-anchor="middle" transform="rotate(-90 14 ${(MT+(H-MB-MT)/2).toFixed(1)})">单次中位时长 (对数)</text>
    </svg>`;
}

// 月度故障率图 (2026-08-28 审核逮的反向误读)。
// 原图画"月度条数", 末月 1371 条看着是全窗最低=在改善; 但 2026-07 只有 6 天数据(覆盖 19.4%),
// 按日均归一后是 228 条/日 = 全窗第二高, 是 6 月(75)的 3 倍 — 方向完全相反。
// ⇒ 残月绝不能与整月并列比较。柱=日均(可比), 灰斜纹=数据不满月, 数字标总条数(原始事实)。
function rateChart(mo){
  const ms=mo.months, vs=mo.vals, cov=mo.cov||ms.map(()=>1), pd=mo.per_day||[];
  const W=720,H=250,ML=48,MR=14,MB=52,MT=18, n=ms.length;
  const mx=Math.max(...pd.filter(x=>x!=null),1), bw=(W-ML-MR)/n;
  let bars='', lab='';
  ms.forEach((m,i)=>{
    const v=pd[i], part=cov[i]<0.5;
    if(v==null) return;
    const hh=v/mx*(H-MT-MB), bx=ML+i*bw+bw*0.16, by=H-MB-hh;
    bars+=`<rect x="${bx.toFixed(1)}" y="${by.toFixed(1)}" width="${(bw*0.68).toFixed(1)}" height="${hh.toFixed(1)}" rx="2"
      fill="${part?'var(--muted)':'var(--accent)'}" fill-opacity="${part?0.32:0.8}"
      stroke="${part?'var(--warn)':'none'}" stroke-dasharray="${part?'3 2':''}">
      <title>${m}: ${v} 条/日 (总 ${vs[i]} 条, 数据覆盖 ${(cov[i]*100).toFixed(0)}%)</title></rect>`;
    lab+=`<text x="${(bx+bw*0.34).toFixed(1)}" y="${(by-4).toFixed(1)}" font-size="9" fill="var(--muted)" text-anchor="middle">${v}</text>`
      +`<text x="${(bx+bw*0.34).toFixed(1)}" y="${H-MB+13}" font-size="9" fill="var(--muted)" text-anchor="middle">${m.slice(5)}月</text>`
      +`<text x="${(bx+bw*0.34).toFixed(1)}" y="${H-MB+25}" font-size="8" fill="var(--muted)" opacity="0.65" text-anchor="middle">${vs[i]}条</text>`
      +(part?`<text x="${(bx+bw*0.34).toFixed(1)}" y="${H-MB+37}" font-size="8" fill="var(--warn)" text-anchor="middle">仅${Math.round(cov[i]*30)}天</text>`:'');
  });
  const yt=[0,.5,1].map(f=>`<text x="${ML-6}" y="${(H-MB-f*(H-MT-MB)+3).toFixed(1)}" font-size="9" fill="var(--muted)" text-anchor="end">${Math.round(mx*f)}</text>`).join('');
  return `<svg class="dt" viewBox="0 0 ${W} ${H}" style="width:${W}px;max-width:100%;height:auto">
    <line x1="${ML}" y1="${H-MB}" x2="${W-MR}" y2="${H-MB}" stroke="var(--line)"/>
    <line x1="${ML}" y1="${MT}" x2="${ML}" y2="${H-MB}" stroke="var(--line)"/>
    ${bars}${lab}${yt}
    <text x="14" y="${(MT+(H-MB-MT)/2).toFixed(1)}" font-size="9.5" fill="var(--muted)" text-anchor="middle"
      transform="rotate(-90 14 ${(MT+(H-MB-MT)/2).toFixed(1)})">条/日</text></svg>`;
}

// 能量账瀑布 (经典发电量分析)。四行工况表回答不了业主唯一关心的问题: 电去哪了。
// 左=理论可发, 中间逐段扣损(按损失降序), 右=实际上网; 段高即电量, 一眼看出谁是大头。
// 物理闸: 理论可发不得超 台数×额定×窗时长 (能量守恒, memory ledger-loss-numbers-need-physical-cap-check)。
const LOSSPLAIN = {
  '限电·绑定':'限电 (命令与实际功率对得上)',
  '限电命令·未绑定':'限电命令期 · 功率未被压制',
  '停机(调度令)':'调度令停机',
  '停机':'故障与检修停机',
  '正常发电':'正常发电时的欠发',
  '低风待机':'低风待机'};
function waterfall(e){
  if(!e||!e.theo) return '';
  const W=720,H=300,ML=8,MR=8,MT=30,MB=64, items=(e.items||[]).filter(x=>x.loss>0);
  const cols=items.length+2, cw=(W-ML-MR)/cols, sc=(H-MT-MB)/e.theo;
  let run=e.theo, h='', i=0;
  const bar=(idx,y,hh,fill,op)=>`<rect x="${(ML+idx*cw+cw*0.14).toFixed(1)}" y="${y.toFixed(1)}"
    width="${(cw*0.72).toFixed(1)}" height="${Math.max(hh,1.2).toFixed(1)}" rx="2" fill="${fill}" fill-opacity="${op}"/>`;
  const lab=(idx,y,t,v,c)=>`<text x="${(ML+idx*cw+cw*0.5).toFixed(1)}" y="${(y-6).toFixed(1)}" font-size="10"
      fill="${c||'var(--fg)'}" text-anchor="middle" font-weight="600">${v}</text>`
    +`<text x="${(ML+idx*cw+cw*0.5).toFixed(1)}" y="${H-MB+14}" font-size="8.5" fill="var(--muted)" text-anchor="middle">${t}</text>`;
  h+=bar(0,H-MB-e.theo*sc,e.theo*sc,'var(--info)',0.45)
    +lab(0,H-MB-e.theo*sc,'理论可发',Math.round(e.theo).toLocaleString());
  items.forEach(x=>{ i++;
    const top=H-MB-run*sc, hh=x.loss*sc; run-=x.loss;
    const nm=LOSSPLAIN[x.k]||x.k;
    h+=bar(i,top,hh,'var(--bad)',0.55)
      +`<line x1="${(ML+(i-1)*cw+cw*0.86).toFixed(1)}" y1="${top.toFixed(1)}" x2="${(ML+i*cw+cw*0.14).toFixed(1)}" y2="${top.toFixed(1)}"
         stroke="var(--muted)" stroke-dasharray="2 2" stroke-opacity="0.6"/>`
      +lab(i,top,nm.length>10?nm.slice(0,9)+'…':nm,'−'+Math.round(x.loss).toLocaleString(),'var(--bad)')
      +`<title>${nm}: 损失 ${x.loss.toLocaleString()} MWh, 占理论 ${(x.loss/e.theo*100).toFixed(1)}%, 时长 ${x.h.toLocaleString()}h</title>`;
  });
  h+=bar(cols-1,H-MB-e.act*sc,e.act*sc,'var(--ok)',0.6)
    +lab(cols-1,H-MB-e.act*sc,'实际上网',Math.round(e.act).toLocaleString(),'var(--ok)');
  return `<svg class="dt" viewBox="0 0 ${W} ${H}" style="width:${W}px;max-width:100%;height:auto">
    <line x1="${ML}" y1="${H-MB}" x2="${W-MR}" y2="${H-MB}" stroke="var(--line)"/>
    <text x="${ML}" y="14" font-size="9.5" fill="var(--muted)">MWh</text>${h}</svg>`;
}

// 可靠性-可维修性象限 (经典 RAM 分析, 2026-08-28 用户令: 停机事件化与可靠性可视化)。
// x=MTBF 平均无故障间隔(可靠性), y=MDT 平均单次停机时长(可维修性), 点面积=累计停机时长。
// 四象限的处置方向完全不同 — 表格按"停机时长"排序把这层结构整个抹掉了:
//   左上 常坏且难修 → 最高优先级   左下 频发易修 → 查根因(治本, 换件无用)
//   右上 罕发难修   → 备件与作业窗   右下 少发好修 → 维持
function ramChart(tb){
  const it=(tb||[]).filter(x=>x.MTBF_h&&x.MDT_h);
  if(it.length<3) return '<p class="small">部件数不足, 不作象限</p>';
  const W=720,H=340,ML=56,MR=112,MB=48,MT=16;
  const lg=v=>Math.log10(v), xs=it.map(d=>lg(d.MTBF_h)), ys=it.map(d=>d.MDT_h);
  const x0=Math.min(...xs)-0.08,x1=Math.max(...xs)+0.08,y0=0,y1=Math.max(...ys)*1.12;
  const PX=v=>ML+(lg(v)-x0)/(x1-x0)*(W-ML-MR), PY=v=>H-MB-(v-y0)/(y1-y0)*(H-MT-MB);
  const md=a=>{const z=[...a].sort((p,q)=>p-q);return z[Math.floor(z.length/2)]};
  const cx=PX(md(it.map(d=>d.MTBF_h))), cy=PY(md(ys));
  const mh=Math.max(...it.map(d=>d.停机时长h));
  const pts=it.map(d=>{
    const r=4+Math.sqrt(d.停机时长h/mh)*13;
    const ext=d.外部, hot=(d.MTBF_h<md(it.map(v=>v.MTBF_h))&&d.MDT_h>=md(ys));
    const c=ext?'var(--muted)':(hot?'var(--bad)':'var(--accent)');
    return `<circle cx="${PX(d.MTBF_h).toFixed(1)}" cy="${PY(d.MDT_h).toFixed(1)}" r="${r.toFixed(1)}"
      fill="${c}" fill-opacity="${ext?0.3:0.42}" stroke="${c}" stroke-width="1.2"
      stroke-dasharray="${ext?'3 2':''}"><title>${d.部件}: MTBF ${d.MTBF_h}h · MDT ${d.MDT_h}h · 停机 ${d.停机时长h}h · ${d.事件数}起 · ${d.影响台数}台${ext?' · 外部类不计设备可靠性':''}</title></circle>
      <text x="${(PX(d.MTBF_h)+r+4).toFixed(1)}" y="${(PY(d.MDT_h)+3.5).toFixed(1)}" font-size="9.5"
        fill="${ext?'var(--muted)':'currentColor'}">${d.部件.slice(0,7)}</text>`;}).join('');
  const qn=(x,y,a,t,sub)=>`<text x="${x}" y="${y}" font-size="10" fill="var(--muted)" text-anchor="${a}" opacity="0.9">${t}</text>
    <text x="${x}" y="${y+12}" font-size="8.5" fill="var(--muted)" text-anchor="${a}" opacity="0.62">${sub}</text>`;
  const xt=[1000,2000,5000,10000,20000].filter(v=>lg(v)>=x0&&lg(v)<=x1).map(v=>
    `<line x1="${PX(v).toFixed(1)}" y1="${MT}" x2="${PX(v).toFixed(1)}" y2="${H-MB}" stroke="var(--line)" stroke-opacity="0.3"/>
     <text x="${PX(v).toFixed(1)}" y="${H-MB+14}" font-size="9" fill="var(--muted)" text-anchor="middle">${v>=1000?(v/1000)+'k':v}</text>`).join('');
  const yt=[0,5,10,15,20].filter(v=>v<=y1).map(v=>
    `<text x="${ML-6}" y="${(PY(v)+3).toFixed(1)}" font-size="9" fill="var(--muted)" text-anchor="end">${v}</text>`).join('');
  return `<svg class="dt" viewBox="0 0 ${W} ${H}" style="width:${W}px;max-width:100%;height:auto">
    ${xt}${yt}
    <line x1="${ML}" y1="${H-MB}" x2="${W-MR}" y2="${H-MB}" stroke="var(--line)"/>
    <line x1="${ML}" y1="${MT}" x2="${ML}" y2="${H-MB}" stroke="var(--line)"/>
    <line x1="${cx.toFixed(1)}" y1="${MT}" x2="${cx.toFixed(1)}" y2="${H-MB}" stroke="var(--muted)" stroke-dasharray="3 3" stroke-opacity="0.45"/>
    <line x1="${ML}" y1="${cy.toFixed(1)}" x2="${W-MR}" y2="${cy.toFixed(1)}" stroke="var(--muted)" stroke-dasharray="3 3" stroke-opacity="0.45"/>
    ${qn(ML+6,MT+12,'start','常坏且难修','最高优先级')}
    ${qn(W-MR-6,MT+12,'end','罕发难修','备件与作业窗')}
    ${qn(ML+6,H-MB-16,'start','频发易修','查根因, 换件无用')}
    ${qn(W-MR-6,H-MB-16,'end','少发好修','维持')}
    ${pts}
    <text x="${(ML+(W-MR-ML)/2).toFixed(1)}" y="${H-8}" font-size="9.5" fill="var(--muted)" text-anchor="middle">平均无故障间隔 MTBF (h, 对数) →  越右越可靠</text>
    <text x="13" y="${(MT+(H-MB-MT)/2).toFixed(1)}" font-size="9.5" fill="var(--muted)" text-anchor="middle"
      transform="rotate(-90 13 ${(MT+(H-MB-MT)/2).toFixed(1)})">单次停机时长 MDT (h) →  越上越难修</text>
    <circle cx="${W-MR+16}" cy="${MT+40}" r="5" fill="var(--accent)" fill-opacity="0.42" stroke="var(--accent)"/>
    <text x="${W-MR+26}" y="${MT+44}" font-size="9" fill="var(--muted)">设备类</text>
    <circle cx="${W-MR+16}" cy="${MT+58}" r="5" fill="var(--muted)" fill-opacity="0.3" stroke="var(--muted)" stroke-dasharray="3 2"/>
    <text x="${W-MR+26}" y="${MT+62}" font-size="9" fill="var(--muted)">外部类</text>
    <text x="${W-MR+6}" y="${MT+84}" font-size="8.5" fill="var(--muted)">圆面积 = 累计停机时长</text>
    <text x="${W-MR+6}" y="${MT+98}" font-size="8.5" fill="var(--muted)">虚线 = 本场中位分界</text>
    </svg>`;
}

// 归因覆盖率条: "无记录停机" 是最大单项却因不给 MTBF 而在可靠性排序里隐身 (规划 P1-2)
function attribBar(tb, tot){
  const nore=(tb||[]).find(x=>x.部件==='无记录停机');
  const unk=nore?nore.停机时长h:0, un2=(tb||[]).filter(x=>x.部件==='未归类').reduce((a,b)=>a+b.停机时长h,0);
  const ok=tot-unk-un2, W=720,H=54;
  const seg=(x,w,c,op)=>`<rect x="${x.toFixed(1)}" y="14" width="${Math.max(w,1).toFixed(1)}" height="22" rx="3" fill="${c}" fill-opacity="${op}"/>`;
  const w1=ok/tot*W, w2=un2/tot*W, w3=unk/tot*W;
  return `<svg class="dt" viewBox="0 0 ${W} ${H}" style="width:${W}px;max-width:100%;height:auto">
    ${seg(0,w1,'var(--accent)',0.55)}${seg(w1,w2,'var(--warn)',0.5)}${seg(w1+w2,w3,'var(--bad)',0.5)}
    <text x="4" y="10" font-size="9" fill="var(--muted)">已归因到部件 ${Math.round(ok)}h (${(ok/tot*100).toFixed(0)}%)</text>
    <text x="${(w1+w2+w3-2).toFixed(1)}" y="10" font-size="9" fill="var(--bad)" text-anchor="end">无记录 ${Math.round(unk)}h (${(unk/tot*100).toFixed(0)}%)</text>
    <text x="${(w1+w2/2).toFixed(1)}" y="50" font-size="9" fill="var(--warn)" text-anchor="middle">未归类 ${Math.round(un2)}h</text>
    </svg>`;
}

// 失败必须响亮 (2026-08-28 全系统盘点逮): 后端 m8/m9/rel/fus 四块都是
// `except: X = {err: ...}`, 前端一律 `&&!d.X.err` 直接跳过渲染 —— 界面看不出"这块没算出来",
// 看起来只是"这一页没这个内容"。reliability 的 bool 位取反 bug 就是这样活下来的。
// ⇒ 出错时改为渲染一张醒目失败卡: 说清哪块没了、意味着什么缺失、错在哪。
const BLOCKDESC = {
  rel:  ['部件停机贡献与可靠性', '本页看不到部件级 MTBF/MDT 与停机归因'],
  m8:   ['停机事件化与故障季节性', '故障统计页缺停机归因与季节形态'],
  m9:   ['控制参数一致性', '发电性能页缺封顶分组与桨距调度差'],
  fus:  ['振动四源融合', '振动融合页缺逐台判级矩阵'],
};
function blockErr(key, err){
  const d = BLOCKDESC[key] || [key, ''];
  return `<div class="card mb" style="border-left:3px solid var(--bad)">
    <h3 style="color:var(--bad)">⚠ ${d[0]} — 未算出</h3>
    <p class="small" style="margin-bottom:6px">${d[1]}。<b>非"本窗无数据", 属计算失败</b> — 下方数字不完整, 不要据此下结论。</p>
    <pre class="small" style="white-space:pre-wrap;color:var(--muted);background:var(--bg);padding:8px 10px;border-radius:6px;margin:0">${String(err).slice(0,300)}</pre></div>`;
}

// 逐页窗声明 (2026-08-28 审核逮的交互欺骗)。
// 顶部窗选择器对"发电性能"完全无效 — 那 19 张图是预计算产物, 窗在生成时钉死为 2025-07~2026-01;
// 用户切到"2026年"图纹丝不动却毫无提示。"控制策略"曾更糟(工况态跟随+参数件固定窗并列),
// 两个窗并列在同一页。窗对不齐 = claim窗≠证据窗, 是判据失效的头号来源, 必须写在脸上。
const WINSPEC = {
  '发电性能': {mode:'fixed', win:'2025-07 ~ 2025-12',
               why:'限电前干净窗 — 2026 起交易策略主导, 曲线与控制参数含策略性少发不可作设备判据。本页含特性曲线与控制参数一致性两件, 同窗'},
  // 2026-08-28 用户裁: 控制参数件(固定窗)迁入发电性能, "电量算账"只留跟随窗内容
  // → 每页只有一个窗制, 混合窗从根上消掉 (原来是本系统唯一的双窗页)
};
function winBanner(tab, curWin, extra){
  const w = WINSPEC[tab];
  if(!w) return `<div class="winb"><b>时间窗</b> ${curWin} · 本页全部数字随上方窗切换${extra?' ｜ '+extra:''}</div>`;
  const c = w.mode==='fixed' ? 'var(--warn)' : 'var(--info)';
  const tag = w.mode==='fixed' ? '固定窗 · 不随上方切换' : '本页含两个窗';
  return `<div class="winb" style="border-left-color:${c}">
    <b style="color:${c}">${tag}</b> ${w.win}
    <div class="small" style="color:var(--muted);margin-top:3px">${w.why}${extra?' ｜ '+extra:''}</div></div>`;
}

// 控制参数三图 (2026-08-28 用户令: 控制参数一致性要图形, 在发电性能展示)。
// 原来是三段密文字, 关键结论"离散成组≠连续分布"完全看不出来 — 而这正是判"参数级差异"的依据。
// A 封顶参数数轴: 台数落在几个离散位置上 = 配置/版本差异; 若是磨损或工况会是连续散布。
// B 桨距同档差: 零中线偏差条, 长度即幅度, 与全场中位同尺比。
// C 尺子巡检: 极差/σ 比 — 38 台正态抽样的极差期望约 3.7σ, 明显超出即分布非单峰(佐证 A 的分组)。
function capAxis(P, W9){
  const W=500, H=158, ML=54, MR=34;
  const row=(y, spec, unit, label)=>{
    const gs=Object.entries(spec.分组).map(([k,v])=>({v:parseFloat(k), n:v, raw:k}));
    if(!gs.length) return '';
    const lo=Math.min(...gs.map(g=>g.v)), hi=Math.max(...gs.map(g=>g.v));
    const pad=(hi-lo)*0.22||1, x0=lo-pad, x1=hi+pad;
    const PX=v=>ML+(v-x0)/(x1-x0)*(W-ML-MR);
    const mn=Math.max(...gs.map(g=>g.n));
    const dots=gs.map(g=>{const r=5+Math.sqrt(g.n/mn)*9;
      return `<circle cx="${PX(g.v).toFixed(1)}" cy="${y}" r="${r.toFixed(1)}" fill="var(--accent)" fill-opacity="0.42" stroke="var(--accent)"/>
        <text x="${PX(g.v).toFixed(1)}" y="${y-r-5}" font-size="9" text-anchor="middle" fill="currentColor">${g.raw}</text>
        <text x="${PX(g.v).toFixed(1)}" y="${y+3.5}" font-size="9" text-anchor="middle" fill="var(--panel)" font-weight="600">${g.n}</text>`}).join('');
    const med=spec['中位'];
    return `<text x="${ML-6}" y="${y+3}" font-size="9.5" text-anchor="end" fill="var(--muted)">${label}</text>
      <line x1="${ML}" y1="${y}" x2="${W-MR}" y2="${y}" stroke="var(--line)"/>
      <line x1="${PX(med).toFixed(1)}" y1="${y-24}" x2="${PX(med).toFixed(1)}" y2="${y+18}" stroke="var(--muted)" stroke-dasharray="3 3" stroke-opacity="0.55"/>
      <text x="${PX(med).toFixed(1)}" y="${y+28}" font-size="8.5" text-anchor="middle" fill="var(--muted)">中位 ${med}</text>
      ${dots}`;
  };
  return `<svg class="dt" viewBox="0 0 ${W} ${H}" style="width:${W}px;max-width:100%;height:auto">
    ${row(44, P, 'kW', '满发封顶')}
    ${row(120, W9, 'rpm', '转速封顶')}
    <text x="${W-MR}" y="12" font-size="8.5" text-anchor="end" fill="var(--muted)">圆内数字=台数, 圆面积∝台数</text></svg>`;
}
function betaBar(b){
  const outs=(b.离群||[]), med=b['全场同档差中位'];
  const W=500, H=34+outs.length*26, ML=52, MR=58;
  const mx=Math.max(med, ...outs.map(o=>o.平均偏))*1.18||1;
  const PX=v=>ML+v/mx*(W-ML-MR);
  const rows=outs.map((o,i)=>{const y=30+i*26;
    return `<text x="${ML-6}" y="${y+10}" font-size="9.5" text-anchor="end" fill="currentColor">${o.t.replace('WTG','')}#</text>
      <rect x="${ML}" y="${y+1}" width="${(PX(o.平均偏)-ML).toFixed(1)}" height="13" rx="2" fill="var(--warn)" fill-opacity="0.62"/>
      <text x="${(PX(o.平均偏)+5).toFixed(1)}" y="${y+11}" font-size="9" fill="var(--warn)">${o.平均偏}°</text>`}).join('');
  return `<svg class="dt" viewBox="0 0 ${W} ${H}" style="width:${W}px;max-width:100%;height:auto">
    <line x1="${PX(med).toFixed(1)}" y1="18" x2="${PX(med).toFixed(1)}" y2="${H-4}" stroke="var(--ok)" stroke-dasharray="3 3"/>
    <text x="${PX(med).toFixed(1)}" y="12" font-size="8.5" fill="var(--ok)">全场中位 ${med}°</text>
    <line x1="${ML}" y1="18" x2="${ML}" y2="${H-4}" stroke="var(--line)"/>
    ${rows}</svg>`;
}
function rulerBar(rl){
  const ks=Object.entries(rl); const W=500, H=26+ks.length*30, ML=88, MR=76;
  const NORM=3.7;   // 38 台正态抽样极差期望 ≈ 3.7σ
  const mxr=Math.max(NORM*1.35, ...ks.map(([,v])=>v.极差/v.σ));
  const PX=v=>ML+v/mxr*(W-ML-MR);
  const rows=ks.map(([k,v],i)=>{const y=22+i*30, ratio=v.极差/v.σ, wide=ratio>NORM;
    return `<text x="${ML-6}" y="${y+11}" font-size="9.5" text-anchor="end" fill="currentColor">${k}</text>
      <rect x="${ML}" y="${y+2}" width="${(PX(ratio)-ML).toFixed(1)}" height="12" rx="2"
        fill="${wide?'var(--warn)':'var(--accent)'}" fill-opacity="0.55"/>
      <text x="${(PX(ratio)+5).toFixed(1)}" y="${y+11}" font-size="9" fill="var(--muted)">${ratio.toFixed(1)}σ　σ=${v.σ}</text>`}).join('');
  return `<svg class="dt" viewBox="0 0 ${W} ${H}" style="width:${W}px;max-width:100%;height:auto">
    <line x1="${PX(NORM).toFixed(1)}" y1="14" x2="${PX(NORM).toFixed(1)}" y2="${H-4}" stroke="var(--ok)" stroke-dasharray="3 3"/>
    <text x="${PX(NORM).toFixed(1)}" y="10" font-size="8.5" fill="var(--ok)" text-anchor="middle">正态期望 3.7σ</text>
    ${rows}</svg>`;
}

// 责任分账 (2026-08-28 用户令: 电量算账优化显示)。
// 瀑布回答"电量流向", 但业主真正要问的下一句是"谁的责任" — 原来只在一段小字里写了个百分比。
// 三分账: 交易与调度侧(限电两项+调度令停机) / 设备侧(故障与检修停机) / 运行侧(正常发电欠发+低风)。
function blameBar(e){
  const cat = k => (k.indexOf('限电')>=0 || k.indexOf('调度')>=0) ? 0 : (k==='停机' ? 1 : 2);
  const NM = ['交易与调度侧','设备侧','运行侧'];
  const NOTE = ['限电与调度令, 不进设备责任','故障与检修停机, 唯一进设备考核','正常发电欠发与低风待机'];
  const CL = ['var(--info)','var(--bad)','var(--muted)'];
  const g = [0,0,0];
  (e.items||[]).forEach(x => { g[cat(x.k)] += x.loss; });
  const tot = g.reduce((a,b)=>a+b,0) || 1;
  const W=500, H=44;
  let x=0, seg='';
  g.forEach((v,i)=>{ const w=v/tot*W;
    seg += `<rect x="${x.toFixed(1)}" y="12" width="${Math.max(w,1).toFixed(1)}" height="26" rx="3" fill="${CL[i]}" fill-opacity="0.55"><title>${NM[i]}: ${Math.round(v).toLocaleString()} MWh</title></rect>`
        + (w>46 ? `<text x="${(x+w/2).toFixed(1)}" y="29" font-size="10.5" fill="currentColor" text-anchor="middle" font-weight="600">${(v/tot*100).toFixed(0)}%</text>` : '');
    x += w; });
  // 图例走 HTML 而非 SVG text: SVG 里估算中文字宽不准, 三段说明会互相压字 (实测重叠)
  const leg = g.map((v,i)=>`<div style="display:flex;align-items:baseline;gap:7px;margin-top:5px">
    <i style="flex:none;width:9px;height:9px;border-radius:2px;background:${CL[i]};opacity:.55"></i>
    <span style="font-weight:600">${NM[i]}</span>
    <span class="cnt">${Math.round(v).toLocaleString()} MWh</span>
    <span class="small" style="color:var(--muted)">${NOTE[i]}</span></div>`).join('');
  return `<svg class="dt" viewBox="0 0 ${W} ${H}" style="width:${W}px;max-width:100%;height:auto">
    <text x="0" y="8" font-size="9" fill="var(--muted)">损失 ${Math.round(tot).toLocaleString()} MWh 按责任归属</text>
    ${seg}</svg>${leg}`;
}

// 帕累托图 (2026-08-28 用户令: 故障统计按经典分析展示)。
// 经典做法 = 条形按降序 + 右轴累计百分比折线 + 80% 参考线 → 一眼看出"关键少数";
// 原来只有两列排序表, 看不出前几项就占了大头。
function paretoChart(items, unit, note){
  const it = (items || []).filter(x => x && x.v > 0);
  if(!it.length) return '<p class="small">窗内无数据</p>';
  // 尺寸 (2026-08-28 排布优化): 原 720x260 + 旋转长标签, 两列并排时被缩到 0.60 倍 = 字高 6.5px 不可读。
  // 改紧凑版 520x236: x 轴只标码号(水平, 不旋转 → 底部留白 86→40), 全名进悬停与图注前三行。
  const W = 520, H = 236, ML = 46, MR = 40, MB = 40, MT = 14;
  const n = it.length, tot = it.reduce((a, x) => a + x.v, 0);
  const mx = Math.max(...it.map(x => x.v));
  const bw = (W - ML - MR) / n;
  const short = k => { const m = String(k).match(/^([0-9]+)/); return m ? m[1] : String(k).slice(0, 4); };
  let cum = 0, bars = '', line = [], dots = '', k80 = null;
  it.forEach((x, i) => {
    const hh = (x.v / mx) * (H - MT - MB);
    const bx = ML + i * bw + bw * 0.14, by = H - MB - hh;
    bars += `<rect x="${bx.toFixed(1)}" y="${by.toFixed(1)}" width="${(bw * 0.72).toFixed(1)}" height="${hh.toFixed(1)}"
      rx="2" fill="var(--accent)" fill-opacity="${i < 3 ? 0.85 : 0.45}"><title>${x.k}: ${x.v}${unit}</title></rect>`;
    cum += x.v;
    const pct = cum / tot;
    if(k80 === null && pct >= 0.8) k80 = i + 1;
    const px = ML + i * bw + bw / 2, py = MT + (1 - pct) * (H - MT - MB);
    line.push(`${px.toFixed(1)},${py.toFixed(1)}`);
    dots += `<circle cx="${px.toFixed(1)}" cy="${py.toFixed(1)}" r="2.4" fill="var(--warn)"><title>${x.k} · 累计 ${(pct*100).toFixed(0)}%</title></circle>`;
  });
  const y80 = MT + 0.2 * (H - MT - MB);
  const xt = it.map((x, i) => `<text x="${(ML + i*bw + bw/2).toFixed(1)}" y="${H - MB + 13}" font-size="9"
      fill="var(--muted)" text-anchor="middle">${short(x.k)}</text>`).join('');
  const yt = [0, .5, 1].map(f => `<text x="${ML-5}" y="${(H-MB-(f*(H-MT-MB))+3).toFixed(1)}" font-size="9"
      fill="var(--muted)" text-anchor="end">${Math.round(mx*f).toLocaleString()}</text>`).join('')
    + [0, .5, 1].map(f => `<text x="${W-MR+5}" y="${(MT+(1-f)*(H-MT-MB)+3).toFixed(1)}" font-size="9"
      fill="var(--warn)">${Math.round(f*100)}%</text>`).join('');
  const top3 = it.slice(0, 3).map(x => `<b>${short(x.k)}</b> ${String(x.k).replace(/^[0-9]+ */, '').slice(0, 13)}`).join(' · ');
  return `<svg class="dt" viewBox="0 0 ${W} ${H}" style="width:${W}px;max-width:100%;height:auto">
    <line x1="${ML}" y1="${H-MB}" x2="${W-MR}" y2="${H-MB}" stroke="var(--line)"/>
    <line x1="${ML}" y1="${MT}" x2="${ML}" y2="${H-MB}" stroke="var(--line)"/>
    ${bars}
    <line x1="${ML}" y1="${y80.toFixed(1)}" x2="${W-MR}" y2="${y80.toFixed(1)}" stroke="var(--warn)"
      stroke-dasharray="4 3" stroke-opacity="0.7"/>
    <text x="${W-MR-3}" y="${(y80-4).toFixed(1)}" font-size="9" fill="var(--warn)" text-anchor="end">累计 80%</text>
    <polyline points="${line.join(' ')}" fill="none" stroke="var(--warn)" stroke-width="1.5"/>${dots}
    ${xt}${yt}
    <text x="${(ML+(W-MR-ML)/2).toFixed(1)}" y="${H-3}" font-size="8.5" fill="var(--muted)" text-anchor="middle">报警码 (悬停看全名)</text></svg>
    <p class="small" style="color:var(--muted);margin-top:5px;line-height:1.6">
      ${k80 ? `<b>关键少数: 前 ${k80} 项占 80%</b> (共 ${n} 项, 合计 ${Math.round(tot).toLocaleString()}${unit})` : `共 ${n} 项, 合计 ${Math.round(tot).toLocaleString()}${unit}`}
      <br>前三: ${top3}${note ? '<br>' + note : ''}</p>`;
}

// ── 风场阵列 (2026-08-31 用户令: 风机与环境形象要用视觉体现) ──────────────
// 视觉语言与推介页 hero 同源: 细线几何 + stroke-opacity 造景深, 不写实。
// 它同时是**信息图**不只是插画 —— 每台按其最严重系统状态着色, 全场健康分布一眼可见。
// 快照版总览原本只有一句"内嵌页不可用", 这里正好补上。
// ── 运维成熟度与四判据 (2026-08-31) ───────────────────────────────
// 为什么放在检修决策页顶端: 这四条是"系统会主动拦下来"的判据, 不是又一张统计图。
// 那三个问题(复发/共性/记录断层)在本场存在五年没被发现, 不是没人懂,
// 是没有任何环节会主动报出来。
// 本体里的文本用 **x** 标重点 (那是给人读源文件时用的)。直接插进 HTML 会把星号
// 原样印在客户交付页上。这里只转粗体, 不引入 markdown 解析器 —— 需求就这一条。
// 用字符类 [*] 而非反斜杠转义 —— CHART_JS 是**非 raw** 的 Python 三引号串,
// 反斜杠在这里会被 Python 当转义处理: 反斜杠加星号触发 SyntaxWarning, 反斜杠加 n
// 直接变成真换行, 把单行注释劈成两行 —— 第二行不再是注释, 当场语法错、页面白屏。
// (写这条注释时我为了举例又写了一次那个转义, 于是当场复现了它描述的 bug,
//  被成品页语法闸逮到。所以: 这个字符串里能不写反斜杠就不写, 举例也别写。)
// 层级后缀单独成常量 —— 原来写成 `${lv}层` 时那个 `层` 是模板里的**字面量孤字**,
// 数据侧的 `机理` 译成了 Domain model 而它没译, 页面上就是 'Domain model层'。
// 提成常量后它是一个可查表的完整词。
const LAYER_SFX = '层';
const TIMES_SFX = '倍';

const mdB = s => String(s == null ? '' : s).replace(/[*][*]([^*]+)[*][*]/g, '<b>$1</b>');

// 快照版总览面板: 用已固化的数据汇总, 而不是道歉。
// 逐系统两个键: 裸名 = 有问题的机组, `·良好` = 判良好的机组 —— 汇总时要分开数。
function snapOverview(d){
  const SY = d.systems || {};
  const rows = [];
  Object.keys(SY).forEach(function(k){
    if (k.indexOf('·') >= 0) return;                 // 只遍历裸名, 良好那半单独取
    const bad = (SY[k] || []).length;
    const good = (SY[k + '·良好'] || []).length;
    if (bad + good) rows.push({sys: k, bad: bad, good: good});
  });
  rows.sort(function(a, b){ return b.bad - a.bad; });
  const K = d.kpi || {};
  const M = (d.m8 && d.m8.mtbf) || {};
  let h = '<div class="card mb"><div class="eyebrow">Where to look</div>';
  h += '<div style="font-size:12px;color:var(--muted);margin:2px 0 12px;line-height:1.6">'
     + '本页为固化快照: 上方每个标签页的数据都已随页面打包, 断网也能看。'
     + '下表按系统汇总当前状态, 点系统名进该系统的机组清单。</div>';
  if (rows.length){
    h += '<table class="tbl"><thead><tr><th>系统</th><th>需跟踪</th><th>判良好</th>'
       + '<th>占全场</th></tr></thead><tbody>';
    rows.forEach(function(r){
      const tot = r.bad + r.good;
      // 用 data 属性 + 委托事件, **不写嵌套引号** —— CHART_JS 是非 raw 的 Python
      // 三引号串, 里面的反斜杠转义会被 Python 吃掉, 反引号/单引号一嵌套就断串。
      // (今天第三次栽在这条上, 每次都是成品页语法闸拦下来的。)
      h += '<tr><td><a class="tl" href="#" data-gotab="部件问题">'
         + r.sys + '</a></td>'
         + '<td class="num"><b style="color:' + (r.bad ? 'var(--warn)' : 'var(--muted)') + '">'
         + r.bad + '</b></td><td class="num">' + r.good + '</td>'
         + '<td class="num small">' + tot + '</td></tr>';
    });
    h += '</tbody></table>';
  }
  h += '<div class="kpis" style="margin-top:12px">'
     + '<div class="kpi"><b>' + (K['报警台'] != null ? K['报警台'] : '—') + '</b>'
     + '<span>机组带报警级判定</span></div>'
     + '<div class="kpi"><b>' + (K['关注台'] != null ? K['关注台'] : '—') + '</b>'
     + '<span>机组在跟踪清单上</span></div>'
     + '<div class="kpi"><b>' + (M['停机事件数'] != null ? M['停机事件数'] : '—') + '</b>'
     + '<span>停机事件 (本窗)</span></div></div>';
  h += '<div style="font-size:12px;color:var(--muted);margin-top:14px;line-height:1.75">'
     + '<b>各屏回答什么</b><br>'
     + '电量算账 — 电去哪了, 每一度归到哪个原因<br>'
     + '部件问题 — 哪台哪系统该管, 依据是什么<br>'
     + '振动融合分析 — 振动与 SCADA 对上没有<br>'
     + '发电性能 — 曲线偏了没有, 偏在哪一段<br>'
     + '故障统计 — 报警的关键少数与可靠性象限<br>'
     + '检修决策 — 数据本身可不可信, 运维体系差在哪</div>';
  h += '</div>';
  return h;
}

// 总览表里的系统名跳到对应标签页。委托绑定, 只挂一次。
document.addEventListener('click', function(e){
  var a = e.target && e.target.closest ? e.target.closest('a[data-gotab]') : null;
  if (!a) return;
  e.preventDefault();
  TAB = a.getAttribute('data-gotab');
  render();
});

function dqFindings(d){
  // 数据可信度 —— 系统自查出的数据质量与口径问题。
  // 放在判据面板之前: 先说"这些数字可不可信", 再说"数字说明什么"。
  // 一个只报结论不报数据缺陷的系统, 是在把风险留给读者。
  if(!d) return '<div class="card">数据可信度加载中…</div>';
  if(d.err) return '<div class="card">数据可信度: '+d.err+'</div>';
  const KIND={data_quality:['数据质量','var(--bad)'], caliber:['口径','var(--warn)'],
              system_coverage:['覆盖','var(--accent)'], tier_trend:['结构趋势','var(--ok)']};
  const GR={established:['定论','var(--bad)'], candidate:['候选','var(--warn)'],
            reference:['参考','var(--muted)']};
  let h='<div class="card"><div class="eyebrow">数据可信度 · 系统自查发现</div>';
  h+='<div style="font-size:12px;color:var(--muted);margin:2px 0 12px;line-height:1.6">'
   +'先回答"这些数字可不可信", 再谈数字说明什么。以下每条都是在做分析的过程中被判据拦下来的, '
   +'不是事后补的说明。</div>';
  (d.rows||[]).forEach(r=>{
    const k=KIND[r.kind]||['其他','var(--muted)'];
    const g=GR[r.grade]||[r.grade,'var(--muted)'];
    h+=`<div style="border:1px solid var(--line);border-left:3px solid ${k[1]};border-radius:var(--r);
         padding:12px 14px;margin-bottom:10px;background:var(--panel-2)">`;
    h+=`<div style="display:flex;gap:8px;align-items:baseline;flex-wrap:wrap;margin-bottom:6px">
        <span style="font-size:11px;padding:1px 8px;border-radius:10px;background:${k[1]};color:#fff">${k[0]}</span>
        <span style="font-size:11px;color:${g[1]};border:1px solid ${g[1]};padding:0 6px;border-radius:10px">${g[0]}</span>
        <span style="font-size:11px;color:var(--muted);font-family:var(--num)">${r.claim_window||''}</span>
        </div>`;
    h+=`<div style="font-size:13px;font-weight:600;line-height:1.5;margin-bottom:6px">${mdB(r.name)}</div>`;
    if((r.evidence||[]).length){
      h+='<ul style="margin:4px 0 6px 16px;padding:0;font-size:12px;color:var(--ink);line-height:1.65">';
      (r.evidence||[]).slice(0,4).forEach(e=>{h+=`<li>${mdB(e)}</li>`});
      h+='</ul>';
    }
    if(r.impact) h+=`<div style="font-size:12px;color:var(--ok);line-height:1.6;margin-top:4px">
        <b>判别 / 处置</b> ${mdB(r.impact)}</div>`;
    if(r.got_wrong) h+=`<div style="font-size:12px;color:var(--warn);line-height:1.6;margin-top:6px;
        padding:6px 10px;background:var(--panel);border-radius:6px;border:1px dashed var(--line)">
        <b>首版判错</b> ${mdB(r.got_wrong)}</div>`;
    // 数据质量标志 + 稳健性复算: 削弱结论的证据, 与证据同级显示
    if(r.quality_flag) h+=`<div style="font-size:12px;color:var(--ink);line-height:1.6;margin-top:6px;
        padding:6px 10px;background:var(--panel);border-radius:6px;border:1px dashed var(--warn)">
        <b style="color:var(--warn)">记录质量</b> ${mdB(r.quality_flag)}</div>`;
    if(r.robust) h+=`<div style="font-size:12px;color:var(--muted);line-height:1.6;margin-top:4px">
        <b>稳健性复算</b> ${mdB(r.robust)}</div>`;
    if(r.basis) h+=`<div style="font-size:12px;color:var(--muted);line-height:1.6;margin-top:4px">
        <b>分类依据</b> ${mdB(r.basis)}</div>`;
    if(r.sensitivity) h+=`<div style="font-size:12px;color:var(--ink);line-height:1.6;margin-top:6px;
        padding:6px 10px;background:var(--panel);border-radius:6px;border:1px dashed var(--accent)">
        <b style="color:var(--accent)">敏感性检验</b> ${mdB(r.sensitivity)}</div>`;
    if(r.age_basis) h+=`<div style="font-size:12px;color:var(--muted);line-height:1.6;margin-top:4px">
        <b>场龄口径</b> ${mdB(r.age_basis)}</div>`;
    // ★边界从 11px/muted 的脚注提到 12px/正文色 (2026-08-31 独立审逮):
    //   它**限定结论成立的范围**, 不是补充说明。原样式让它成为卡片里最小最淡的元素,
    //   排在一串证据数字之后 —— 读者读完数字就走了, 限定语等于没写。
    if(r.caveat) h+=`<div style="font-size:12px;color:var(--ink);line-height:1.6;margin-top:6px;
        padding:6px 10px;background:var(--panel);border-radius:6px;border-left:3px solid var(--muted)">
        <b>结论边界</b> ${mdB(r.caveat)}</div>`;
    h+='</div>';
  });
  h+='</div>';
  return h;
}

function maintFw(d){
  // 运维管理体系三维骨架 — 架构取自一套跨厂商通用的培训编号体系, 实证取自本场五年工单。
  // 放在四判据之后: 判据回答"哪台该管", 本面板回答"这个场的运维能力结构长什么样"。
  // 配色一律走 CSS 变量 —— 页面有明暗两套 :root, 硬编码色在另一套下不可读。
  if(!d) return '<div class="card">运维体系加载中…</div>';
  if(d.err) return '<div class="card">运维体系: '+d.err+'</div>';
  const c=d.coverage||{}, g=d.gaps||{};
  const tierName={common:'通用 · 换机型仍有效', platform:'机型专属 · 绑定当前机型', basic:'技术基础', eng:'工程改造'};
  const tierCol={common:'var(--accent)', platform:'var(--warn)', basic:'var(--muted)', eng:'var(--unknown)'};
  let h='<div class="card"><div class="eyebrow">运维管理体系 · 系统 × 阶段 × 记录</div>';
  // ★跨厂商借用必须在**用它的地方**声明 (2026-08-31 双票独立命中)。
  //   ★这套码是**借来的跨厂商分类法**, 不点任何厂商名 (点了等于用否定把机型漏回去)。
  //   声明写在别的页面等于没声明: 读者是在这一屏做判断的。
  h+='<div style="font-size:12px;color:var(--muted);margin:2px 0 12px;line-height:1.6">'
   +'三位系统码分两层 (3xx 跨机型通用 / 4xx 机型专属), 判据与缺口取自本场五年工单实证。'
   +'<b style="color:var(--warn)">口径声明</b>: '
   // ★整句不嵌 <b> —— 中间插标签会把这段切成多个 PH 片段, 逐片查表再拼回去,
   //   结果是"arenot"这种缺空格拼接 + 某一片查不到就留中文 (实测两种都发生了)。
   //   要强调就整句强调, 别在句中加标记。整段一个 key, 查得到就整段换, 查不到就整段留。
   // ★整句放在**一个**字符串字面量里。apply() 跑在**源码文本**上, 拆成多个字面量拼接时,
   //   源码里它们被换行加 + 号隔开 ⇒ PH 切出的段与渲染后看到的整句**不是同一个东西**,
   //   (注意: CHART_JS 是非 raw 的 Python 三引号串, 注释里写反斜杠-n 会变成**真换行**,
   //    把 // 注释劈成两行 —— 第二行不再是注释, 直接语法错。本行原来就踩了这个坑。)
   //   我按渲染后的整句注册 key, 页面上却按源码分段查表 → 全部 miss。
   //   (实测踩到: 助手 --segments 报"命中", 页面上仍是中文。验证跑在渲染后, 翻译跑在源码上。)
   +'三位码仅用于能力分级与培训投资参照。部件到系统码的映射由本项目建立、未经确认, 因此结构趋势比绝对占比可靠。</div>';

  // ① 覆盖率 — 本轮最实的一条发现
  h+='<div style="display:flex;gap:12px;flex-wrap:wrap;margin-bottom:16px">';
  h+=`<div style="flex:1;min-width:180px;padding:12px 14px;border-radius:var(--r);background:var(--panel-2);border:1px solid var(--line);border-left:3px solid var(--bad)">
      <div style="font-size:28px;font-weight:600;color:var(--bad);font-family:var(--num)">${c.system_pct}%</div>
      <div style="font-size:12px;color:var(--muted);margin-top:2px">工单可归属到系统<br><span style="font-family:var(--num)">${c.mapped} / ${c.n_orders}</span></div></div>`;
  h+=`<div style="flex:1;min-width:180px;padding:12px 14px;border-radius:var(--r);background:var(--panel-2);border:1px solid var(--line);border-left:3px solid var(--warn)">
      <div style="font-size:28px;font-weight:600;color:var(--warn);font-family:var(--num)">${c.part_field_pct}%</div>
      <div style="font-size:12px;color:var(--muted);margin-top:2px">工单填了部件字段<br><span style="font-family:var(--num)">${c.with_part} / ${c.n_orders}</span></div></div>`;
  h+=`<div style="flex:2.2;min-width:280px;padding:12px 14px;border-radius:var(--r);background:var(--accent-soft);border:1px solid var(--line);border-left:3px solid var(--ok)">
      <div style="font-size:12px;color:var(--ok);font-weight:600;margin-bottom:4px">怎么补</div>
      <div style="font-size:12px;color:var(--ink);line-height:1.65">工单模板增加系统码必填项 (31 个系统码下拉), 此后每条工单按构造自动归属。
      <div style="color:var(--muted);margin-top:4px">归属率低是模板缺字段, 不是维修没做 — 后者要贵得多。</div></div></div>`;
  h+='</div>';

  // ② 通用 vs 机型专属 — 决定培训投资与合同边界
  h+='<div style="font-size:13px;font-weight:600;margin:16px 0 4px;color:var(--ink)">作业量结构 · 通用能力 vs 机型专属</div>';
  h+='<div style="font-size:12px;color:var(--muted);margin-bottom:8px">通用能力换机型仍成立, 属场站资产; 机型专属绑定当前机队, 更适合合同覆盖</div>';
  const byT=g.by_tier||{}, tks=Object.keys(byT).sort((a,b)=>byT[b].jobs-byT[a].jobs);
  h+='<div style="display:flex;height:24px;border-radius:4px;overflow:hidden;margin-bottom:6px;border:1px solid var(--line)">';
  tks.forEach(t=>{h+=`<div style="width:${byT[t].share}%;background:${tierCol[t]||'var(--muted)'};display:flex;align-items:center;justify-content:center;font-size:11px;color:#fff;font-family:var(--num)">${byT[t].share}%</div>`;});
  h+='</div><div style="font-size:11px;color:var(--muted);margin-bottom:14px">';
  tks.forEach(t=>{h+=`<span style="margin-right:16px"><span style="display:inline-block;width:9px;height:9px;background:${tierCol[t]||'var(--muted)'};border-radius:2px;margin-right:5px;vertical-align:middle"></span>${tierName[t]||t} · <span style="font-family:var(--num)">${byT[t].jobs}</span> 次</span>`;});
  h+='</div>';

  // ③ 系统作业量排行
  h+='<div style="font-size:13px;font-weight:600;margin:16px 0 6px;color:var(--ink)">按系统码的作业量</div>';
  h+='<table class="tbl"><tr><th>码</th><th>系统</th><th>类别</th><th>作业次数</th><th>台数</th><th>次/台</th></tr>';
  (d.systems||[]).slice(0,10).forEach(r=>{
    h+=`<tr><td style="font-family:var(--num)">${r.code}</td><td>${r.zh}<div style="font-size:11px;color:var(--muted)">${r.en}</div></td>
        <td style="color:${tierCol[r.tier]||'var(--muted)'};font-size:12px">${tierName[r.tier]||r.tier}</td>
        <td style="font-family:var(--num)">${r.jobs}</td><td style="font-family:var(--num)">${r.n_units}</td><td style="font-family:var(--num)">${r.per_unit}</td></tr>`;});
  h+='</table>';

  // ④ 阶段 × 出口闸 × 记录
  h+='<div style="font-size:13px;font-weight:600;margin:18px 0 4px;color:var(--ink)">六个运维阶段与各自的放行条件</div>';
  h+='<div style="font-size:12px;color:var(--muted);margin-bottom:8px">放行条件 = 不满足就不该进下一阶段; 记录 = 该阶段必须留下的凭据</div>';
  h+='<table class="tbl"><tr><th style="width:15%">阶段</th><th style="width:38%">放行条件</th><th>必备记录</th></tr>';
  (d.stages||[]).forEach(st=>{
    const rn=(st.records||[]).map(r=>((d.records||{})[r]||{}).zh||r)
      .map(x=>`<span style="display:inline-block;padding:1px 7px;margin:1px 3px 1px 0;border-radius:10px;background:var(--panel-2);border:1px solid var(--line);font-size:11px">${x}</span>`).join('');
    // ★英文侧 zh 已被 _proj 投影成英文 (裸 zh/en 成对的处理), 两行会显示成一样的字 ——
    //   相同就只出一行。出口闸那列同理: 页面原读 st.gate_zh, 而投影后字段名是 gate,
    //   于是**整列 undefined** —— 而"出口闸"正是这张表最要紧的一列 (无闸的阶段划分只是标签)。
    h+=`<tr><td><span style="font-family:var(--num);color:var(--muted)">${st.seq}</span> ${st.zh||st.en||''}
        ${(st.en&&st.en!==st.zh)?`<div style="font-size:11px;color:var(--muted)">${st.en}</div>`:''}</td>
        <td style="font-size:12px;line-height:1.5">${st.gate||st.gate_zh||''}</td><td>${rn}</td></tr>`;});
  h+='</table>';

  // ⑤ 未映射 — 不猜归属
  const um=(g.unmapped_top||[]);
  if(um.length){
    h+='<div style="font-size:11px;color:var(--muted);margin-top:12px;line-height:1.6">未映射到系统码的部件 (不猜归属, 留待补映射表): '
      + um.slice(0,10).map(x=>`${x[0]}<span style="font-family:var(--num)">×${x[1]}</span>`).join('、')+'</div>';}
  h+='</div>';
  return h;
}

function maintStd(d){
  if(!d) return '<div class="card"><p class="small">载入中…</p></div>';
  if(d.err) return `<div class="card"><p class="small" style="color:var(--bad)">${d.err}</p></div>`;
  const S=d.score||{}; let h='';
  const dims=(S.dims||[]).map(x=>{
    // ★"不可评估"要在**出现的地方**就自明 —— 用户读到这四个字问"什么意思",
    //   说明把解释放在上一行的口径说明里不够。它不是"做得差", 是"没法判":
    //   工单模板里没有记录该证据的位置, 所以既不能记功也不能记过。
    if(!x.evaluable) return `<div class="kpi"><b style="color:var(--muted)">—</b>
      <span>${x.dim} · <b style="color:var(--warn)">不可评估</b>
      <span style="color:var(--muted)">(工单里没有记录这项证据的字段, 所以既不能算做到、也不能算没做到 &mdash; 不是 0 分, 是无法判断)</span><br>
      <span style="color:var(--muted)">${mdB(x.detail)}</span></span></div>`;
    const pct=Math.round(x.score/x.full*100);
    const cls=pct>=70?'ok':pct>=40?'':'bad';
    return `<div class="kpi ${cls}"><b>${x.score}<span style="font-size:14px;color:var(--muted)">/${x.full}</span></b>
      <span>${x.dim}<br><span style="color:var(--muted)">${mdB(x.detail)}</span></span></div>`;
  }).join('');
  // 两个分并排、各自带标签; 口径与理由见 src/windscada/maint/standards.py。
  // (页面源码随交付件一起发出去, 内部审核讨论不留在这里。)
  const _en=(typeof window!=='undefined'&&window.__EN);
  const twoScore=(lab,val,ev,n,tone)=>`<div style="flex:1;min-width:190px;padding:12px 14px;
      border-radius:var(--r);background:var(--panel-2);border:1px solid var(--line);border-left:3px solid ${tone}">
    <div style="font-size:12px;color:var(--muted)">${lab||''}</div>
    <div style="font-size:30px;font-weight:600;font-family:var(--num);color:${tone};line-height:1.15">
      ${val!=null?val:'—'}<span style="font-size:14px;color:var(--muted);font-weight:400">/100</span></div>
    <div style="font-size:11.5px;color:var(--muted);margin-top:2px">${ev} / ${n} ${_en?'dimensions measurable':'维可测'}</div></div>`;
  h+=`<div class="card mb"><h3>${_en?'Maintenance scorecard':'运维评分卡'}
      <span class="badge" style="margin-left:10px">${S.stage_label||('第 '+S.stage+' 阶')} · ${S.stage_name}</span></h3>
    <div style="display:flex;gap:12px;flex-wrap:wrap;margin:4px 0 12px">
      ${twoScore(S.record_label,S.record_score,S.record_evaluable,S.record_dims,'var(--bad)')}
      ${twoScore(S.exec_label,S.exec_score,S.exec_evaluable,S.exec_dims,'var(--ok)')}
    </div>
    ${S.score_basis?`<p class="small" style="color:var(--muted);margin:0 2px 10px;line-height:1.6">${mdB(S.score_basis)}</p>`:''}
    <div class="kpis">${dims}</div>
    <p class="small" style="color:var(--warn);margin:8px 2px 0">${mdB(S.caveat)}</p>
    ${S.model_source?`<p class="small" style="color:var(--muted);margin:6px 2px 0;line-height:1.6">
       <b>评分方法来源</b> ${mdB(S.model_source)}</p>`:''}
    ${S.bottleneck?`<p class="small" style="margin:4px 2px 0">当前瓶颈: <b>${S.bottleneck}</b> — 先补这一项, 其余维度的提升都受它限制。</p>`:''}</div>`;
  // R1 复发
  const R=(d.recurrence||[]).slice(0,10);
  if(R.length) h+=`<div class="card mb"><h3>复发 · ${d.recurrence.length} 组</h3>
    <p class="small" style="color:var(--muted)">同一机组同一部件多次更换 — 换件未解决产生它的原因。按作业日去重计数, 非工单条数。</p>
    <table class="tbl"><thead><tr><th>机组</th><th>部件</th><th>作业次数</th><th>首次</th><th>末次</th><th>最短间隔</th></tr></thead><tbody>
    ${R.map(x=>`<tr><td>${x.turbine}</td><td>${x.part}</td><td><b>${x.n_jobs}</b></td>
      <td>${x.first}</td><td>${x.last}</td><td>${x.min_gap_months} 月</td></tr>`).join('')}
    </tbody></table></div>`;
  // R2 批次候选
  const B=(d.batch||[]).slice(0,8);
  if(B.length) h+=`<div class="card mb"><h3>共性候选 · ${d.batch.length} 项</h3>
    <p class="small" style="color:var(--warn)">仅候选。分布形态无法区分 批次 / 共模应力 / 耗损期 — 三者形态相似而处置方向完全不同(追索赔 / 改运行条件 / 排寿命更换)。定性需物料证据。</p>
    <table class="tbl"><thead><tr><th>部件</th><th>涉及台数</th><th>作业次数</th><th>每台</th><th>缺什么才能定性</th></tr></thead><tbody>
    ${B.map(x=>`<tr><td>${x.part}</td><td>${x.n_units}</td><td>${x.n_jobs}</td>
      <td>${x.per_unit}</td><td class="small" style="color:var(--muted)">${x.needs}</td></tr>`).join('')}
    </tbody></table></div>`;
  // R4 断层
  const D=d.discontinuity||{};
  if((D.breaks||[]).length) h+=`<div class="card mb"><h3>记录断层</h3>
    <p class="small">${D.note}</p>
    ${D.breaks.map(b=>`<p class="small"><b>${b.before} → ${b.after}</b>: ${b.n_before} → ${b.n_after} 条 (<b style="color:var(--bad)">${b.ratio}×</b>) — 机组不会一年之间变坏这么多, 变的是记录制度。</p>`).join('')}
    </div>`;
  return h;
}

function farmScene(d){
  const RANK={'危险':4,'报警':3,'不可判':2,'良好':1,'优秀':0};
  const COL={'危险':'var(--bad)','报警':'var(--bad)','不可判':'var(--unknown)',
             '良好':'var(--ok)','优秀':'var(--st-exc)'};
  const S={};
  Object.entries((d&&d.systems)||{}).forEach(([sys,rows])=>(rows||[]).forEach(r=>{
    if(!r||!r.t) return;
    const st=String(r.st||'').split('·')[0].trim();
    if(!(st in RANK)) return;
    if(!(r.t in S) || RANK[st] > RANK[S[r.t]]) S[r.t]=st;
  }));
  // 补全: 预烤 key 里有全场台号; 在线模式下退回已知台集合
  let all=Object.keys(S);
  if(typeof window.__SNAP__!=='undefined'){
    const ks=new Set();
    Object.keys(window.__SNAP__).forEach(k=>{const m=/[?&]t=([A-Za-z0-9]+)/.exec(k); if(m)ks.add(m[1])});
    if(ks.size>all.length) all=[...ks];
  }
  all=all.sort();
  if(!all.length) return '';
  const n=all.length, W=980, H=190, m=30;
  const per=Math.ceil(n/2), gap=(W-m*2)/(per-1||1);
  let g='';
  all.forEach((t,i)=>{
    const row=i<per?0:1, idx=i<per?i:i-per;
    const x=m+idx*gap+(row?gap/2:0);
    const base=row?150:126, hh=row?30:38, op=row?.55:.92, bw=row?12:15;
    const st=S[t]||'优秀', c=COL[st]||'var(--unknown)';
    const hub=base-hh;
    g+=`<g opacity="${op}"><title>${t} · ${st}</title>`
      +`<path d="M${x} ${base} L${x} ${hub}" stroke="${c}" stroke-width="${row?1:1.3}" fill="none" stroke-linecap="round"/>`
      +`<path d="M${x} ${hub} L${x} ${hub-bw}" stroke="${c}" stroke-width="${row?.9:1.1}" fill="none" stroke-linecap="round"/>`
      +`<path d="M${x} ${hub} L${(x+bw*0.87).toFixed(1)} ${(hub+bw*0.5).toFixed(1)}" stroke="${c}" stroke-width="${row?.9:1.1}" fill="none" stroke-linecap="round"/>`
      +`<path d="M${x} ${hub} L${(x-bw*0.87).toFixed(1)} ${(hub+bw*0.5).toFixed(1)}" stroke="${c}" stroke-width="${row?.9:1.1}" fill="none" stroke-linecap="round"/>`
      +`<circle cx="${x}" cy="${hub}" r="${row?1.5:1.9}" fill="${c}"/></g>`;
  });
  const cnt={};
  Object.values(S).forEach(v=>cnt[v]=(cnt[v]||0)+1);
  const legend=['危险','报警','不可判','良好','优秀'].filter(k=>cnt[k])
    .map(k=>`<span style="display:inline-flex;align-items:center;gap:5px">
      <i style="width:7px;height:7px;border-radius:50%;background:${COL[k]};display:inline-block"></i>${k} ${cnt[k]}</span>`).join('');
  return `<div class="card mb"><svg viewBox="0 0 ${W} ${H}" style="width:100%;height:auto;display:block"
      role="img" aria-label="Fleet layout: each turbine coloured by its most severe system state">
      <defs><linearGradient id="fsea" x1="0" y1="0" x2="0" y2="1">
        <stop offset="0" stop-color="var(--accent)" stop-opacity=".14"/>
        <stop offset="1" stop-color="var(--accent)" stop-opacity="0"/></linearGradient></defs>
      <path d="M0 150 H${W}" stroke="var(--line)" stroke-width="1" fill="none"/>
      <path d="M0 126 H${W}" stroke="var(--line)" stroke-width="1" fill="none" opacity=".5"/>
      <rect x="0" y="150" width="${W}" height="${H-150}" fill="url(#fsea)"/>
      ${g}</svg>
    <p class="small" style="color:var(--muted);display:flex;gap:16px;flex-wrap:wrap;margin:10px 2px 0">
      <b style="color:var(--ink)">全场态势</b>${legend}
      <span style="margin-left:auto">按各台最严重系统状态着色 · 悬停看台号</span></p></div>`;
}

function drawFig(f){
  if(f.kind==='vib'){return figWrap(f, dtSVG(f.comp||f.text||'',f.sev||'var(--warn)',880), (f.text||'').replace(/</g,'&lt;'))}
  if(f.kind==='text'){return `<div class="card"><h3>${f.title||''}</h3><p class="small">${(f.text||'').replace(/</g,'&lt;')}</p></div>`}
  if(f.kind==='vibbar'){
    // 倍中位条 (1× 为基准竖线; 绝对值量级差 3 个数量级时按绝对值画条会全部顶满 — 速度有效值 0.001 实例)
    const rows=f.rows||[]; if(!rows.length) return '';
    const sig=v=>{const a=Math.abs(v); return a>=100?v.toFixed(0):a>=10?v.toFixed(1):a>=1?v.toFixed(2):a>=0.01?v.toFixed(3):v.toExponential(1)};
    const byM={}; rows.forEach(r=>{(byM[r.指标]=byM[r.指标]||[]).push(r)});
    const LO=0.5, HI=2.5, W2=190, xr=v=>((Math.max(LO,Math.min(HI,v))-LO)/(HI-LO))*W2;
    let inner=`<div class="small" style="color:var(--muted);margin-bottom:8px">条为本台与全场中位之比, 竖线取 1× 基准, 右端封顶 2.5×; 色按 z (稳健离群度): 绿&lt;2 · 橙2~3 · 红≥3</div>`;
    for(const [mk,rs] of Object.entries(byM)){
      inner+=`<div style="margin-bottom:9px;overflow-x:auto"><b class="small" style="color:var(--muted)">${mk}</b><table style="width:100%;margin-top:2px">`;
      rs.forEach(r=>{
        const v=r.倍中位||1, col=Math.abs(r.z)>=3?'var(--bad)':Math.abs(r.z)>=2?'var(--warn)':'var(--ok)';
        const x1=xr(1), xv=xr(v), left=Math.min(x1,xv), wid=Math.max(Math.abs(xv-x1),1.5);
        inner+=`<tr><td class="small" style="width:104px">${r.测点}</td>
          <td style="width:${W2+10}px"><svg class="dt" viewBox="0 0 ${W2} 16" style="width:${W2}px;height:16px">
            <line x1="0" y1="8" x2="${W2}" y2="8" stroke="var(--line)" stroke-width="1"/>
            <line x1="${x1}" y1="1" x2="${x1}" y2="15" stroke="var(--muted)" stroke-width="1"/>
            <rect x="${left}" y="4" width="${wid}" height="8" rx="2" fill="${col}" fill-opacity="0.9"/>
            ${v>HI?`<path d="M${W2-1},8 l-6,-4 v8 z" fill="${col}"/>`:''}</svg></td>
          <td class="num small" style="width:60px;color:${col};font-weight:600">${r.倍中位!=null?r.倍中位+'×':'—'}</td>
          <td class="num small" style="width:80px">${sig(r.本台)}</td>
          <td class="num small" style="width:78px;color:var(--muted)">中位 ${sig(r.全场中位)}</td>
          <td class="num small" style="width:56px;color:${Math.abs(r.z)>=3?'var(--bad)':'var(--muted)'}">z ${r.z}</td>
          <td class="num small" style="width:64px;color:${r.六窗比>1.15?'var(--warn)':'var(--muted)'}">${r.六窗比!=null?'趋势'+r.六窗比+'×':'趋势—'}</td></tr>`;
      });
      inner+='</table></div>';
    }
    return figWrap(f, inner, f.note);
  }
  const W=620,H=250,ML=52,MB=34;
  let xs=f.months||f.x, n=xs.length; if(!n) return '';
  const X=i=>sc(i,0,Math.max(n-1,1),ML,W-12);
  let all=[];
  if(f.kind==='band'){all=[...(f.self||[]),...(f.med||[]),...(f.q1||[]),...(f.q3||[])]}
  else if(f.kind==='bars'){all=[0,...(f.vals||[])]}
  else if(f.kind==='xy'){all=[...(f.self||[]),...(f.med||[])]}
  else {(f.series||[]).forEach(s=>all.push(...s.vals))}
  (f.thresholds||[]).forEach(t=>all.push(t.v));
  all=all.filter(v=>v!==null&&v===v); if(!all.length) return '';
  let lo=Math.min(...all),hi=Math.max(...all); if(lo===hi){lo-=1;hi+=1} const pad=(hi-lo)*0.08; lo-=pad; hi+=pad;
  const Y=v=>sc(v,lo,hi,H-MB,14);
  const line=(vals,st)=>{let p=vals.map((v,i)=>v===null||v!==v?null:`${X(i).toFixed(1)},${Y(v).toFixed(1)}`);
    let segs=[],cur=[]; p.forEach(q=>{if(q)cur.push(q);else{if(cur.length)segs.push(cur);cur=[]}}); if(cur.length)segs.push(cur);
    return segs.map(sg=>`<polyline points="${sg.join(' ')}" style="fill:none;${st}"/>`).join('')}
  let body='';
  if(f.kind==='band'&&f.q1){
    let up=f.q3.map((v,i)=>v===null?null:`${X(i).toFixed(1)},${Y(v).toFixed(1)}`).filter(Boolean);
    let dn=f.q1.map((v,i)=>v===null?null:`${X(i).toFixed(1)},${Y(v).toFixed(1)}`).filter(Boolean).reverse();
    if(up.length&&dn.length) body+=`<polygon points="${up.join(' ')} ${dn.join(' ')}" fill="#cbd5e1" fill-opacity="0.45"/>`;
  }
  if(f.kind==='bars'){const bw=Math.max(3,(W-ML-20)/n*0.6);
    body+=f.vals.map((v,i)=>`<rect x="${(X(i)-bw/2).toFixed(1)}" y="${Y(v).toFixed(1)}" width="${bw.toFixed(1)}" height="${(Y(Math.max(lo,0))-Y(v)).toFixed(1)}" fill="#0f4c75" fill-opacity="0.75"/>`).join('');}
  if(f.med) body+=line(f.med,'stroke:#64748b;stroke-width:1.7');
  if(f.self) body+=line(f.self,'stroke:#c0392b;stroke-width:2.1')+
    f.self.map((v,i)=>v===null||v!==v?'':`<circle cx="${X(i)}" cy="${Y(v)}" r="2.4" fill="var(--bad)"/>`).join('');
  const cols=['#0f4c75','#ef6c00','#0e6e66','#7c5295'];
  (f.series||[]).forEach((s,k)=>{body+=line(s.vals,`stroke:${cols[k%4]};stroke-width:1.8`)});
  (f.thresholds||[]).forEach(t=>{body+=`<line x1="${ML}" x2="${W-12}" y1="${Y(t.v)}" y2="${Y(t.v)}" stroke="var(--muted)" stroke-dasharray="5 4"/>`+
    (t.label?`<text x="${ML+6}" y="${Y(t.v)-4}" font-size="10" fill="var(--muted)">${t.label}</text>`:'')});
  const step=Math.max(1,Math.ceil(n/8));
  let xt=''; for(let i=0;i<n;i+=step) xt+=`<text x="${X(i)}" y="${H-10}" font-size="10" fill="var(--muted)" text-anchor="middle">${String(xs[i]).includes('-')?String(xs[i]).slice(2,7):String(xs[i])}</text>`;
  let yt=''; for(let k=0;k<5;k++){const v=lo+(hi-lo)*k/4; yt+=`<text x="${ML-6}" y="${Y(v)+3}" font-size="10" fill="var(--muted)" text-anchor="end">${v.toFixed(Math.abs(hi)<10?1:0)}</text>`+
    `<line x1="${ML}" x2="${W-12}" y1="${Y(v)}" y2="${Y(v)}" stroke="var(--line-2)"/>`}
  if(f.band&&f.band.q1){const q1=f.band.q1,q3=f.band.q3;
    let up='',dn='';
    for(let i=0;i<n;i++){if(q3[i]!=null)up+=`${X(i)},${Y(q3[i])} `}
    for(let i=n-1;i>=0;i--){if(q1[i]!=null)dn+=`${X(i)},${Y(q1[i])} `}
    body=`<polygon points="${up}${dn}" fill="var(--unknown)" fill-opacity="0.16"/>`+body}
  if(f.xlab) body+=`<text x="${(ML+W)/2}" y="${H-1}" font-size="10" fill="var(--unknown)" text-anchor="middle">${f.xlab}</text>`;
  let leg = f.kind==='band' ? `<text x="${W-190}" y="12" font-size="10" fill="var(--bad)">— 本台</text><text x="${W-130}" y="12" font-size="10" fill="var(--muted)">— 全场中位</text><text x="${W-60}" y="12" font-size="10" fill="var(--unknown)">▧ 四分位</text>` :
    ((f.series&&f.series.length<=2)?(()=>{const n2=f.series.length,gap=Math.min(118,Math.floor((W-ML-20)/n2));
      return f.series.map((s,k)=>`<text x="${W-12-(n2-1-k)*gap}" y="12" font-size="10" fill="${cols[k%4]}" text-anchor="end">— ${s.name}</text>`).join('')})():'');
  const legendHtml=(f.series&&f.series.length>2)?`<div class="legend">`+f.series.map((s,k)=>
      `<span class="lgi"><i style="background:${cols[k%4]}"></i>${s.name}</span>`).join('')+`</div>`:'';
  // 统一走 figWrap: 图身按类别封顶宽度 (曲线760/月度620), 不再随容器拉伸成巨图
  return figWrap(f, `<svg viewBox="0 0 ${W} ${H}">${yt}${body}${xt}${leg}</svg>`+legendHtml,
                 f.note||'').replace('<h3>'+(f.title||''), '<h3>'+(f.title||'')+(f.unit?' ('+f.unit+')':''));
}

function ordersHtml(o){
  if(!o) return '';
  let h=`<div class="card mb"><h3>工单处理史 · 该系统 (处理 ${o.n} 次${o.窗?'; 窗 '+o.窗:''})</h3>`;
  if(o.n===0){h+=`<p class="small">该窗内无工单记录。${o.note||''}</p></div>`; return h}
  const acts=Object.entries(o.动作统计||{}).map(([k,v])=>k+'×'+v).join(' / ');
  if(acts) h+=`<p class="small" style="margin-bottom:6px">处置动作统计: <b>${acts}</b></p>`;
  h+=`<table><tr><th style="width:92px">日期</th><th>故障/工作</th><th>排查发现</th><th>处置</th><th>类别</th></tr>`;
  o.rows.forEach(r=>{h+=`<tr><td class="num" style="text-align:left">${r.日期}</td><td class="small">${r.故障}</td><td class="small">${r.排查&&r.排查!=='nan'?r.排查:'—'}</td><td class="small">${r.处置||'—'}</td><td class="small">${r.类别||''}</td></tr>`});
  h+=`</table><p class="small">${o.note||''}</p></div>`;
  return h;
}
let ONT=null;
async function loadDbase(){
  const el=document.getElementById('dbase'); if(!el) return;
  if(!ONT) ONT=await (await fetch('/api/ontology')).json();
  const C=ONT.chain29; let h='';
  // ① 机制链横图 (决策的证据底座, 图形化)
  const node=(label,val,color)=>`<div style="min-width:120px;flex:1;text-align:center">
    <div style="border:1.5px solid ${color};border-radius:10px;padding:8px;background:var(--panel)">
      <div class="small" style="color:var(--muted);letter-spacing:.05em">${label}</div>
      <div style="font-weight:600;font-size:13.5px;margin-top:4px">${val}</div></div></div>`;
  const arrow=`<div style="align-self:center;color:var(--muted);font-size:16px;padding:0 4px">→</div>`;
  // 每格加一行"这一格回答什么" (2026-08-28 用户问"什么意思" — 六个词现场看不出是干嘛的)
  const node2=(t,v,c,q)=>`<div style="flex:none;min-width:132px;border:1px solid ${c};border-radius:10px;padding:9px 12px;text-align:center">
    <div class="small" style="color:var(--muted)">${t}</div>
    <div style="font-weight:600;margin:4px 0 3px">${v}</div>
    <div class="small" style="color:var(--muted);line-height:1.45">${q}</div></div>`;
  // 决策链进度盘 (2026-08-28 用户问"这个到底能怎么用, 我没看太懂")。
  // 原来是 29# 一台的静态六格 — 打开它做不了任何决定, 是展示牌不是工作面。
  // 改为: 全部需跟踪台各走到第几步 / 卡在哪一步 / 下一步具体做什么 / 点台号进该台。
  // 这样它回答的是"今天该管谁、卡在哪、谁去做什么", 而不是"29# 的故事是怎样的"。
  const BD=(window.D&&D.fus&&D.fus.链盘)?D.fus.链盘:(D.fus&&D.fus.链盘);
  if(BD&&BD.rows&&BD.rows.length){
    const SK=Object.entries(BD.stuck||{}).sort((a,b)=>b[1]-a[1]);
    const tot=BD.rows.length;
    const cell=st=>st==='done'?`<i style="display:inline-block;width:13px;height:13px;border-radius:3px;background:var(--accent);opacity:.8"></i>`
      :st==='unknown'?`<i style="display:inline-block;width:13px;height:13px;border-radius:3px;border:1.5px dashed var(--muted);opacity:.75"></i>`
      :`<i style="display:inline-block;width:13px;height:13px;border-radius:3px;border:1.5px solid var(--line)"></i>`;
    h+=`<div class="card mb"><h3>决策链进度盘 · ${tot} 台需跟踪</h3>
      <p class="small" style="color:var(--muted);margin-bottom:10px">
      一台机组从发现异常到修完验收要走六步。这张盘不讲某一台的故事, 用于确认<b>当前需处置机组、各自所处环节、后续动作</b>。
      <span style="color:var(--accent)">■</span> 已达 ·
      <span style="color:var(--muted)">▢ 虚线</span> 数据不足不可判 ·
      <span style="color:var(--muted)">▢ 实线</span> 未达</p>
      <div style="display:flex;gap:10px;flex-wrap:wrap;align-items:center;margin-bottom:12px;
        padding:9px 12px;border-radius:8px;background:var(--bg);border:1px solid var(--line)">
        <b class="small">瓶颈</b>${SK.map(([k,n])=>`<span class="small">
          <b style="color:${n/tot>0.5?'var(--bad)':'var(--warn)'}">${n} 台</b> 卡在「${k}」</span>`).join('<span class="small" style="color:var(--muted)">·</span>')}
        ${SK.length&&SK[0][1]/tot>0.5?`<span class="small" style="color:var(--muted)">— 瓶颈集中在一步, 不是"再多看点数据"能解的</span>`:''}
        <div style="flex-basis:100%;height:0"></div>
        ${SK.map(([k,n])=>{const r=BD.rows.find(x=>x.stuck===k);
          /* 值为空就整块不出 —— 原来无条件渲染, 没 next 的两个环节在页面上留下
             "「机制」24 台的下一步:" 后面空着的悬空标签 (中英文版同样露)。 */
          return (r&&r.next)?`<div class="small" style="color:var(--muted);margin-top:3px">
          <b>「${k}」${n} 台的下一步:</b> ${r.next}</div>`:''}).join('')}</div>
      <table><tr><th style="width:52px">机组</th><th style="width:64px">状态</th>
        <th style="width:126px">六步进度</th><th style="width:70px">卡在</th><th>本台情况</th></tr>`;
    BD.rows.forEach(r=>{
      const ris=r.rising;
      h+=`<tr><td><a class="tl" href="javascript:void(0)" onclick="popChain('${r.t}')" title="点开看这一台的六步决策链"><b>${r.t.replace('WTG','')}#</b></a>
          ${ris?`<span class="small" style="color:var(--bad)" title="${ris.component} 末三窗/早三窗 ${ris.ratio}×">↑${ris.ratio}×</span>`:''}</td>
        <td>${chip(r.ostate||'—')}</td>
        <td style="white-space:nowrap">${r.steps.map((x,i)=>`<span title="${i+1} ${x.k}: ${x.v} — ${x.d}" style="margin-right:3px">${cell(x.st)}</span>`).join('')}
          <span class="cnt">${r.done}/6</span></td>
        <td class="small" style="color:${r.stuck_kind==='unknown'?'var(--muted)':'var(--warn)'}">${r.stuck||'全通'}${r.stuck_kind==='unknown'?' <span title="非未执行, 系统无法判定">?</span>':''}</td>
        <td class="small" style="color:var(--muted)">${r.part&&r.part.indexOf('未收录')<0?`<b style="color:var(--ink)">${r.part}</b> · `:''}证据 ${(r.srcs||[]).join('/')||'—'}
          ${ris?` · <span style="color:var(--bad)">${ris.component}末三窗/早三窗 ${ris.ratio}×${ris.工单可对===false?', 待现场/工单确认':''}</span>`:''}
          ${r.hist_loop?` · <span style="color:var(--ok)">${r.hist_loop.replace_date} 有过闭环 ${r.hist_loop.ratio}×</span>`:''}</td></tr>`;});
    h+=`</table>
      <p class="small" style="color:var(--muted);margin-top:8px">
      <b>「动作」一列全场都是不可判</b>, 不是偷懒: ${BD.wo_bound}, 而判级窗在 2026 —
      台账里的历史工单不可能是针对本次问题的, 用"有没有工单"判已派工会造出假的完成态。要填这一列须向现场要 25~26 工单。</p>`;
    if(BD.closed&&BD.closed.length){
      h+=`<div style="margin-top:12px;padding:10px 12px;border-radius:8px;background:var(--bg);border:1px solid var(--line)">
        <div class="small" style="font-weight:600;margin-bottom:5px">已走完全程并退出盘面 · ${BD.closed.length} 台 (端到端闭环实证)</div>
        ${BD.closed.map(x=>`<div class="small" style="color:var(--muted)">
          <a class="tl" href="/turbine/${x.turbine}"><b>${x.turbine.replace('WTG','')}#</b></a>
          ${x.component}${x.title?' · '+x.title:''} ${x.replace_date} 换件 →
          振动 ${x.pre} 降至 ${x.post} = <b style="color:var(--ok)">${x.ratio}×</b></div>`).join('')}
        <div class="small" style="color:var(--muted);margin-top:5px">
        这三台正是算法当初的检出台 ⇒ <b>故障前能看见、换件后能看见恢复</b>, 这条链是通的; 闭环成功的台会从盘面消失。</div></div>`;
    }
    h+=`</div>`;
  }
  // ② 四情景损失对比 (log 尺度条形; 数值解析电费口径区间取中值)
  const sc=C.scenario.scenarios||[];
  const parseWan=t=>{const m=/([0-9.]+)~([0-9.]+) 万元/.exec(t||'');return m?(+m[1]+ +m[2])/2:null};
  const rows=sc.map(x=>{
    let v=parseWan(x.停机损失&&x.停机损失.电费口径), extra=0, lab=x.id;
    if(x.停机损失&&x.停机损失.大部件成本){extra=350; lab+=' (+大部件成本200-500万)';   // 用 - 不用 ~ : ~ 不在 PH 续接字符类里, 会把整串切断
    }
    return {lab, v:(v||0)+extra, base:v||0, extra};});
  if(rows.length){
    const mx=Math.max(...rows.map(r=>r.v));
    h+=`<div class="card mb"><h3>排期沙盘 · 四情景损失对比 (万元, 电价区间中值; 建议级待人裁)</h3>`;
    rows.forEach(r=>{
      const w=Math.max(3,Math.round(Math.log10(1+r.v)/Math.log10(1+mx)*320));
      const col=r.extra?'var(--bad)':(r.lab.startsWith('A')?'var(--ok)':'var(--warn)');
      h+=`<div style="display:flex;align-items:center;gap:10px;margin:8px 0">
        <div class="small" style="width:170px;text-align:right">${r.lab}</div>
        <div style="height:16px;width:${w}px;background:${col};border-radius:4px;opacity:.85"></div>
        <div class="small" style="font-variant-numeric:tabular-nums"><b>${r.v>=100?r.v.toFixed(0):r.v.toFixed(1)}</b> 万元</div></div>`});
    h+=`<p class="small">条长=log 尺度 (跨两个数量级); D 含大部件成本中值 350 万 (grade D 弱源)。早修成本被限电稀释, 晚修成本被窗口与船期放大。</p></div>`;
  }
  // ③ 天气窗热力条 (近12月, CTV/吊装 双行)
  const W=ONT.weather||{}; const ms=Object.keys(W).sort().slice(-12);
  if(ms.length){
    const cell=(v,d)=>{const r=v/d; const bg=r>0.9?'var(--ok)':r>0.7?'var(--warn)':'var(--bad)';
      return `<td style="text-align:center;padding:4px"><div style="background:${bg};opacity:${0.25+r*0.6};border-radius:4px;padding:4px 0;font-size:11.5px;font-variant-numeric:tabular-nums">${v}</div></td>`};
    h+=`<div class="card mb"><h3>海上作业天气窗 · 近12月可作业日 (公开再分析统计, 非派工依据)</h3>
    <div style="overflow-x:auto"><table><tr><th style="width:90px"></th>${ms.map(m=>`<th class="small" style="text-align:center">${m.slice(2)}</th>`).join('')}</tr>`;
    h+=`<tr><td class="small">CTV人员转运</td>${ms.map(m=>cell(W[m]['CTV人员转运']||0,W[m]['天数']||30)).join('')}</tr>`;
    h+=`<tr><td class="small">吊装作业</td>${ms.map(m=>cell(W[m]['吊装作业']||0,W[m]['天数']||30)).join('')}</tr>`;
    h+=`</table></div><p class="small">CTV 级小修全年窗宽; 吊装级受台风季约束, 色深表示可作业占比。限值取行业常规 (CTV Hs≤1.5m∧风速≤12m/s, 吊装 1.2/8), 非本场合同值。</p></div>`;
  }
  el.innerHTML=h;
}
async function renderOntology(){
  const root=document.getElementById('root');
  if(!ONT){
    root.innerHTML='<div class="card"><div class="skel" style="width:40%"></div><div class="skel" style="width:70%;margin-top:9px"></div></div>';
    ONT=await (await fetch('/api/ontology')).json();
  }
  const O=ONT; let h='';
  h+=`<div class="eyebrow">语义本体 · 对象/机制/决策/约束 (Palantir 思路轻量自建; 判读纪律=写入闸, 违反写不进库)</div>`;
  h+=`<div class="card mb" style="border-left:3px solid var(--accent)"><b>六条写入约束 (库级保证)</b><p class="small">${O.constraints}</p></div>`;
  h+=`<div class="kpis">`+Object.entries(O.stats).map(([k,v])=>`<div class="kpi"><b>${v}</b><span>${k}</span></div>`).join('')+`</div>`;

  const C=O.chain29;
  h+=`<div class="card mb"><h3>机制链视图 · 29# 范例 (证据 → 机制 → 判级 → 沙盘 → 动作 → 验收)</h3>
  <div style="display:flex;gap:10px;overflow-x:auto;padding:6px 0">`;
  h+=`<div style="min-width:240px;flex:1"><p class="small"><b>① 证据 ×${C.evidence.length} (${C.mechanism.independent_source_count||4} 观测面)</b></p>`;
  C.evidence.forEach(e=>{h+=`<div class="small" style="border:1px solid var(--line);border-left:3px solid var(--info);border-radius:6px;padding:6px 8px;margin-bottom:6px"><b>${e.facet}</b> · 窗 ${e.claim_window}<br>${(e.summary||'').slice(0,90)}…<br><span style="color:var(--muted)">${e.id}</span></div>`});
  h+=`</div>`;
  const box=(t,color,inner)=>`<div style="min-width:210px;flex:1"><p class="small"><b>${t}</b></p><div class="small" style="border:1px solid var(--line);border-left:3px solid ${color};border-radius:6px;padding:8px">${inner}</div></div>`;
  h+=box('② 机制','var(--warn)',`<b>${C.mechanism.name}</b><br>源数=观测面去重 ${C.mechanism.independent_source_count} (证据${C.evidence.length}条)<br><span style="color:var(--muted)">${C.mechanism.id}</span>`);
  h+=box('③ 判级','var(--bad)',`<b>${C.verdict.level}</b> · 审级 ${C.verdict.review_tier}<br>${(C.verdict.title||'').slice(0,110)}…<br><span style="color:var(--muted)">${C.verdict.id}</span>`);
  h+=box('④ 沙盘','var(--accent)',`${(C.scenario.recommendation||'').slice(0,130)}…<br><span style="color:var(--muted)">${C.scenario.id}</span>`);
  h+=box('⑤ 动作','var(--warn)',`${(C.action.name||'').slice(0,90)}<br>闸: ${C.action.gate?C.action.gate.reversibility+' · '+C.action.gate.review_tier:''} · ${C.action.status||''}<br><span style="color:var(--muted)">${C.action.id}</span>`);
  h+=box('⑥ 验收状态机','var(--ok)',`状态 <b>${C.acceptance.state||'—'}</b> 分支 ${C.acceptance.branch||'—'}<br>${(C.acceptance.note||'').slice(0,110)}<br><span style="color:var(--muted)">acceptance/WTG29/state</span>`);
  h+=`</div><p class="small">判读纪律: 六个观测量=一条机制链 (C3 源数按观测面), 禁写多源印证; 判级只在 L1/审级产生, 本体转录带审级。</p></div>`;

  h+=`<div class="card mb"><h3>失效机制库 (${O.mechanisms.length} 族)</h3><div style="display:grid;grid-template-columns:repeat(auto-fill,minmax(300px,1fr));gap:10px">`;
  O.mechanisms.forEach(m=>{h+=`<div class="small" style="border:1px solid var(--line);border-radius:8px;padding:9px"><b>${m.name}</b><br>状态: ${m.status||''}<br>观测面: ${(m.facets||[]).join('/')}<br>涉及: ${(m.affects||[]).map(a=>a.split('/').pop()).join(', ')||'fleet'}<br><span style="color:var(--muted)">${m.id}</span></div>`});
  h+=`</div></div>`;

  h+=`<div class="card mb"><h3>决策台 (决策捕获 + 月度滚动)</h3><table><tr><th>决策</th><th>裁决人</th><th>时间</th><th>状态</th></tr>`;
  O.decisions.forEach(x=>{const on=x.status==='pending_user';
    h+=`<tr><td class="small">${(x.decision||'').slice(0,130)}</td><td>${x.decided_by}</td><td class="small">${x.when}</td>
    <td><span class="badge" style="border-color:${on?'var(--warn)':'var(--ok)'};color:${on?'var(--warn)':'var(--ok)'}">${x.status}</span></td></tr>`});
  h+=`</table><p class="small">月度滚动: 数据月 ${O.roll.data_month||'—'} · 上次动作 ${(O.roll.last_roll_actions||[]).join('; ')||'—'} · 变化 ${(O.roll.last_changes||[]).join('; ')||'—'}</p></div>`;

  h+=`<div class="card mb"><h3>对象浏览器 (${Object.values(O.stats).reduce((a,b)=>a+b,0)} 对象)</h3>
  <div style="display:flex;gap:8px;flex-wrap:wrap;margin-bottom:8px">
    <select id="obType" style="padding:8px;border:1px solid var(--line);border-radius:8px;background:var(--panel);color:var(--ink)"><option value="">全部类型</option>${Object.keys(O.stats).map(k=>`<option>${k}</option>`).join('')}</select>
    <input id="obT" placeholder="台号 如 29" style="padding:8px 12px;border:1px solid var(--line);border-radius:8px;background:var(--panel);color:var(--ink);width:110px">
    <button onclick="obGo()" style="cursor:pointer;padding:8px 16px;border-radius:8px;border:1px solid var(--accent);background:var(--accent);color:#fff">查询</button>
  </div><div id="obOut" class="small">选类型/台号后查询; 点结果行看对象全文与链接。</div></div>`;
  root.innerHTML=h;
  document.getElementById('foot').innerHTML='本体=只读语义层; 判级权在 L1+审级, 模型与网页均零判级权';
}
async function obGo(){
  const t=document.getElementById('obType').value, tb=document.getElementById('obT').value;
  const d=await (await fetch(`/api/ont_list?type=${encodeURIComponent(t)}&t=${encodeURIComponent(tb)}&limit=60`)).json();
  const el=document.getElementById('obOut');
  if(!d.rows||!d.rows.length){el.textContent='无结果';return}
  el.innerHTML=`<table><tr><th>id</th><th>类型</th><th>要点</th></tr>`+d.rows.map(r=>
    `<tr style="cursor:pointer" onclick="obOpen('${r.id}')"><td class="small">${r.id}</td><td>${r.type}</td><td class="small">${r.name||r.level||r.status||''} ${r.review_tier?'· '+r.review_tier:''}</td></tr>`).join('')+`</table><div id="obDetail"></div>`;
}
async function obOpen(id){
  const d=await (await fetch('/api/ont_obj?id='+encodeURIComponent(id))).json();
  const el=document.getElementById('obDetail'); if(!el) return;
  el.innerHTML=`<pre style="white-space:pre-wrap;background:var(--ground);border:1px solid var(--line);border-radius:8px;padding:10px;margin-top:8px">${JSON.stringify(d,null,1).replace(/</g,'&lt;')}</pre>`;
}
// 模型档位 (2026-08-28 用户令: 模型切换的应用你设计好; 去 30B 用 27B)。
// 按"这个问题值不值得等"选, 而非凭型号大小猜 — 每档写清 在哪跑 / 要多久 / 适合什么。
// 云端档单独标"内容会外发", 因为那是一个需要用户知情的选择而不是性能选项。
// ★页面用的是**这一份** (JS), 上面 L1158 那份是 Python 的 —— 两份同名不同源。
//   我第一次只改了 Python 那份, 页面一点没变 (deepseek-chat 在成品件里 0 命中)。
//   同名双实现: 改一处不报错、不生效, 只能靠回查产物发现。
const MODEL_SPEC = {
  'qwen3:8b':        {nm:'轻量 8B',  loc:'本地', t:'约 30 到 60 秒', use:'默认档: 快速简答问答', warn:''},
  'qwen3.8:27b':     {nm:'标准 27B', loc:'本地', t:'约 2 到 4 分钟', use:'复杂问题档: 多台横向比对与机制推断', warn:''},
  'qwen3:30b-a3b':   {nm:'快 30B (a3b)', loc:'本地', t:'约 20 到 60 秒', use:'8B 成文校验未过时自动升档目标', warn:''},
  'deepseek-r1:14b': {nm:'本机 DeepSeek 14B', loc:'本地', t:'约 1 到 3 分钟', use:'交叉审核审核档 (作答请优先 27B)', warn:''},
  'deepseek-r1:32b': {nm:'本机 DeepSeek 32B', loc:'本地', t:'约 3 到 8 分钟', use:'备用: 更强更慢, 引用格式不稳', warn:''},
  'deepseek-chat':   {nm:'DeepSeek', loc:'云端', t:'约 3 到 10 秒',  use:'默认档, 状态查询与机制推断', warn:'内容会外发到模型厂商, 场名与台号已去标识化'},
  'kimi-fast':       {nm:'Kimi',     loc:'云端', t:'约 5 到 20 秒',  use:'长文归纳', warn:'内容会外发到模型厂商, 场名与台号已去标识化'},
  'qwen-plus':       {nm:'通义千问',  loc:'云端', t:'约 5 到 20 秒',  use:'备用云端档', warn:'内容会外发到模型厂商, 场名与台号已去标识化'},
  'deepseek-v4-pro': {nm:'云端 DS',  loc:'云端', t:'约 2 到 6 分钟', use:'复杂推理与交叉审核', warn:'内容会外发到模型厂商, 场名与台号已去标识化'},
};
function mdlNote(){
  const el=document.getElementById('mdlnote'), sel=document.getElementById('askm');
  if(!el||!sel) return;
  const v=MODEL_SPEC[sel.value]||{};
  // ★查不到档位时**不能**默认"零外发" —— 未知档只可能是新加的云端模型。宁可说重不说轻。
  const note = v.warn ? `<span style="color:var(--warn)">${v.warn}</span>`
             : (v.loc==='本地' ? '全程零外发' : '<span style="color:var(--warn)">未知档位, 按内容会外发处理</span>');
  el.innerHTML=`${v.use||''} · ${note}`;
}
async function askGo(){
  const q=document.getElementById('askq').value, m=document.getElementById('askm').value;
  if(!q.trim()){document.getElementById('askout').textContent='问题为空';return}
  const r=await fetch('/api/ask',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({q,model:m,cat:window.ASKCAT||'',xrev:(document.getElementById('askxrev')||{}).checked||false})});
  const d=await r.json();
  if(d.err){document.getElementById('askout').textContent=d.err;return}
  askPoll();
}
// ★这句提示原文是「本地直连约 45~250 秒 (复合问题更久; 全程零外发)」—— 那是本地模型
//   时期的文案, 两处都已失真 (2026-09-01 用户说"太慢", 实测才发现):
//     ① 时间: 云端档实测 3~7 秒, 而提示写 45~250 秒 —— **是提示语在告诉用户它很慢**
//     ② 「全程零外发」现在是**假的**: 云端档的问题会发到厂商 API。
//        向用户保证一件不成立的事, 比写慢了严重得多。
//   故改为按档给话, 本地档才说零外发。
function MDLNOTE(m){
  // ★不用正则: CHART_JS 是**非 raw** 的 Python 三引号串, 反斜杠转义序列会被 Python
  //   吃掉并报 SyntaxWarning/SyntaxError。本地档判别用朴素前缀/子串即可。
  //   (本会话第 4 次踩这个坑 —— 而这一次是在**写这条警告的注释里**踩的。)
  const s0=String(m||'').toLowerCase();
  const local = s0.indexOf(':')>=0 || ['qwen3','llama','gemma','deepseek-r1'].some(x=>s0.indexOf(x)===0);
  return local ? '本地直连, 约 45 到 250 秒 (复合问题更久), 全程零外发'
               : '云端模型, 通常 3 到 10 秒 (复合问题更久), 问题与检索到的证据会发往模型厂商';
}
async function askPoll(){
  const el=document.getElementById('askout'); if(!el) return;
  const r=await fetch('/api/ask_status'); const s=await r.json();
  if((s.state==='running'||s.state==='partial')){
    // 进度上屏 (2026-08-28 用户"刚发现给不出结果"): 原来只有一个秒数在跳, 本地模型一问 45~250s,
    // 看不见它在干什么就会被读成卡死。现在报当前阶段(预取/推理第n轮/取证工具名/成文/校闸)与轨迹。
    const st=(s.steps||[]);
    el.innerHTML=`<b>推理中…</b> ${s.elapsed}s · <span style="color:var(--accent)">${s.step||'启动'}</span>
      <div class="small" style="color:var(--muted);margin-top:5px">${s.model} · ${MDLNOTE(s.model)}</div>
      ${st.length?`<div class="small" style="color:var(--muted);margin-top:4px">${st.slice(-6).join(' → ')}</div>`:''}
      <div class="small" style="color:var(--muted);margin-top:4px">问题: ${(s.q||'').slice(0,90)}</div>`;
    setTimeout(askPoll, 2000);
  }else if(s.state==='done'){
    const v=s.verify||{};
    const badge=v.全通过?`<span class="badge" style="border-color:var(--ok);color:var(--ok)">溯源核验 ${v.引用id数}/${v.引用id数} 全真</span>`
                        :`<span class="badge" style="border-color:var(--warn);color:var(--warn)">溯源核验未全过 (引用${v.引用id数||0})</span>`;
    const R=s.review;
    const rv=R?`<div class="card mb" style="border-left:3px solid ${R.issues&&R.issues.length?'var(--warn)':'var(--ok)'};margin-top:10px">
      <h3>交叉审核 · ${R.model} <span class="small" style="font-weight:400;color:${R.issues&&R.issues.length?'var(--warn)':'var(--ok)'}">${R.verdict}</span></h3>
      <p class="small" style="color:var(--muted);margin-bottom:${R.issues&&R.issues.length?'8px':'0'}">
        由另一本地模型基于<b>同一份证据</b>复核上述答案。溯源核验仅校验数字与机组号是否越界, 本项校验结论是否有证据支撑。</p>
      ${(R.issues||[]).map(i=>`<div class="small" style="padding:5px 0;border-top:1px solid var(--line-2)">
        <span class="badge" style="border-color:var(--warn);color:var(--warn)">${i.type}</span>
        <b>「${i.quote}」</b> <span style="color:var(--muted)">${i.why}</span></div>`).join('')}
      ${R.err?`<p class="small" style="color:var(--bad)">审核未完成: ${R.err}</p>`:''}</div>`:'';
    el.innerHTML=`<p>${badge} · 模型 ${s.model} · 用时 ${s.elapsed}s · ${(s.steps||[]).length} 步</p><pre style="white-space:pre-wrap;background:var(--ground);padding:12px;border-radius:8px;border:1px solid var(--line)">${(s.answer||'').replace(/</g,'&lt;')}</pre>${rv}`;
  }else if(s.state==='error'){
    el.textContent='出错: '+s.err;
  }
}
function winSel(cur){
  const base=['近30日','近90日','2026年','2026H1','2025H2','全程'];
  const ms=(window.ALLMONTHS&&ALLMONTHS.length)?ALLMONTHS:[];   // 按月份过滤和选择 (用户令): 预设窗+逐月
  let h=`<select id="win" onchange="reload(this.value)"><optgroup label="预设窗">`+
    base.map(w=>`<option ${w===cur?'selected':''}>${w}</option>`).join('')+`</optgroup>`;
  if(ms.length) h+=`<optgroup label="按月">`+ms.slice().reverse().map(m=>`<option ${m===cur?'selected':''}>${m}</option>`).join('')+`</optgroup>`;
  else if(!base.includes(cur)) h+=`<option selected>${cur}</option>`;   // 台页/问题页无月轴时保显当前月窗
  return h+`</select>`}
"""

PAGE_FLEET = """<!doctype html><html lang="zh" data-theme="light"><head><meta charset="utf-8"><script>(function(){try{var q=new URLSearchParams(location.search).get("theme");if(q){localStorage.setItem("windscada_theme",q)}var t=q||"light";document.documentElement.setAttribute("data-theme",t)}catch(e){}})();</script><meta name="viewport" content="width=device-width,initial-scale=1">
<title>观澜 · 风电智能分析决策</title><style>%CSS%</style></head><body>
<header><h1><s>观澜</s> 如东海上</h1><span id="winbox"></span>
</header>
<nav class="tabs" id="tabs"></nav>
<div id="root"><div class="card"><div class="skel" style="width:38%"></div><div class="skel" style="width:72%;margin-top:9px"></div><div class="skel" style="width:56%;margin-top:9px"></div></div></div>
<footer id="foot"></footer>
<script>%JS%
async function reload(win){
  const r=await fetch('/api/fleet?win='+encodeURIComponent(win)); const d=await r.json();
  if(d.all_months) window.ALLMONTHS=d.all_months;
  document.getElementById('winbox').innerHTML=winSel(d.win);
  D=d; renderTabs(); render();
  syncOverviewWin();
}
function syncOverviewWin(){
  // 总览静态页窗自适应 (2026-08-28 用户令): 把所选窗月列表推给 iframe, 页内重算 KPI/五态/限电/损失账
  const f=document.getElementById('ovframe');
  if(f&&D&&D.months) try{ f.contentWindow.postMessage({months:D.months, label:D.win}, '*') }catch(e){}
}
const TABS=['总览','电量算账','部件问题','振动融合分析','发电性能','故障统计','检修决策','检修助手','汇报定制','系统维护']   // 2026-08-28 用户指定顺序与命名; 分组标签撤 (10 个平铺, 分组反而多一层视觉层级);   // 问题总览撤: 系统入口进总览, 点系统看详情  // 本体不设独立tab (用户裁: 检修决策页=ontology展现的窗口)
let CURVES=null;
let D=null, TAB='总览';
const TABGROUPS=null;   // 分组已撤 (用户裁 2026-08-28)
function renderTabs(){
  // 平铺 (2026-08-28 用户裁): 10 个标签直接排, 撤掉"状态/分析/决策/维护"分组标签 —
  // 分组标签本身占一个视觉层级, 而 10 个中文标签本来就读得完, 分组是多余的一跳。
  document.getElementById('tabs').innerHTML=TABS.map(t=>
    `<button class="${t===TAB?'on':''}" onclick="TAB='${t}';renderTabs();render()">${t}</button>`).join('');
}
function render(){
  const d=D; const k=d.kpi, m=(d.m8&&!d.m8.err)?d.m8.mtbf:null;
  let h='';
  // 九系统入口 + 系统详情 (2026-08-28 用户令: 取消问题总览, 每个系统点开看详情)
  // 系统详情: 入口卡已随'两页顶端互换'移到可靠性概览, 条件不能再钉死总览 (2026-08-28 用户逮'点卡没反应')
  if(window.SYSV&&(TAB==='部件问题'||TAB==='总览')){
    const sname=window.SYSV, rows=(d.systems||{})[sname]||[], dist=(d.sysdist||{})[sname]||{};
    const cnt=st=>dist[st]||0;
    const al=rows.filter(r=>r.st==='报警'), un=rows.filter(r=>r.st==='不可判'), gd=(d.systems||{})[sname+'·良好']||[];
    const N=Object.values(dist).reduce((x,y)=>x+y,0)||1;
    h+=`<div class="card mb"><p class="small"><a class="tl" href="#" onclick="window.SYSV=null;render();return false">← 返回${TAB}</a></p>
      <h3>${sname} · 全场 ${N} 台</h3>
      <div style="display:flex;height:14px;border-radius:4px;overflow:hidden;margin:8px 0 4px">
        ${[['报警','var(--bad)'],['不可判','var(--unknown)'],['良好','var(--info)'],['优秀','var(--ok)']]
          .map(([k,c])=>{const n=cnt(k); return n?`<i title="${k} ${n}" style="width:${(n/N*100).toFixed(1)}%;background:${c}"></i>`:''}).join('')}
      </div>
      <div class="small" style="color:var(--muted)">报警 ${cnt('报警')} · 不可判 ${cnt('不可判')} · 良好 ${cnt('良好')} · 优秀 ${cnt('优秀')}</div></div>`;
    // 部件解剖图: 该系统内部怎么构成、介质/动力怎么流 (与传动链简图分工: 链=哪一环, 解剖=环内怎么坏的)
    if(ANAT[sname]){
      const _hit = al.map(r=>r.why).join(' ');
      h+=`<div class="card mb"><h3>${sname} 部件构成与失效路径</h3>${ANAT[sname](_hit, {})}</div>`;
    }
    const tbl=(title,list,col)=>list.length?`<div class="card mb"><h3>${title} (${list.length} 台)</h3>
      <table><tr><th style="width:74px">机组</th><th>依据</th><th style="width:96px">详情</th></tr>
      ${list.map(r=>`<tr><td><a class="tl" href="/turbine/${r.t}"><b>${r.t.replace('WTG','')}#</b></a></td>
        <td class="small">${r.why}</td>
        <td><a class="tl small" href="/problem/${r.t}/${encodeURIComponent(sname)}">该问题页 →</a></td></tr>`).join('')}</table></div>`:'';
    h+=tbl('报警机组',al)+tbl('不可判 (监测/数据不足, ≠正常)',un);
    if(gd.length) h+=`<details class="card mb"><summary style="cursor:pointer;font-weight:600;font-size:14px">良好 ${gd.length} 台 (轻微偏离, 周期观察 — 点开看逐台依据)</summary>
      <table style="margin-top:10px"><tr><th style="width:74px">机组</th><th>依据</th><th style="width:96px">详情</th></tr>
      ${gd.map(r=>`<tr><td><a class="tl" href="/turbine/${r.t}"><b>${r.t.replace('WTG','')}#</b></a></td><td class="small">${r.why}</td>
        <td><a class="tl small" href="/problem/${r.t}/${encodeURIComponent(sname)}">该问题页 →</a></td></tr>`).join('')}</table></details>`;
    if(!al.length&&!un.length&&!gd.length) h+=`<div class="card"><p class="small">本系统全场无非常态。</p></div>`;
    document.getElementById('root').innerHTML=h; document.getElementById('foot').innerHTML=d.note; return;
  }
  if(TAB==='总览'){
    // 总览顶部 = 可用率与损失总结 (2026-08-28 用户令: 与可靠性页最上端互换)
    const LS={}; ((d.control&&d.control.states)||[]).forEach(x=>{LS[x.k]=x.loss});
    const M8=(d.m8&&d.m8.mtbf)||null;
    h+=`<div class="kpis">
      <div class="kpi ${d.control&&d.control.avail>=95?'ok':'warn'}"><b>${d.control?d.control.avail:'—'}%</b><span>时间可用率(不含调度令) · ${d.win}</span></div>`;
    if(M8) h+=`<div class="kpi"><b>${M8.停机总时长h}h</b><span>停机时长 ｜ ${M8.停机事件数} 起 (${d.win})</span></div>
      <div class="kpi"><b>${M8.MTBF_h}h</b><span>平均停机间隔MTBO ｜ 剔除口径 ${M8.剔除口径.MTBF_h}h (非行业MTBF)</span></div>`;
    if(LS['停机']!=null) h+=`<div class="kpi"><b>${Math.round(LS['停机']).toLocaleString()}</b><span>停机损失 MWh${LS['停机(调度令)']!=null?` (另调度令 ${Math.round(LS['停机(调度令)']).toLocaleString()})`:''}</span></div>`;
    if(LS['限电·绑定']!=null) h+=`<div class="kpi"><b>${Math.round(LS['限电·绑定']).toLocaleString()}</b><span>限电·绑定损失 MWh</span></div>`;
    h+=`</div>`;

    // 快照模式下 /static/index.html 取不到 (它是服务端另一套页面), 会渲染出静态服务的 404 页;
    // 快照里改为提示条, 并指向快照内已有的各分析页。
    const _snap = (typeof window.__SNAP__!=='undefined');
    // ★快照版的总览不能是一句"内嵌页不可用" (2026-09-01 用户: "over view 也打不开")。
    //   它是访客落地的**第一屏**, 而原来那句等于开门就说"这里没东西"。
    //   数据本来就在快照里 —— 逐系统机组、kpi、可靠性统计 —— 直接在这里汇总,
    //   并给一张"哪一屏回答什么"的导览。服务端版仍走 iframe, 不受影响。
    document.getElementById('root').innerHTML = h + (_snap
      ? (farmScene(d) + snapOverview(d))
      : `<iframe id="ovframe" src="/static/index.html" title="总览" onload="syncOverviewWin()"></iframe>`);
    document.getElementById('foot').innerHTML=d.note; return;
  }
  if(TAB==='发电性能'){ renderCurves(); return; }
  if(TAB==='本体'){ renderOntology(); return; }
  if(TAB==='振动融合分析'&&d.fus&&!d.fus.err&&d.fus.kpi){
    const K=d.fus.kpi; // 振动域分布卡·按钮化 (用户令: 点卡进入看该级具体台; FUSF=当前筛选级)
    const btn=(f,cls,val,label)=>{const on=window.FUSF===f;
      return `<div class="kpi ${cls}" role="button" tabindex="0" onclick="window.FUSF=window.FUSF==='${f}'?null:'${f}';window.FUSSUB='逐台情况';render()" style="cursor:pointer${on?';outline:2px solid var(--accent)':''}"><b>${val}</b><span>${label}${on?' · <b>筛选中,再点清除</b>':' · 点击查看'}</span></div>`};
    h+=`<div class="kpis">`;
    h+=btn('bad', K.定论>0?'bad':'ok', K.定论, `定论/报警级 (机制链定案 ${K.机制链} 台)`);
    h+=btn('warn', K.预警>0?'warn':'ok', K.预警, '预警级机组');
    h+=btn('note', '', K.候选观察, '候选/监视/观察级');
    h+=btn('ok', 'ok', K.销案正常, '销案/无新证');
    h+=btn('unlisted', '', `${K.收录台}<span style="font-size:13px;color:var(--muted)">/${K.全场}</span>`, `振动线收录台 (未列 ${K.未列} 台 ≠ 正常)`);
    // (可检出系数KPI卡撤 — 2026-08-28 用户令: 能力边界取消, 模型计算隐藏)
    h+=`</div>`;
    // 数据时点 (用户令"以最新导入的报告日期为准, 并说明时间"): 判级转录自振动线, 有自己的出件日期
    // 与证据窗末, 与本页所选时间窗无关 — 不标时点会让人以为它跟着窗走
    if(d.fus.数据时点) h+=`<p class="small" style="color:var(--muted);margin:-4px 0 12px">
      判级数据: ${d.fus.数据时点} — 转录自振动线, <b>不随上方时间窗变</b>; 报警/工单/温度列才跟随所选窗。</p>`;
  } else {
  // (KPI 组已移至总览顶部 — 2026-08-28 用户令: 两页最上端互换)
  }


  if(TAB==='部件问题'){
    // 九系统入口 (点开看该系统全场详情) — 替代原"问题总览"tab
    const SD=d.sysdist||{};
    h+=`<div class="eyebrow">按系统查看</div><div class="card mb"><div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:10px">`
      +Object.entries(SD).map(([s2,dist])=>{
        const a=dist['报警']||0, u=dist['不可判']||0, N=Object.values(dist).reduce((x,y)=>x+y,0)||1;
        const col=a>=8?'var(--bad)':a>=3?'var(--warn)':a?'var(--info)':'var(--ok)';
        return `<div role="button" tabindex="0" onclick="window.SYSV='${s2}';render()" style="cursor:pointer;border:1px solid var(--line);border-left:3px solid ${col};border-radius:9px;padding:10px 12px"
          onmouseover="this.style.borderColor='var(--accent)';this.style.borderLeftColor='${col}'" onmouseout="this.style.borderColor='var(--line)';this.style.borderLeftColor='${col}'">
          <div style="font-weight:600;font-size:13px">${s2}</div>
          <div style="display:flex;height:7px;border-radius:3px;overflow:hidden;margin:6px 0 5px">
            ${[['报警','var(--bad)'],['不可判','var(--unknown)'],['良好','var(--info)'],['优秀','var(--ok)']]
              .map(([k,c])=>{const n=dist[k]||0; return n?`<i title="${k} ${n}" style="width:${(n/N*100).toFixed(1)}%;background:${c}"></i>`:''}).join('')}
          </div>
          <div class="small" style="color:var(--muted)">报警 <b style="color:${col}">${a}</b>${u?` · 不可判 ${u}`:''} · 全场 ${N} 台</div></div>`}).join('')
      +`</div><p class="small" style="margin-top:8px;color:var(--muted)">点系统卡 → 该系统全场机组与依据; 九系统 = 交付九分册一一对应; 叶片与叶根/塔架与基础无 SCADA 轴 (分册蓝本取 CMS/巡检)</p></div>`;

  if(d.rel&&d.rel.err) h+=blockErr('rel', d.rel.err);
  if(d.rel&&!d.rel.err){
    const R=d.rel, tb=R.表, maxH=Math.max(...tb.map(r=>r.停机时长h));
    h+=`<div class="eyebrow">部件可靠性 · ${R.窗}</div>`;
    h+=`<div class="card mb"><h3>部件停机贡献与可靠性 <span class="small" style="font-weight:400;color:var(--muted)">总停机 ${R.总停机h}h = 设备类 ${R.设备类停机h} + 外部类 ${R.外部类停机h}</span></h3>
    <p class="small" style="color:var(--muted);margin:-2px 0 8px">口径 ≥1h 停机段, 不含调度令 —
    与"电量算账"里的停机时长${(function(){var v=d.control.energy&&d.control.energy.items.filter(function(x){return x.k==='停机'}).map(function(x){return x.h})[0];return (v===undefined||v===null)?'':' '+v+'h'})()} 不同,
    差额是 <b>短于 1h 的停机段</b> (本页按段做可靠性指标须成段, 能量账按逐条工况态算电量): 两个数都对, 不可互相相减。</p>
    <table><tr><th>部件</th><th class="barcell">停机时长</th><th class="num">事件</th><th class="num">MTBO h</th><th class="num">MDT h</th><th class="num">影响台</th><th>典型失效模式 (按时长)</th></tr>`;
    tb.forEach(r=>{
      const w=Math.round(r.停机时长h/maxH*72);
      const sev=r.部件==='无记录停机'?'var(--unknown)':r.外部?'var(--info)':(r.占停机>=0.06?'var(--bad)':r.占停机>=0.03?'var(--warn)':'var(--ok)');
      h+=`<tr><td><b>${r.部件}</b>${r.外部?' <span class="badge">外部</span>':''}</td>
        <td class="barcell"><i class="bar" style="width:${w}px;--c:${sev}"></i><span class="cnt">${r.停机时长h}h · ${(r.占停机*100).toFixed(1)}%</span></td>
        <td class="num">${r.事件数}</td><td class="num">${r.外部?'—':r.MTBF_h}</td><td class="num">${r.MDT_h}</td>
        <td class="num">${r.影响台数}</td><td class="small">${r.典型失效模式||'—'}</td></tr>`});
    h+=`</table><p class="small">${R.口径}</p></div>`;
  }
  if(d.fus&&d.fus.err) h+=blockErr('fus', d.fus.err);
  if(d.fus&&!d.fus.err){
    h+=`<div class="card mb"><p class="small">振动线结论与四源融合已移至独立板块 → <a class="tl" href="#" onclick="TAB='振动融合分析';render();return false"><b>振动融合</b></a> (${d.fus.表.length} 台次收录)</p></div>`;
  }
  h+=`<div class="eyebrow">多系统交叉机组</div>`;
  h+=`<div class="card mb"><h3>关注机组 (≥2 系统交叉, ${d.watch.length} 台; 点机组号 → 该台独立页)</h3>
  <table><tr><th>机组</th><th>系统数</th><th>命中系统</th><th>依据</th></tr>`;
  d.watch.forEach(w=>{h+=`<tr><td><a class="tl" href="/turbine/${w.t}"><b>${w.t.replace('WTG','')}#</b></a></td><td class="num">${w.n}</td>
    <td class="small">${w.syss.map(x=>`<a class="tl" href="/problem/${w.t}/${encodeURIComponent(x)}">${x}</a>`).join(' · ')}</td>
    <td class="small">${w.why}</td></tr>`});
  h+=`</table></div>`;
  }
  if(TAB==='振动融合分析'){
  if(!d.fus||d.fus.err){ h+=`<div class="card"><p>融合面数据不可用: ${d.fus&&d.fus.err||'无数据'}</p></div>`; }
  else{
    const F=d.fus, CL={bad:'var(--bad)',warn:'var(--warn)',note:'var(--muted)',ok:'var(--ok)',unlisted:'var(--muted)',stale:'var(--muted)'};
    if(!window.FUSSUB||window.FUSSUB==='能力边界') window.FUSSUB='融合矩阵';   // 旧持久值兜底
    const SUBS=['融合矩阵','端到端闭环','逐台情况','报警工单','振动分析'];
    h+=`<div class="eyebrow">振动与 SCADA 证据视图 · 展示振动结论、SCADA 指标、报警与工单线索</div>`;
    h+=`<div style="display:flex;gap:8px;margin-bottom:14px;flex-wrap:wrap">`+SUBS.map(s=>{
      const on=s===FUSSUB;
      return `<button onclick="window.FUSSUB='${s}';if('${s}'!=='逐台情况')window.FUSF=null;render()" style="cursor:pointer;padding:8px 16px;border-radius:20px;border:1px solid ${on?'var(--accent)':'var(--line)'};background:${on?'var(--accent)':'var(--panel)'};color:${on?'#fff':'var(--ink)'};font-size:13px;font-weight:${on?'600':'400'}">${s}</button>`}).join('')+`</div>`;

    if(FUSSUB==='融合矩阵'){
    h+=`<div class="card mb" style="border-left:3px solid var(--warn)"><b>两条判读纪律 (随板块常显)</b><p class="small">① 同一失效机制的多个观测面 ≠ 多源印证 — 融合禁按源数加权 (29# 柱塞/温度/振动稳态/振动瞬态 = 四个观测面一条机制链)。<br>② "没报警" ≠ "正常" — 在已知盲区上 (见"能力边界"页), 振动阴性不构成证据; 矩阵"未列"台同理。</p></div>`;
    const spark=(hist,color)=>{ // 记忆轨迹: 旧窗=细线, 现窗=实心点
      if(!hist||hist.filter(x=>x!=null).length<3) return '';
      const vs=hist.filter(x=>x!=null), mn=Math.min(...vs), mx=Math.max(...vs), sp=(mx-mn)||1;
      const W=84,H=22,n=hist.length;
      let dpath='',last=null;
      hist.forEach((v,i)=>{ if(v==null)return; const x=(i/(n-1))*W, y=H-2-((v-mn)/sp)*(H-4);
        dpath+=(dpath?'L':'M')+x.toFixed(1)+' '+y.toFixed(1); last=[x,y]; });
      return `<svg width="${W}" height="${H}" style="vertical-align:middle;margin-left:6px"><path d="${dpath}" fill="none" stroke="${color}" stroke-width="1.2" opacity="0.75"/><circle cx="${last[0]}" cy="${last[1]}" r="2.4" fill="${color}"/></svg>`;
    };
    h+=`<div class="card mb"><h3>全场融合矩阵 (38 台 × 6 个证据面)</h3>\n    <p class="small" style="color:var(--muted)">各列取数窗口不同 (见列头) — 不同窗的两格同时发红不等于"同时发生", 不可当共时印证。</p>
    <p class="small">每格右侧曲线 = 逐月记忆轨迹 (${(F.列窗.months||[]).length} 个月, ${(F.列窗.months||['?'])[0]}起; 实心点=现窗) — 现窗快照会丢形态, 轨迹才看得见"塌→回升→翻转"类机制签名。</p>`;
    // 等宽固定布局 (用户令): 六证据列各 15.5%, 机组列 7%; 长口径收进列头副行与悬停
    const shortWin=w=>{const t=zh(w||''); const m=t.match(/20[0-9][0-9]-[0-9][0-9](?:~20[0-9][0-9]-[0-9][0-9])?|至[ ]*20[0-9][0-9]-[0-9][0-9]|20[0-9][0-9]~20[0-9][0-9]/); return m?m[0]:t.slice(0,14)};
    const th=(name,win,extra)=>`<th title="${esc(zh(win))}${extra?' · '+extra:''}"><div>${name}</div>
      <div class="small" style="font-weight:400;color:var(--muted)">${shortWin(win)}${extra?' · '+extra:''}</div></th>`;
    h+=`<div class="small" style="color:var(--muted);margin:6px 0 12px;line-height:2">
      <div><b>格子颜色 = 设备状态 (业主口径, 与 windcms 报告同一套):</b>
        ${['危险','报警','良好','优秀','不可判'].map(k=>
          `<span style="display:inline-flex;align-items:center;gap:4px;margin-right:12px"><i style="width:10px;height:10px;border-radius:2px;background:${C[k]||'#ccc'}"></i>${k}</span>`).join('')}</div>
      <div><b>徽章 = 证据状态 (可信度, windcms 九枚举):</b>
        ${['定论','准定论·预警','候选·新发','候选','候选·记基线','参考','INSUFFICIENT'].map(k=>
          `<span style="display:inline-flex;align-items:center;gap:4px;margin-right:12px"><i style="width:10px;height:10px;border-radius:2px;background:${(F.色标||{})[k]||'#ccc'}"></i>${k}</span>`).join('')}</div>
      <div style="color:var(--muted)">两轴不可互相替代: "候选"说的是可信度不是设备好坏; "良好"说的是设备状态不是证据强度。设备状态只取自振动线的判级栏这一个来源。</div>
    </div>`;
    h+=`<table style="table-layout:fixed;width:100%"><colgroup><col style="width:7%">${'<col style="width:15.5%">'.repeat(6)}</colgroup>
    <tr><th>机组</th>${th('振动',F.列窗.振动,'不随本窗')}${th('温度',F.列窗.温度)}${th('润滑柱塞',F.列窗.润滑,'只展示')}${th('油液',F.列窗.油液)}${th('报警',F.列窗.报警||'')}${th('工单',F.列窗.工单||'')}</tr>`;
    const MAXAL = Math.max(1, ...F.矩阵.map(r=>(r.报警||{}).n||0));
    const MAXWO = Math.max(1, ...F.矩阵.map(r=>(r.工单||{}).n||0));
    F.矩阵.forEach(r=>{
      // 各列只列与问题相关的 (2026-08-28 用户令"不要发散"): 该格非问题级 → 收敛成一词, 全文留悬停;
      // 有问题才展开证据。矩阵是找问题的面, 不是数据倾倒面。
      // 非问题格短词: 优先取 note 里的判断短语 (振动列已把"未收录"细化成
      // 已评估无异常 / 数据不足·不可判 / 未评估 三类, 固定字典会把这个区分盖掉)
      // 格内一律显示明确定级词, 不显示截断的原文 (2026-08-28 用户逮"评估报告 2026-08-2…"这类无意义截断)
      const shortOf = (c) => {
        if(c.ostate && c.ostate !== '不可判') return c.ostate;          // 明确设备状态优先
        if(/数据不足|不可判/.test(String(c.note))) return '数据不足';
        if(/未评估/.test(String(c.note))) return '未评估';
        if(/无样|未取样/.test(String(c.note))) return '未取样';
        if(/样龄|stale/.test(String(c.note))) return '样龄过期';
        return {ok:'正常', unlisted:'未收录', stale:'样龄过期'}[c.level] || '—';
      };
      // ★两套体系并存 (2026-08-28 用户令"参照 windcms 优秀/良好/报警/危险 级别体系"):
      //   ① 业主口径状态等级 (危险>报警>良好>优秀>不可判) = 设备状态轴 → 决定格子颜色 (C 表, 与九系统矩阵同色)
      //   ② 证据状态 九枚举 (定论/准定论·预警/候选/参考/INSUFFICIENT) = 可信度轴 → 作徽章挂在旁边 (windcms 色标)
      // 两轴不可互相替代: "候选"是可信度不是设备好坏, "良好"是设备状态不是证据强度。
      const WC = F.色标 || {};
      const cell=(c,lim,icon,tid)=>{
        const col = C[c.ostate] || WC[c.wlevel] || CL[c.level] || 'var(--muted)';
        const full = vibPlain(zh(c.note));
        const isProb = ['bad','warn','note'].includes(c.level);
        if(!isProb) return `<td class="small tipw" data-tip="${esc(full)} — 设备状态 ${c.ostate||'?'}" style="border-left:3px solid ${col};color:var(--muted)">${shortOf(c)}</td>`;
        const cut = full.length>(lim||46) ? full.slice(0,lim||46)+'…' : full;
        const hot = ['报警','危险'].includes(c.ostate);
        const ic = icon ? partGlyph(full.split(/[:：]/)[0], hot ? col : 'var(--muted)', hot) : '';
        // 图 + 判级短词; 全文走悬停浮层 (2026-08-28 用户令: 列宽有限, 长句在格里会被挤成竖排)
        // 部件名已由图表达 ⇒ 格内文字只留判级词, 不重复部件名
        const parts = full.split(/[:：]/);
        // 明确定级词打头, 后面才是简述; 截断的原文(如"评估报告 2026-08-2…")不作为格内主文案
        const brief = (parts.length > 1 ? parts.slice(1).join(':') : full).trim();
        const cleanBrief = /^[ ]*(评估报告|两口径差异|⚠)/.test(brief) || brief.length > 16 ? '' : brief;
        // duo 徽章已给定级词 → 主文案只留简述, 无简述时才回退定级词 (避免同格重复两次)
        const shortCut = cleanBrief || (c.ostate && c.ostate !== '不可判' ? '' : shortOf(c));
        // 点部件图 → 浮窗 (问题说明 + 该部件小曲线 + 四源微视图); 悬停只给文字
        const clk = (tid && ic) ? ` onclick="popPart('${tid}','${esc(parts[0]).replace(/'/g,'')}')" style="cursor:pointer"` : '';
        // 设备状态 | 证据状态 同框 (用户令: 两个 UI 分开显示太乱)
        const ev = (c.wlevel && c.wlevel !== '—' && c.wlevel !== '正常' && c.ostate)
          ? `<span class="duo" style="--c:${col};margin-top:4px"><span class="st">${c.ostate}</span><span class="ev">${c.wlevel}</span></span>` : '';
        return `<td class="small tipw" data-tip="${esc(full)} — 设备状态 ${c.ostate||'?'} / 证据状态 ${c.wlevel||'?'}"
            style="border-left:3px solid ${col};overflow:hidden">
          <div${clk}>${ic || ''}<div style="color:${col};font-weight:${['bad','warn'].includes(c.level)?600:400}">${shortCut}</div>${ev}</div>
          ${spark(c.hist,c.level==='bad'?'var(--bad)':c.level==='warn'?'var(--warn)':'var(--muted)')}</td>`};
      const al=r.报警||{n:0,fam:[]}, wo=r.工单||{n:0,acts:[]};
      const alc=al.rank&&al.rank<=5?'var(--warn)':'var(--line)';
      const bu=al.burst;
      h+=`<tr><td><a class="tl" href="/turbine/${r.turbine}"><b>${r.turbine.replace('WTG','')}#</b></a></td>${cell(r.振动,46,true,r.turbine)}${cell(r.温度)}${cell(r.润滑)}${cell(r.油液)}
        <td class="${(al.items||[]).length?'tipw':''}" data-tip="${esc(((al.items||[]).map(x=>`${x.code} ${x.text} — ${x.n} 条 (${x.first}~${x.last})`).join('\\n')) + (bu?`\\n⚠ 单码 ${bu.code} 占 ${(bu.share*100).toFixed(0)}%, 中位 ${bu.med_s} 秒/次 — 条数被抖动灌满`:''))}" style="border-left:3px solid ${bu?'var(--unknown)':alc};white-space:pre-line">
          <b class="small" style="font-variant-numeric:tabular-nums;color:${al.rank&&al.rank<=10?'var(--ink)':'var(--muted)'}">${al.n} 条</b>
          ${al.rank?`<span class="small" style="color:var(--muted)"> · 第${al.rank}/${al.tot}</span>`:''}
          ${bu?`<div class="small" style="color:var(--unknown)">⚠ ${(bu.share*100).toFixed(0)}% 是码${bu.code}抖动</div>`:''}
          ${(al.rank&&al.rank<=10)||bu?famBar(al.fam,al.n,MAXAL):''}</td>
        <td class="${(wo.items||[]).length?'tipw':''}" data-tip="${esc((wo.items||[]).map(x=>`${x.date} ${x.name} → ${x.act}${x.part?' '+x.part:''}`).join('\\n') || '窗内无传动链工单')}" style="min-width:110px;white-space:pre-line">
          ${wo.n?`<b class="small">${wo.n} 单</b>${wo.last?`<span class="small" style="color:var(--muted)"> · ${wo.last}</span>`:''}
            <div style="height:7px;border-radius:3px;background:var(--muted);opacity:.5;margin-top:4px;width:${Math.max(6,Math.round(wo.n/MAXWO*90))}px"></div>
            <div class="small" style="color:var(--muted);margin-top:3px">${(wo.acts||[]).slice(0,2).map(a=>a.k+'×'+a.n).join(' · ')}</div>`
            :`<span class="small" style="color:var(--muted)">—</span>`}</td></tr>`});
    h+=`</table><p class="small">润滑柱塞各台设定本就不同 (全场单次循环 22~961 秒), 所以此列只展示不判级, 只有已定案的机制链才标色; 油液多数台末次取样距今超 12 个月, 此列看的是"样够不够新", 不代表当前状态。</p></div>`;
    }

    // (能力边界撤; 端到端闭环替入 — 2026-08-28 用户令: 回恢复的和不恢复的都列, 结果性实证非方法学)
    if(FUSSUB==='端到端闭环'){
    const LP=(F.能力&&F.能力.loop&&F.能力.loop['换件闭环 (检出→换件→恢复)'])?F.能力.loop:null;
    if(!LP){ h+=`<div class="card mb"><p class="small">handoff 无端到端闭环数据</p></div>`; }
    else {
    const cl=LP['换件闭环 (检出→换件→恢复)']||[], up=LP['当前在升 (无工单可对)']||[], neg=LP['负面对照 (工单后持平)'];
    h+=`<div class="card mb"><h3>维修后验证案例 (检出 → 换件 → 恢复)</h3>
      <p class="small">有换件记录且同口径指标回落, 可作为检测链已闭合的案例; 指标仍在上升但缺少可匹配工单的机组, 需现场或台账确认后再关闭。</p>
      <h3 style="margin-top:8px">已闭环 · 换件后恢复 (${cl.length} 例)</h3>
      <table><tr><th>机组</th><th>部件</th><th>事项</th><th>换件日</th><th>换前→换后 (同标尺)</th><th>恢复比</th><th>判</th></tr>
      ${cl.map(r=>`<tr><td><b>${r.turbine.replace('WTG','')}#</b></td><td style="min-width:220px">${dtMini(r.component+(r.title||''),'var(--ok)',null,r.turbine)}</td><td class="small">${r.title}</td><td>${r.replace_date}</td><td>${baBar(r.pre,r.post,'var(--ok)')}<span class="small" style="color:var(--muted)">${r.pre} → ${r.post}</span></td><td class="num"><b style="color:var(--ok)">${r.ratio}×</b></td><td><span class="chip" style="--c:var(--ok)">${r.verdict}</span></td></tr>`).join('')}</table>
      <p class="small" style="margin-top:6px">负面对照: 工单后持平 ${neg} 例 (换件≠必然回落, 说明回落非巧合)。</p>
      <h3 style="margin-top:14px">未闭环 · 指标上升待现场/工单确认 (${up.length} 台)</h3>
      <table><tr><th>机组</th><th>部件</th><th>早期→近期 (同标尺)</th><th>倍比</th><th>状态</th></tr>
      ${up.map(r=>`<tr><td><b>${r.turbine.replace('WTG','')}#</b></td><td style="min-width:220px">${dtMini(r.component,'var(--warn)',null,r.turbine)}</td><td>${baBar(r.early,r.late,'var(--warn)')}<span class="small" style="color:var(--muted)">${r.early} → ${r.late}</span></td><td class="num"><b style="color:var(--warn)">${r.ratio}×</b></td><td><span class="chip" style="--c:var(--warn)">上升待确认</span></td></tr>`).join('')}</table>
      <p class="small" style="margin-top:8px;color:var(--muted)">数据边界: ${(LP['★数据边界']||'').split('**').join('')}</p>
    </div>`;
    }
    }
    if(FUSSUB==='逐台情况'){
    const lv=v=>/定论|报警/.test(v)?'bad':/预警/.test(v)?'warn':/销案|无新证|保留/.test(v)?'ok':'note';
    if(window.FUSF==='unlisted'){
      const un=F.矩阵.filter(r=>r.振动.level==='unlisted');
      h+=`<div class="card mb"><h3>未列机组 ${un.length} 台 (振动线未收录 — <b>未列 ≠ 正常</b>, 盲区见"能力边界"页) <a class="tl" href="#" onclick="window.FUSF=null;render();return false">×清除筛选</a></h3>
      <table><tr><th>机组</th><th>温度轴现状</th><th>润滑柱塞现状</th></tr>`;
      un.forEach(r=>{h+=`<tr><td><a class="tl" href="/turbine/${r.turbine}"><b>${r.turbine.replace('WTG','')}#</b></a></td><td class="small">${r.温度.note}</td><td class="small">${r.润滑.note}</td></tr>`});
      h+=`</table></div>`;
    } else {
    let rows=F.表;
    const FLABEL={bad:'定论/报警级',warn:'预警级',note:'候选/监视/观察级',ok:'销案/无新证'};
    if(window.FUSF) rows=F.表.filter(r=>lv(r.振动结论)===FUSF);
    h+=`<div class="card mb"><h3>逐台情况 (全场 ${new Set(F.表.map(x=>x.turbine)).size} 台 / ${rows.length}${window.FUSF?`/${F.表.length} 台次 · 筛选: ${FLABEL[FUSF]} <a class="tl" href="#" onclick="window.FUSF=null;render();return false">×清除</a>`:' 台次'}; 深入谱图/波形 → "振动分析"页)</h3>
    <div class="card" style="border-left:3px solid var(--accent);margin-bottom:12px">
      <b class="small">评价体系 (规范化定义 — 两轴并存, 不可互相替代)</b>
      <table style="margin-top:8px"><tr><th style="width:34%">设备状态 (业主口径)</th><th style="width:34%">证据状态 (可信度)</th><th>含义</th></tr>
        <tr><td>${chip('危险')}</td><td><span class="badge">定论</span></td><td class="small">异常严重, 建议尽快停机检查 <span style="color:var(--muted)">(证据: 已定案)</span></td></tr>
        <tr><td>${chip('报警')}</td><td><span class="badge">准定论·预警 / 候选·新发</span></td><td class="small">存在需现场核实或处置的异常 <span style="color:var(--muted)">(证据: 基本确认 / 新出现待核实)</span></td></tr>
        <tr><td>${chip('良好')}</td><td><span class="badge">候选 / 候选·记基线</span></td><td class="small">轻微偏离, 记录观察 <span style="color:var(--muted)">(证据: 待现场核实 / 已记为基线下窗观察)</span></td></tr>
        <tr><td>${chip('优秀')}</td><td><span class="badge">参考 / 正常 / 撤回</span></td><td class="small">未见异常, 保持常规监视 <span style="color:var(--muted)">(证据: 仅记录 / 已取消)</span></td></tr>
        <tr><td>${chip('不可判')}</td><td><span class="badge">INSUFFICIENT</span></td><td class="small">数据不足或监测中断 — 不等于正常 <span style="color:var(--muted)">(证据: 数据不足)</span></td></tr></table>
      <p class="small" style="color:var(--muted);margin-top:7px">
        设备状态答"这台设备现在怎么样"(危险>报警>良好>优秀>不可判); 证据状态答"这个判断有多可信"(定论→INSUFFICIENT)。
        设备状态一律取自振动线的判级栏这一个来源(遇到未登记的定级词直接报错, 不静默当成"优秀")。
        本页判级为转录, 不产新判级; 标注为引用同族/谱线级/测量链/未映射的行<b>不作部件级结论消费</b>;
        claim_window = 该结论的证据窗, 窗外状态该结论不背书。</p></div>
    <table><tr><th>机组</th><th>部件</th><th>设备状态 / 振动结论</th><th>证据窗<span class='small' style='color:var(--muted);font-weight:400'> 26-01→09</span></th><th>振动信号</th><th>温度轴 <span class='small' style='color:var(--muted);font-weight:400'>±6K</span></th><th>油样</th></tr>`;
    rows.forEach(r=>{
      // 判级取后端单源列 (禁前端正则: '销案(定论)'含'定论'会被误染红 — 2026-08-28 同根第2例)
      const LVC={bad:'var(--bad)',warn:'var(--warn)',ok:'var(--ok)',meta:'var(--muted)',note:'var(--info)'};
      const sev=LVC[r.级]||'var(--info)';
      h+=`<tr><td><a class="tl" href="/turbine/${r.turbine}"><b>${r.turbine.replace('WTG','')}#</b></a></td>
      <td style="min-width:220px">${dtMini(r.部件,sev,null,r.turbine)}</td>
      <td><span class="duo" style="--c:${C[r.设备状态]||'var(--muted)'}" title="${r.设备状态||'?'}: ${ST_NOTE[r.设备状态]||''} | 证据 ${r.证据状态||'?'}: ${EV_NOTE[r.证据状态]||''} | 振动线原文: ${esc(r.振动结论)}">
        <span class="st">${r.设备状态||'—'}</span><span class="ev">${plain(r.振动结论)}</span></span></td>
      <td style="min-width:130px">${winBar(r.窗区间,r.claim_window)}</td>
      <td class="small tipw" data-tip="振动线原文: ${esc(r.振动信号)}">${vibPlain(r.振动信号)}</td><td style="min-width:158px">${devBar(r.温度通道,r.温度dev,r.温度判,r.温度轴)}</td>
      <td style="min-width:112px">${oilPill(r.油末样,r.油新鲜,r.油样轴)}</td></tr>`});
    h+=`</table></div>`;
    }
    }

    if(FUSSUB==='报警工单'&&F.事件){
      // 数据边界长条撤 (2026-08-28 用户令): 两源不重叠的完整说明太长且每页重复;
      // 关键一句仍在工单卡("0 条=记录缺失非未修过")与汇报定制页第⑧章口径与数据边界。
      h+=`<div class="card mb"><p class="small" style="color:var(--muted)"><b>时间窗 ${d.win}</b> · 顶部选择器可换</p></div>`;
      for(const [comp,E] of Object.entries(F.事件)){
        h+=`<div class="card mb"><h3>${comp} — 报警 ${E.报警.总条数} 条/${E.报警.台数} 台 · 工单 ${E.工单.总条数} 条/${E.工单.台数} 台 (窗内)</h3>`;
        if(E.报警.总条数>0){
          h+=`<table><tr><th>码</th><th>报警内容</th><th class="num">条数</th><th class="num">台数</th><th class="num">累计时长h</th></tr>`;
          E.报警.码统计.forEach(c=>{h+=`<tr><td>${c.code}</td><td class="small">${c.text}</td><td class="num">${c.条数}</td><td class="num">${c.台数}</td><td class="num">${c.时长h}</td></tr>`});
          h+=`</table><p class="small">台分布 top: ${Object.entries(E.报警.top台).map(([t,n])=>`<a class="tl" href="/turbine/${t}">${t.replace('WTG','')}#</a>×${n}`).join(' · ')}</p>`;
          h+=`<details><summary class="small">最近 ${E.报警.近况.length} 条明细</summary><table><tr><th>机组</th><th>时间</th><th>码</th><th>内容</th><th class="num">时长min</th></tr>`;
          E.报警.近况.forEach(r=>{h+=`<tr><td>${r.t.replace('WTG','')}#</td><td class="small">${r.on}</td><td>${r.code}</td><td class="small">${r.text}</td><td class="num">${r.dur_min??'—'}</td></tr>`});
          h+=`</table></details>`;
        } else h+=`<p class="small">窗内无该部件报警</p>`;
        if(E.工单.总条数>0){
          h+=`<table style="margin-top:8px"><tr><th>机组</th><th>日期</th><th>故障名称</th><th>处理</th><th>原因</th></tr>`;
          E.工单.明细.forEach(r=>{h+=`<tr><td>${r.t.replace('WTG','')}#</td><td class="small">${r.date}</td><td class="small">${r.name}</td><td class="small">${r.act}</td><td class="small">${r.cause}</td></tr>`});
          h+=`</table>`;
        } else h+=`<p class="small">窗内无该部件工单 (工单数据止 2024-11, 2026 类窗必空 = 数据边界)</p>`;
        h+=`</div>`;
      }
    }

    if(FUSSUB==='振动分析'){
    // 2026-08-28 用户令: 生接改融合 — 只显示结果(windcms 评估报告转录), 模型与计算隐藏, 分析功能留独立 cms
    if(!window.VIBCMS) { fetch('/api/vibcms').then(r=>r.json()).then(d=>{window.VIBCMS=d; render();}); h+=`<div class="card mb"><p class="small">载入振动评估结果…</p></div>`; }
    else if(VIBCMS.error){ h+=`<div class="card mb"><p class="small" style="color:var(--bad)">${VIBCMS.error}</p></div>`; }
    else {
    const V=VIBCMS;
    const gc=st=>({'报警':'var(--bad)','危险':'var(--bad)','不可判':'#9aa4b0','良好':'var(--warn2,#8a8f3b)','优秀':'var(--ok)'}[st]||'var(--muted)');
    const cp=st=>`<span class="chip" style="--c:${gc(st)}">${st}</span>`;
    h+=`<div class="card mb"><h3>振动状态评估 (windcms 报告 ${V.date} 结果转录)</h3>
      <p class="small">${V.overall||''} 状态管理判级, 不代表确诊数量; 判据/谱线/计算过程不在本页 — 深潜走底部独立系统。</p>
      <h3 style="margin-top:10px">需行动机组 (报警/不可判)</h3>
      <table><tr><th>机组</th><th>状态</th><th>状态焦点 <span class='small' style='font-weight:400;color:var(--muted)'>(传动链: 主承前·主承后·齿轮箱·发电机两端)</span></th><th>证据强度</th><th>行动</th></tr>
      ${V.action.map(r=>{const cm={};String(r[2]).split(/[；;]/).forEach(seg=>{const m=seg.split(/[：:]/);
        if(m.length>1){const k=m[0].trim(); cm[k]=gc(m[1].trim())}});
        return `<tr><td><b>${r[0]}</b></td><td>${cp(r[1])}</td><td style="min-width:220px" title="${esc(r[2])}">${dtChainStates(cm,null,r[0])}</td>
        <td style="min-width:150px">${evLadder(r[3])}</td><td>${/P0/.test(r[4])?`<b style="color:var(--bad)">${r[4]}</b>`:r[4]}</td></tr>`}).join('')}</table>
      <h3 style="margin-top:14px">38 台部件等级一览</h3>
      <table><tr><th>机组</th><th>部件状态链 <span class='small' style='font-weight:400;color:var(--muted)'>(主承前·主承后·齿轮箱三级·发电机DE/NDE; 悬停看逐件等级)</span></th><th>综合</th><th>行动</th></tr>
      ${V.grades.map(g=>`<tr><td><b>${g.t}</b></td>
        <td style="min-width:220px" title="主轴承前 ${g.主轴承前} · 主轴承后 ${g.主轴承后} · 齿轮箱 ${g.齿轮箱} · 发电机 ${g.发电机}">${dtChainStates({'主轴承前':gc(g.主轴承前),'主轴承后':gc(g.主轴承后),'齿轮箱':gc(g.齿轮箱),'发电机':gc(g.发电机)},null,g.t)}</td>
        <td>${cp(g.综合)}</td><td class="small">${g.行动}</td></tr>`).join('')}</table>
      <div class="small" style="margin-top:12px;padding:10px;border:1px solid var(--line);border-radius:8px">
        <b>口径说明</b> 本表=windcms 状态管理判级(含标量趋势与数据可判性); 融合矩阵/逐台结论=振动线定谳链转录(候选以上)。两口径差异台:
        仅本表列 ${V.diff.only_cms.join(', ')||'无'} (多为标量发作/数据不可判, 未到定谳链); 仅定谳链列 ${V.diff.only_handoff.join(', ')||'无'} (预警级在察, 状态管理未升)。
      </div>
      <p class="small" style="margin-top:10px;color:var(--muted)">谱图 · 波形 · 判据 · 工作台等分析功能在独立 windcms 系统 →
        <a class="tl" href="http://localhost:8030/index.html" target="_blank">打开 windcms ↗</a> (未启动时 <a class="tl" href="/windcms/index.html" target="_blank">静态版</a>)</p>
    </div>`;
    }
    }
  }
  }
  if(TAB==='系统维护'){
    h+=`<div class="eyebrow">系统维护 · 数据输入与更新端口</div>
      <div id="mtOut"><div class="card"><p class="small">盘点中…</p></div></div>`;
    document.getElementById('root').innerHTML=h;
    document.getElementById('foot').innerHTML=d.note;
    fetch('/api/maint_survey').then(r=>r.json()).then(md=>{
      const el=document.getElementById('mtOut'); if(el) el.innerHTML=maintCards(md);
    }).catch(e=>{const el=document.getElementById('mtOut'); if(el) el.innerHTML=`<div class="card"><p class="small" style="color:var(--bad)">盘点失败: ${e.message}</p></div>`});
    return;
  }

  if(TAB==='检修助手'){
    // 三窗并列 (2026-08-28 用户令): 抢修 / 预防性维护 / 故障树 各有自己的输入与结果,
    // 不再共用一个框切换 — 实际用法是三者对照着看。
    const SYSOPT=['变桨','偏航','主轴承','齿轮箱','发电机','变流器','塔架与基础','主控与传感网'];
    // ★示例码原来写死 5 个, 其中 64000 在本体里 name 是字符串 "nan" (pandas NaN 漏成字符串,
    //   555 个码里有 17 个是这样) —— 页面把一条垃圾记录当"常查"推荐, 点了必然空白。
    //   改为**按本场实际计数**取: 只从 (本场出现过 ∧ 名字有效) 的 309 个里选。
    //   写死清单迟早与数据脱节, 数据驱动才不会推荐自己答不上的东西。
    const HOT=(window.__HOTCODES && window.__HOTCODES.length) ? window.__HOTCODES
              : ['3225','3130','13902','10105','3224'];
    const btn=m=>`<button onclick="asstGo('${m}')" style="cursor:pointer;flex:none;padding:7px 18px;border-radius:7px;
      border:1px solid var(--accent);background:var(--accent);color:#fff;font-weight:600;font-size:13px">查询</button>`;
    h+=`<div class="eyebrow">检修助手 · 手册、报警与工单证据查询</div>`;

    h+=`<div class="card mb"><h3>抢修 <span class="small" style="font-weight:400;color:var(--muted)">报警码 → 失效模式 → 手册分步处置 → 历史工单</span></h3>
      <div style="display:flex;gap:8px;align-items:center;flex-wrap:wrap">
        <input id="asstIn_fault" placeholder="报警码, 如 3225 / 3130 / 13902" value="${window.ASSTV||''}"
          onkeydown="if(event.key==='Enter')asstGo('fault')"
          style="flex:1 1 220px;min-width:180px;padding:7px 12px;border:1px solid var(--line);border-radius:7px;background:var(--panel);color:var(--ink);font-size:13px">
        ${btn('fault')}
        <span class="small" style="color:var(--muted);flex:none">常查 ${HOT.map(c=>
          `<a class="tl" href="#" onclick="document.getElementById('asstIn_fault').value='${c}';asstGo('fault');return false">${c}</a>`).join(' · ')}</span></div>
      <div id="asstOut_fault" style="margin-top:10px"></div></div>`;

    h+=`<div class="card mb"><h3>预防性维护 <span class="small" style="font-weight:400;color:var(--muted)">系统 → 失效模式 → 年度任务 → WI 步骤</span></h3>
      <div style="display:flex;gap:8px;align-items:center;flex-wrap:wrap">
        <select id="asstIn_prev" style="flex:1 1 200px;min-width:170px;padding:7px 10px;border:1px solid var(--line);border-radius:7px;background:var(--panel);color:var(--ink);font-size:13px">
          ${SYSOPT.map(x=>`<option>${x}</option>`).join('')}</select>
        ${btn('prev')}</div>
      <div id="asstOut_prev" style="margin-top:10px"></div></div>`;

    h+=`<div class="card mb"><h3>故障树 <span class="small" style="font-weight:400;color:var(--muted)">系统失效模式按实证量排 + 部件级原因</span></h3>
      <div style="display:flex;gap:8px;align-items:center;flex-wrap:wrap">
        <select id="asstIn_tree" style="flex:1 1 200px;min-width:170px;padding:7px 10px;border:1px solid var(--line);border-radius:7px;background:var(--panel);color:var(--ink);font-size:13px">
          ${SYSOPT.map(x=>`<option>${x}</option>`).join('')}</select>
        ${btn('tree')}</div>
      <div id="asstOut_tree" style="margin-top:10px"></div></div>`;

    document.getElementById('root').innerHTML=h;
    document.getElementById('foot').innerHTML=d.note;
    for(const m of ['fault','prev','tree']){
      const c=(window.ASSTCACHE3||{})[m], el=document.getElementById('asstOut_'+m);
      if(c&&el) el.innerHTML=c;
    }
    return;
  }

  if(TAB==='检修决策'){
    if(!window.MAINTSTD){ fetch('/api/maint_std').then(r=>r.json()).then(d=>{window.MAINTSTD=d; render()}); }
    h+=maintStd(window.MAINTSTD);
    if(!window.MAINTFW){ fetch('/api/maint_framework').then(r=>r.json()).then(d=>{window.MAINTFW=d; render()}); }
    h+=maintFw(window.MAINTFW);
    if(!window.DQF){ fetch('/api/dq_findings').then(r=>r.json()).then(d=>{window.DQF=d; render()}); }
    h+=dqFindings(window.DQF);
    h+=`<div class="eyebrow">检修决策 · ontology 展现的窗口 (语义本体 + dsh 编排; 推理无界, 结论受闸)</div>`;
    const CATS={
      '设备类':{hint:'设备状态/机制/判级 — 从机组档案、对象查询与机制检索取证',
        qs:['29号机组现在什么状态、为什么、该怎么办?','全场哪些机组有报警级或定论级判级?逐台列出并注明审级','失效机制库里有哪些机制族?各涉及哪些机组、状态如何?']},
      '检修排程决策':{hint:'排期沙盘/天气窗/验收树 — ont_scenario/ont_get 取证',
        qs:['29号修泵什么时候做最合适?对比各情景的损失与风险','未来几个月哪些月份适合安排CTV检修和吊装作业?依据历史可作业窗','29号修好之后按什么判据验收?三分支分别是什么条件?']},
      '损失分析':{hint:'当前3个月损失/未来损失 — ont_loss/ont_scenario 取证, 金额带电价区间口径',
        qs:['近3个月全场损失结构如何?分状态和分机组说, 电量与金额都给','29号如果拖到主轴承失效, 未来损失量级是多少?与现在修对比','限电常态化对检修机会成本有什么影响?']},
      '安全风险预测':{hint:'风险敞口/劣化趋势/盲区 — ont_risk/ont_mechanism_search 取证, 未列≠正常',
        qs:['当前哪些机组风险在上升需要重点盯?联动监视读数如何?','监测有哪些盲区?哪些"没报警"不等于正常?','29号轴承正在承受金属接触, 风险敞口怎么评估?']}};
    h+=`<div id="dbase"><div class="card mb"><div class="skel" style="width:40%"></div><div class="skel" style="width:65%;margin-top:8px"></div></div></div>`;
    setTimeout(loadDbase, 200);
    if(!window.ASKCAT) window.ASKCAT='设备类';
    h+=`<div style="display:flex;gap:8px;margin-bottom:12px;flex-wrap:wrap">`+Object.keys(CATS).map(c=>{
      const on=c===ASKCAT;
      return `<button onclick="ASKCAT='${c}';render()" style="cursor:pointer;padding:8px 16px;border-radius:20px;border:1px solid ${on?'var(--accent)':'var(--line)'};background:${on?'var(--accent)':'var(--panel)'};color:${on?'#fff':'var(--ink)'};font-weight:${on?'600':'400'}">${c}</button>`}).join('')+`</div>`;
    const cat=CATS[ASKCAT];
    h+=`<div class="card mb"><h3>${ASKCAT} · 常用问题 (点即问, 或下方自由输入)</h3>
    <p class="small">${cat.hint}。答案句句带[对象id]溯源+接地闸核验; 判级只转述本体原文带审级, 模型零判级权。</p>`;
    cat.qs.forEach(q=>{h+=`<div class="small" style="cursor:pointer;border:1px solid var(--line);border-radius:8px;padding:8px 12px;margin-bottom:8px" onclick="document.getElementById('askq').value=this.textContent;askGo()">${q}</div>`});
    h+=`<div style="display:flex;gap:8px;flex-wrap:wrap;margin:10px 0">
      <input id="askq" type="text" placeholder="自由提问 (${ASKCAT})" style="flex:1;min-width:280px;padding:8px 12px;border:1px solid var(--line);border-radius:8px;background:var(--panel);color:var(--ink)">
      <select id="askm" onchange="mdlNote()" style="padding:8px;border:1px solid var(--line);border-radius:8px;background:var(--panel);color:var(--ink)">
        <option value="">…</option>
      </select>
      <span id="mdlnote" class="small" style="color:var(--muted)"></span>
      <label class="small" style="cursor:pointer;white-space:nowrap" title="由另一本地模型基于同一份证据复核; 同一模型自审无法构成独立校验">
        <input type="checkbox" id="askxrev"> 交叉审核 <span style="color:var(--muted)">(DeepSeek 14B 互审, +约 1 分钟)</span></label>
      <button onclick="askGo()" style="cursor:pointer;padding:8px 16px;border-radius:8px;border:1px solid var(--accent);background:var(--accent);color:#fff;font-weight:600">提问</button>
    </div>
    <div id="askout" class="small">空闲 — 点常用问题或输入后提问 (实测: 8b 单台问约 45 秒 / 复合问题约 50~90 秒, 27b/30b 约 2~4 分钟, deepseek 走 dsh 约 2~6 分钟; 串行一次一问; 本地模型零外发)。</div></div>`;
    setTimeout(askPoll, 300); setTimeout(askModelInit, 320);   // 填下拉后 askModelInit 内部会调 mdlNote
  }
  if(TAB==='故障统计'){
    const _pt=(d.faults.partial||[]);
    h+=`<div class="eyebrow">故障统计与可靠性</div>`
      +winBanner('故障统计', d.win, _pt.length?`<span style="color:var(--warn)">窗内 ${_pt.join('/')} 数据不满月(覆盖 ${Math.round(d.faults.cov_min*100)}%), 月度图已按天归一</span>`:'');
  }
  if(TAB==='电量算账') h+=`<div class="eyebrow">电量算账</div>`+winBanner('电量算账', d.win, '');
  if(TAB==='汇报定制'){ document.getElementById('root').innerHTML=renderReport(d);
    document.getElementById('foot').innerHTML=d.note; return; }
  h+=`<div class="grid">`;
  if(TAB==='故障统计'){
  // 排布 (2026-08-28 用户令: 界面优化排布)。原来 9 张卡一条龙堆着, 报警面与停机面混排,
  // 且三张卡硬设 grid-column:1/-1 — 窄视口本来就单列, 全宽设置只在宽屏起反作用(挡住并排)。
  // 现按经典可靠性报告顺序分两节: 报警面 总量→关键少数→结构→台级→季节; 停机面 结构→归因→台级。
  // 只有"需要横向空间才读得出结构"的图保留全宽 (四象限散点 / RAM 象限), 其余交给 auto-fit:
  // 窄屏自然单列(帕累托 720 viewBox 几乎 1:1), 宽屏自动两列。
  const F2=d.faults, _pm=(F2.partial||[]);
  const sec=(t,n)=>`<div class="eyebrow" style="grid-column:1/-1;margin-top:4px">${t}<span
    style="text-transform:none;letter-spacing:0;font-weight:400;color:var(--muted)">${n}</span></div>`;

  h+=sec('报警面', `${F2.total.toLocaleString()} 条 · ${F2.n_codes} 个码 · 窗 ${d.win}`);
  h+=`<div class="card" style="grid-column:1/-1"><h3>月度故障率</h3>${rateChart(F2.monthly)}
    <p class="small" style="color:var(--muted);margin-top:6px">
    <b>柱高=日均条数, 不是月总数</b> — ${_pm.length?`本窗 ${_pm.join('/')} 数据不满月(灰虚线柱), 直接比月总数会读反`:'各月覆盖完整'}。
    ${_pm.length?`实测: ${_pm[0]} 总数最低但日均 ${F2.monthly.per_day[F2.monthly.months.indexOf(_pm[0])]} 条/日 = 全窗前列。`:''}</p></div>`;
  h+=`<div class="card"><h3>帕累托 · 按发生条数</h3>
    ${paretoChart(F2.pareto_n, ' 条', '条数=发生频次, 不反映影响程度 — 高频短时报警码(信号抖动或重复触发)排序靠前')}</div>`;
  h+=`<div class="card"><h3>帕累托 · 按持续时长</h3>
    ${paretoChart(F2.pareto_d, ' h', '时长=闩锁口径(复位−激活), 只作排序参考不作停机时长')}</div>`;
  h+=`<div class="card" style="grid-column:1/-1"><h3>故障模式四象限 · 条数 × 单次时长</h3>
    ${quadChart(F2.quad)}
    <p class="small" style="color:var(--muted);margin-top:6px">窗内共 ${F2.n_codes} 个码, 图上为条数前 ${F2.quad.length} 个。
    ${_pm.length?`<span style="color:var(--warn)">窗含不满月 ${_pm.join('/')} (覆盖 ${Math.round(F2.cov_min*100)}%), 条数为原始累计未按天归一。</span> `:''}
    点面积表示影响台数, 大点为批次共性、小点为单台; 竖分界取条数中位, 横分界取 10min (一个SCADA采样格)。
    <b>右下角的码不要按条数排优先级</b> — 属重复触发, 非硬件故障。上面两张帕累托对照看即此图的两条投影。</p></div>`;
  const maxT=Math.max(1,...F2.per_t.map(x=>x.v));
  h+=`<div class="card"><h3>台级分布 · 报警条数 top${F2.per_t.length}</h3>
    <table><tr><th style="width:70px">机组</th><th class="barcell">条数</th><th class="num" style="width:80px">占全场</th></tr>
    ${F2.per_t.map(x=>`<tr><td><a class="tl" href="/turbine/${x.k}"><b>${x.k.replace('WTG','')}#</b></a></td>
      <td class="barcell"><i class="bar" style="width:${Math.round(x.v/maxT*90)}px;--c:${x.v/maxT>0.6?'var(--bad)':'var(--accent)'}"></i><span class="cnt">${x.v.toLocaleString()}</span></td>
      <td class="num small">${(x.v/F2.total*100).toFixed(1)}%</td></tr>`).join('')}</table>
    <p class="small" style="color:var(--muted);margin-top:6px">全场合计 ${F2.total.toLocaleString()} 条 · 单台占比高须先核查是否为单一报警码重复触发</p></div>`;
  if(d.m8&&d.m8.err) h+=blockErr('m8', d.m8.err);
  if(m) h+=drawFig({kind:'multiline',title:'故障季节性 · top 报警族 × 月',unit:'条/月',xlab:'月',
      months:d.m8.seasonal[0].months, series:d.m8.seasonal.slice(0,4).map(x=>({name:x.name.slice(0,16),vals:x.vals})),
      note:'全程 19 个月 (跨 2 冬 1 夏); 未做 χ² 显著性检验前为【参考级】, 只看形态不作季节归因'});

  if(m){
    const RT=(d.rel&&!d.rel.err)?d.rel:null;
    h+=sec('停机面', `${m.停机总时长h?m.停机总时长h.toLocaleString():''}h · ${m.停机事件数||''} 起 · 口径 ≥1h 段, 不含调度令`);
    if(RT) h+=`<div class="card" style="grid-column:1/-1"><h3>可靠性 × 可维修性 · 部件象限</h3>
      ${ramChart(RT.表)}
      <p class="small" style="color:var(--muted);margin-top:6px">
      按停机时长排序的表看不出这层结构: <b>同样 500h 的停机, "频发易修"要查根因、"罕发难修"要备件, 处置相反</b>。
      设备类停机 ${RT.设备类停机h}h / 外部类 ${RT.外部类停机h}h (外部=电网·风况·运维操作, 不计设备可靠性)。
      海上机组 MDT 普遍偏高是<b>交通窗口</b>决定的, 不等于维修本身慢 — 跨场比 MDT 须同为海上。</p>
      <div style="margin-top:12px">${attribBar(RT.表, RT.总停机h)}</div>
      <p class="small" style="color:var(--muted);margin-top:2px">
      归因覆盖: "无记录停机" ${(RT.表.find(x=>x.部件==='无记录停机')||{}).停机时长h||0}h 是全场最大单项,
      因不给 MTBF 而在上图中<b>不出现</b> — 它不是"没有故障", 是"没归上因"。
      口径为段起点±30min 首发码。<b>缺口成因待定</b>: 此前写的"98% 的段在前 72h 内有报警 ⇒ 长停远窗"
      不成立 — 前 72h 有报警不等于该报警与本段停机有因果 (双模审 2026-08-28 逮)。
      要定成因须改判"段起止是否落在某条报警的持续区间内", 未做之前只报缺口不报原因。</p></div>`;
    h+=`<div class="card"><h3>停机归因帕累托</h3>
      ${paretoChart(d.m8.stop_pareto.map(x=>({k:x.k.split(';')[0].slice(0,26), v:x.h})), ' h',
        '按停机时长; 事件次数见悬停')}
      <p class="small" style="color:var(--muted);margin-top:4px">${m.口径}</p></div>`;
    h+=`<div class="card"><h3>台级停机 top${m.台级top.length}</h3>
      <table><tr><th style="width:64px">机组</th><th class="barcell">停机时长</th><th class="num" style="width:56px">次数</th></tr>
      ${(()=>{const mx=Math.max(...m.台级top.map(x=>x.时长h));return m.台级top.map(x=>`<tr>
        <td><a class="tl" href="/turbine/${x.t}"><b>${x.t.replace('WTG','')}#</b></a></td>
        <td class="barcell"><i class="bar" style="width:${Math.round(x.时长h/mx*92)}px;--c:${x.时长h/mx>0.6?'var(--bad)':'var(--accent)'}"></i><span class="cnt">${x.时长h}h</span></td>
        <td class="num small">${x.次}</td></tr>`).join('')})()}</table>
      <p class="small" style="color:var(--muted);margin-top:6px">停机时长高 ≠ 设备差 — 须先看归因里外部类占比 (调度令已剔除)</p></div>`;
  }
  }
  if(TAB==='电量算账'){
  const E=d.control.energy;
  if(E) h+=`<div class="kpis" style="grid-column:1/-1;margin-bottom:0">
    <div class="kpi"><b>${E.theo.toLocaleString()}<span> MWh</span></b><span>理论可发 (实际+损失)</span></div>
    <div class="kpi ok"><b>${E.act.toLocaleString()}<span> MWh</span></b><span>实际上网 · 等效满发 ${E.eflh.toLocaleString()} h</span></div>
    <div class="kpi ${E.loss_pct>=10?'warn':''}"><b>${E.loss_pct}<span>%</span></b><span>损失率 · ${E.loss.toLocaleString()} MWh</span></div>
    <div class="kpi ${E.cap_ok?'ok':'bad'}"><b>${E.cap_ok?'通过':'不通过'}</b><span>能量守恒核 · 理论 ${E.cap_ok?'<':'≥'} 全额定上限 ${E.cap.toLocaleString()}</span></div></div>`;
  if(E) h+=`<div class="card" style="grid-column:1/-1"><h3>电量平衡 <span class="small" style="font-weight:400;color:var(--muted)">窗 ${d.win}</span></h3>
    ${waterfall(E)}</div>`;
  if(E) h+=`<div class="card"><h3>损失责任分账</h3>${blameBar(E)}
    <p class="small" style="color:var(--muted);margin-top:6px"><b>最大一笔是限电不是故障。</b>
    进设备考核的只有"故障与检修停机" ${Math.round((E.items.find(x=>x.k==='停机')||{}).loss||0).toLocaleString()} MWh;
    限电属交易与调度侧, 2026 起交易策略主导, 少发未必是弃风。</p></div>`;
  h+=`<div class="card"><h3>工况态明细 <span class="small" style="font-weight:400;color:var(--muted)">窗 ${d.win}</span></h3>
    <table><tr><th>工况态</th><th class="barcell">时长占比</th><th class="num" style="width:76px">损失MWh</th></tr>`;
  const _mxp=Math.max(...d.control.states.map(x=>x.pct));
  d.control.states.forEach(x=>{h+=`<tr><td class="small">${LOSSPLAIN[x.k]||x.k}</td>
    <td class="barcell"><i class="bar" style="width:${Math.round(x.pct/_mxp*84)}px;--c:${x.k.indexOf('停机')>=0&&x.k.indexOf('调度')<0?'var(--bad)':'var(--accent)'}"></i><span class="cnt">${x.pct}% · ${Math.round(x.h).toLocaleString()}h</span></td>
    <td class="num small">${Math.round(x.loss).toLocaleString()}</td></tr>`});
  h+=`</table><p class="small" style="color:var(--muted)">${d.control.anchors}
    <br>控制参数一致性与曲线欠发筛查在<b>固定干净窗</b>判, 已迁入「发电性能」页 — 本页只出当期电量账。</p></div>`;
  }

  h+=`</div>`;
  document.getElementById('root').innerHTML=h;
  document.getElementById('foot').innerHTML=d.note;
}
async function renderCurves(){
  const root=document.getElementById('root');
  if(!CURVES){root.innerHTML='<div class="card"><h3>特性曲线多镜头</h3><p class="small">正在计算七个镜头 (剥限电 · 逐档中位 · 同型机群残差)…</p><div class="skel" style="width:60%;margin-top:10px"></div><div class="skel" style="width:80%;margin-top:8px"></div></div>';
    CURVES=await (await fetch('/api/curves')).json();}
  const d=CURVES; let h='';
  // 物理闸: 表格窄屏崩版 (2026-08-28 用户内部设计审逮) → 响应式三卡
  const P=d.physics, L=P['λ叶尖速比'];
  const pg=(name,crit,meas,verdict)=>`<div style="flex:1;min-width:220px;border:1px solid var(--line);border-left:3px solid var(--ok);border-radius:10px;padding:12px 14px;background:var(--panel)">
    <div style="font-weight:600">${name} <span class="small" style="color:var(--muted);font-weight:400">${crit}</span></div>
    <div class="num" style="margin:6px 0;font-size:15px">${meas}</div>
    <div class="small" style="color:var(--muted)">${verdict}</div></div>`;
  // (第一性原理硬闸卡撤 — 2026-08-28 用户令: 数据分析原则不出现在交付界面; 校验仍在后端跑, 只是不展示)
  h+=`<div class="eyebrow">特性曲线与控制参数</div>`+winBanner('发电性能','','');
  // 控制参数一致性与曲线欠发候选自「控制策略」页迁入 (2026-08-28 用户裁): 三者同为固定干净窗,
  // 放在跟随窗的电量页里会造成一页两窗 — 迁过来后两页各自单窗。
  const _D=(typeof D!=='undefined'&&D)?D:null;       // D 是块作用域变量, 不挂 window
  const F=(_D&&_D.control)?_D.control:null, M9=(_D&&_D.m9&&!_D.m9.err)?_D.m9:null;
  if(_D&&_D.m9&&_D.m9.err) h+=blockErr('m9', _D.m9.err);
  if(M9){
    const p9=M9['P封顶'],w9=M9['ω封顶'],b9=M9['β_schedule'];
    h+=`<div class="card mb" style="grid-column:1/-1"><h3>控制参数一致性 <span class="small" style="font-weight:400;color:var(--muted)">窗 ${M9['窗']}</span></h3>
      <div style="display:flex;flex-wrap:wrap;gap:18px">
        <div style="flex:1 1 300px;min-width:280px">
          <div class="small" style="font-weight:600;margin-bottom:4px">封顶参数落位</div>
          ${capAxis(p9, w9)}
          <p class="small" style="color:var(--muted);margin-top:4px"><b>台数落在几个离散位置上, 不是连成一片</b> —
          这是配置/版本差异的形状; 磨损或工况引起的会是连续散布。两轴各自成组且分组不同台 ⇒ 参数级差异, 成因须配置台账。</p>
        </div>
        <div style="flex:1 1 300px;min-width:280px">
          <div class="small" style="font-weight:600;margin-bottom:4px">桨距调度同档差</div>
          ${betaBar(b9)}
          <p class="small" style="color:var(--muted);margin-top:4px">同一功率档下的桨角与全场中位之差。
          ${b9.离群.map(x=>'<a class="tl" href="/turbine/'+x.t+'">'+x.t.replace('WTG','')+'#</a>').join(' / ')} 偏离达中位的
          ${Math.round(Math.max(...b9.离群.map(x=>x.平均偏))/Math.max(b9.全场同档差中位,0.01))} ${TIMES_SFX} → ${b9.判}</p>
          <div class="small" style="font-weight:600;margin:12px 0 4px">尺子巡检 · 极差 ÷ σ</div>
          ${rulerBar(M9['尺子'])}
          <p class="small" style="color:var(--muted);margin-top:4px">判据自身的分辨力。38 台正态抽样的极差期望约 3.7σ,
          <b>明显超出即分布非单峰</b> — 与左图的分组互为印证; 落在期望附近的轴(额定桨角)则是连续分布。</p>
        </div>
      </div></div>`;
  }
  if(F&&F.curve){
    h+=`<div class="card mb"><h3>曲线欠发筛查 <span class="small" style="font-weight:400;color:var(--muted)">${F.curve.note} · σ=${F.sigma||F.curve.sigma}%</span></h3>
    <p class="small">${F.curve.cands.map(c=>'<a class="tl" href="/turbine/'+c.t+'">'+c.t.replace('WTG','')+'#</a> '+c.dev+'% '+c.判).join(' ｜ ')||'无候选'}</p></div>`;
  }
  h+=`<div class="grid">`; d.figs.forEach(f=>{h+=drawFig(f)}); h+=`</div>`;
  root.innerHTML=h;
  document.getElementById('foot').innerHTML=d.note;
}
reload('2026年');
</script></body></html>"""

PAGE_PROBLEM = """<!doctype html><html lang="zh" data-theme="light"><head><meta charset="utf-8"><script>(function(){try{var q=new URLSearchParams(location.search).get("theme");if(q){localStorage.setItem("windscada_theme",q)}var t=q||"light";document.documentElement.setAttribute("data-theme",t)}catch(e){}})();</script><meta name="viewport" content="width=device-width,initial-scale=1">
<title>%T% %SYS% · windscada</title><style>%CSS%</style></head><body>
<header><h1>%T% · %SYS%</h1><span id="winbox"></span>
<a class="badge" href="/">← 总览</a><a class="badge" href="/turbine/%T%">本台全部问题</a></header>
<div id="one">加载中…</div>
<footer>单问题视图: 只呈现本台该系统的判据与证据图, 不带出其他系统</footer>
<script>%JS%
const T='%T%', SYS='%SYS%';
async function reload(win){
  const r=await fetch('/api/problem?t='+T+'&sys='+encodeURIComponent(SYS)+'&win='+encodeURIComponent(win)); const d=await r.json();
  document.getElementById('winbox').innerHTML=winSel(win);
  let h='';
  if(!d.problems.length){h='<div class="card"><p class="empty">该系统在判级窗内无非常态。</p></div>'}
  d.problems.forEach(p=>{
    h+=`<div class="card mb"><h3>${p.sys} ${chip(p.状态)}</h3><p style="margin-bottom:8px">${p.依据}</p></div>`;
    if(p.figs.length){h+=`<div class="grid">`; p.figs.forEach(f=>{h+=drawFig(f)}); h+=`</div>`}
    h+=ordersHtml(p.orders);
  });
  document.getElementById('one').innerHTML=h;
}
reload('2026年');
</script></body></html>"""

PAGE_TURBINE = """<!doctype html><html lang="zh" data-theme="light"><head><meta charset="utf-8"><script>(function(){try{var q=new URLSearchParams(location.search).get("theme");if(q){localStorage.setItem("windscada_theme",q)}var t=q||"light";document.documentElement.setAttribute("data-theme",t)}catch(e){}})();</script><meta name="viewport" content="width=device-width,initial-scale=1">
<title>%T% · windscada</title><style>%CSS%</style></head><body>
<header><h1>%T% <a href="/">← 工作台</a></h1><span id="winbox"></span><span class="badge">只显示有问题的系统; 无问题不出图</span></header>
<div id="probs">加载中…</div>
<div class="card" style="margin-top:14px"><h3>台内即时查询 (任一契约通道 × 时间窗 × 聚合)</h3>
<div style="display:flex;gap:8px;flex-wrap:wrap;margin-bottom:8px">
<select id="qch" style="max-width:340px"></select>
<select id="qagg"><option value="med">月中位</option><option value="dutyd">月duty(秒/日)</option><option value="daily">逐日中位</option></select>
<button onclick="runQ()">出图</button><span class="small" id="qmsg"></span></div>
<div id="qfig"></div></div>
<footer>边界: 叶片/塔架无SCADA轴 ｜ 对风误差=wrap(风向−机舱位置) vane口径; 死区/速率需≤30s数据=INSUFFICIENT ｜ 判级窗: 变桨/偏航/蓄能/温度判级=近90日固定, 曲线=2025H2; 图内月序=所选时间窗 ｜ P级归综合报告线</footer>
<script>%JS%
const T='%T%';let WIN='2026年';
async function reload(win){WIN=win;
  const r=await fetch('/api/turbine?t='+T+'&win='+encodeURIComponent(win)); const d=await r.json();
  document.getElementById('winbox').innerHTML=winSel(win);
  let h='';
  if(!d.problems.length) h='<div class="card"><p class="empty">各系统在判级窗内均无非常态 —— 可用下方即时查询查看任意契约通道。</p></div>';
  d.problems.forEach(p=>{
    h+=`<div class="card mb"><h3>${p.sys} ${chip(p.状态)}</h3><p class="small" style="margin-bottom:8px">${p.依据}</p>`;
    if(p.figs.length){h+=`<div class="grid">`; p.figs.forEach(f=>{h+=drawFig(f)}); h+=`</div>`}
    h+=`</div>`+ordersHtml(p.orders)});
  document.getElementById('probs').innerHTML=h;
}
async function loadCh(){const r=await fetch('/api/channels');const d=await r.json();
  let o='';for(const [g,cols] of Object.entries(d)){o+=`<optgroup label="${g}">`+cols.map(c=>`<option value="${c.code}">${c.cn}</option>`).join('')+`</optgroup>`}
  document.getElementById('qch').innerHTML=o}
async function runQ(){document.getElementById('qmsg').textContent='计算中…';
  const ch=document.getElementById('qch').value, agg=document.getElementById('qagg').value;
  const r=await fetch(`/api/query?t=${T}&ch=${encodeURIComponent(ch)}&win=${encodeURIComponent(WIN)}&agg=${agg}`);
  const f=await r.json(); document.getElementById('qmsg').textContent=f.err||'';
  document.getElementById('qfig').innerHTML=f.err?'':drawFig(f)}
reload(WIN);loadCh();
</script></body></html>"""

class H(BaseHTTPRequestHandler):
    def log_message(self, *a): pass
    def _send(self, body, ctype='text/html; charset=utf-8', code=200):
        if 'text/html' in ctype and not self.path.startswith('/v2'):   # 2026-09-06 用户批: /v2 = detail_style_baseline, 不注入 unified-review 样式/导航条 (基线令牌须等于门户)
            from src.windscada.design import GUANLAN_REVIEW_CSS
            text = body.decode('utf-8') if isinstance(body, bytes) else body
            text = text.replace('</header>', '</header><nav class="action-path" aria-label="页面操作"><a href="http://127.0.0.1:18084/观澜_如东样板_门户_单文件.html#index" target="_top">← 返回观澜门户</a><a href="/">分析总览 / 重新选择</a></nav>', 1)
            if '</head>' in text:
                body = text.replace('</head>', '<style id="guanlan-unified-review-v1">' + GUANLAN_REVIEW_CSS + '</style></head>', 1)
        b = body.encode('utf-8') if isinstance(body, str) else body
        self.send_response(code)
        self.send_header('Content-Type', ctype)
        self.send_header('Content-Length', str(len(b)))
        self.end_headers()
        self.wfile.write(b)

    def do_POST(self):
        try:
            u = urllib.parse.urlparse(self.path)
            n = int(self.headers.get('Content-Length', 0))
            body = json.loads(self.rfile.read(n) or b'{}')
            if u.path == '/api/ask':
                self._send(_jdump(ask_start(body.get('q', ''), body.get('model', 'qwen3:8b'), body.get('cat', ''),
                                            body.get('xrev', False), body.get('lang', 'zh'), body.get('display_q', '')),
                                  ensure_ascii=False), 'application/json; charset=utf-8')
            else:
                self._send('404', code=404)
        except Exception as e:
            self._send(_jdump(dict(err=str(e)[:300]), ensure_ascii=False), 'application/json; charset=utf-8', 500)

    def do_GET(self):
        try:
            u = urllib.parse.urlparse(self.path)
            # encoding='utf-8' 显式给定 (默认 latin-1 会把中文参数解成乱码 — "齿轮箱"→"齿轮箱",
            # 浏览器 encodeURIComponent 路径侥幸正常, curl/直传中文即崩; 2026-08-28 四链接口实逮)
            q = dict(urllib.parse.parse_qsl(u.query, encoding='utf-8', errors='replace'))
            _REQ.lang = q.get('lang', '')      # 本请求的语言, _jdump 出口据此投影文本层
            _REQ.keep_orig = q.get('keep') == '1'   # v2: 译不出留原文, 不写 [translation pending]
            win = q.get('win', '2026年')
            if u.path == '/':
                _pg = PAGE_FLEET.replace('%CSS%', BASE_CSS).replace('%JS%', CHART_JS)
                self._send(_en_page(_pg))
            elif u.path == '/v2':
                # 新前端 (2026-09-03 用户裁"完全重新做一套, 在原来的基础上"): 同一套 /api/*,
                # 表现层双语原生 —— 不经 _en_page/ui_en 那三层事后翻译。迁移期与 / 并存,
                # 页签逐个搬完后再切默认。
                from src.windscada.ui import build as _v2
                self._send(_v2.render('en' if q.get('lang') == 'en' else 'zh'))
            elif u.path == '/v2/snapshot':
                # 新版单文件快照 (静态站用): 接口响应烤进页面, 拦截器实时优先快照兜底。
                # 取数函数与在线 API 同一实现; 英文走同一套 _redact → _proj 投影 (keep=1 留原文)。
                from src.windscada.ui import snapshot as _snap
                from src.ontology import mcp_server as _omc
                import json as _j3, pathlib as _p3
                def _codes():
                    db = _j3.loads(_p3.Path(_omc.OBJ_PATH).read_text(encoding='utf-8'))
                    return sorted(k.split('/')[-1] for k in db if k.startswith('alarmcode/'))
                _ctx = dict(fleet_view=fleet_view, curve_view=curve_view, vibcms_results=vibcms_results,
                            survey=__import__('src.ontology.maintenance', fromlist=['survey']).survey,
                            ont=_omc, alarm_codes=_codes, turbine_problems=turbine_problems,
                            single_problem=single_problem, _redact=_redact, _jclean=_jclean, _proj=_proj, _REQ=_REQ)
                _v2_lang = 'en' if q.get('lang') == 'en' else 'zh'
                _html, _rep = _snap.bake(_v2_lang, _ctx,
                                          peer=q.get('peer', ''), noindex=q.get('noindex') == '1',
                                          slim=(q.get('slim') != '0' if _v2_lang == 'en' else False))
                print('[v2 snapshot] %s' % _j3.dumps(_rep, ensure_ascii=False)[:600], flush=True)
                self._send(_html)
            elif u.path.startswith('/turbine/'):
                t = u.path.rsplit('/', 1)[1]
                _pg = PAGE_TURBINE.replace('%CSS%', BASE_CSS).replace('%JS%', CHART_JS).replace('%T%', t)
                self._send(_en_page(_pg))
            elif u.path == '/api/maint_survey':
                try:
                    from src.ontology.maintenance import survey as _sv
                    r = dict(rows=_sv())
                except Exception as e:
                    r = dict(rows=[], error=f'维护面盘点失败: {e}'[:200])
                self._send(_jdump(r, ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/ont_chain':
                try:
                    from src.ontology import mcp_server as _om
                    kind = q.get('kind', 'fault')
                    fn = {'fault': lambda: _om.ont_chain_fault(code=q.get('code', '')),
                          'prev': lambda: _om.ont_chain_preventive(system=q.get('system', '')),
                          'tree': lambda: _om.ont_fault_tree(system=q.get('system', '')),
                          'plan': lambda: _om.ont_maint_plan(top=q.get('top', 10)),
                          'doc': lambda: _om.ont_doc_search(keyword=q.get('keyword', ''), kind=q.get('dkind', ''))}
                    r = fn[kind]() if kind in fn else dict(text=f'未知链 {kind}', error=True)
                except Exception as e:
                    r = dict(text=f'本体查询失败: {e}'[:200], error=True)
                self._send(_jdump(r, ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/maint_std':
                # 运维标准四判据 + 成熟度评分 (docs/如东运维标准化设计.md)
                try:
                    import json as _j, pathlib as _p
                    from src.windscada.maint import standards as _st
                    _db = _j.loads(_P.objects_json()
                                   .read_text(encoding='utf-8'))
                    _wo = [(v.get('props') or {}) for k, v in _db.items()
                           if k.startswith('workorder/')]
                    _r = _st.run_all(_wo)
                    _r['score'] = _st.score(_wo, _r)
                except Exception as e:
                    _r = dict(err=f'运维标准判据失败: {e}'[:200])
                self._send(_jdump(_r, ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/maint_framework':
                # 运维管理体系 —— 与快照预烤**同一实现** (maint_framework_view)
                try:
                    _r = maint_framework_view()
                except Exception as e:
                    _r = dict(err=f'运维体系读取失败: {e}'[:200])
                self._send(_jdump(_r, ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/dq_findings':
                # 数据可信度发现 —— 与快照预烤**同一实现** (dq_findings_view)
                try:
                    _r = dq_findings_view()
                except Exception as e:
                    _r = dict(rows=[], err=f'数据可信度读取失败: {e}'[:200])
                self._send(_jdump(_r, ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/vibcms':
                self._send(_jdump(vibcms_results(), ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/curves':
                # ★2026-09-21: 接 win（按所选时间窗重算；未命中就起后台线程 + 回 building，页面轮询）
                self._send(_jdump(curve_view(q.get('win') or '2026年'), ensure_ascii=False),
                           'application/json; charset=utf-8')
            elif u.path == '/api/fleet':
                CUR_WIN[0] = win
                self._send(_jdump(fleet_view(win), ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path.startswith('/problem/'):
                import urllib.parse as _up
                _, _, t, sysn = u.path.split('/', 3)
                self._send(PAGE_PROBLEM.replace('%CSS%', BASE_CSS).replace('%JS%', CHART_JS)
                           .replace('%T%', t).replace('%SYS%', _up.unquote(sysn)))
            elif u.path == '/api/problem':
                self._send(_jdump(dict(problems=single_problem(q['t'], q['sys'], win)), ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/turbine':
                self._send(_jdump(dict(problems=turbine_problems(q['t'], win)), ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/query':
                agg = q.get('agg', 'med')
                self._send(json.dumps(adhoc_query(q['t'], q['ch'], win, 'sum' if agg == 'dutyd' else agg), ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/snapshot':
                _lang = urllib.parse.parse_qs(u.query).get('lang', [''])[0]
                # 单文件快照 (2026-08-28 用户: 我怎么发给别人)。
                # 把各窗 fleet / curves / ontology / 维护盘点全部内联进 HTML, 并在页内改写
                # window.fetch 直接返回内联数据 —— 前端代码一行不改, 收件人双击即开, 不需要
                # 装 Python、不需要连内网、断网也能看。数据按当前受众设置脱敏后再内联。
                try:
                    _wins = ['2026年', '2026H1', '2025H2', '全程']
                    snap, _skip = {}, []

                    def _nk(path, **kw):
                        """快照 key 归一化: 参数**解码后**排序拼接。

                        必须与页内 window.__NK 同语义 —— 直接用 URL 字符串做 key 会被
                        encodeURIComponent 与 urllib quote 的编码差异 (! * ' ( ) 一编一不编)
                        和参数顺序打掉, 而这种失效是**静默**的: 命中不了就退到
                        "快照版不含此功能", 看起来像功能没做, 不像 key 错了。
                        """
                        a = sorted('%s=%s' % (k, v) for k, v in kw.items() if v not in (None, ''))
                        return path + ('?' + '&'.join(a) if a else '')

                    def _bake(key, fn):
                        """烤一个 API 响应。失败**记名**不静默 —— 守护步骤失败必须响亮。

                        ★2026-08-31: 此前直接 _redact(_jclean(...)), **绕过 _jdump 里的语言投影**,
                          于是 ?lang=en 的快照内联的仍是中文数据 (实测 57 万→11 万中文只是
                          页面文案变了, 数据没变)。这里补上同一套投影。
                        """
                        try:
                            # ★顺序是 **_redact 先, _proj 后**, 不要"为了与在线同序"去调它:
                            #   曲线图注等模板的 key 是照**脱敏后**的文本登记的 (含 ▪ 掩码),
                            #   先投影的话字符串里还是真实数字, 模板全部对不上, 整批退回
                            #   [translation pending]。我按"同序"改过一次, 当场被 parity 闸逮住。
                            #   在线路径没有这个问题是因为脱敏在页面层统一做, 不在数据层。
                            _v = _redact(_jclean(fn()))
                            if _lang and _lang != 'zh':
                                _v = _proj(_v, _lang)
                            snap[key] = _v
                            return True
                        except Exception as e:
                            _skip.append('%s: %s' % (key, str(e)[:60]))
                            return False

                    for _w in _wins:
                        _bake(_nk('/api/fleet', win=_w), lambda w=_w: fleet_view(w))
                    _bake('/api/curves', curve_view)
                    _bake('/api/ontology', ontology_view)
                    # ★后加的面板接口也要预烤 —— 漏了会在离线快照里空掉。
                    #   新增接口时必须回到这里补一行, 否则快照静默少一块。
                    def _maint_std():
                        import json as _j2, pathlib as _p2
                        from src.windscada.maint import standards as _st2
                        _db2 = _j2.loads(_P.objects_json()
                                         .read_text(encoding='utf-8'))
                        _wo2 = [(v.get('props') or {}) for k, v in _db2.items()
                                if k.startswith('workorder/')]
                        _r2 = _st2.run_all(_wo2)
                        _r2['score'] = _st2.score(_wo2, _r2)
                        return _r2

                    _maint_fw = maint_framework_view   # ★与在线 API 同一实现
                    _dq = dq_findings_view          # ★与在线 API 同一实现

                    _bake('/api/maint_std', _maint_std)
                    _bake('/api/maint_framework', _maint_fw)
                    _bake('/api/dq_findings', _dq)
                    _bake('/api/maint_survey',
                          lambda: dict(rows=__import__('src.ontology.maintenance',
                                                       fromlist=['survey']).survey()))
                    # ── 扩展预烤 (2026-08-30 用户"完整展示") ───────────────────────
                    # 原先只烤上面 4 个, 另外 7 个接口在离线版里是死的: 部件问题下钻、
                    # 本体对象/清单/链、振动详情点开全是"快照版不含此功能" —— 页面能渲染
                    # 掩盖了功能不可用, 我此前按"十页可交互"汇报是说过头了。
                    # ask / rpt_compose 要现跑模型, 不烤 (页面另给在线提示), 其余全量枚举。
                    _bake('/api/vibcms', vibcms_results)
                    # 离线桩: 快照里没有服务端跑模型, 所以这条**有意**与在线不同。
                    # note 双写 —— 靠翻译层会得到 [translation pending], 而这是给读者看的一句话。
                    _bake('/api/ask_status', lambda: dict(
                        offline=True, models=[],
                        note_zh='离线版: 模型问答需连接系统',
                        note_en='Offline copy: the model Q&A needs a live connection to the system'))
                    # 部件问题: (机组, 系统) 从各窗 systems 展开, 每个窗各烤一份
                    _pairs = set()
                    for _w in _wins:
                        _fv = snap.get(_nk('/api/fleet', win=_w)) or {}
                        for _sysn, _rows in (_fv.get('systems') or {}).items():
                            for _r in (_rows or []):
                                if isinstance(_r, dict) and _r.get('t'):
                                    _pairs.add((_r['t'], _sysn))
                    # ★系统名两种形态都要烤 (2026-09-01 实逮"点开是空浮层")。
                    #   systems 的分组键带**等级后缀** (`塔架与基础·良好`), 而页面上
                    #   `/problem/<t>/<sys>` 链接发出的是**裸系统名** (`塔架与基础`) ——
                    #   于是 key 差一截, 取不到数, 浮层开了但里面是"本窗无记录"。
                    #   **这种失效最难发现: 浮层确实弹出来了, 看着像"这台这系统没数据",
                    #   而不像"key 错了"。** 两种形态都烤成同一份数据即可。
                    for _t, _sy in sorted(_pairs):
                        _forms = {_sy}
                        if '·' in _sy:
                            _forms.add(_sy.split('·')[0])
                        for _w in _wins:
                            for _f in sorted(_forms):
                                # ★每种形态烤**它自己**的数据。上一版这里捕获的是带等级的 _sy,
                                #   于是裸名 key 拿到的是带等级那份 —— 实测差出 0 vs 1 条,
                                #   **被对拍闸逮到**。lambda 默认参数必须捕获循环变量 _f 本身。
                                _bake(_nk('/api/problem', t=_t, sys=_f, win=_w),
                                      lambda t=_t, sy=_f, w=_w: dict(problems=single_problem(t, sy, w)))
                    # 整机视图: 页面上机组号链到 /turbine/<t>, 弹层要用
                    for _t in sorted({t for t, _ in _pairs}):
                        for _w in _wins:
                            _bake(_nk('/api/turbine', t=_t, win=_w),
                                  lambda t=_t, w=_w: dict(problems=turbine_problems(t, w)))
                    # 本体清单 + 每个对象详情 (清单里出现的 id 才可能被点开)
                    _oids = set()
                    for _ty in sorted((ontology_view().get('stats') or {})):
                        _k = _nk('/api/ont_list', type=_ty, limit=60)
                        if _bake(_k, lambda ty=_ty: dict(rows=ontology_list(ty, '', 60))):
                            for _row in (snap[_k].get('rows') or []):
                                if isinstance(_row, dict) and _row.get('id'):
                                    _oids.add(_row['id'])
                    for _oid in sorted(_oids):
                        _bake(_nk('/api/ont_obj', id=_oid), lambda i=_oid: ontology_obj(i))
                    # 本体链: kind 五种, 参数取页面下拉的实际取值域
                    try:
                        from src.ontology import mcp_server as _omc
                        _bake(_nk('/api/ont_chain', kind='plan', top='12'),
                              lambda: _omc.ont_maint_plan(top=12))
                        _syslist = sorted({sy for _, sy in _pairs}) or ['齿轮箱']
                        for _sy in _syslist:
                            _bake(_nk('/api/ont_chain', kind='prev', system=_sy),
                                  lambda sy=_sy: _omc.ont_chain_preventive(system=sy))
                            _bake(_nk('/api/ont_chain', kind='tree', system=_sy),
                                  lambda sy=_sy: _omc.ont_fault_tree(system=sy))
                        # ★原来码源是**另一处烤好的** /api/ont_list?limit=60 的行, 于是全场 555 个码
                        #   只进了按码号排序的前 60 个; 而页面上"点一下就查"的示例码
                        #   (3225/64000/64001/4110/13121) 恰好都不在那 60 个里
                        #   ⇒ **页面在推荐自己答不上的码**, 点下去整条抢修链没反应。
                        #   "排序后取前 N"的裁剪最容易把真正要用的挡在外面。
                        # ★改为**直接从本体读**, 不再依赖别处烤没烤、烤了多少 ——
                        #   跨模块借数据是这次截断的根因, 借来的上限管不着。
                        #   (中途踩坑: 我先写成 _omc.ont_list(...), 而 mcp_server 根本没有这个函数,
                        #    AttributeError 被外层 try 吞掉 ⇒ 整段 fault 一条都没烤, 还静默。)
                        import json as _js
                        _db = _js.loads(pathlib.Path(_omc.OBJ_PATH).read_text(encoding='utf-8'))
                        _codes = sorted(k.split('/')[-1] for k in _db
                                        if k.startswith('alarmcode/'))
                        for _c in [c for c in _codes if c]:
                            _bake(_nk('/api/ont_chain', kind='fault', code=_c),
                                  lambda c=_c: _omc.ont_chain_fault(code=c))
                    except Exception as _e:
                        _skip.append('ont_chain: %s' % str(_e)[:60])
                    if _skip:
                        print('[snapshot] 未烤成 %d 项: %s' % (len(_skip), '; '.join(_skip[:6])),
                              file=sys.stderr)
                    print('[snapshot] 预烤 %d 键 (%s)' % (
                        len(snap), ', '.join(sorted({k.split('?')[0] for k in snap}))), file=sys.stderr)
                    if _lang and _lang != 'zh':
                        # ★key 统一在**全部烤完之后**加 lang: 英文页的 fetch 会自动追加
                        #   ?lang=en, 预烤 key 不带就永远对不上 (miss 是静默的, 退到 err 提示,
                        #   看着像功能没做)。
                        #   ★不能在 _bake 内部改 —— 后续代码还要用原 key 从 snap 取值,
                        #     改了就 KeyError (本次实测踩到)。
                        # ★存双 key: 带 lang 与不带。页面首帧的 fetch 可能早于 fetch patch
                        #   生效, 那一发不带 lang —— 只存带 lang 的会 miss 一次 (实测首屏 fleet)。
                        #
                        # ★★ 加 lang 必须走**同一个归一化器**, 不能字符串拼接 (2026-09-01 实逮)。
                        #   __NK 把参数**按字母排序**, 所以正确形态是 `?lang=en&sys=…&t=…&win=…`;
                        #   而拼接得到的是 `?sys=…&t=…&win=…&lang=en` —— 差一个顺序, 全部 miss。
                        #   后果极隐蔽: 十个标签页照常显示 (它们命中的是**不带 lang** 的那份),
                        #   只有**点开下钻**才走带 lang 的 key ⇒ 浮层弹出来却是"本窗无记录",
                        #   看着像"这台这系统没数据", 不像 key 错了。用户报的"有些点不开"就是它。
                        def _with_lang(k):
                            base, _, q = k.partition('?')
                            kv = dict(x.split('=', 1) for x in q.split('&') if '=' in x) if q else {}
                            kv['lang'] = _lang
                            return base + '?' + '&'.join(sorted('%s=%s' % (a, b) for a, b in kv.items()))
                        snap = dict(snap, **{_with_lang(k): v for k, v in snap.items()})
                    page = PAGE_FLEET.replace('%CSS%', BASE_CSS).replace('%JS%', CHART_JS)
                    if _lang and _lang != 'zh':
                        # 快照页面本身也走英文化 (文案表 + 显示层脚本), 并改 lang 属性 ——
                        # 此前只投影了 API 路径, 快照页漏了, 导出的 index.html 一直是 lang="zh"
                        page = _en_page(page).replace('<html lang="zh"', '<html lang="%s"' % _lang, 1)
                    inject = ('<script>window.__SNAP__='
                              + json.dumps(snap, ensure_ascii=False, allow_nan=False) + ';\n'
                              '/* 快照模式: 拦截 fetch 从内联数据取。key 走归一化(参数解码后排序)而非 */'
                              '/* 原样 URL —— 编码差异(encodeURIComponent 不编 !*\'() 而 quote 编)与参数 */'
                              '/* 顺序都会让字符串比对落空, 且落空是静默的: 退到 err 提示, 看着像功能没做。 */'
                              'window.__NK=function(u){var s=String(u),i=s.indexOf("?");if(i<0)return s;'
                              'var p=s.slice(0,i),a=s.slice(i+1).split("&").filter(Boolean).map(function(kv){'
                              'var j=kv.indexOf("=");if(j<0)return kv;var k=kv.slice(0,j),v=kv.slice(j+1);'
                              'try{v=decodeURIComponent(v.replace(/\\+/g," "))}catch(e){}'
                              'return v===""?null:k+"="+v}).filter(function(x){return x!==null}).sort();'
                              'return p+(a.length?"?"+a.join("&"):"")};'
                              'window.__HIT={ok:0,miss:[]};window.__RF=window.fetch;'
                              # ★没烤的窗按钮直接摘掉: 让用户点一个必然空白的选项, 比少给几个窗更糟。
                              #   默认窗取**已烤窗里最新的那个**, 供上面的回落候选用。
                              'window.__WINS=(function(){var s={};Object.keys(window.__SNAP__).forEach('
                              'function(k){var m=/[?&]win=([^&]*)/.exec(k);if(m)s[decodeURIComponent(m[1])]=1});'
                              'return Object.keys(s)})();'
                              'window.__DEFWIN=window.__WINS[0]||"";'
                              'window.__WINLABEL=' + json.dumps(
                                  'Latest completed build' if _lang == 'en'
                                  else '最新一次完整分析') + ';'
                              # ★快照里**去掉窗选择器**, 换成固定标签 (2026-09-01 用户令
                              #   "设定不随时间窗动, 就显示最新的")。
                              #   理由: 选择器给约 20 个窗而只烤了 4 个, 选中其余任何一个都空白;
                              #   而这 4 个窗的内容**完全一样** (fus 40 行 / 需跟踪 76 台次 逐窗相同),
                              #   所以留着选择器只会让人以为能切、切了还空。
                              #   ★先前那版是"摘掉没烤的 option" —— 摘过头了: 选项显示文本已英文化
                              #   ("2026 full year"), 而 __WINS 是中文键, 匹配不上就把有效的也摘了。
                              #   **文本匹配在译过的 UI 上天然不可靠**, 所以改为整体替换而非逐项筛。
                              'window.__PINWIN=function(){try{'
                              'var sel=document.querySelector("select#win");if(!sel)return;'
                              'var lab=document.createElement("span");lab.id="winpin";'
                              'lab.style.cssText="font-size:12.5px;color:var(--muted);padding:5px 9px;'
                              'border:1px solid var(--line);border-radius:7px;background:var(--panel)";'
                              'lab.textContent=window.__WINLABEL||"Latest build";'
                              'lab.title="This snapshot is fixed to the latest completed build; '
                              'the panels below do not vary by window.";'
                              'sel.parentNode.replaceChild(lab,sel)}catch(e){}};'
                              'try{new MutationObserver(function(){window.__PINWIN()})'
                              '.observe(document.documentElement,{childList:true,subtree:true})}catch(e){}'
                              'document.addEventListener("DOMContentLoaded",function(){'
                              'setTimeout(window.__PINWIN,300)});'
                              # 问答接口不能被离线拦截: 云上 nginx /api/ 后面有真服务在跑,
                              # 其余接口才走预烤。放行名单写死, 免得日后新增接口误穿。
                              'window.fetch=function(u,o){var k=window.__NK(u);'
                              'if(/^\\/api\\/(ask|ask_status|ask_models|rpt_compose|rpt_export)\\b/.test(String(u)))return window.__RF(u,o);'
                              # ★第 4 个候选: 把 win 换成默认窗 (2026-09-01 用户令"不随时间窗动, 就显示最新的")。
                              #   窗选择器给了约 20 个选项而快照只烤了 4 个 —— 选中其余任何一个
                              #   都会整页空白 (表现为"该系统全场无异常"、振动页空), 看着像没数据,
                              #   实则是没烤。这些面板的内容本就不随窗变 (四个窗 fus 完全一样),
                              #   所以回落到默认窗是**正确答案**而不是遮丑。
                              # ★同 src/windscada/ui/snapshot.py 的坑: 这里不能 encodeURIComponent —— k 与
                              #   __SNAP__ 键都是原文(未编码)中文, 编码后拼出的键谁都不匹配, 兜底静默失效
                              #   (2026-09-03 实逮: 换窗点浮层报"本窗无记录", 默认窗其实有数据)。
                              'var c=[k,k.replace(/&?win=[^&]*/,"").replace(/\\?$/,""),String(u).split("?")[0],'
                              'k.replace(/win=[^&]*/,"win="+(window.__DEFWIN||""))];'
                              'for(var i=0;i<c.length;i++){var d=window.__SNAP__[c[i]];'
                              'if(d!==undefined){window.__HIT.ok++;return Promise.resolve({ok:true,'
                              'json:function(){return Promise.resolve(d)}})}}'
                              'if(window.__HIT.miss.indexOf(k)<0)window.__HIT.miss.push(k);'
                              'return Promise.resolve({ok:true,json:function(){return Promise.resolve('
                              '{err:"离线版不含此功能 (模型问答与报告生成需连接系统)"})}})};'
                              '</script>')
                    # ★英文版改走**源码级生成**, 不再注入运行时翻译 hook
                    #   (2026-08-31 用户令: 不要打补丁式翻译, 整个系统重新生成一遍)。
                    #   hook 的本质是给中文系统套一层英文 —— 只译写入 DOM 的那一刻,
                    #   JS 逻辑与 JSON 键仍是中文, 长尾补不完且源码里满是中文。
                    #   改为在页面拼好后整页替换 (见本函数末尾与 i18n_en.to_english_source)。
                    #   ★中文版完全不受影响: 不带 lang=en 时这条分支不执行, 国内照常用。
                    # ★ 单文件版的下钻: 页面上 74 个链接指向 /problem/<t>/<sys> 与 /turbine/<t>,
                    #   那是服务端独立页面 —— 快照里点了就是死链 (404/白页)。此前"十页可交互"
                    #   的说法没覆盖这一层。改法: 拦截这两类链接, 用已预烤的同一份数据在页内
                    #   开浮层, 图表复用共享的 drawFig, 与在线版看到的是同一批图。
                    # ★注入块里的文案要**自己**按语言选: 它加在 _en_page 之后,
                    #   英文化那一遍已经跑完了, 这里的中文字面量永远不会被翻译。
                    #   实逮: 英文页浮层里弹出"本窗无记录"。
                    #   ('状态'/'依据' 是 JSON 键, '年' 是窗名数据值 —— 都不能动。)
                    inject += ('<script>(function(){var M=null;'
                               'function esc(s){return String(s==null?"":s).replace(/[&<>]/g,function(c){'
                               'return {"&":"&amp;","<":"&lt;",">":"&gt;"}[c]})}'
                               'window.__CLOSEM=function(){if(M)M.style.display="none"};'
                               'function box(){if(M)return M;M=document.createElement("div");'
                               'M.style.cssText="position:fixed;left:0;top:0;right:0;bottom:0;z-index:9999;'
                               'background:rgba(0,0,0,.6);overflow:auto";'
                               'M.onclick=function(e){if(e.target===M)window.__CLOSEM()};'
                               'document.body.appendChild(M);return M}'
                               'async function open2(t,sys){'
                               'var w=(window.D&&window.D.win)||"2026年";'
                               'var u=sys?("/api/problem?t="+t+"&sys="+encodeURIComponent(sys)+"&win="+encodeURIComponent(w))'
                               ':("/api/turbine?t="+t+"&win="+encodeURIComponent(w));'
                               'var d={};try{d=await (await fetch(u)).json()}catch(e){}'
                               'var ps=(d&&d.problems)||[];'
                               'var h=\'<div style="max-width:1120px;margin:26px auto;background:var(--card,#111a24);\''
                               '+\'border:1px solid var(--line,#22303d);border-radius:10px;padding:18px 20px">\''
                               '+\'<div style="display:flex;justify-content:space-between;align-items:flex-start;gap:12px">\''
                               '+"<h3 style=\'margin:0 0 4px\'>"+esc(t)+(sys?" · "+esc(sys):"")+"</h3>"'
                               '+\'<button onclick="window.__CLOSEM()" style="background:none;border:1px solid \'' 
                               '+\'var(--line,#22303d);color:inherit;border-radius:6px;padding:2px 9px;cursor:pointer">×</button></div>\';'
                               'if(!ps.length)h+=\'<p class="small">' + ('No records in this window' if _lang == 'en' else '本窗无记录') + '</p>\';'
                               'ps.forEach(function(p){h+=\'<div class="card mb"><b>\'+esc(p.sys)+\'</b> · \'+esc(p["状态"])'
                               '+\'<p class="small">\'+esc(p["依据"])+\'</p>\';'
                               'if(p.figs&&p.figs.length&&typeof drawFig==="function"){h+=\'<div class="grid">\';'
                               'p.figs.forEach(function(f){try{h+=drawFig(f)}catch(e){}});h+="</div>"}'
                               'h+="</div>"});'
                               'h+="</div>";var b=box();b.innerHTML=h;b.style.display="block";b.scrollTop=0}'
                               'document.addEventListener("click",function(e){'
                               'var a=e.target&&e.target.closest?e.target.closest(\'a[href^="/problem/"],a[href^="/turbine/"]\'):null;'
                               'if(!a)return;e.preventDefault();e.stopPropagation();'
                               'var q=a.getAttribute("href").split("/").filter(Boolean);'
                               'open2(decodeURIComponent(q[1]||""),q[0]==="problem"?decodeURIComponent(q[2]||""):"")},true);'
                               'document.addEventListener("keydown",function(e){if(e.key==="Escape")window.__CLOSEM()});'
                               '})();</script>')
                    page = page.replace('<script>%JS%', inject + '<script>%JS%') if '%JS%' in page else page.replace('</head>', inject + '</head>')
                    if inject not in page:
                        page = page.replace('</head>', inject + '</head>')
                    # ★这里**曾经**调 i18n_en.to_english_source(page) 做逐词替换。
                    #   它跑在 inject 之后, 作用在含 __SNAP__ JSON 的整页上, 把预烤 key 里的
                    #   中文吃掉: win=2026年 → win=2026, win=全程 → win=full window,
                    #   于是页面按原 key 取数全部 miss —— **而 miss 是静默的**, 退到 err 提示,
                    #   看着像功能没做。_PROT 保护不了 JSON 里的 key。
                    #   页面英文化已在前面由 _en_page (整段短语表 + NEVER 数据值保护) 完成,
                    #   这里不再需要第二遍, 已删。
                    # ★成品页语法闸 —— 校验**最终字节**, 不是中间态 (2026-08-31)。
                    #   _en_page 里也有一道, 但它跑在 value_script 与 __SNAP__ 注入**之前**,
                    #   护不住后注入的脚本。而快照是要上云的成品, 坏了就是白屏,
                    #   且白屏时"可见中文=0"会让所有自查指标全绿 —— 最坏的一种失败。
                    try:
                        from src.windscada import ui_en as _uie
                        _nchk = 0
                        for _m in re.finditer(r'<script([^>]*)>(.*?)</script>', page, re.S):
                            if 'application/json' in _m.group(1) or not _m.group(2).strip():
                                continue
                            _uie.check_js(_m.group(2), label='快照脚本#%d' % (_nchk + 1))
                            _nchk += 1
                        print('[snapshot] 成品页语法闸: %d 个脚本全部通过 node --check' % _nchk,
                              file=sys.stderr)
                        if _nchk == 0:
                            print('[snapshot] 🔴 语法闸切出 0 个脚本 —— **本次未校验**, 非通过',
                                  file=sys.stderr)
                    except Exception as _e:
                        print('[snapshot] 🔴 成品页语法闸失败: %s' % _e, file=sys.stderr)
                        raise
                    if _lang == 'en':
                        _n1 = len(re.findall(r'[\u4e00-\u9fff]', page))
                        print('[snapshot] 英文快照: 页面残留中文 %d 字 (含内联数据)' % _n1,
                              file=sys.stderr)
                    # ★脱敏必须是**最后一步**, 且只对上云那一版做 (2026-09-01 用户令)。
                    #   中文快照是内部工作副本, 要保留真实场名/机型, 不脱敏。
                    #   英文快照是要发到公网的, 而它此前带着 rudong×366 / Siemens×194 /
                    #   SWT×89 —— **同时页面上写着 "site, owner and OEM removed"**,
                    #   产物与自己的声明不符, 这比不声明更糟。
                    #   放最后: 对象 id 与引用它的地方必须换成同一个词, 只能整体做。
                    if _lang == 'en':
                        from src.windscada import deid_public as _dp
                        page = _dp.scrub_or_die(page, label='英文快照 (上云件)')
                        print('[snapshot] 脱敏回扫: 干净 (rudong/OEM/机型/省市/业主/坐标 全零)',
                              file=sys.stderr)
                    fn = (f'Guanlan_Snapshot_{CUR_WIN[0]}_EN.html' if _lang == 'en'
                          else f'观澜快照_{CUR_WIN[0]}_{"上报版" if not INTERNAL else "内部版"}.html')
                    data = page.encode('utf-8')
                    self.send_response(200)
                    self.send_header('Content-Type', 'text/html; charset=utf-8')
                    self.send_header('Content-Length', str(len(data)))
                    self.send_header('Content-Disposition',
                                     "attachment; filename*=UTF-8''" + urllib.parse.quote(fn))
                    self.end_headers()
                    self.wfile.write(data)
                except Exception as e:
                    import traceback
                    self._send(_jdump(dict(err=str(e)[:200], tb=traceback.format_exc()[-500:]),
                                      ensure_ascii=False), 'application/json; charset=utf-8', 500)
            elif u.path == '/api/rpt_export':
                # 导出 Word/Excel (2026-08-28 用户令: 导出 demo)。图表块转数据表, 不放位图 —
                # Word 里的位图既不能编辑也无法核对, 上报集团要的是能核的数字。
                q = urllib.parse.parse_qs(u.query)
                fmt = q.get('fmt', ['docx'])[0]
                blocks = [x for x in q.get('blocks', [''])[0].split(',') if x]
                aud = q.get('aud', ['in'])[0]
                w = q.get('win', ['2026年'])[0]
                narr = q.get('narr', [''])[0] or None
                try:
                    from src.windscada import report_export as _rx
                    fl = fleet_view(w)
                    if aud == 'up':          # 上报版走同一套脱敏规则
                        fl = _redact(_jclean(fl))
                    data = (_rx.to_xlsx if fmt == 'xlsx' else _rx.to_docx)(fl, blocks, w, aud, narr)
                    ext = 'xlsx' if fmt == 'xlsx' else 'docx'
                    mime = ('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' if fmt == 'xlsx'
                            else 'application/vnd.openxmlformats-officedocument.wordprocessingml.document')
                    fn = f'运行分析报告_{w}_{"上报版" if aud == "up" else "内部版"}.{ext}'
                    self.send_response(200)
                    self.send_header('Content-Type', mime)
                    self.send_header('Content-Length', str(len(data)))
                    self.send_header('Content-Disposition',
                                     "attachment; filename*=UTF-8''" + urllib.parse.quote(fn))
                    self.end_headers()
                    self.wfile.write(data)
                except Exception as e:
                    import traceback
                    self._send(_jdump(dict(err=str(e)[:200], tb=traceback.format_exc()[-400:]),
                                      ensure_ascii=False), 'application/json; charset=utf-8', 500)
            elif u.path in ('/api/facts', '/api/facts/claim'):
                # 结构化事实契约 (用户批 2026-09-06 "8033 /api 切到契约生成"): 只读 derived/ 产物, 不算数不改写;
                # 生成器 = scripts/guanlan_facts_contract.py render, 契约 sha 随体返回供前端/CI 对拍.
                import json as _json
                _dd = _P.guanlan() / 'derived'
                try:
                    if u.path == '/api/facts':
                        _body = _dd.joinpath('detail_cards.json').read_text(encoding='utf-8')
                    else:
                        _cid = urllib.parse.parse_qs(u.query).get('id', [''])[0]
                        _qa = _json.loads(_dd.joinpath('qa_refs.json').read_text(encoding='utf-8'))
                        _hit = next((r for r in _qa.get('refs', []) if r.get('claim_id') == _cid), None)
                        _body = _jdump(dict(contract_sha256=_qa.get('contract_sha256'), claim=_hit, err=None if _hit else 'unknown claim_id'), ensure_ascii=False)
                    self._send(_body, 'application/json; charset=utf-8')
                except FileNotFoundError as e:
                    self._send(_jdump(dict(err='facts derived 缺失: %s' % e), ensure_ascii=False), 'application/json; charset=utf-8', 503)
            elif u.path == '/api/rpt_compose':
                q = urllib.parse.parse_qs(u.query)
                if q.get('probe', [''])[0]:
                    # 前端只探"编排接口是否存在" (v2 bindReport probe=1); 原先照跑 rpt_compose('', [], model) 走模型,
                    # 汇报定制页首屏空等 ~23 s (2026-09-06 实测) —— 探针只答存在性, 不算数.
                    self._send(_jdump(dict(ok=True, probe=True), ensure_ascii=False), 'application/json; charset=utf-8'); return
                r = rpt_compose(q.get('need', [''])[0], [x for x in q.get('canvas', [''])[0].split(',') if x],
                                q.get('model', ['qwen3:8b'])[0])
                self._send(_jdump(r, ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/ask_status':
                self._send(_jdump(ask_status(), ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/ask_models':
                # 与云端问答微服务 (windscada_ask_serve.py) 同形: {models: {id: {...}}}。此前本地没有
                # 这条路由, 经典页的模型下拉在本地永远是"无可用模型" —— v2 与经典页同源取清单。
                self._send(_jdump(dict(models={k: {} for k in ASK_MODELS}), ensure_ascii=False),
                           'application/json; charset=utf-8')
            elif u.path == '/api/ontology':
                self._send(_jdump(ontology_view(), ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/ont_list':
                self._send(_jdump(dict(rows=ontology_list(q.get('type', ''), q.get('t', ''), q.get('limit', 60))),
                                  ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/ont_obj':
                self._send(_jdump(ontology_obj(q.get('id', '')), ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path == '/api/channels':
                self._send(_jdump(channel_list(), ensure_ascii=False), 'application/json; charset=utf-8')
            elif u.path.startswith('/static/'):
                f = ST / u.path[len('/static/'):]
                if f.is_file():
                    self._send(f.read_bytes(), 'text/html; charset=utf-8')
                else:
                    # 裸 404 会让总览 iframe 变成"一块空白"(用户 2026-09-17 报的正是这个现象) ⇒ 结构化缺件页
                    self._send(_gap_page(u.path, f, '总览（全场状态）'), 'text/html; charset=utf-8')
            elif u.path.startswith('/turbines/'):
                f = ST / u.path.lstrip('/')
                if f.is_file():
                    raw = f.read_text(encoding='utf-8', errors='ignore')
                    light = '<style>:root[data-theme="light"]{--ground:#f3f6f9;--panel:#fff;--panel-2:#f8fbfc;--ink:#0c1622;--muted:#5a6b7d;--line:#d8e1e9;--line-2:#eaf0f5;--accent:#0d7183;--accent-soft:#e6f3f5;--accent-ink:#095764;--ok:#137a68;--warn:#8a5a12;--bad:#a32d38;--unknown:#4d5d6e;--info:#0d7183}</style><script>(function(){try{document.documentElement.setAttribute("data-theme","light")}catch(e){}})();</script>'
                    raw = raw.replace('</head>', light + '</head>', 1) if '</head>' in raw else light + raw
                    self._send(raw)
                else:
                    self._send(_gap_page(u.path, f, '机组详情页'), 'text/html; charset=utf-8')
            elif u.path.startswith('/windcms/'):
                # windcms 振动分析本体嵌入 (用户令: 原振动分析板块进入振动融合板块; 静态挂载非复制,
                # 正本仍在 outputs/rudong/windcms 由振动线维护, 本路由只读)
                base = (ST.parent / 'windcms').resolve()
                f = (base / u.path[len('/windcms/'):]).resolve()
                if base in f.parents or f == base:
                    if f.is_dir(): f = f / 'index.html'
                    if f.is_file():
                        ext = f.suffix.lower()
                        mime = {'.html': 'text/html; charset=utf-8', '.json': 'application/json; charset=utf-8',
                                '.png': 'image/png', '.svg': 'image/svg+xml', '.css': 'text/css',
                                '.js': 'application/javascript', '.md': 'text/plain; charset=utf-8'}.get(ext, 'application/octet-stream')
                        self._send(f.read_bytes(), mime)
                    else:
                        self._send('404', code=404)
                else:
                    self._send('403', code=403)
            elif u.path == '/api/reload':
                # 产物重载 (2026-09-16 用户令: 重算产物即时可用于页面呈现)。
                # 平时**不需要**调它 —— _load() 每次请求都会比产物指纹, 变了自动重载;
                # 这个端点给"重算结束想立刻生效"的显式动作, 也便于运维界面/脚本确认当前指纹。
                _old = reload_products(urllib.parse.parse_qs(u.query).get('why', ['manual'])[0])
                self._send(_jdump(dict(ok=True, old_stamp=_old, stamp=products_stamp(force=True),
                                       files=len(_product_files())), ensure_ascii=False),
                           'application/json; charset=utf-8')
            else:
                self._send('404', code=404)
        except ProductsMissing as e:
            # 产物缺失不是"程序坏了": 回 200 + 结构化无数据, 前端按正常渲染显示原因 (2026-09-11 空状态检查)
            self._send(_jdump(dict(kind='multiline', title='无产物', unit='', months=[], series=[],
                                   err='no_products',
                                   note=f'{e.what} 不存在 → {_P.rel(e.path)}; 先放原始件再跑 '
                                        f'scripts/rebuild_from_raw.py (SCADA 侧加 --scada) 或 '
                                        f'scripts/rebuild_all.py 生成产物。'
                                        f'"包内没有生成端"的件按用户令 2026-09-17 **运行期不由交付包补齐**: '
                                        f'要么等研发补生成端(逐族可逆性见 docs/系统设计说明.md §13.6), '
                                        f'要么由人离线补救(products_restore_missing.py --stash <…>, 不在运行链里); '
                                        f'2026-09-16 起清除产物不留备份, 故没有 --on 还原'), ensure_ascii=False),
                       'application/json; charset=utf-8')
        except Exception as e:
            import traceback
            self._send(_jdump(dict(err=str(e), tb=traceback.format_exc()[-500:]), ensure_ascii=False), 'application/json; charset=utf-8', 500)

if __name__ == '__main__':
    # 统一日志口径 (用户令 2): 之后每一行都带 时间戳/级别/组件（详情见 src/logfile.py）
    import pathlib as _pl, sys as _sys0
    _sys0.path.insert(0, str(_pl.Path(__file__).resolve().parents[1]))
    from src import logfile as _lf; _lf.prefix_stdout('detail')
    # 控制台可能是 GBK(中文 Windows 代码页 936): 正文里的 ✔ ✗ ✅ ⚠ 这类字符编不出来会抛
    # UnicodeEncodeError, 脚本干成了事却以退出码 1 结束(同类坑见 src/console.py)。降级为 '?' 而不是崩;
    # 不用 import 是为了兼顾 python -m 与直接当脚本跑两种启动方式。
    import sys as _sys
    for _s in (_sys.stdout, _sys.stderr):
        try: _s.reconfigure(errors='replace')
        except Exception: pass
    import argparse
    ap = argparse.ArgumentParser()
    import os
    ap.add_argument('--port', type=int, default=int(os.environ.get('PORT', 8033)))   # PORT 环境变量优先, 供 preview 分配端口
    ap.add_argument('--host', default='127.0.0.1', help='0.0.0.0 = 对局域网开放 (演示用, 结束请关)')
    ap.add_argument('--farm', default=None, help='场名 (默认 rudong; 可用场见 configs/farms/)')
    a = ap.parse_args()
    print(f'windscada serve :{a.port}', flush=True)
    # --host 0.0.0.0 供局域网演示 (2026-08-28 用户: 怎么发给别人)。
    # 默认仍只绑本机 — 内部数据不该因为一次演示就对整个网段开放, 要开是显式动作。
    if getattr(a, 'farm', None):
        # ★CFG/ST 在模块加载时就绑定了 (第 81 行), 这里必须显式重绑而不是只切 current —
        # 否则 --farm 只改了配置模块里的指针, 服务用的仍是启动时那个场 (静默不生效)。
        # 用模块字典赋值而非 global: main 里更早处已引用过 CFG, global 声明会触发
        # "used prior to global declaration"。改模块属性等效且不受声明位置约束。
        from src.windscada import config as _cfg
        import sys as _sysmod
        _me = _sysmod.modules[__name__]
        _cfg.set_current(a.farm)
        _me.CFG = _cfg.farm()
        _me.ST = pathlib.Path(_me.CFG['store'])
        _CACHE.clear()
        _STAMP['val'] = None            # 换场后产物指纹必须重算, 否则新场的缓存判为"未变化"
        print(f'场: {_me.CFG["name"]} ({a.farm}, {_me.CFG["n_turbines"]} 台, 仓 {_me.ST})')
    else:
        print(f'场: {CFG["name"]} (默认; 可用 {list(__import__("src.windscada.config", fromlist=["available"]).available())})')
    _host = getattr(a, 'host', '127.0.0.1')
    if _host != '127.0.0.1':
        import socket as _sk
        try:
            _ip = _sk.gethostbyname(_sk.gethostname())
        except Exception:
            _ip = _host
        print(f'⚠ 已对局域网开放: http://{_ip}:{a.port}  (同网段任何人可访问, 演示结束请关闭)')
    # ★按窗重算的**预热**（用户令 2026-09-21：判级/曲线随所选时间窗变化）。
    #   判级矩阵 ≈25 s/窗、镜头 ≈10~45 s/窗 —— 不预热的话重启后第一个访客要等 pending 轮询。
    #   这里在**后台守护线程**里顺序把预设窗算进进程缓存（页面照常可用，未就位的窗如实标 pending）。
    def _warm():
        if _os.environ.get('GUANLAN_WIN_WARM', '1') == '0':
            print('[warm] 按窗预热被 GUANLAN_WIN_WARM=0 关掉（按需算，首次看窗会 pending 一轮）', flush=True)
            return
        import time as _t
        n = 0
        for w in list(WINDOWS):
            try:
                sysmx_of(w)                       # 未命中即起后台线程
                if _win_wait('sysmx', w, timeout=180) is not None:
                    n += 1
                _t.sleep(2)                       # 留口气: 小内存机器上连续重算更容易被系统盯上
            except Exception as e:
                print(f'[warm] 判级 {w} 失败: {type(e).__name__}: {e}'[:160], flush=True)
        for w in ('2026年',):
            try:
                curves_of(w)                      # 未命中即起后台线程
                _win_wait('curves', w, timeout=240)
            except Exception as e:
                print(f'[warm] 镜头 {w} 失败: {type(e).__name__}: {e}'[:160], flush=True)
        print(f'[warm] 按窗缓存预热完成: 判级 {n}/{len(WINDOWS)} 窗（可用内存 {_mem_mb()} MB）', flush=True)

    _thr.Thread(target=_warm, name='win-warm', daemon=True).start()
    ThreadingHTTPServer((_host, a.port), H).serve_forever()