weaver-work-cli 0.1.6 → 0.1.7

package/tools/weaver-skill-detector-1.0.13/scripts/validate_skill.py

@@ -0,0 +1,4190 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+泛微技能检测工具 · 静态检测脚本
+
+检测上传的 skill 压缩包(.zip) 或 Markdown 文件(.md) 是否为「符合 WorkBuddy 规范、
+且通过泛微专属安全合规质检」的 skill。
+
+用法:
+    python validate_skill.py <path_to_skill.zip|.md|directory> [--json] [--out report.md] [--html report.html]
+                                     [--market-catalog catalog.json] [--market-live] [--no-html]
+                                     [--platform {weaver,qwenwork}]
+    # 默认每次检测都会自动输出 HTML 报告到「输入同目录/<输入名>-report.html」（如 a.zip → a-report.html）；
+    # 显式传 --html <path> 可自定义输出路径；--no-html 可完全关闭 HTML 输出（仅控制台/JSON）。
+    # --platform 显式指定目标发布平台（默认 weaver）：
+    #     weaver    - 泛微生态（WorkBuddy 平台 + 泛微专属品牌/契约约束，原默认行为）
+    #     qwenwork  - 千问办公生态（按千问开发指南校验打包硬性、frontmatter 字段、连接器契约等）
+
+检测维度:
+    A. 基础合规 (WorkBuddy 通用): SKILL.md / frontmatter / name(必须weaver前缀) / display_name(必须泛微前缀)
+       / display_name_en / description / description_zh / description_en / version / author(泛微强制) / 命名规范
+       / 打包结构: A1a Windows反斜杠路径(BLOCK) + A1b 目录层级不超过两级(BLOCK: 仅支持 根/二级目录/文件)
+       / A1c 文件总数≤300(BLOCK) + A1d 仅纯文本(禁止任意位置二进制/压缩/媒体, BLOCK)
+       / A1e SKILL.md 文件名大小写精确(BLOCK: 必须精确大写 SKILL.md, 禁止 skill.md/Skill.md 等变体)
+       / A2 结构化文件可解析性(BLOCK: JSON/YAML/TOML) / A3 依赖引导完整性(WARN)
+    B. 专项质检 (泛微合规与安全): 默认登录地址、硬编码 IP、硬编码凭证、凭证来源、敏感词
+       / API 请求凭证完整性(BLOCK: 发起 API 请求必须携带 Cookie 完整原始串+eteamsid+User-Agent(AgentType=,IsAgent=true))
+    G. 扩展安全 (对齐官方 expert-reviewer): G02危险命令 / G03内网域名 / G04个人路径+IDE残留+CDN@latest
+       / C08平台虚假承诺 / BOM+CRLF编码规范
+    Q. 质量评估 (启发式): Q1路由触发清晰度 / Q2上下文效率 / Q3容错降级 / Q4字段字数控制
+    C. 威胁模型 (8 类) 与 D. 行为图谱: 暂时停用（用户要求移除，函数保留可随时恢复）
+    E. 技能能力清单: HTTP/API/文件读写/安装依赖/浏览器控制/环境变量/命令执行等
+
+退出码:
+    0  通过 (PASS) 或 仅警告通过 (WARN)
+    1  不通过 (FAIL，存在阻断项)
+    2  输入非法 (文件不存在 / 无法识别)
+
+检测维度:
+    A. 基础合规 (WorkBuddy 通用): SKILL.md / frontmatter / name(必须weaver前缀) / display_name(必须泛微前缀)
+       / display_name_en / description / description_zh / description_en / version / author(泛微强制) / 命名规范
+       / 打包结构: A1a Windows反斜杠路径(BLOCK) + A1b 目录层级不超过两级(BLOCK: 仅支持 根/二级目录/文件)
+       / A1c 文件总数≤300(BLOCK) + A1d 仅纯文本(禁止任意位置二进制/压缩/媒体, BLOCK)
+       / A1e SKILL.md 文件名大小写精确(BLOCK: 必须精确大写 SKILL.md, 禁止 skill.md/Skill.md 等变体)
+       / A2 结构化文件可解析性(BLOCK: JSON/YAML/TOML) / A3 依赖引导完整性(WARN)
+    B. 专项质检 (泛微合规与安全): 默认登录地址、硬编码 IP、硬编码凭证、凭证来源、敏感词
+       / API 请求凭证完整性(BLOCK: 发起 API 请求必须携带 Cookie 完整原始串+eteamsid+User-Agent(AgentType=,IsAgent=true))
+    G. 扩展安全 (对齐官方 expert-reviewer): G02危险命令 / G03内网域名 / G04个人路径+IDE残留+CDN@latest
+       / C08平台虚假承诺 / BOM+CRLF编码规范
+    Q. 质量评估 (启发式): Q1路由触发清晰度 / Q2上下文效率 / Q3容错降级 / Q4字段字数控制
+    C. 威胁模型 (8 类) 与 D. 行为图谱: 暂时停用（用户要求移除，函数保留可随时恢复）
+    E. 技能能力清单: HTTP/API/文件读写/安装依赖/浏览器控制/环境变量/命令执行等
+"""
+
+import sys
+import os
+import re
+import json
+import zipfile
+import tempfile
+import shutil
+import hashlib
+from datetime import datetime
+from pathlib import Path
+import urllib.request
+import urllib.parse
+
+# ---------------------------------------------------------------------------
+# 检测规则常量
+# ---------------------------------------------------------------------------
+
+# skillhub.cn 公开检索接口（市场可达性动态核查用，零第三方依赖，仅用标准库）
+SKILLHUB_API = "https://api.skillhub.cn/api/skills"
+
+# 泛微自用系统地址（严禁作为默认地址写死在 skill 中）
+WEAVER_OWNED_DOMAINS = [
+    "e-cology.com.cn",
+    "e-weaver.com",
+    "weaver.com.cn",
+    "eteams.cn",
+    "weaver.com",
+]
+
+# 可接受的占位符 / 示例地址（不应判定为真实 IP）
+SAFE_IP_PATTERNS = re.compile(
+    r"^(127\.0\.0\.1|0\.0\.0\.0|255\.255\.255\.255|10\.0\.0\.0|192\.168\.0\.0|172\.16\.0\.0)$"
+)
+
+# 文本文件扩展名（仅扫描这些，避免二进制误读）
+TEXT_EXTS = {
+    ".md", ".markdown", ".txt", ".py", ".sh", ".bash", ".js", ".mjs", ".cjs", ".ts",
+    ".jsx", ".tsx", ".json", ".yaml", ".yml", ".toml", ".cfg", ".ini", ".env",
+    ".html", ".htm", ".css", ".scss", ".java", ".sql", ".xml", ".csv", ".rst",
+    ".go", ".rb", ".php", ".ps1", ".bat", ".pl",
+}
+
+# 纯文本允许清单（ZIP 包内只允许包含以下纯文本格式文件，其余一律视为违规）
+TEXT_EXT_ALLOWLIST = {
+    # 文档 / 标记
+    "md", "markdown", "txt", "text", "rst", "adoc", "asc", "org",
+    # 源码 / 脚本
+    "py", "pyw", "js", "mjs", "cjs", "ts", "tsx", "jsx", "json", "jsonl",
+    "yaml", "yml", "toml", "ini", "cfg", "conf", "config", "sh", "bash", "zsh",
+    "ps1", "bat", "cmd", "html", "htm", "xhtml", "css", "scss", "less", "svg",
+    "xml", "csv", "tsv", "tab", "vue", "svelte", "ipynb",
+    # 编译型 / 其它文本源码
+    "c", "h", "cpp", "cc", "hpp", "java", "go", "rs", "rb", "php", "sql",
+    "r", "lua", "pl", "scala", "kt", "swift", "dart",
+    # 数据 / 配置 / 杂项文本
+    "proto", "graphql", "gql", "drawio", "lock", "log", "env", "env.example",
+    "gitignore", "gitattributes", "dockerignore", "editorconfig", "npmignore",
+}
+
+# 已知二进制扩展名黑名单（命中即视为二进制文件，禁止打包）
+BINARY_EXT_BLACKLIST = {
+    # 可执行 / 库
+    "exe", "dll", "so", "dylib", "sys", "ocx", "com", "msi", "class", "jar",
+    "pyc", "pyd", "pyo", "wasm", "node", "nupkg",
+    # 图片 / 媒体
+    "png", "jpg", "jpeg", "gif", "bmp", "tiff", "tif", "webp", "ico", "heic",
+    "mp4", "mov", "avi", "mkv", "webm", "flv", "wmv", "mp3", "wav", "ogg",
+    "flac", "m4a", "aac", "wma", "bin",
+    # 压缩 / 归档
+    "zip", "tar", "gz", "tgz", "bz2", "xz", "7z", "rar", "zst", "iso", "img",
+    # 办公 / 文档二进制
+    "pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "odt", "ods", "odp",
+    # 数据库 / 数据
+    "db", "sqlite", "sqlite3", "mdb", "dat",
+    # 字体
+    "ttf", "otf", "woff", "woff2", "eot",
+}
+
+# 无扩展名但允许的常见纯文本文件名（避免误杀 LICENSE / Makefile 等）
+KNOWN_TEXT_NOEXT = {
+    "license", "licence", "makefile", "dockerfile", "copying", "authors",
+    "changelog", "notice", "readme", "news", "todo",
+}
+
+# 二进制文件魔数（内容嗅探，防止「文本扩展名但实为二进制」漏网）
+BINARY_MAGIC_PREFIXES = (
+    b"\x89PNG", b"\xff\xd8\xff", b"GIF87a", b"GIF89a", b"%PDF",
+    b"PK\x03\x04", b"PK\x05\x06", b"PK\x07\x08", b"\x1f\x8b", b"Rar!",
+    b"\x37\x7a\xbc\xaf", b"RIFF", b"OggS", b"\xca\xfe\xba\xbe", b"\xfe\xed\xfa\xce",
+    b"\x4d\x5a",  # MZ (Windows 可执行)
+)
+
+
+def _sniff_binary(path: Path) -> bool:
+    """读取前 512 字节做二进制嗅探：含空字节或命中魔数即判为二进制。"""
+    try:
+        with open(path, "rb") as f:
+            head = f.read(512)
+    except OSError:
+        return False
+    if not head:
+        return False
+    if b"\x00" in head:
+        return True
+    for m in BINARY_MAGIC_PREFIXES:
+        if head.startswith(m):
+            return True
+    return False
+
+
+# 硬编码凭证可疑模式（赋值型字面量）
+# 负向前瞻 (?![\w_]+\s*\()：排除 RHS 为函数调用（如 token = _parent_token(key)）的误判；
+# 真实硬编码字面量不会以「标识符(」开头，故该排除安全。
+CREDENTIAL_PATTERNS = [
+    re.compile(r"(?i)(password|passwd|pwd)\s*[:=]\s*(?![\w_]+\s*\()['\"]?[^\s'\"]{4,}"),
+    re.compile(r"(?i)(api[_-]?key|apikey|secret|token|access[_-]?key)\s*[:=]\s*(?![\w_]+\s*\()['\"]?[A-Za-z0-9_\-]{8,}"),
+    re.compile(r"(?i)authorization\s*[:=]\s*['\"]?bearer\s+[A-Za-z0-9._\-]{8,}"),
+    re.compile(r"(?i)cookie\s*[:=]\s*['\"]?[A-Za-z0-9_=;.\-]{12,}"),
+]
+
+# 凭证应通过 E10 插件获取的迹象（用于正向确认）
+PLUGIN_CREDENTIAL_HINTS = [
+    "命名凭据", "e10 插件", "E10 插件", "ETEAMSID", "获取.*凭证", "凭据",
+    "plugin", "credential",
+]
+
+# ---------------------------------------------------------------------------
+# 运行时行为风险（B6/B7/B8）：子进程、命令行传凭证、硬编码密钥解密本地凭证
+# ---------------------------------------------------------------------------
+# 仅对脚本类扩展名做 AST 级检测，避免对文档正文误报
+SCRIPT_EXTS = (".py", ".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx",
+               ".sh", ".bash", ".bat", ".ps1", ".rb", ".pl")
+
+# 敏感子进程调用（实际调用点；import child_process 不算调用，由 COMMAND_EXEC_RE 在威胁模型中识别）
+RISKY_SUBPROCESS_RE = re.compile(
+    r"\b(spawnSync|spawn|execSync|execFileSync|execFile|exec)\s*\("
+    r"|\bsubprocess\.(Popen|run|call|check_output|check_call)\b",
+    re.IGNORECASE,
+)
+
+# 调用了包外脚本文件（.py/.sh 等拼在子进程参数里）
+EXTERNAL_SCRIPT_RE = re.compile(
+    r"['\"][^'\"]*\.(py|sh|bash|bat|ps1|pl|rb|js|mjs|ts)['\"]", re.IGNORECASE)
+
+# 子进程参数块内出现的凭证类字段（命令行明文传递）
+CRED_IN_SUBPROC_RE = re.compile(
+    r"\b(ETEAMSID|eteamsid|token|session|cookie|password|passwd|"
+    r"secret|credential|auth)\b", re.IGNORECASE)
+
+# AES / 解密调用
+AES_DECRYPT_RE = re.compile(
+    r"aes-?256|createDecipheriv|createDecipher|decipher|cipher\.update|"
+    r"cipher\.final|AES\.(new|decrypt|createDecipheriv)|CryptoJS\.AES|"
+    r"cryptography.*decrypt|fromEncryptedString|\.decrypt\(", re.IGNORECASE)
+
+# 疑似硬编码密钥常量（较长随机字符串字面量，如 'cow_eteams_auth_v1_8a3f...'）
+HARDCODED_SECRET_RE = re.compile(r"['\"][A-Za-z0-9_\-]{16,}['\"]")
+
+# 本地敏感凭证路径（会话/凭证文件）
+# 注意：第四分支要求路径上下文（引号/反引号/~/斜杠开头），避免把 x.key 这类
+# 对象属性访问误判为本地凭证文件；统一用 [^\s'"] 排除空白/引号（含换行，不跨行）。
+LOCAL_CRED_PATH_RE = re.compile(
+    r"(~?/?\.?(?:e10-cli|e10|eteams|weaver)[^\s'\"]*profiles[^\s'\"]*auth(?:[\"'\s\`]|$))"
+    r"|([^\s'\"]*profiles[^\s'\"]*/(?:auth|session|cookie|credential)(?:[\"'\s\`]|$))"
+    r"|([^\s'\"]*/(?:session|cookie|credential)[^\s'\"]*file(?:[\"'\s\`]|$))"
+    r"|([\"'`~][^\s'\"\`]*\.(?:auth|session|cookie|pem|key)(?:[\"'\s\`]|$))",
+    re.IGNORECASE)
+
+TODO_PATTERN = re.compile(r"\[?TODO\]?|待补充|待填写|placeholder\s*=|示例填写", re.IGNORECASE)
+
+
+# ---------------------------------------------------------------------------
+# 威胁模型 / 行为图谱 / 技能能力清单（新增）
+# ---------------------------------------------------------------------------
+# 说明：以下规则用于从 skill 源码/文档中识别运行时行为、威胁分类与能力清单，
+#       辅助提交前做「威胁捕获模型视图」与「威胁行为图谱」式自检。
+# 注意：C（威胁捕获模型视图）/ D（威胁行为图谱）已重新启用，详见 main() 内调用与 render_report。
+
+# 安装依赖 / 供应链风险
+DEPENDENCY_INSTALL_RE = re.compile(
+    r"\b(pip\s+install|pip3\s+install|npm\s+install|npm\s+i\b|yarn\s+add|"
+    r"pnpm\s+add|pnpm\s+install|composer\s+require|gem\s+install|"
+    r"apt-get\s+install|yum\s+install|brew\s+install)\b",
+    re.IGNORECASE)
+
+# 命令执行风险（含 eval / system / os.system 等）
+COMMAND_EXEC_RE = re.compile(
+    r"\b(eval|exec|system|os\.system|subprocess\.call|subprocess\.run|"
+    r"subprocess\.Popen|subprocess\.check_output|subprocess\.check_call|"
+    r"spawnSync|spawn|execSync|execFileSync|execFile|exec\s*\(|"
+    r"child_process|powershell|cmd\.exe|bash\s+-c|sh\s+-c)\b",
+    re.IGNORECASE)
+
+# 网络请求与数据外传（避免把 dict.get() 等误判为 HTTP GET）
+NETWORK_RE = re.compile(
+    r"\b(requests\.(get|post|put|patch|delete)|urllib\.request|http\.client|"
+    r"httpx\b|aiohttp\b|axios\.(get|post|put|patch|delete)|fetch\(|"
+    r"XMLHttpRequest|curl\b|wget\b|Invoke-WebRequest|Invoke-RestMethod|"
+    r"\.(post|put|patch|delete)\s*\()")
+EXTERNAL_API_RE = re.compile(
+    r"\b(api\.|openapi|external\s+api|third.?party|第三方接口|调用.*接口|"
+    r"https?://[^\s'\"]+/(api|v\d+|rest|graphql|webhook))",
+    re.IGNORECASE)
+
+# 文件操作（读 / 写 / 删）
+FILE_IO_RE = re.compile(
+    r"\b(open\s*\(|read_text\(|write_text\(|read_file\(|write_file\(|"
+    r"readFileSync|writeFileSync|readFile\(|writeFile\(|fs\.read|fs\.write|"
+    r"os\.path\.join|Path\(|with\s+open|\.open\s*\()\b",
+    re.IGNORECASE)
+
+# 敏感路径（凭证、系统、隐私数据）
+# 注意：这里的 `[^\s'\"]*` 一律写成有界量词 `{0,N}`。
+# 无界量词 + 末尾定界在超长单行（压缩 JS / 无换行数据）上会退化成逐起点回溯的 O(n²)，
+# 11 MB 单行曾让扫描卡死数百秒；有界后单次尝试被限制在 N 个字符内，整体降为线性。
+# 写法约定（性能关键）：每条分支都**先锚定字面量 token**，再向后做「有界尾部 + 定界」校验。
+# 反例（切勿回退）：`[^\s'\"]{0,120}(?:\.ssh|\.aws|...)` 这种「可空前缀 + 有界量词」写法，
+# 引擎会在每个起点试 120 种前缀长度 → 单次扫描退化为准 O(n·120)，1.6 MB 单行需 90+ 秒。
+SENSITIVE_PATH_RE = re.compile(
+    # ① 泛微 / eteams 客户端凭证目录（如 ~/.e10-cli/profiles/<x>/auth）
+    r"((?:e10-cli|e10|eteams|weaver)[^\s'\"]{0,120}profiles[^\s'\"]{0,120}auth(?:[\"'\s`]|$))"
+    # ② .ssh / .aws / .docker 等敏感目录本身，或其下的配置文件（如 .aws/credentials）
+    r"|((?:\.ssh|\.aws|\.kube|\.docker|\.gitconfig|\.npmrc|"
+    r"\.pypirc|id_rsa|id_dsa|known_hosts|passwd|shadow|sam)"
+    r"(?:/[^\s'\"]{0,60})?(?:[\"'\s`]|$))"
+    # ③ profiles/<x>/{auth,session,cookie,credential} 形态
+    r"|(profiles[^\s'\"]{0,60}/(?:auth|session|cookie|credential)(?:[\"'\s`]|$))",
+    re.IGNORECASE)
+
+# 浏览器控制
+BROWSER_CONTROL_RE = re.compile(
+    r"\b(playwright|puppeteer|selenium|webdriver|chromium|chrome|edge|"
+    r"browserType|launch\(|new_context\(|new_page\()\b",
+    re.IGNORECASE)
+
+# 沙箱绕过参数
+SANDBOX_BYPASS_RE = re.compile(
+    r"--no-sandbox|--disable-gpu|--disable-setuid-sandbox|--disable-dev-shm-usage|"
+    r"--no-first-run|--single-process|--disable-web-security|--disable-features", re.IGNORECASE)
+
+# dangerouslyDisableSandbox + run_in_background（跨行匹配用）
+DISABLE_SANDBOX_FLAG_RE = re.compile(r"dangerouslyDisableSandbox", re.IGNORECASE)
+RUN_BACKGROUND_FLAG_RE = re.compile(r"run_in_background", re.IGNORECASE)
+
+# 环境变量读取
+ENV_READ_RE = re.compile(
+    r"\b(os\.environ|process\.env|env\.|getenv|ENV\[|os\.getenv|"
+    r"process\.env\[|dotenv|load_dotenv)\b",
+    re.IGNORECASE)
+
+# Prompt 注入 / 诱导用户贴凭证（限定强诱导动词，避免“提供登录地址”等正常说明误报）
+PROMPT_CRED_RE = re.compile(
+    r"(ETEAMSID|token|session|cookie|password|passwd|secret|credential)\b"
+    r"[^。，\n]{0,35}(粘贴|贴到|贴入|贴进|贴出来|发给我|发过来|发送给|"
+    r"告诉我|输入.*对话|贴到对话|贴进对话)", re.IGNORECASE)
+# 否定/禁止性安全声明（如「不要要求用户直接粘贴 ETEAMSID」），属合规正向约束，非诱导贴凭证
+NEGATION_SAFE_RE = re.compile(
+    r"(不要|禁止|严禁|不得|切勿|请勿|不可|避免|不允许|拒绝|无须|无需|不必)", re.IGNORECASE)
+PROMPT_INJECTION_RE = re.compile(
+    r"(忽略.*指令|ignore\s+previous\s+instructions|忽略.*提示|"
+    r"\bDAN\b|\bjailbreak\b|越狱|绕过.*限制|你是.*现在.*需要)", re.IGNORECASE)
+
+# 远程脚本下载执行
+REMOTE_SCRIPT_EXEC_RE = re.compile(
+    r"(curl\s+[^|]*\|\s*(bash|sh|python|python3|powershell)|"
+    r"wget\s+.*\|\s*(bash|sh)|"
+    r"powershell\s+-enc|iex\s+\(Invoke-WebRequest|"
+    r"Invoke-Expression|"
+    r"https?://[^\s'\"]+\.(py|sh|ps1|bat|js|mjs)\b)",
+    re.IGNORECASE)
+
+# 可疑编码 / 混淆（不再裸匹配长串 base64，避免 URL 路径误报）
+OBFUSCATION_RE = re.compile(
+    r"(eval\s*\(\s*(atob|btoa|Base64|decodeURIComponent|unescape)|"
+    r"atob\s*\(|btoa\s*\(|base64\s+--decode|Base64\.decode|Base64\.encode|"
+    r"\\\\x[0-9a-fA-F]{2}|\\\\u[0-9a-fA-F]{4}|"
+    r"(\\x[0-9a-fA-F]{2}){8,})", re.IGNORECASE)
+
+# 其他高风险：屏幕截图、键盘记录、剪贴板读取、摄像头/麦克风
+OTHER_PRIVACY_RE = re.compile(
+    r"\b(screenshot|keylogger|clipboard|camera|microphone|录音|录屏|截屏|"
+    r"getUserMedia|navigator\.mediaDevices)\b",
+    re.IGNORECASE)
+
+# ---------------------------------------------------------------------------
+# 官方 expert-reviewer 对齐补充检测规则（G 组安全 + C 组展示 + A 组结构 + Q 组质量）
+# ---------------------------------------------------------------------------
+
+# G02: 危险 shell 命令（rm -rf /、curl|sh、sudo、chmod 777、dd、fork bomb 等）
+DANGEROUS_CMD_RE = re.compile(
+    r"\brm\s+-rf\s+/(?!\w)|"              # rm -rf /
+    r"\brm\s+-rf\s+~(?!\w)|"              # rm -rf ~
+    r"\brm\s+-rf\s+\*(?!\w)|"            # rm -rf *
+    r":\(\)\s*\{.*;\}\s*:|&?\s*\};:|"     # fork bomb :(){ :|:& };:
+    r"\bcurl\s+[^|]*\|\s*(?:bash|sh|python|python3)\b|"
+    r"\bwget\s+[^|]*\|\s*(?:bash|sh)\b|"
+    r"\bsudo\s+(?:rm|chmod|chown|dd|mkfs|kill|reboot|shutdown)\b|"
+    r"\bchmod\s+777\s+/(?!\w)|"          # chmod 777 /
+    r"\bdd\s+if=.*of=/dev/|"
+    r"\bmkfs\.\w+\s+/dev/|"
+    r">\s*/dev/sda\b|"
+    r"\bshutdown\s+-[rh]|"
+    r"\breboot\b|"
+    r"\bkill\s+-9\s+-?\d+\s*$",
+    re.IGNORECASE)
+
+# G04a: 开发者个人路径残留（/Users/xxx/、/home/xxx/、C:\Users\xxx\）
+PERSONAL_PATH_RE = re.compile(
+    r"/Users/[a-zA-Z0-9._-]+/"            # macOS: /Users/tangbin/
+    r"|/home/[a-zA-Z0-9._-]+/"           # Linux: /home/user/
+    r"|C:\\Users\\[a-zA-Z0-9._-]+\\\\"   # Windows: C:\Users\user\
+    r"|C:/Users/[a-zA-Z0-9._-]+/",       # Windows forward slash
+    re.IGNORECASE)
+
+# G04b: 其他 IDE / 平台配置目录残留
+IDE_DIR_RE = re.compile(
+    r"\.cursor/|\.vscode/|\.idea/|\.codebuddy/|\.fleet/|"
+    r"\.claude/|\.aider/|\.github/|\.gitlab/|"
+    r"\.DS_Store|Thumbs\.db",
+    re.IGNORECASE)
+
+# G04c: CDN @latest 未锁定版本（jsdelivr/unpkg/cdnjs 等）
+CDN_LATEST_RE = re.compile(
+    r"https?://(?:cdn\.jsdelivr\.net|unpkg\.com|cdnjs\.cloudflare\.com|"
+    r"cdn\.tailwindcss\.com|esm\.sh)/[^\s'\"]+@latest\b",
+    re.IGNORECASE)
+
+# G03: 扩展内网域名 / IP 段（除泛微自用域名外，补充通用内网域名）
+# 注意：10.x / 172.16-31.x / 192.168.x 由 B2 IP 检查覆盖，此处仅补充域名
+INTERNAL_DOMAIN_RE = re.compile(
+    r"\b[\w.-]+\.("
+    r"woa\.com|oa\.com|tencent\.com|"
+    r"internal|local|localhost|intranet|"
+    r"corp|privatesubnet|test\.local"
+    r")\b",
+    re.IGNORECASE)
+
+# C08: 平台虚假技术承诺（本地AI/离线运行/不上云/数据不出本机 等）
+FALSE_PROMISE_RE = re.compile(
+    r"本地AI|本地运行|离线运行|不上云|完全离线|"
+    r"无需联网|不联网|纯本地|数据不出本机|"
+    r"100%.*私密|绝对.*安全|永不泄露|"
+    r"完全私有化部署.*无需|零云端|no.*cloud|"
+    r"fully\s+offline|local\s+only|runs?\s+locally\s+only",
+    re.IGNORECASE)
+
+# BOM 检测：UTF-8 BOM (EF BB BF)
+BOM_RE = re.compile(b"\xef\xbb\xbf")
+# CRLF 行尾
+CRLF_RE = re.compile(b"\r\n")
+
+# 结构化配置文件扩展名（可解析性检查）
+STRUCTURED_EXTS = (".json", ".yaml", ".yml", ".toml")
+
+
+# ---------------------------------------------------------------------------
+# 工具函数
+# ---------------------------------------------------------------------------
+
+def log(msg):
+    sys.stderr.write(msg + "\n")
+
+
+def extract_frontmatter(content):
+    """返回 (frontmatter_text, body_text, ok)。"""
+    if not content.startswith("---"):
+        return None, content, False
+    m = re.match(r"^---\s*\n(.*?)\n---\s*\n?(.*)$", content, re.DOTALL)
+    if not m:
+        return None, content, False
+    return m.group(1), m.group(2), True
+
+
+def parse_frontmatter_field(fm, key):
+    """宽松解析 frontmatter **顶层**单行字段（容忍引号与不整齐缩进）。
+
+    仅认可顶层写法（行首顶格 `key: ...`），不认可嵌套写法——例如
+    `metadata:\\n  author: ...` 中的 author 不会被读取（视为缺失）。
+    合作方规范：所有字段（name/version/author/description 等）均为顶层，
+    不存在 metadata 块；嵌套写法由 check_frontmatter_flat_structure 单独阻断。
+    """
+    m = re.search(r"^" + re.escape(key) + r"\s*:\s*(.*)$", fm, re.MULTILINE)
+    if not m:
+        return None
+    val = m.group(1).strip()
+    # 去掉首尾引号
+    if (val.startswith('"') and val.endswith('"')) or (val.startswith("'") and val.endswith("'")):
+        val = val[1:-1]
+    return val
+
+
+def get_field(fm, *keys):
+    """按顺序读取多个候选字段名，返回首个非空值。
+
+    用于兼容不同平台/规范的字段命名差异，例如：
+        get_field(fm, "display_name", "displayName")
+        # 优先取 display_name，缺失时回退取 displayName
+    全部候选都缺失则返回 None。
+    """
+    for k in keys:
+        if not k:
+            continue
+        val = parse_frontmatter_field(fm, k)
+        if val:
+            return val, k  # 同时返回命中字段名用于提示
+    return None, (keys[0] if keys else "")
+
+
+def check_frontmatter_flat_structure(fm, checks):
+    """A2m frontmatter 顶层结构（禁止 metadata 嵌套）。
+
+    合作方规范：所有字段均为顶层，frontmatter 中不应出现 `metadata:` 块。
+    若出现嵌套且其中包含关键字段（author/version/name/description 等），
+    检测器按顶层读取会判缺失，因此嵌套写法必须 BLOCK 纠正；metadata 块内
+    无关键字段则 WARN 提示提升到顶层。
+    """
+    meta_idx = None
+    for i, ln in enumerate(fm.splitlines()):
+        if re.match(r"^metadata\s*:", ln):
+            meta_idx = i
+            break
+    if meta_idx is None:
+        return
+    lines = fm.splitlines()
+    inner = []
+    for ln in lines[meta_idx + 1:]:
+        if ln.strip() and not (ln.startswith(" ") or ln.startswith("\t")):
+            break
+        if ln.strip():
+            inner.append(ln.strip())
+    keys_in_meta = re.findall(r"^([\w-]+)\s*:", "\n".join(inner), re.MULTILINE)
+    CRITICAL_KEYS = ("author", "version", "name", "description", "description_zh",
+                     "description_en", "display_name", "display_name_en")
+    blocked = [k for k in CRITICAL_KEYS if k in keys_in_meta]
+    if blocked:
+        checks.append(Check(
+            "基础合规", "frontmatter 顶层结构(禁止metadata嵌套)", "FAIL", "BLOCK",
+            f"frontmatter 不允许 `metadata:` 嵌套块，字段 {blocked} 必须写在顶层。"
+            "嵌套写法不会被识别，将视为字段缺失。",
+            suggestion="删除 `metadata:` 层级，改为顶层字段，例如：\n"
+                       "author: 泛微网络科技股份有限公司\nversion: 1.0.0"))
+    else:
+        checks.append(Check(
+            "基础合规", "frontmatter 顶层结构(禁止metadata嵌套)", "WARN", "MEDIUM",
+            "frontmatter 中不应包含 `metadata:` 嵌套块；所有字段（name/version/author 等）均为顶层字段。",
+            suggestion="删除 `metadata:` 层级，把其中的字段提升到顶层。"))
+
+
+def check_frontmatter_yaml_syntax(fm, checks):
+    """A2n frontmatter YAML 语法真解析（BLOCK）。
+
+    平台上传时用真 YAML 解析器（Go gopkg.in/yaml）解析 SKILL.md frontmatter，
+    典型报错「yaml: line N: mapping values are not allowed in this context」，
+    常见触发：① 一行挤多个键值对（`name: xxx display_name: yyy`，粘贴丢换行）；
+    ② 值中含未加引号的 `: `（如 `description: 使用 xxx: yyy`）；③ Tab 缩进。
+    本检查双层实现：PyYAML 可用时真解析并精确报行号；否则降级为启发式扫描，
+    覆盖上述三类高频错误（零第三方依赖，保证可移植）。
+    """
+    lines = fm.splitlines()
+    errors = []
+
+    try:
+        import yaml  # noqa: F401
+        has_yaml = True
+    except ImportError:
+        has_yaml = False
+
+    if has_yaml:
+        try:
+            data = yaml.safe_load(fm)
+            if data is None:
+                errors.append("frontmatter 解析结果为空（仅含注释或空白）")
+            elif not isinstance(data, dict):
+                errors.append(f"frontmatter 解析结果不是键值映射（得到 {type(data).__name__}），"
+                              "顶层必须是一组 `key: value`")
+        except yaml.YAMLError as e:
+            mark = getattr(e, "problem_mark", None)
+            if mark is not None and mark.line < len(lines):
+                ctx = lines[mark.line].strip()[:60]
+                errors.append(f"YAML 解析失败（第 {mark.line + 1} 行，near: `{ctx}`）："
+                              f"{getattr(e, 'problem', '') or str(e)}")
+            else:
+                errors.append(f"YAML 解析失败：{e}")
+    else:
+        # 降级启发式：覆盖 Go yaml 报 mapping values are not allowed 的高频场景
+        for i, line in enumerate(lines, start=1):
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#"):
+                continue
+            indent = line[:len(line) - len(line.lstrip())]
+            if "\t" in indent:
+                errors.append(f"第 {i} 行: 行首使用 Tab 缩进（YAML 仅允许空格缩进）: `{stripped[:60]}`")
+                continue
+            # 仅检查顶层键行（行首顶格 key: value）
+            m = re.match(r"^([A-Za-z_][\w-]*)\s*:\s*(.*)$", line)
+            if not m:
+                continue
+            key, val = m.group(1), m.group(2).strip()
+            if not val:
+                continue
+            quoted = (val.startswith('"') and val.endswith('"')) or \
+                     (val.startswith("'") and val.endswith("'"))
+            if quoted:
+                # 整体引号包裹的值内部 `: ` 合法
+                continue
+            # ① 一行多键：值中再出现 ` word: `（键名后冒号+空格）
+            mm = re.search(r"(?:^|\s)([A-Za-z_][\w-]*)\s*:\s", val)
+            if mm:
+                errors.append(
+                    f"第 {i} 行: 一行内出现多个键值对（`{key}: … {mm.group(1)}: …`）。"
+                    "YAML 不允许在值中继续写键——这正是平台报 "
+                    "`mapping values are not allowed in this context` 的最常见原因"
+                    "（多为粘贴时丢失换行）。"
+                )
+                continue
+            # ② 值中含裸冒号+空格（如 `description: 支持 xx: yy 模式`）
+            if re.search(r":\s", val) and not re.match(r"https?://", val):
+                errors.append(
+                    f"第 {i} 行: `{key}` 的值中含未加引号的冒号+空格（`{stripped[:60]}`），"
+                    "会被 YAML 解析器误判为新键。请用引号包裹整个值，或改用中文全角冒号「：」。"
+                )
+
+    if errors:
+        checks.append(Check(
+            "基础合规", "frontmatter YAML 语法", "FAIL", "BLOCK",
+            "SKILL.md frontmatter 存在 YAML 语法错误，平台上传时会直接报 "
+            "「frontmatter 无法解析 / mapping values are not allowed in this context」。",
+            locations=errors[:10],
+            suggestion=(
+                "常见修复：① 每个字段独占一行（`key: value`），不要把多个字段挤在一行；"
+                "② 值中含英文冒号+空格时用引号包裹整个值（`description: '支持 xx: yy'`）；"
+                "③ 缩进只用空格，不用 Tab；④ 冒号后必须有一个空格。"
+            )
+        ))
+    else:
+        checks.append(Check(
+            "基础合规", "frontmatter YAML 语法", "PASS", "INFO",
+            "frontmatter YAML 语法校验通过"
+            + ("（PyYAML 真解析）" if has_yaml else "（启发式扫描，未安装 PyYAML）") + "。"
+        ))
+
+
+# 单文件参与正则扫描的最大字节数（超出部分截断）。
+# 背景：超大文本（如 11 MB 单行数据文件）会让扫描耗时从毫秒级膨胀到分钟级。
+MAX_SCAN_FILE_BYTES = 4 * 1024 * 1024
+
+
+def iter_text_files(root: Path):
+    """遍历 root 下所有文本文件，yield (rel_path, text)。
+
+    超大文件按 MAX_SCAN_FILE_BYTES 截断后再参与扫描：既避免病态耗时，
+    又不影响检测结论（威胁特征几乎总在前若干 KB 内出现；扫描顺序覆盖全部文件）。
+    """
+    for p in root.rglob("*"):
+        if not p.is_file():
+            continue
+        if p.suffix.lower() not in TEXT_EXTS:
+            continue
+        try:
+            text = p.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, OSError):
+            # 二进制或无法解码，跳过
+            continue
+        except MemoryError:
+            # 超大/异常文件：直接跳过，避免拖垮整体扫描
+            continue
+        if len(text.encode("utf-8", errors="ignore")) > MAX_SCAN_FILE_BYTES:
+            text = _truncate_chars(text, MAX_SCAN_FILE_BYTES)
+        yield p.relative_to(root), text
+
+
+def _truncate_chars(text: str, max_bytes: int) -> str:
+    """按字节预算安全截断文本（不切断多字节字符的语义，直接按字符切片后解码回退）。"""
+    encoded = text.encode("utf-8", errors="ignore")
+    if len(encoded) <= max_bytes:
+        return text
+    return encoded[:max_bytes].decode("utf-8", errors="ignore")
+
+
+# 单行参与正则扫描的最大字符数（超出部分截断，行号保持不变）。
+# 背景：部分检测正则含 `[^\\s'\"]*` 这类可回溯量词，在超长单行（压缩 JS、
+# 无换行数据文件）上会退化成逐起点回溯的 O(n²)，11 MB 单行曾导致扫描卡死数百秒。
+# 截断后行号一一对应，正常代码行远小于阈值，检测结论不受影响。
+SCAN_LINE_MAX_CHARS = 4000
+
+
+def scan_lines(text: str, max_chars: int = SCAN_LINE_MAX_CHARS):
+    """返回与 splitlines() 行号一一对应的截断行列表，供所有逐行正则扫描使用。"""
+    return [ln if len(ln) <= max_chars else ln[:max_chars]
+            for ln in text.splitlines()]
+
+
+def is_safe_ip(ip):
+    """判断是否为明显占位/回环地址，避免误报。"""
+    if SAFE_IP_PATTERNS.match(ip):
+        return True
+    # 数字段中带 x / * / 0 占据多段 视为占位
+    if re.search(r"\bx\b|\*|example", ip):
+        return True
+    return False
+
+
+# ---------------------------------------------------------------------------
+# 检测主流程
+# ---------------------------------------------------------------------------
+
+class Check:
+    def __init__(self, category, name, status, severity, detail, locations=None, suggestion=None, extra=None):
+        self.category = category
+        self.name = name
+        self.status = status          # PASS / FAIL / WARN / INFO
+        self.severity = severity      # BLOCK / HIGH / MEDIUM / LOW / INFO
+        self.detail = detail
+        self.locations = locations or []
+        self.suggestion = suggestion
+        self.extra = extra            # 可选：结构化附加数据（如依赖市场可达性）
+
+    def to_dict(self):
+        return {
+            "category": self.category,
+            "name": self.name,
+            "status": self.status,
+            "severity": self.severity,
+            "detail": self.detail,
+            "locations": self.locations,
+            "suggestion": self.suggestion,
+            "extra": self.extra,
+        }
+
+
+def prepare_skill_source(target: Path):
+    """
+    根据输入类型准备 skill 源码目录。
+    返回 (skill_root: Path, source_type: str, cleanup: bool, error: str, zip_raw_names: list)
+    source_type ∈ {'directory','zip','markdown'}
+    zip_raw_names: 对 zip 输入返回原始 namelist（保留 zip 条目中的反斜杠等字面字符），
+                   用于 A1a 跨平台准确判定；其他类型为 None。
+    """
+    if not target.exists():
+        return None, None, False, f"文件/目录不存在: {target}", None
+
+    if target.is_dir():
+        return target, "directory", False, None, None
+
+    suffix = target.suffix.lower()
+    if suffix == ".zip":
+        tmp = tempfile.mkdtemp(prefix="weaver_skill_")
+        zip_raw_names = []
+        try:
+            # 文件名编码鲁棒处理：优先 gbk（兼容 Windows 打包的中文名），
+            # 失败则依次回退 utf-8 / 自动（Python 依据 UTF-8 标志位选 utf-8，否则 cp437），
+            # 避免 gbk 无法解码某些字节（如 UTF-8 文件名）时直接崩溃。
+            zf = None
+            last_err = None
+            for enc in ("gbk", "utf-8", None):
+                try:
+                    zf = zipfile.ZipFile(target, "r", metadata_encoding=enc)
+                    break
+                except UnicodeDecodeError as e:
+                    last_err = e
+                    continue
+            if zf is None:
+                shutil.rmtree(tmp, ignore_errors=True)
+                return None, None, False, f"压缩包文件名解码失败: {last_err}", None
+            with zf:
+                # 防止 zip 路径穿越
+                zip_raw_names = list(zf.namelist())
+                for name in zip_raw_names:
+                    if name.startswith("/") or ".." in name.split("/"):
+                        return None, None, False, f"压缩包含不安全路径: {name}", None
+                zf.extractall(tmp)
+        except zipfile.BadZipFile:
+            shutil.rmtree(tmp, ignore_errors=True)
+            return None, None, False, "压缩包损坏或不是合法的 zip 文件", None
+        return Path(tmp), "zip", True, None, zip_raw_names
+
+    if suffix in (".md", ".markdown"):
+        # 单 Markdown 文件：视作 SKILL.md 候选，临时目录承载
+        tmp = tempfile.mkdtemp(prefix="weaver_skill_")
+        shutil.copy(target, Path(tmp) / "SKILL.md")
+        return Path(tmp), "markdown", True, None, None
+
+    return None, None, False, f"不支持的输入类型: {suffix}（仅支持 .zip / .md / 目录）", None
+
+
+def find_skill_md(root: Path):
+    """在 root 下查找 SKILL.md，返回其所在目录与路径。
+    兼容 Windows 反斜杠路径：反斜杠在 Unix 上是文件名里的字面字符，
+    需对路径字符串归一化（\\ -> /）后判断末段是否为 SKILL.md。"""
+    def _is_skill_md(p: Path) -> bool:
+        return str(p).replace("\\", "/").split("/")[-1] == "SKILL.md"
+    candidates = [p for p in root.rglob("*") if p.is_file() and _is_skill_md(p)]
+    if not candidates:
+        return None, None
+    if len(candidates) == 1:
+        p = candidates[0]
+        return p, p.parent
+    # 多个：优先选取层级最浅的（最接近 root 的）
+    candidates.sort(key=lambda p: len(p.parts))
+    p = candidates[0]
+    return p, p.parent
+
+
+def _duplicate_skill_md_at_same_level(root: Path):
+    """返回同一目录下出现多个 SKILL.md 的重复路径列表（平台 450019 的真正拒收情形）。"""
+    def _is_skill_md(p: Path) -> bool:
+        return str(p).replace("\\", "/").split("/")[-1] == "SKILL.md"
+    by_parent = {}
+    for p in root.rglob("*"):
+        if p.is_file() and _is_skill_md(p):
+            by_parent.setdefault(p.parent, []).append(p)
+    dups = []
+    for paths in by_parent.values():
+        if len(paths) > 1:
+            dups.extend(str(x) for x in paths)
+    return dups
+
+
+# ---------------------------------------------------------------------------
+# 各维度检测
+# ---------------------------------------------------------------------------
+
+def check_package_constraints(root: Path, platform: str = "weaver", target: Path = None):
+    """A. 打包约束红线：① 文件总数（按 platform 取阈值，weaver ≤ 300 / qwenwork < 1000）；
+    ③ 禁止任意位置含二进制文件；
+    ④ ZIP 包内只允许纯文本格式文件；
+    ⑤ ZIP 包整体大小（仅 qwenwork，硬性 ≤ 10 MB）。
+
+    target 为原始输入路径：zip/md 输入时直接 stat 真实文件体积（权威值）；
+    目录输入时无 archive 可测，降级为「解压后文件合计」并在结论中标注为近似值。
+
+    实现稳健性：
+    - 允许清单法 + 二进制魔数嗅探双保险：扩展名不在纯文本清单内的文件，
+      再做内容嗅探（空字节 / 文件头魔数），确保「文本扩展名却实为二进制」也漏不掉。
+    - 无扩展名的纯文本文件（LICENSE / Makefile 等）通过已知名单或嗅探放行，
+      避免因命名习惯误杀。
+    - macOS 打包垃圾（.DS_Store / ._xxx / __MACOSX/）一律判为违规二进制。
+    """
+    checks = []
+    spec = PLATFORMS.get(platform, PLATFORMS["weaver"])
+    files = [p for p in root.rglob("*") if p.is_file()]
+    total = len(files)
+    max_entries = spec["max_entries"]
+    entry_rule_name = (f"文件总数 < {max_entries + 1}" if max_entries == 999
+                       else f"文件总数 ≤ {max_entries}")
+
+    # --- ① 文件总数（按 platform 阈值） ---
+    if total > max_entries:
+        checks.append(Check(
+            "基础合规", entry_rule_name, "FAIL", "BLOCK",
+            f"包内文件总数为 {total}，超过 {spec['label']} 平台上限 {max_entries} 个，"
+            f"上传将被拒收。",
+            suggestion="清理冗余文件（如 __pycache__、.DS_Store、临时产物），"
+                       "或将大文件外链到 SKILL.md 而非塞进包里。",
+        ))
+    else:
+        checks.append(Check(
+            "基础合规", entry_rule_name, "PASS", "INFO",
+            f"包内文件总数 {total}（≤ {max_entries}）。",
+        ))
+
+    # --- ⑤ ZIP 包大小（仅 qwenwork，硬性 ≤ 10 MB） ---
+    if spec.get("max_zip_mb"):
+        max_bytes = spec["max_zip_mb"] * 1024 * 1024
+        # 优先使用真实归档文件体积（zip/md 输入）；目录输入降级为「文件合计」近似值
+        zip_note = ""
+        if target is not None and target.is_file():
+            try:
+                total_bytes = target.stat().st_size
+                zip_note = f"（实测归档文件 {target.name}）"
+            except OSError:
+                total_bytes = None
+        else:
+            total_bytes = None
+        if total_bytes is None:
+            total_bytes = 0
+            for p in files:
+                try:
+                    total_bytes += p.stat().st_size
+                except OSError:
+                    pass
+            zip_note = "（目录输入，无归档文件，取包内文件合计近似）"
+        if total_bytes > max_bytes:
+            checks.append(Check(
+                "基础合规", f"zip 包大小 ≤ {spec['max_zip_mb']} MB", "FAIL", "BLOCK",
+                f"包体积 {total_bytes / 1024 / 1024:.2f} MB {zip_note}，"
+                f"超过 {spec['label']} 平台硬性上限 {spec['max_zip_mb']} MB，上传将被拒收。",
+                suggestion=f"瘦身包体积：图片/示例文档外链到 SKILL.md，"
+                          f"剔除冗余文件，控制在 {spec['max_zip_mb']} MB 以内。",
+            ))
+        else:
+            checks.append(Check(
+                "基础合规", f"zip 包大小 ≤ {spec['max_zip_mb']} MB", "PASS", "INFO",
+                f"包体积 {total_bytes / 1024 / 1024:.2f} MB {zip_note}"
+                f"（≤ {spec['max_zip_mb']} MB）。",
+            ))
+
+    # --- ②/③ 禁止二进制 / 仅纯文本 ---
+    violations = []
+    for p in files:
+        rel = str(p.relative_to(root))
+        parts = Path(rel).parts
+        name = p.name
+        # macOS 打包垃圾（二进制/无意义）
+        if name == ".DS_Store" or name.startswith("._") or "__MACOSX" in parts:
+            violations.append((rel, "macOS 垃圾/二进制文件（禁止打包）"))
+            continue
+        ext = p.suffix.lower().lstrip(".")
+        if ext in TEXT_EXT_ALLOWLIST:
+            if _sniff_binary(p):
+                violations.append((rel, "扩展名虽为纯文本，但内容为二进制（疑似伪装）"))
+            continue
+        if ext == "":
+            if name.lower() in KNOWN_TEXT_NOEXT:
+                continue
+            if _sniff_binary(p):
+                violations.append((rel, "无扩展名且内容为二进制"))
+            # 无扩展名但内容为文本 → 放行（避免误杀 LICENSE 等）
+            continue
+        # 扩展名不在纯文本允许清单
+        if ext in BINARY_EXT_BLACKLIST or _sniff_binary(p):
+            violations.append((rel, "二进制文件（禁止）"))
+        else:
+            violations.append((rel, "非纯文本文件（不在允许清单）"))
+
+    if violations:
+        locs = [f"{rel} —— {reason}" for rel, reason in violations[:30]]
+        tail = f"（共 {len(violations)} 个，仅展示前 30）" if len(violations) > 30 else ""
+        checks.append(Check(
+            "基础合规", "仅含纯文本文件（禁止二进制）", "FAIL", "BLOCK",
+            f"包内存在 {len(violations)} 个非纯文本/二进制文件，违反"
+            f"「ZIP 包内只允许纯文本文件」规定{tail}：",
+            locations=locs,
+            suggestion="移除所有二进制/压缩/媒体文件，仅保留 .md/.py/.js/.txt/.json/.yaml 等纯文本。",
+        ))
+    else:
+        checks.append(Check(
+            "基础合规", "仅含纯文本文件（禁止二进制）", "PASS", "INFO",
+            "包内所有文件均为允许清单内的纯文本格式。",
+        ))
+
+    return checks
+
+
+def check_skill_md_naming(root: Path):
+    """A. SKILL.md 文件名大小写精确性：必须是精确大写 SKILL.md，
+    不允许 skill.md / Skill.md / Skill.MD 等任何大小写变体。
+
+    平台/工具以区分大小写方式匹配入口文件名，变体不会被识别为 skill 入口，
+    等于「无 SKILL.md」。本检查给出明确、可操作的判定与重命名建议，
+    优于笼统的「未找到 SKILL.md」。
+    """
+    checks = []
+    md_variants = [p for p in root.rglob("*") if p.is_file() and p.name.lower() == "skill.md"]
+    exact = [p for p in md_variants if p.name == "SKILL.md"]
+    wrong_case = [str(p.relative_to(root)) for p in md_variants if p.name != "SKILL.md"]
+
+    if exact and not wrong_case:
+        checks.append(Check(
+            "基础合规", "SKILL.md 文件名大小写精确", "PASS", "INFO",
+            "已找到精确大写的 SKILL.md，且无大小写变体。",
+        ))
+    elif not exact and wrong_case:
+        checks.append(Check(
+            "基础合规", "SKILL.md 文件名大小写精确", "FAIL", "BLOCK",
+            f"未找到精确大写的 SKILL.md，但发现大小写变体：{', '.join(wrong_case)}。"
+            "平台要求入口文件名必须精确为 SKILL.md（区分大小写），变体将不被识别为 skill 入口。",
+            locations=wrong_case,
+            suggestion="将变体文件重命名为 SKILL.md（首字母大写、后缀全大写 MD）。",
+        ))
+    elif exact and wrong_case:
+        checks.append(Check(
+            "基础合规", "SKILL.md 文件名大小写精确", "FAIL", "BLOCK",
+            f"同时存在精确 SKILL.md 与大小写变体 {', '.join(wrong_case)}，"
+            "可能导致平台/工具加载歧义或重复打包。",
+            locations=wrong_case,
+            suggestion="删除多余的大小写变体，仅保留 SKILL.md。",
+        ))
+    # 两者皆无：交给 check_structure 的「SKILL.md 存在」检查处理，不重复添加。
+    return checks
+
+
+def check_structure(root: Path, skill_md: Path, skill_dir: Path, source_type: str, zip_raw_names=None, platform: str = "weaver"):
+    """A. 基础合规检测。
+    默认 platform="weaver"（泛微生态，保持向后兼容）；platform="qwenwork" 时启用千问专属规则。
+    """
+    checks = []
+    spec = PLATFORMS.get(platform, PLATFORMS["weaver"])
+
+    # A1 文件/SKILL.md 存在
+    if skill_md is None:
+        # 若已存在大小写变体（skill.md/Skill.md 等），精确大小写检查已给出 BLOCK，
+        # 此处不再重复「未找到 SKILL.md」，避免提示歧义。
+        has_case_variant = any(
+            p.is_file() and p.name.lower() == "skill.md" and p.name != "SKILL.md"
+            for p in root.rglob("*")
+        )
+        if not has_case_variant:
+            checks.append(Check(
+                "基础合规", "SKILL.md 存在", "FAIL", "BLOCK",
+                "未找到 SKILL.md，这不是一个标准 WorkBuddy skill 包。"
+                + ("（单 Markdown 文件未包含 frontmatter，或压缩包内无 SKILL.md）" if source_type in ("markdown", "zip") else ""),
+                suggestion="在 skill 根目录放置 SKILL.md（含 YAML frontmatter 与正文说明）。"
+            ))
+        return checks, None
+
+    content = skill_md.read_text(encoding="utf-8")
+    checks.append(Check("基础合规", "SKILL.md 存在", "PASS", "INFO", f"已找到: {skill_md.name}"))
+
+    # A1a Windows 反斜杠路径（打包安全，阻断性）
+    # skillhub 上传校验运行在 Unix 环境，反斜杠在 zip 条目路径里会被视为文件名中的
+    # 非法/不安全字符，整包被判「文件路径不安全」而拒收。常见于 Windows 资源管理器
+    # 直接拖拽打包（中文 Windows 易写出反斜杠路径）。请用 `zip -r xxx.zip xxx/`
+    # 或 7-Zip「标准 zip」模式重新打包。
+    #
+    # 实现稳健性：必须基于 zip 原始条目名判断，不能检查解压后的 OS 路径——在 Windows
+    # 上 OS 路径天然使用 \，会 100% 误报；在 Unix 上目录输入的文件名若含 \ 也会误报。
+    # prepare_skill_source 已把 zip.namelist() 原始字符串传入 zip_raw_names。
+    if source_type == "zip" and zip_raw_names is not None:
+        _bs = [n for n in zip_raw_names if "\\" in n]
+        if _bs:
+            _sample = _bs[:5]
+            checks.append(Check(
+                "基础合规", "Windows 反斜杠路径分隔符", "FAIL", "BLOCK",
+                f"检测到 {len(_bs)} 个 zip 条目路径使用 Windows 反斜杠 `\\` 作为分隔符"
+                f"（示例：{'; '.join(_sample)}" + (" …" if len(_bs) > 5 else "") + "）。"
+                "skillhub 的上传校验运行在 Unix 环境，会把反斜杠判定为文件名中的非法/不安全字符，"
+                "整包将被标记为「文件路径不安全」而无法上传。",
+                suggestion=(
+                    "在 Windows 上重新打包：用 `zip -r weaver-e10-doc.zip weaver-e10-doc/` "
+                    "或 7-Zip 的「标准 zip」模式；不要使用资源管理器直接拖拽"
+                    "（中文 Windows 易写出反斜杠路径）。"
+                )
+            ))
+        else:
+            checks.append(Check("基础合规", "Windows 反斜杠路径分隔符", "PASS", "INFO",
+                                "未检测到 Windows 反斜杠路径分隔符，所有 zip 条目均为 Unix 正斜杠路径。"))
+    elif source_type == "directory":
+        # 目录输入不是 zip，无法从 OS 路径推断打包后的 zip 路径分隔符，跳过本检查。
+        checks.append(Check(
+            "基础合规", "Windows 反斜杠路径分隔符", "PASS", "INFO",
+            "目录输入：跳过 zip 路径分隔符检查（打包时请使用 Unix 正斜杠 `/`）。"
+        ))
+
+    # A1b 目录层级限制（打包结构合规，阻断性）
+    # Skill 包仅支持两级目录结构：根目录/二级目录/文件。以 SKILL.md 所在目录为 skill 根，
+    # 任何条目相对深度超过 2（即出现三级及以上子目录）即判 FAIL——平台解析会异常。
+    # 构建产物（__pycache__/.pyc）与隐藏项（.git、.DS_Store 等）不计入层级判定。
+    if source_type in ("zip", "directory"):
+        _deep = []
+        for _dp, _dirs, _files in os.walk(skill_dir):
+            _dirs[:] = [d for d in _dirs if d != "__pycache__" and not d.startswith(".")]
+            for _f in sorted(_files):
+                if _f.endswith(".pyc") or _f.startswith("."):
+                    continue
+                _rel = Path(_dp).relative_to(skill_dir) / _f
+                if len(_rel.parts) > 2:
+                    _deep.append(str(_rel))
+        if _deep:
+            _sample = _deep[:5]
+            checks.append(Check(
+                "基础合规", "目录层级不超过两级", "FAIL", "BLOCK",
+                f"检测到 {len(_deep)} 个条目超过两级目录结构（根目录/二级目录/文件）"
+                f"（示例：{'; '.join(_sample)}" + (" …" if len(_deep) > 5 else "") + "）。"
+                "Skill 包仅支持两级目录结构，三级及以上子目录会导致平台解析异常。",
+                suggestion=(
+                    "将深层文件上移到二级目录，仅保留「根目录/二级目录/文件」结构，"
+                    "例如 scripts/ 或 references/ 下直接放文件，不要再嵌套子目录。"
+                )
+            ))
+        else:
+            checks.append(Check("基础合规", "目录层级不超过两级", "PASS", "INFO",
+                                "所有条目均符合两级目录结构（根目录/二级目录/文件）。"))
+
+    # A1b SKILL.md 唯一性（平台 450019 的真正拒收情形：同一层级出现多个 SKILL.md）
+    # 说明：外层包裹目录（如 weaver-e10-xxx/ 单一包裹层）是允许的，平台取最浅层 SKILL.md 作为根。
+    #       仅在「同一目录下存在多个 SKILL.md」时才无法确定根目录，会被拒（450019）。
+    if source_type in ("zip", "directory"):
+        dup = _duplicate_skill_md_at_same_level(root)
+        if dup:
+            checks.append(Check(
+                "基础合规", "SKILL.md 唯一性(450019)", "FAIL", "BLOCK",
+                f"在同一目录下发现多个 SKILL.md，平台无法确定根目录，会拒绝（450019）。"
+                f"重复路径：{'; '.join(dup[:6])}" + (" …" if len(dup) > 6 else ""),
+                suggestion="每个 skill 包只保留一个 SKILL.md（移除多余的副本或合并）。"
+            ))
+        else:
+            checks.append(Check("基础合规", "SKILL.md 唯一性(450019)", "PASS", "INFO",
+                                "SKILL.md 唯一，无同级重复。"))
+
+    # A2 frontmatter
+    fm, body, fm_ok = extract_frontmatter(content)
+    if not fm_ok:
+        checks.append(Check(
+            "基础合规", "YAML frontmatter 完整", "FAIL", "BLOCK",
+            "SKILL.md 缺少以 `---` 包裹的 YAML frontmatter。",
+            suggestion="在文件开头使用:\n---\nname: xxx\ndescription: xxx\n---"
+        ))
+        return checks, (None, body)
+    checks.append(Check("基础合规", "YAML frontmatter 完整", "PASS", "INFO", "frontmatter 解析成功"))
+
+    # A2n frontmatter YAML 语法真解析（平台用真 YAML 解析器，语法错误直接拒收）
+    check_frontmatter_yaml_syntax(fm, checks)
+
+    # A2m frontmatter 顶层结构（禁止 metadata 嵌套；author/version 等必须为顶层字段）
+    check_frontmatter_flat_structure(fm, checks)
+
+    # A3 name
+    name = parse_frontmatter_field(fm, "name")
+    if not name:
+        checks.append(Check("基础合规", "name 字段", "FAIL", "BLOCK",
+                            "frontmatter 缺少 `name` 字段。",
+                            suggestion="补充 name: your-skill-name（hyphen-case）。"))
+    else:
+        if not re.match(r"^[a-z0-9-]+$", name):
+            checks.append(Check("基础合规", "name 命名规范", "FAIL", "BLOCK",
+                                f"name='{name}' 必须为 hyphen-case（仅小写字母、数字、连字符）。",
+                                suggestion="改为小写连字符命名，如 weaver-skill-detector。"))
+        elif name.startswith("-") or name.endswith("-") or "--" in name:
+            checks.append(Check("基础合规", "name 命名规范", "FAIL", "BLOCK",
+                                f"name='{name}' 不能以连字符开头/结尾，也不能含连续连字符。",
+                                suggestion="修正命名。"))            
+        elif len(name) < 3 or len(name) > 64:
+            checks.append(Check("基础合规", "name 命名规范", "FAIL", "BLOCK",
+                                f"name='{name}' 长度 {len(name)}，必须在 3-64 个字符之间。",
+                                suggestion="调整 name 长度至 3-64 个字符。"))
+        else:
+            checks.append(Check("基础合规", "name 命名规范", "PASS", "INFO",
+                                f"name='{name}' 合法（字符集/首尾/连字符/长度 3-64 均通过）"))
+
+    # A3b name 前缀（按 platform 区分：weaver 必须 weaver- 开头；qwenwork 无品牌前缀要求）
+    if name:
+        if platform == "weaver":
+            if not name.startswith("weaver"):
+                checks.append(Check(
+                    "基础合规", "name 前缀(泛微强制)", "FAIL", "BLOCK",
+                    f"name='{name}' 必须以 `weaver` 开头。泛微相关 skill 的唯一标识必须以 weaver 作为前缀。",
+                    suggestion="将 name 改为以 weaver 开头，如 weaver-e10-xxx。"))
+            else:
+                checks.append(Check("基础合规", "name 前缀(泛微强制)", "PASS", "INFO",
+                                    f"name='{name}' 以 weaver 开头"))
+        elif platform == "qwenwork":
+            # 千问硬性：仅小写字母、数字、连字符，首尾不能是连字符，≤ 64 字符（沿用 A3 命名规范）
+            # 千问另要求 name 与目录名完全一致（精确匹配在 A4b 单独触发）
+            if len(name) > 64:
+                checks.append(Check(
+                    "基础合规", "name 长度(千问硬性 ≤ 64)", "FAIL", "BLOCK",
+                    f"name='{name}' 长度 {len(name)}，超过千问硬性上限 64 字符。",
+                    suggestion="精简 name 至 64 字符以内。"))
+
+    # A4 千问规范：name 与目录名完全一致（精确路径匹配 <name>/SKILL.md，硬性）
+    # 三种输入形态都能判定：
+    #   zip       → 用原始 namelist 精确比对 "<name>/SKILL.md"
+    #   directory → 用 SKILL.md 所在目录名比对 name（与解压后必须保留同名目录等价）
+    #   markdown  → 单文件输入无目录结构，不做该项判定
+    if name and platform == "qwenwork":
+        if source_type == "zip" and zip_raw_names:
+            # 千问硬性：必须存在精确路径 <name>/SKILL.md（区分大小写、区分路径分隔符）
+            target_path = f"{name}/SKILL.md"
+            has_exact = any(
+                n == target_path or n == f"./{target_path}"
+                for n in zip_raw_names
+            )
+            if not has_exact:
+                checks.append(Check(
+                    "基础合规", "千问硬性 <name>/SKILL.md 精确路径", "FAIL", "BLOCK",
+                    f"千问硬性要求压缩包内必须存在精确路径 `<name>/SKILL.md`（即 `{target_path}`），"
+                    f"且目录名与填写的名称完全一致。这是千问平台最高频的失败原因——"
+                    f"macOS Finder 右键压缩文件会得到 `SKILL.md` 而不是 `<name>/SKILL.md`，会被直接拒收。",
+                    suggestion=(
+                        f"在命令行执行：`zip -r my-skill.zip {name}/`（带上外层目录一起压缩），\\"
+                        f"不要使用 Finder 的「压缩 N 项」只压缩内部文件。"
+                    )
+                ))
+            else:
+                checks.append(Check(
+                    "基础合规", "千问硬性 <name>/SKILL.md 精确路径", "PASS", "INFO",
+                    f"精确路径 `{target_path}` 命中。"
+                ))
+        elif source_type == "directory" and skill_dir is not None:
+            # 目录输入：无 zip namelist 可比对，改为校验「SKILL.md 所在目录名 == name」，
+            # 与 zip 场景的 <name>/SKILL.md 等价（解压后同样必须保留外层同名目录）。
+            dir_name = skill_dir.name
+            if dir_name != name:
+                checks.append(Check(
+                    "基础合规", "千问硬性 <name>/SKILL.md 精确路径", "FAIL", "BLOCK",
+                    f"SKILL.md 所在目录名为 `{dir_name}`，与 frontmatter 的 name=`{name}` 不一致。"
+                    f"千问硬性要求入口路径为 `<name>/SKILL.md`，解压后同样必须保留这层同名目录，"
+                    f"否则会被直接拒收。",
+                    suggestion=f"把 SKILL.md 放进以 `{name}` 命名的目录后再打包："
+                               f"`mkdir -p {name} && mv SKILL.md {name}/ && zip -r {name}.zip {name}/`"
+                ))
+            else:
+                checks.append(Check(
+                    "基础合规", "千问硬性 <name>/SKILL.md 精确路径", "PASS", "INFO",
+                    f"SKILL.md 位于 `<name>/` 目录（`{name}/SKILL.md`）命中。"
+                ))
+
+    # A4 description
+    desc = parse_frontmatter_field(fm, "description")
+    if not desc:
+        checks.append(Check("基础合规", "description 字段", "FAIL", "BLOCK",
+                            "frontmatter 缺少 `description` 字段。",
+                            suggestion="补充 description，写明技能做什么、何时触发。"))
+    else:
+        if len(desc) > 1024:
+            checks.append(Check("基础合规", "description 长度(1-1024)", "FAIL", "BLOCK",
+                                f"description 长度 {len(desc)} 字符，超过 1024 字符上限。",
+                                suggestion="精简 description 至 1024 字符以内；详细内容放入 description_zh/description_en 或正文。"))
+        elif "<" in desc or ">" in desc:
+            checks.append(Check("基础合规", "description 无尖括号", "WARN", "LOW",
+                                "description 包含尖括号 `<` 或 `>`。平台规范未禁止，但建议改为全角〈〉或直接移除占位符，"
+                                "避免个别 YAML 解析器对未加引号的尖括号标量产生误判。",
+                                suggestion="将 <> 占位符改为中文全角〈〉，或移除；确保 YAML 中 description 用单引号包裹。"))
+        elif len(desc) < 20:
+            checks.append(Check("基础合规", "description 充分性", "WARN", "MEDIUM",
+                                f"description 仅 {len(desc)} 字，过于简略，不利于触发匹配。",
+                                suggestion="补全为 1-3 句：技能能力 + 触发场景。"))
+        else:
+            checks.append(Check("基础合规", "description 充分性", "PASS", "INFO",
+                                f"description 长度 {len(desc)} 字，内容充分。"))
+
+    # A5 agent_created 标志
+    if parse_frontmatter_field(fm, "agent_created") != "true":
+        checks.append(Check("基础合规", "agent_created 标志", "WARN", "LOW",
+                            "缺少 `agent_created: true`（由 WorkBuddy 生成的技能建议带此标志，便于后续管理）。",
+                            suggestion="在 frontmatter 增加 agent_created: true"))
+    else:
+        checks.append(Check("基础合规", "agent_created 标志", "PASS", "INFO", "已包含 agent_created: true"))
+
+    # A5b 中文展示名（按 platform 区分字段名 + 前缀要求）
+    cn_name_field = spec["name_cn_field"]
+    cn_aliases = tuple(filter(None, [cn_name_field, "display_name", "displayName"]))
+    cn_name, cn_hit_field = get_field(fm, *cn_aliases)
+    cn_prefix_required = spec.get("name_cn_prefix_required")
+    if not cn_name:
+        checks.append(Check(
+            "基础合规", f"{cn_name_field} 字段", "FAIL", "BLOCK",
+            f"frontmatter 缺少 `{cn_name_field}` 字段（{spec['label']}规范必填）。",
+            suggestion=f"补充 {cn_name_field}: 中文展示名称"))
+    elif cn_prefix_required and not cn_name.startswith(cn_prefix_required):
+        checks.append(Check(
+            "基础合规", f"{cn_name_field} 前缀({cn_prefix_required}强制)", "FAIL", "BLOCK",
+            f"{cn_name_field}='{cn_name}' 必须以「{cn_prefix_required}」开头。",
+            suggestion=f"将 {cn_name_field} 改为以「{cn_prefix_required}」开头，"
+                       f"如「{cn_prefix_required} E10 日程管理」。"))
+    else:
+        checks.append(Check("基础合规", f"{cn_name_field} 字段", "PASS", "INFO",
+                            f"{cn_name_field}='{cn_name}' 符合要求"))
+
+    # A5c 英文展示名（按 platform 区分字段名）
+    en_name_field = spec["name_en_field"]
+    en_aliases = tuple(filter(None, [en_name_field, "display_name_en", "name_en"]))
+    en_name, _ = get_field(fm, *en_aliases)
+    if not en_name:
+        checks.append(Check(
+            "基础合规", f"{en_name_field} 字段", "FAIL", "BLOCK",
+            f"frontmatter 缺少 `{en_name_field}` 字段（{spec['label']}规范必填）。",
+            suggestion=f"补充 {en_name_field}: English Display Name"))
+    else:
+        checks.append(Check("基础合规", f"{en_name_field} 字段", "PASS", "INFO",
+                            f"{en_name_field}='{en_name}'"))
+
+    # A5d 中文描述（按 platform 区分字段名）
+    # 千问：description 直接是中文（已在 A4 校验）；description_zh 不强制，但仍可识别存在
+    desc_cn_field = spec["desc_cn_field"]
+    desc_cn_aliases = tuple(filter(None, [desc_cn_field, "description_zh", "description"]))
+    desc_cn, desc_cn_hit = get_field(fm, *desc_cn_aliases)
+    if not desc_cn:
+        # 千问模式下，description 在前面已经校验过必填，所以这里基本不会触发
+        checks.append(Check(
+            "基础合规", f"{desc_cn_field} 字段", "FAIL", "BLOCK",
+            f"frontmatter 缺少 `{desc_cn_field}` 字段（{spec['label']}规范必填）。",
+            suggestion=f"补充 {desc_cn_field}: 简短中文介绍"))
+    else:
+        checks.append(Check("基础合规", f"{desc_cn_field} 字段", "PASS", "INFO",
+                            f"{desc_cn_hit or desc_cn_field} 长度 {len(desc_cn)} 字"))
+
+    # A5e 英文描述（按 platform 区分字段名）
+    desc_en_field = spec["desc_en_field"]
+    desc_en_aliases = tuple(filter(None, [desc_en_field, "description_en"]))
+    desc_en, _ = get_field(fm, *desc_en_aliases)
+    if not desc_en:
+        checks.append(Check(
+            "基础合规", f"{desc_en_field} 字段", "FAIL", "BLOCK",
+            f"frontmatter 缺少 `{desc_en_field}` 字段（{spec['label']}规范必填）。",
+            suggestion=f"补充 {desc_en_field}: A Brief English Introduction"))
+    else:
+        checks.append(Check("基础合规", f"{desc_en_field} 字段", "PASS", "INFO",
+                            f"{desc_en_field} 长度 {len(desc_en)} 字符"))
+
+    # A5f version 字段（泛微强制）
+    version = parse_frontmatter_field(fm, "version")
+    if not version:
+        checks.append(Check(
+            "基础合规", "version 字段", "FAIL", "BLOCK",
+            "frontmatter 缺少顶层 `version` 字段（不允许 metadata 嵌套，嵌套写法判为缺失）。",
+            suggestion="补充顶层 version: 1.0.0"))
+    elif not re.fullmatch(r"\d+\.\d+\.\d+", version):
+        checks.append(Check(
+            "基础合规", "version 格式(SemVer)", "FAIL", "BLOCK",
+            f"version='{version}' 不符合 SemVer 格式。必须是「主版本.次版本.修订号」三段纯数字（如 1.0.0），"
+            "不支持 v1.0、1.0、latest 等非标准格式。",
+            suggestion="改为严格的 x.y.z 三段数字格式，如 1.0.0。"))
+    else:
+        checks.append(Check("基础合规", "version 字段", "PASS", "INFO",
+                            f"version='{version}' 符合 SemVer 格式"))
+
+    # A9 author 作者字段（按 platform 区分）
+    # - weaver：硬性要求顶层 author = 「泛微网络科技股份有限公司」
+    # - qwenwork：可选字段（author 用于展示给用户的发布方名称，255 字符内）
+    author_locked = spec.get("author_locked")
+    author = parse_frontmatter_field(fm, "author")
+    if author_locked:
+        if not author:
+            checks.append(Check(
+                "基础合规", "author 作者字段(泛微强制)", "FAIL", "BLOCK",
+                "frontmatter 缺少顶层 `author` 字段。"
+                "提交至泛微相关市场的 skill 必须声明作者为「泛微网络科技股份有限公司」。",
+                suggestion=f"在 frontmatter 顶层增加：\nauthor: {author_locked}"
+            ))
+        elif author != author_locked:
+            checks.append(Check(
+                "基础合规", "author 作者字段(泛微强制)", "FAIL", "BLOCK",
+                f"作者字段值为「{author}」，不符合要求。泛微相关 skill 的作者必须声明为「{author_locked}」。",
+                suggestion=f"将 author 改为：{author_locked}"
+            ))
+        else:
+            checks.append(Check("基础合规", "author 作者字段(泛微强制)", "PASS", "INFO",
+                                f"author='{author}' 符合泛微作者要求"))
+    else:
+        # 千问模式：author 是「推荐」字段，不强制；缺失只给 INFO 提示
+        if author:
+            if len(author) > 255:
+                checks.append(Check(
+                    "基础合规", "author 长度(≤ 255)", "WARN", "LOW",
+                    f"author 长度 {len(author)}，超过推荐上限 255 字符。",
+                    suggestion="精简至 255 字符以内。"
+                ))
+            else:
+                checks.append(Check("基础合规", "author 字段(推荐)", "PASS", "INFO",
+                                    f"author='{author}'"))
+        else:
+            checks.append(Check("基础合规", "author 字段(推荐)", "INFO", "INFO",
+                                "frontmatter 未声明 author（千问推荐字段，可选）："
+                                "展示给用户的发布方名称，便于用户识别。"))
+
+    # A5f 千问特有：author_name 字段（必填，255 字符内，新建必填）
+    #     与 author 的区别：author_name 是表单字段（市场列表展示），author 是 frontmatter 字段
+    extra_field = spec.get("extra_name_field")
+    if extra_field:
+        extra_val = parse_frontmatter_field(fm, extra_field)
+        if not extra_val:
+            checks.append(Check(
+                "基础合规", f"{extra_field} 字段(千问硬性)", "FAIL", "BLOCK",
+                f"frontmatter 缺少 `{extra_field}` 字段（千问硬性必填）。"
+                f"这是「创建表单必填字段」对应的 frontmatter 字段，新建技能时必须填写，"
+                f"后续编辑不强求重填。",
+                suggestion=f"补充 {extra_field}: 发布方名称（≤ 255 字符）"))
+        elif len(extra_val) > 255:
+            checks.append(Check(
+                "基础合规", f"{extra_field} 长度(≤ 255)", "FAIL", "BLOCK",
+                f"{extra_field}='{extra_val}' 长度 {len(extra_val)}，超过硬性上限 255 字符。",
+                suggestion=f"精简 {extra_field} 至 255 字符以内。"))
+        else:
+            checks.append(Check("基础合规", f"{extra_field} 字段", "PASS", "INFO",
+                                f"{extra_field}='{extra_val}'"))
+
+    # A5h 千问特有：argument-hint 字段（推荐，可缺不阻）
+    #     用户点开该技能时预填在输入框里的引导语；缺则没预填，用户自由输入。
+    if platform == "qwenwork":
+        arg_hint = parse_frontmatter_field(fm, "argument-hint")
+        if arg_hint:
+            checks.append(Check("基础合规", "argument-hint 字段", "PASS", "INFO",
+                                f"argument-hint='{arg_hint}'（预填引导语已设置）"))
+        else:
+            checks.append(Check("基础合规", "argument-hint 字段", "INFO", "INFO",
+                                "未设置 argument-hint（千问推荐，可缺不阻）："
+                                "用于在用户输入框预填引导语，如「合同文件或条款文本」。"))
+
+    # A6 目录名一致性（仅真实目录输入有意义；zip 解包临时目录名为随机值，跳过）
+    if source_type == "directory" and name:
+        if skill_dir.name != name:
+            checks.append(Check("基础合规", "目录名与 name 一致", "WARN", "MEDIUM",
+                                f"目录名 '{skill_dir.name}' 与 frontmatter name '{name}' 不一致。",
+                                suggestion="确保 skill 目录名与 name 完全一致（打包时外层目录即 name）。"))
+        else:
+            checks.append(Check("基础合规", "目录名与 name 一致", "PASS", "INFO", "目录名与 name 一致"))
+    elif source_type in ("zip", "markdown") and name:
+        checks.append(Check("基础合规", "目录名与 name 一致", "INFO", "INFO",
+                            "zip / 单 md 输入无法校验目录名，跳过（平台以 name 字段为准）。"))
+
+    # A7 TODO 占位符残留
+    todo_hits = []
+    for m in TODO_PATTERN.finditer(body):
+        todo_hits.append(m.group(0))
+    if todo_hits:
+        checks.append(Check("基础合规", "无 TODO 占位残留", "WARN", "MEDIUM",
+                            f"正文仍含占位标记: {', '.join(sorted(set(todo_hits))[:5])}",
+                            suggestion="删除模板占位符，填充真实内容。"))
+    else:
+        checks.append(Check("基础合规", "无 TODO 占位残留", "PASS", "INFO", "正文无模板占位符"))
+
+    # A8 正文体量
+    if len(body.strip()) < 100:
+        checks.append(Check("基础合规", "正文内容充实", "WARN", "MEDIUM",
+                            f"SKILL.md 正文仅 {len(body.strip())} 字，偏空。",
+                            suggestion="补充技能说明、流程、示例。"))
+    else:
+        checks.append(Check("基础合规", "正文内容充实", "PASS", "INFO", f"正文 {len(body.strip())} 字"))
+
+    # A8b 正文档行数（建议 ≤500 行，内容过多时拆分到 references/ 独立文件）
+    body_lines = len(body.splitlines())
+    if body_lines > 500:
+        checks.append(Check("基础合规", "正文档行数≤500", "WARN", "MEDIUM",
+                            f"SKILL.md 正文 {body_lines} 行，超过建议上限 500 行。",
+                            suggestion="将详细内容拆分为 references/ 目录下的独立文件，正文只保留路由触发与核心说明。"))
+    else:
+        checks.append(Check("基础合规", "正文档行数≤500", "PASS", "INFO", f"正文 {body_lines} 行"))
+
+    # A11d 千问硬性：SKILL.md 正文 ≤ 64 KB（超出部分会被市场详情页截断）
+    if spec.get("max_body_kb"):
+        max_kb = spec["max_body_kb"]
+        body_bytes = len(body.encode("utf-8"))
+        if body_bytes > max_kb * 1024:
+            checks.append(Check(
+                "基础合规", f"SKILL.md 正文 ≤ {max_kb} KB", "FAIL", "BLOCK",
+                f"SKILL.md 正文 UTF-8 字节 {body_bytes / 1024:.2f} KB，"
+                f"超过 {spec['label']}硬性上限 {max_kb} KB，"
+                f"超出部分会被市场详情页说明文档展示时截断（不影响上传成功，但首屏体验劣化）。",
+                suggestion=f"将长知识拆到 references/ 目录，正文只保留路由触发与核心说明，控制在 {max_kb} KB 以内。"
+            ))
+        else:
+            checks.append(Check(
+                "基础合规", f"SKILL.md 正文 ≤ {max_kb} KB", "PASS", "INFO",
+                f"SKILL.md 正文 UTF-8 字节 {body_bytes / 1024:.2f} KB（≤ {max_kb} KB）。"
+            ))
+
+    # A6c 千问特有：category_code 字段（推荐，14 个固定分类枚举）
+    category_enum = spec.get("category_enum")
+    if category_enum:
+        cat_code = parse_frontmatter_field(fm, "category_code")
+        if cat_code:
+            if cat_code not in category_enum:
+                checks.append(Check(
+                    "基础合规", "category_code 分类(千问硬性枚举)", "FAIL", "BLOCK",
+                    f"category_code='{cat_code}' 不在千问固定 14 个分类清单内。",
+                    suggestion=f"从下列分类中选一个：{', '.join(category_enum)}。",
+                    locations=[f"category_code={cat_code}"]))
+            else:
+                checks.append(Check(
+                    "基础合规", "category_code 分类(千问硬性枚举)", "PASS", "INFO",
+                    f"category_code='{cat_code}' 属于千问固定分类。"))
+        else:
+            checks.append(Check(
+                "基础合规", "category_code 分类(推荐)", "INFO", "INFO",
+                "未设置 category_code（千问推荐字段）："
+                f"从 14 个分类中选一个，便于市场筛选归类：{', '.join(category_enum)}。"))
+
+    # A6e 千问特有：icon 字段（必需，公网可访问的 icon_url）
+    if platform == "qwenwork":
+        icon = parse_frontmatter_field(fm, "icon") or parse_frontmatter_field(fm, "icon_url")
+        if not icon:
+            checks.append(Check(
+                "基础合规", "icon 字段(千问硬性)", "FAIL", "BLOCK",
+                "frontmatter 缺少 `icon` 字段（千问硬性必填）。"
+                "用于在市场列表展示技能图标，必须是公网可访问的 URL（推荐 HTTPS）。",
+                suggestion="补充 icon: https://example.com/icon-240.png  "
+                          "（规格 240*240 PNG，≤ 2 MB；SVG 免尺寸校验）"))
+        else:
+            if not re.match(r"^https?://", icon):
+                checks.append(Check(
+                    "基础合规", "icon 协议(千问)", "WARN", "LOW",
+                    f"icon='{icon}' 不是 http(s) URL；千问要求公网可访问。",
+                    suggestion="icon 改为公网 URL，如 https://example.com/icon-240.png。"))
+            else:
+                checks.append(Check(
+                    "基础合规", "icon 字段(千问硬性)", "PASS", "INFO",
+                    f"icon='{icon}'（公网 URL）"))
+
+    # A6f 千问特有：tags 字段（推荐，回车或逗号分隔）
+    if platform == "qwenwork":
+        tags_raw = parse_frontmatter_field(fm, "tags")
+        if tags_raw:
+            # 仅做基本结构校验：含中英文/数字/下划线/逗号分隔即可；详细过滤是平台职责
+            checks.append(Check(
+                "基础合规", "tags 字段(推荐)", "PASS", "INFO",
+                f"tags='{tags_raw}'（当前不在市场界面展示，仅用于平台内部筛选归类）"))
+        else:
+            checks.append(Check(
+                "基础合规", "tags 字段(推荐)", "INFO", "INFO",
+                "未设置 tags（推荐，可选）：回车或逗号分隔录入，自动去重。"
+                "当前不在市场界面展示，仅用于平台内部筛选归类，按需填写。"))
+
+    # A6g 千问特有：初始提示词（可选，frontmatter 中以 description 替代——已在 A4 校验）
+
+    # A8c 引用相对路径规范：引用其他文件须使用相对 Skills 根目录的路径
+    #    （如 references/api-docs.md、scripts/main.py），且被引用文件须真实存在于包内。
+    bad_refs, missing_refs = [], []
+    ref_candidates = set()
+    # ① Markdown 链接目标：[文本](path)
+    for m in re.finditer(r"\[[^\]]*\]\(([^)\s]+)\)", body):
+        p = m.group(1).strip()
+        if p and not p.startswith(("http://", "https://", "#", "mailto:", "//")):
+            ref_candidates.add(p)
+    # ② 反引号包裹的路径（须带目录段 + 文件扩展名，如 references/api-docs.md；兼容反斜杠与前导 / 以捕获违规）
+    for m in re.finditer(r"`(/?(?:[\w.-]+[/\\])+[\w.-]+\.[A-Za-z0-9]+)`", body):
+        ref_candidates.add(m.group(1).strip())
+    # 占位符/示例路径豁免：<xxx>、{var}、xxx.md、your-xxx、示例/模板字样等，避免文档举例误报
+    _PLACEHOLDER_RE = re.compile(r"[<>{}*]|xxx|yyy|zzz|your[-_]|示例|模板|占位")
+    # 运行时系统路径豁免：/tmp/、/Users/、~/、C:\ 等是文档描述的运行时数据目录，不是「引用包内文件」
+    _RUNTIME_PATH_RE = re.compile(
+        r"^(?:/(?:tmp|var|usr|etc|home|Users|opt|private|Library|System|data|srv|mnt)/|~/|[A-Za-z]:[\\/])",
+        re.IGNORECASE)
+    # 存在性校验仅针对已知资源目录前缀：其余自定义相对路径可能是运行时产物描述，不校验以免误报
+    _RESOURCE_DIR_RE = re.compile(
+        r"^(?:references|scripts|assets|docs|examples|templates|config|prompts|data|output|outputs)/",
+        re.IGNORECASE)
+    for p in sorted(ref_candidates):
+        if _PLACEHOLDER_RE.search(p):
+            continue
+        if _RUNTIME_PATH_RE.match(p):
+            continue  # 运行时系统路径（非包内文件引用），跳过
+        if "\\" in p:
+            bad_refs.append(f"{p}（含反斜杠，须用 / 分隔）")
+            continue
+        if p.startswith("/"):
+            bad_refs.append(f"{p}（绝对路径，须改为相对 skill 根目录的路径）")
+            continue
+        norm = p[2:] if p.startswith("./") else p
+        norm = norm.split("#")[0].strip()
+        if norm and _RESOURCE_DIR_RE.match(norm) and not (skill_dir / norm).exists():
+            missing_refs.append(norm)
+    if bad_refs or missing_refs:
+        _parts = []
+        if bad_refs:
+            _parts.append("路径格式问题: " + "; ".join(bad_refs[:5]))
+        if missing_refs:
+            _parts.append("引用文件不存在: " + "; ".join(missing_refs[:5]))
+        checks.append(Check("基础合规", "引用相对路径规范", "WARN", "MEDIUM",
+                            "。".join(_parts) + "。引用其他文件时必须使用相对 Skills 根目录的路径。",
+                            suggestion="改为如 references/api-docs.md、scripts/main.py 的相对路径，并确保被引用文件已随包分发。"))
+    else:
+        checks.append(Check("基础合规", "引用相对路径规范", "PASS", "INFO",
+                            "正文引用路径均为相对路径且文件存在"))
+
+    return checks, (name, body)
+
+
+def _is_detector_script(rel: str, text: str) -> bool:
+    """判断是否为检测工具自身源码（避免规则定义字符串自匹配误报）。"""
+    return rel == "scripts/validate_skill.py" and ("泛微技能检测工具" in text or "weaver-skill-detector" in text)
+
+
+def _is_detector_doc(rel: str, text: str) -> bool:
+    """判断是否为检测工具自身说明文档（避免规则说明文字被当成风险命中）。"""
+    if rel not in ("SKILL.md", "references/checklist.md"):
+        return False
+    return "泛微技能检测工具" in text or "weaver-skill-detector" in text
+
+
+def check_weaver_compliance(skill_dir: Path, body: str, source_type: str):
+    """B. 泛微专项质检（安全合规）。"""
+    checks = []
+
+    # 汇总所有文本文件内容用于扫描（排除检测工具自身源码，避免正则常量自匹配）
+    file_texts = {}
+    for rel, text in iter_text_files(skill_dir):
+        if _is_detector_script(str(rel), text):
+            continue
+        file_texts[str(rel)] = text
+    # 也确保 SKILL.md 正文在列（单 md 情形）
+    all_text = "\n".join(file_texts.values())
+
+    # B1 默认登录地址指向泛微自用系统（核心红线）
+    # 仅在「作为 URL」或「赋值给配置型变量」时判定为默认地址，
+    # 避免 SKILL.md / references 正文为说明规则而提及域名时造成误报。
+    CONFIG_VAR_RE = re.compile(
+        r"^\s*[A-Za-z_\u4e00-\u9fff]*(?:url|host|base|login|endpoint|address|addr|"
+        r"server|domain|site|target|api|default|link)[A-Za-z_\u4e00-\u9fff]*\s*[:=]",
+        re.IGNORECASE,
+    )
+    URL_RE = re.compile(r"https?://", re.IGNORECASE)
+    default_addr_hits = []
+    for rel, text in file_texts.items():
+        for li, line in enumerate(scan_lines(text), start=1):
+            lower = line.lower()
+            for domain in WEAVER_OWNED_DOMAINS:
+                if domain.lower() not in lower:
+                    continue
+                is_url = bool(URL_RE.search(line))
+                is_assign = bool(CONFIG_VAR_RE.match(line))
+                if is_url or is_assign:
+                    default_addr_hits.append(f"{rel}:{li} → {line.strip()[:120]}")
+                break
+    if default_addr_hits:
+        checks.append(Check(
+            "专项质检", "默认登录地址未指向泛微自用系统", "FAIL", "BLOCK",
+            "检测到 skill 内写死了泛微自用系统域名（如 e-cology.com.cn）。"
+            "若作为默认值，客户下载后会访问到泛微自用系统，存在越权访问与隐私合规风险。",
+            locations=default_addr_hits[:20],
+            suggestion="移除写死的默认地址；改为运行时由用户显式提供自身系统地址，"
+                      "或在说明中要求用户填写自有域名，绝不给默认系统地址。"
+        ))
+    else:
+        checks.append(Check("专项质检", "默认登录地址未指向泛微自用系统", "PASS", "INFO",
+                            "未发现泛微自用域名写死为默认地址。"))
+
+    # B2 硬编码真实 IP
+    ip_hits = []
+    ip_re = re.compile(r"\b(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\b")
+    for rel, text in file_texts.items():
+        text_lines = scan_lines(text)  # 每个文件只截断一次，避免逐命中重复构造
+        for m in ip_re.finditer(text):
+            ip = m.group(1)
+            parts = ip.split(".")
+            if not all(0 <= int(p) <= 255 for p in parts):
+                continue
+            if is_safe_ip(ip):
+                continue
+            line_no = text.count("\n", 0, m.start()) + 1
+            snippet = text_lines[line_no - 1].strip() if line_no <= len(text_lines) else ""
+            ip_hits.append(f"{rel}:{line_no} → {ip}  ({snippet[:80]})")
+    if ip_hits:
+        checks.append(Check(
+            "专项质检", "无硬编码真实 IP", "WARN", "HIGH",
+            "检测到疑似硬编码 IP 地址（可能是真实服务器地址）。对外分发前必须脱敏。",
+            locations=ip_hits[:20],
+            suggestion="将真实 IP 替换为占位符（如 <服务器IP> 或 192.168.x.x 示例），"
+                      "并改为配置/参数传入。"
+        ))
+    else:
+        checks.append(Check("专项质检", "无硬编码真实 IP", "PASS", "INFO", "未发现疑似硬编码真实 IP"))
+
+    # B3 硬编码凭证
+    cred_hits = []
+    for rel, text in file_texts.items():
+        text_lines = scan_lines(text)  # 每个文件只截断一次，避免逐命中重复构造
+        for pat in CREDENTIAL_PATTERNS:
+            for m in pat.finditer(text):
+                line_no = text.count("\n", 0, m.start()) + 1
+                snippet = text_lines[line_no - 1].strip() if line_no <= len(text_lines) else ""
+                cred_hits.append(f"{rel}:{line_no} → {snippet[:120]}")
+    if cred_hits:
+        checks.append(Check(
+            "专项质检", "无硬编码凭证", "WARN", "HIGH",
+            "检测到疑似硬编码凭证（密码 / token / secret / api_key 等字面量）。",
+            locations=cred_hits[:20],
+            suggestion="移除硬编码凭证；统一通过 E10 命名凭据插件获取（如 key=ETEAMSID），"
+                      "严禁将密钥写入脚本或聊天。"
+        ))
+    else:
+        checks.append(Check("专项质检", "无硬编码凭证", "PASS", "INFO", "未发现疑似硬编码凭证"))
+
+    # B4 凭证来源建议（若涉及 Weaver API 调用）
+    mentions_api = bool(re.search(r"e10|eteams|e-cology|weaver|api|接口", all_text, re.IGNORECASE))
+    mentions_plugin = any(re.search(h, all_text, re.IGNORECASE) for h in PLUGIN_CREDENTIAL_HINTS)
+    if mentions_api and not mentions_plugin:
+        checks.append(Check(
+            "专项质检", "凭证应通过插件获取", "WARN", "MEDIUM",
+            "skill 涉及 Weaver / API 调用，但未说明凭证通过 E10 插件（命名凭据）获取。",
+            suggestion="补充：凭证须由 E10 命名凭据插件提供，禁止硬编码或 Playwright 登录兜底。"
+        ))
+    elif mentions_api and mentions_plugin:
+        checks.append(Check("专项质检", "凭证应通过插件获取", "PASS", "INFO",
+                            "已说明使用 E10 插件/命名凭据获取凭证。"))
+    else:
+        checks.append(Check("专项质检", "凭证应通过插件获取", "INFO", "INFO",
+                            "未检测到 Weaver API 调用，跳过此项。"))
+
+    # B5 敏感词占位规范（软性）
+    uses_placeholder = "-替换敏感词占位符-" in all_text
+    if uses_placeholder:
+        checks.append(Check("专项质检", "敏感词占位规范", "PASS", "INFO",
+                            "已采用 `-替换敏感词占位符-` 占位规范处理敏感内容。"))
+    else:
+        checks.append(Check("专项质检", "敏感词占位规范", "INFO", "INFO",
+                            "未检测到敏感词占位处理；若 skill 会向 Weaver 发送内容，"
+                            "建议复用 `-替换敏感词占位符-` 规范以避免敏感词拦截。"))
+
+    # -----------------------------------------------------------------------
+    # B6/B7/B8 运行时行为风险（仅扫描脚本类文件）
+    # 子进程调用块上下文：命中行 + 后续 6 行（覆盖 spawn/exec 的 args / command 列表）
+    # -----------------------------------------------------------------------
+    ext_script_calls = []
+    cred_in_subproc = []
+    aes_decrypt_files = set()
+    hardcoded_key_files = set()
+    local_cred_path_hits = []
+
+    for rel, text in file_texts.items():
+        if not rel.lower().endswith(SCRIPT_EXTS):
+            continue
+        lines = scan_lines(text)
+        for i, line in enumerate(lines, start=1):
+            if RISKY_SUBPROCESS_RE.search(line):
+                block = "\n".join(lines[i - 1:i + 6])
+                if EXTERNAL_SCRIPT_RE.search(block):
+                    ext_script_calls.append(f"{rel}:{i} → {line.strip()[:120]}")
+                if CRED_IN_SUBPROC_RE.search(block):
+                    cred_in_subproc.append(f"{rel}:{i} → {line.strip()[:120]}")
+            if AES_DECRYPT_RE.search(line):
+                aes_decrypt_files.add(rel)
+        if HARDCODED_SECRET_RE.search(text):
+            hardcoded_key_files.add(rel)
+        for m in LOCAL_CRED_PATH_RE.finditer(text):
+            local_cred_path_hits.append(f"{rel} → {m.group(0)[:100]}")
+
+    # B6 包外脚本子进程调用
+    if ext_script_calls:
+        checks.append(Check(
+            "专项质检", "无包外脚本子进程调用", "WARN", "MEDIUM",
+            "检测到 skill 通过子进程（spawnSync/spawn/exec/subprocess 等）调用了包外脚本文件。"
+            "这类行为可能在用户环境自动执行外部代码，需审查其来源、参数与权限范围。",
+            locations=ext_script_calls[:20],
+            suggestion="尽量用内置 SDK/库替代子进程调用；若必须调用，应明确脚本来源、"
+                      "限制参数范围，并向用户说明所执行的外部脚本。"
+        ))
+    else:
+        checks.append(Check("专项质检", "无包外脚本子进程调用", "PASS", "INFO",
+                            "未发现调用包外脚本的子进程行为。"))
+
+    # B7 凭证通过命令行参数明文传递
+    if cred_in_subproc:
+        checks.append(Check(
+            "专项质检", "凭证未通过命令行明文传递", "WARN", "HIGH",
+            "检测到子进程（spawnSync/spawn/exec 等）调用附近出现凭证类字段"
+            "（ETEAMSID/token/session/cookie/password/secret 等），疑似将凭证以命令行参数明文传入。",
+            locations=cred_in_subproc[:20],
+            suggestion="严禁将凭证作为命令行参数或 env 明文传入子进程；"
+                      "凭证须由 E10 命名凭据插件提供，通过标准输入或安全配置文件传递。"
+        ))
+    else:
+        checks.append(Check("专项质检", "凭证未通过命令行明文传递", "PASS", "INFO",
+                            "未发现子进程命令行中明文传递凭证。"))
+
+    # B8 硬编码加密密钥解密本地凭证
+    aes_and_key = sorted(aes_decrypt_files & hardcoded_key_files)
+    if aes_and_key:
+        checks.append(Check(
+            "专项质检", "无硬编码加密密钥解密本地凭证", "WARN", "HIGH",
+            "检测到使用 AES 解密且同文件存在硬编码密钥常量，疑似用于解密本地存储的登录会话凭证。",
+            locations=[f"{r}（AES 解密 + 硬编码密钥常量）" for r in aes_and_key][:20],
+            suggestion="不得硬编码加密密钥；密钥与凭证应由 E10 插件安全管理，"
+                      "本地凭证文件须脱敏并限定在用户授权范围内读取。"
+        ))
+    else:
+        checks.append(Check("专项质检", "无硬编码加密密钥解密本地凭证", "PASS", "INFO",
+                            "未发现硬编码密钥 + AES 解密组合。"))
+
+    if local_cred_path_hits:
+        checks.append(Check(
+            "专项质检", "无本地敏感凭证路径访问", "WARN", "MEDIUM",
+            "检测到访问本地敏感凭证路径（如 ~/.e10-cli/profiles/*/auth）。"
+            "对外分发前须确认已脱敏，且仅在用户授权范围内读取。",
+            locations=local_cred_path_hits[:20],
+            suggestion="移除对本地凭证文件的硬编码路径引用；如需读取，须明确授权并脱敏后处理。"
+        ))
+    else:
+        checks.append(Check("专项质检", "无本地敏感凭证路径访问", "PASS", "INFO",
+                            "未发现访问本地敏感凭证路径。"))
+
+    return checks
+
+
+# ---------------------------------------------------------------------------
+# 扩展安全检测（对齐官方 expert-reviewer G 组）
+# ---------------------------------------------------------------------------
+
+def check_extended_security(skill_dir: Path):
+    """G 组扩展安全检测：危险命令、个人路径、IDE残留、CDN未锁定、内网域名、虚假承诺、BOM/CRLF。"""
+    checks = []
+
+    file_texts = {}
+    for rel, text in iter_text_files(skill_dir):
+        if _is_detector_script(str(rel), text) or _is_detector_doc(str(rel), text):
+            continue
+        file_texts[str(rel)] = text
+
+    # G02: 危险 shell 命令模式
+    dangerous_hits = []
+    for rel, text in file_texts.items():
+        for i, line in enumerate(scan_lines(text), start=1):
+            if DANGEROUS_CMD_RE.search(line):
+                # 豁免否定语境（如「禁止使用 rm -rf /」）
+                if NEGATION_SAFE_RE.search(line):
+                    continue
+                dangerous_hits.append(f"{rel}:{i} → {line.strip()[:120]}")
+    if dangerous_hits:
+        checks.append(Check(
+            "扩展安全", "无危险 shell 命令", "WARN", "HIGH",
+            "检测到危险 shell 命令模式（如 rm -rf /、curl|sh、sudo、chmod 777、dd、fork bomb 等），"
+            "可能在用户环境造成不可逆破坏。",
+            locations=dangerous_hits[:20],
+            suggestion="移除危险命令；如需清理操作应限制范围并加确认逻辑；禁止 curl|sh 远程管道执行。"
+        ))
+    else:
+        checks.append(Check("扩展安全", "无危险 shell 命令", "PASS", "INFO",
+                            "未检测到危险 shell 命令模式。"))
+
+    # G04a: 开发者个人路径残留
+    personal_hits = []
+    for rel, text in file_texts.items():
+        for i, line in enumerate(scan_lines(text), start=1):
+            if PERSONAL_PATH_RE.search(line):
+                personal_hits.append(f"{rel}:{i} → {line.strip()[:120]}")
+    if personal_hits:
+        checks.append(Check(
+            "扩展安全", "无开发者个人路径残留", "WARN", "MEDIUM",
+            "检测到开发者个人路径残留（如 /Users/xxx/、C:\\Users\\xxx\\）。"
+            "对外分发后其他用户环境路径不一致，会导致脚本/配置失效。",
+            locations=personal_hits[:20],
+            suggestion="将个人路径替换为相对路径或环境变量（如 $HOME、~/、os.path.expanduser）。"
+        ))
+    else:
+        checks.append(Check("扩展安全", "无开发者个人路径残留", "PASS", "INFO",
+                            "未检测到个人路径残留。"))
+
+    # G04b: 其他 IDE / 平台配置目录残留
+    ide_hits = []
+    for rel, text in file_texts.items():
+        for i, line in enumerate(scan_lines(text), start=1):
+            if IDE_DIR_RE.search(line):
+                ide_hits.append(f"{rel}:{i} → {line.strip()[:120]}")
+    if ide_hits:
+        checks.append(Check(
+            "扩展安全", "无 IDE/平台配置目录残留", "WARN", "LOW",
+            "检测到其他 IDE/平台配置目录残留（如 .vscode/、.idea/、.cursor/、.DS_Store）。"
+            "这些文件不应包含在发布包中。",
+            locations=ide_hits[:20],
+            suggestion="从发布包中移除 IDE 配置目录与系统生成文件；添加 .gitignore 排除规则。"
+        ))
+    else:
+        checks.append(Check("扩展安全", "无 IDE/平台配置目录残留", "PASS", "INFO",
+                            "未检测到 IDE 配置目录残留。"))
+
+    # G04c: CDN @latest 未锁定版本
+    cdn_hits = []
+    for rel, text in file_texts.items():
+        for i, line in enumerate(scan_lines(text), start=1):
+            if CDN_LATEST_RE.search(line):
+                cdn_hits.append(f"{rel}:{i} → {line.strip()[:120]}")
+    if cdn_hits:
+        checks.append(Check(
+            "扩展安全", "CDN 依赖版本锁定", "WARN", "MEDIUM",
+            "检测到 CDN 引用使用 @latest 未锁定版本（如 cdn.jsdelivr.net/.../@latest）。"
+            "上游更新可能导致引入不兼容或恶意代码。",
+            locations=cdn_hits[:20],
+            suggestion="将 @latest 替换为具体版本号（如 @1.2.3），锁定依赖版本。"
+        ))
+    else:
+        checks.append(Check("扩展安全", "CDN 依赖版本锁定", "PASS", "INFO",
+                            "未检测到未锁定版本的 CDN 引用。"))
+
+    # G03: 扩展内网域名检测（泛微自用域名已由 B1 覆盖，此处补充通用内网域名）
+    internal_hits = []
+    for rel, text in file_texts.items():
+        for i, line in enumerate(scan_lines(text), start=1):
+            if INTERNAL_DOMAIN_RE.search(line):
+                # 豁免否定语境
+                if NEGATION_SAFE_RE.search(line):
+                    continue
+                internal_hits.append(f"{rel}:{i} → {line.strip()[:120]}")
+    if internal_hits:
+        checks.append(Check(
+            "扩展安全", "无内网域名残留", "WARN", "MEDIUM",
+            "检测到通用内网域名（如 *.woa.com、*.tencent.com、*.internal、*.local）。"
+            "对外分发后这些域名不可达，且可能泄露内部网络拓扑。",
+            locations=internal_hits[:20],
+            suggestion="移除内网域名引用；改为用户提供的外部地址或占位符。"
+        ))
+    else:
+        checks.append(Check("扩展安全", "无内网域名残留", "PASS", "INFO",
+                            "未检测到通用内网域名残留。"))
+
+    # C08: 平台虚假技术承诺
+    promise_hits = []
+    for rel, text in file_texts.items():
+        if not str(rel).lower().endswith((".md", ".markdown")):
+            continue
+        for i, line in enumerate(scan_lines(text), start=1):
+            if FALSE_PROMISE_RE.search(line):
+                # 豁免否定语境（如「不应声称完全离线」）
+                if NEGATION_SAFE_RE.search(line):
+                    continue
+                promise_hits.append(f"{rel}:{i} → {line.strip()[:120]}")
+    if promise_hits:
+        checks.append(Check(
+            "扩展安全", "无平台虚假技术承诺", "WARN", "MEDIUM",
+            "检测到可能的技术承诺（如「本地AI」「离线运行」「不上云」「数据不出本机」）。"
+            "技能实际运行在云端 Agent 中，这些承诺与平台运行方式不符，可能误导用户。",
+            locations=promise_hits[:20],
+            suggestion="移除或修正不实技术承诺；如实描述技能运行环境（云端执行、需联网等）。"
+        ))
+    else:
+        checks.append(Check("扩展安全", "无平台虚假技术承诺", "PASS", "INFO",
+                            "未检测到虚假技术承诺。"))
+
+    # B11: BOM / CRLF / 编码规范性
+    bom_files = []
+    crlf_files = []
+    for p in skill_dir.rglob("*"):
+        if not p.is_file():
+            continue
+        if p.suffix.lower() not in TEXT_EXTS:
+            continue
+        if _is_detector_script(str(p.relative_to(skill_dir)), ""):
+            continue
+        try:
+            raw = p.read_bytes()[:4096]  # 只读前 4KB 判断 BOM/CRLF
+        except (OSError, IOError):
+            continue
+        if BOM_RE.match(raw):
+            bom_files.append(str(p.relative_to(skill_dir)))
+        if CRLF_RE.search(raw):
+            crlf_files.append(str(p.relative_to(skill_dir)))
+
+    if bom_files:
+        checks.append(Check(
+            "扩展安全", "无 BOM 头残留", "WARN", "LOW",
+            f"检测到 {len(bom_files)} 个文件含 UTF-8 BOM 头（EF BB BF）。"
+            "BOM 在某些解析器中会被当作正文内容，可能导致 YAML frontmatter 解析失败。",
+            locations=bom_files[:10],
+            suggestion="使用 `sed -i '1s/^\\xef\\xbb\\xbf//' <file>` 或编辑器设置「保存时不带 BOM」移除。"
+        ))
+    else:
+        checks.append(Check("扩展安全", "无 BOM 头残留", "PASS", "INFO",
+                            "未检测到 BOM 头残留。"))
+
+    if crlf_files:
+        checks.append(Check(
+            "扩展安全", "无 CRLF 行尾", "WARN", "LOW",
+            f"检测到 {len(crlf_files)} 个文件使用 CRLF (\\r\\n) 行尾。"
+            "跨平台分发时 CRLF 可能导致 shell 脚本执行异常或 YAML 解析问题。",
+            locations=crlf_files[:10],
+            suggestion="使用 `dos2unix` 或 `sed -i 's/\\r$//' <file>` 统一为 LF 行尾。"
+        ))
+    else:
+        checks.append(Check("扩展安全", "无 CRLF 行尾", "PASS", "INFO",
+                            "所有文本文件均为 LF 行尾。"))
+
+    return checks
+
+
+# ---------------------------------------------------------------------------
+# API 请求凭证完整性检测（泛微强制红线）
+#   被检测 skill 在发起 API 请求时，必须同时携带：
+#     ① Cookie 完整原始串（禁止裁剪/去重/改写）
+#     ② eteamsid
+#     ③ User-Agent（AgentType=<agentType>,IsAgent=true）
+#   三条缺一不可，作为阻断性规则（BLOCK）。仅当源码确实存在发起 HTTP/API 请求的代码时生效。
+# ---------------------------------------------------------------------------
+
+# 源码中出现「发起 HTTP/API 请求」的触发模式（仅在脚本文件中判定，避免文档描述误触发）
+API_CALL_RE = re.compile(
+    r"\b(requests\.(?:get|post|put|delete|patch|request)|httpx\.(?:get|post|request)|"
+    r"http\.client|urllib\.request|aiohttp\.|session\.(?:get|post|request)|"
+    r"fetch\s*\(|axios(?:\.[a-z]+)?\s*\(|got\s*\(|\bcurl\b|\bwget\b|\.request\s*\()",
+    re.IGNORECASE,
+)
+
+# API 触发行的「否定/断言/列举」语境豁免：这些行只是在检查「不应出现某调用」，
+# 而非真正发起请求（如 `for marker in ("fetch(", ...)` / `assert "fetch(" not in html` /
+# `token not in html`）。命中即不视为发起 API 请求，避免误阻断。
+API_CALL_NEGATION_RE = re.compile(
+    r"\b(not in|assert|marker|token|forbidden|blocked|noNetwork|"
+    r"does not contain|不包含|禁止出现|不得包含)\b", re.IGNORECASE)
+
+# 弱信号动词（fetch/got/axios）若以引号包裹，说明是字符串字面量（被列举/检查的词），非真实调用。
+API_CALL_QUOTED_LITERAL_RE = re.compile(r"""["'](?:fetch|got|axios)\b""", re.IGNORECASE)
+
+
+def _line_has_real_api_call(line: str) -> bool:
+    """判定一行是否「真正发起 API 请求」，排除否定/断言/字面量列举等误触发语境。"""
+    if API_CALL_NEGATION_RE.search(line):
+        return False
+    if not API_CALL_RE.search(line):
+        return False
+    # fetch/got/axios 出现在引号内（如 ("fetch(", ...)）视为字面量，不算调用
+    if API_CALL_QUOTED_LITERAL_RE.search(line):
+        return False
+    return True
+
+
+# Cookie 头/参数出现的标记（大小写不敏感）
+COOKIE_HEADER_RE = re.compile(r"['\"]?Cookie['\"]?\s*[:=]|cookie\s*=", re.IGNORECASE)
+
+# eteamsid 出现的标记（覆盖 eteamsid / eteams_id / ETEAMSID / eteamsId）
+ETEAMSID_RE = re.compile(r"eteams[_-]?id", re.IGNORECASE)
+
+# User-Agent 必须携带 AgentType=<agentType>,IsAgent=true
+UA_RE = re.compile(r"User-Agent", re.IGNORECASE)
+AGENT_TYPE_RE = re.compile(r"AgentType\s*=", re.IGNORECASE)
+IS_AGENT_RE = re.compile(r"IsAgent\s*[:=]\s*true", re.IGNORECASE)
+
+# Cookie 裁剪/去重/改写的可疑模式（违反「禁止裁剪/去重/改写」）
+COOKIE_TAMPER_RES = [
+    re.compile(r"cookie\b[^;]{0,50}?\.(?:split|replace)\s*\(", re.IGNORECASE),
+    re.compile(r"dict\s*\([^)]{0,80}?cookie", re.IGNORECASE),
+    re.compile(r"cookie\b[^;]{0,50}?\[[0-9\s:]+[\]:]", re.IGNORECASE),
+]
+
+
+def check_api_request_credentials(skill_dir: Path):
+    """
+    B 红线补充：被检测 skill 在发起 API 请求时，必须同时携带
+      ① Cookie 完整原始串（禁止裁剪/去重/改写）
+      ② eteamsid
+      ③ User-Agent（AgentType=<agentType>,IsAgent=true）
+    三条缺一不可，作为阻断性规则（BLOCK）。仅当源码中确实存在发起 HTTP/API 请求的代码时才生效；
+    纯文档/纯提示词类 skill 不触发。
+    """
+    # 收集文件：排除检测工具自身（避免规则说明文字 / urllib 自调用误触发）
+    script_texts = {}   # 脚本文件（用于判断是否发起 API 请求）
+    all_texts = {}      # 全量文本（用于查找凭证标记）
+    for rel, text in iter_text_files(skill_dir):
+        if _is_detector_script(str(rel), text) or _is_detector_doc(str(rel), text):
+            continue
+        all_texts[str(rel)] = text
+        if Path(str(rel)).suffix.lower() in SCRIPT_EXTS:
+            script_texts[str(rel)] = text
+
+    # 1) 是否发起 API 请求（仅在脚本文件中判定触发，避免文档描述误触发）
+    api_hits = []
+    for rel, text in script_texts.items():
+        for i, line in enumerate(scan_lines(text), start=1):
+            if _line_has_real_api_call(line):
+                api_hits.append(f"{rel}:{i} → {line.strip()[:120]}")
+
+    if not api_hits:
+        return [Check(
+            "API 凭证完整性", "发起 API 请求时携带完整凭证", "PASS", "INFO",
+            "未检测到发起 HTTP/API 请求的源码（requests/urllib/httpx/fetch/axios/curl 等），"
+            "本规则不适用（仅约束实际对外发起请求的 skill）。"
+        )]
+
+    # 2) 三项凭证标记是否齐全（在包内全量文本中查找；模块化 skill 凭证可能在独立模块）
+    joined = "\n".join(all_texts.values())
+    has_cookie = bool(COOKIE_HEADER_RE.search(joined))
+    has_eteamsid = bool(ETEAMSID_RE.search(joined))
+    has_ua = bool(UA_RE.search(joined) and AGENT_TYPE_RE.search(joined) and IS_AGENT_RE.search(joined))
+
+    missing = []
+    if not has_cookie:
+        missing.append("① Cookie 完整原始串（headers 中未携带 'Cookie' 头/参数）")
+    if not has_eteamsid:
+        missing.append("② eteamsid（源码中未出现 eteamsid 相关字段）")
+    if not has_ua:
+        missing.append("③ User-Agent（AgentType=<agentType>,IsAgent=true）")
+
+    checks = []
+    if missing:
+        checks.append(Check(
+            "API 凭证完整性", "API 请求携带 Cookie+eteamsid+User-Agent", "FAIL", "BLOCK",
+            "被检测 skill 在发起 API 请求时，必须同时携带 ① Cookie 完整原始串 "
+            "（禁止裁剪/去重/改写）② eteamsid ③ User-Agent（AgentType=<agentType>,IsAgent=true），"
+            "三条缺一不可。当前缺失以下项，阻断上架：\n" + "\n".join(f"  · {m}" for m in missing),
+            locations=api_hits[:15],
+            suggestion="在请求 headers 中补充：'Cookie': <完整原始 Cookie 串>、"
+                      "'eteamsid': <从 E10 插件获取的凭证>、"
+                      "'User-Agent': 'AgentType=<agentType>,IsAgent=true'。"
+                      "Cookie 必须原样透传，禁止 split / 去重 / 切片 / 改写。"
+        ))
+    else:
+        checks.append(Check(
+            "API 凭证完整性", "API 请求携带 Cookie+eteamsid+User-Agent", "PASS", "INFO",
+            "检测到对外 API 请求，且三项强制凭证（Cookie 完整原始串 / eteamsid / "
+            "User-Agent:AgentType=...,IsAgent=true）均已在包内源码中出现。"
+        ))
+
+    # 3) Cookie 裁剪/去重/改写嫌疑（违反「禁止裁剪/去重/改写」），作为独立 WARN 提示
+    tamper_hits = []
+    for rel, text in all_texts.items():
+        for i, line in enumerate(scan_lines(text), start=1):
+            for rx in COOKIE_TAMPER_RES:
+                if rx.search(line):
+                    tamper_hits.append(f"{rel}:{i} → {line.strip()[:120]}")
+                    break
+    if tamper_hits:
+        checks.append(Check(
+            "API 凭证完整性", "Cookie 未裁剪/去重/改写", "WARN", "MEDIUM",
+            "检测到 Cookie 变量可能存在裁剪/去重/改写操作（如 cookie.split() / dict(cookie) / cookie[..]），"
+            "违反「Cookie 必须完整原始串、禁止裁剪/去重/改写」的要求。",
+            locations=tamper_hits[:15],
+            suggestion="将服务端下发的原始 Cookie 串原样放入请求头（headers['Cookie'] = raw_cookie），"
+                      "不要拆分、去重或重新拼装。"
+        ))
+    else:
+        checks.append(Check(
+            "API 凭证完整性", "Cookie 未裁剪/去重/改写", "PASS", "INFO",
+            "未检测到 Cookie 裁剪/去重/改写的可疑操作。"
+        ))
+
+    return checks
+
+
+# ---------------------------------------------------------------------------
+# E10 接口型技能「登录 + 凭证」契约检测（泛微强制红线，仅对 weaver-e10- 前缀技能生效）
+#   规则 1（B10a，BLOCK）：登录必须走登录 skill —— 必须声明/引用 weaver-e10-login（或 e10-login CLI），
+#                          且不得自建登录（Playwright/Selenium 自动登录、账号密码登录、自建 OAuth 等）。
+#   规则 2（B10c，BLOCK）：API 请求必须携带 e10-login 返回的三项用户信息参数 ——
+#                          ① Cookie 完整原始串（禁止裁剪/去重/改写）
+#                          ② eteamsid
+#                          ③ User-Agent（AgentType=<agentType>,IsAgent=true）
+#   触发范围：name 以 weaver-e10- 开头（weaver-e10-login 自身豁免），且确实存在 API 表面
+#             （脚本内真实 HTTP 调用，或文档中描述了接口请求/curl/请求头）。
+# ---------------------------------------------------------------------------
+
+LOGIN_SKILL_NAME = "weaver-e10-login"
+
+# 「登录走登录 skill」的证据模式（任一命中即认为已接入登录 skill）
+LOGIN_DEP_RE = re.compile(
+    r"weaver-e10-login"                      # 技能名（frontmatter 声明或正文引用）
+    r"|\be10[-_]login\b"                     # e10-login CLI（如 `e10-login whoami`）
+    r"|E10_LOGIN_ENTRY"                      # 登录入口环境变量
+    r"|登录\s*(?:专用\s*)?s?kill"             # 中文表述：登录 skill / 登录技能
+    r"|登录技能",
+    re.IGNORECASE,
+)
+
+# 自建登录（绕过登录 skill）的可疑模式：命中即 BLOCK
+SELF_LOGIN_RES = [
+    re.compile(r"\b(playwright|selenium|puppeteer|pyppeteer)\b", re.IGNORECASE),
+    re.compile(r"扫码\s*登录|二维码\s*登录", re.IGNORECASE),
+    re.compile(r"(账号|用户名|username)[^\n]{0,10}(密码|password)[^\n]{0,10}登录", re.IGNORECASE),
+    re.compile(r"login\s*\(\s*[^)]{0,60}(password|passwd)\s*=", re.IGNORECASE),
+    re.compile(r"oauth2?\s*/\s*(authorize|token)[^\n]{0,40}(client_secret|grant_type)", re.IGNORECASE),
+]
+
+# 文档型（无脚本）E10 技能的「API 表面」证据：接口请求示例 / 请求头说明 / 接口地址
+DOC_API_SURFACE_RES = [
+    re.compile(r"\bcurl\s+-|\bcurl\s+['\"]", re.IGNORECASE),
+    re.compile(r"\b(GET|POST|PUT|DELETE|PATCH)\s+/\S+", re.IGNORECASE),
+    re.compile(r"请求头|请求头部|headers?\s*[:：]", re.IGNORECASE),
+    re.compile(r"接口\s*地址|API\s*地址|请求\s*URL|base\s*url", re.IGNORECASE),
+]
+
+# E10 生态标识（用于确认该技能确实面向 E10 接口，避免误伤纯 UI/规范类技能）
+E10_API_CONTEXT_RE = re.compile(
+    r"\bE10\b|eteams|ebuilder|esb\b|/api/|泛微|weaver",
+    re.IGNORECASE,
+)
+
+
+def collect_api_surface(skill_dir: Path):
+    """
+    收集 skill 的 API 表面证据。
+    返回 (script_hits, doc_hits, all_texts)
+      script_hits: 脚本文件中「真实发起 HTTP/API 请求」的行（复用 B9 的判定逻辑）
+      doc_hits:    Markdown 文档中描述接口请求/请求头/curl 的行
+      all_texts:   {相对路径: 全文}（已排除检测器自身文件）
+    """
+    script_hits, doc_hits = [], []
+    all_texts = {}
+    for rel, text in iter_text_files(skill_dir):
+        rel_s = str(rel)
+        if _is_detector_script(rel_s, text) or _is_detector_doc(rel_s, text):
+            continue
+        all_texts[rel_s] = text
+        is_script = Path(rel_s).suffix.lower() in SCRIPT_EXTS
+        if is_script:
+            for i, line in enumerate(scan_lines(text), start=1):
+                if _line_has_real_api_call(line):
+                    script_hits.append(f"{rel_s}:{i} → {line.strip()[:120]}")
+        elif rel_s.lower().endswith((".md", ".markdown")):
+            for i, line in enumerate(scan_lines(text), start=1):
+                if any(rx.search(line) for rx in DOC_API_SURFACE_RES):
+                    doc_hits.append(f"{rel_s}:{i} → {line.strip()[:120]}")
+    return script_hits, doc_hits, all_texts
+
+
+def check_weaver_e10_auth_contract(skill_dir: Path, name: str):
+    """
+    E10 接口型技能专属红线（BLOCK）：
+      B10a 登录必须走登录 skill（依赖 weaver-e10-login，且不得自建登录）
+      B10c API 请求必须携带 Cookie 完整原始串 + eteamsid + User-Agent(AgentType=,IsAgent=true)
+    仅对 name 以 weaver-e10- 开头的技能生效；weaver-e10-login 自身豁免。
+    """
+    checks = []
+    nm = (name or "").strip().strip('"\'`')
+    if not nm.lower().startswith("weaver-e10-"):
+        return [Check("E10 登录与凭证契约", "适用范围内（weaver-e10- 前缀技能）", "PASS", "INFO",
+                      f"当前技能 name='{nm}' 非 weaver-e10- 前缀，本组规则不适用。")]
+    if nm.lower() == LOGIN_SKILL_NAME:
+        return [Check("E10 登录与凭证契约", "登录 skill 自身豁免", "PASS", "INFO",
+                      "当前技能即 weaver-e10-login，登录契约规则豁免。")]
+
+    script_hits, doc_hits, all_texts = collect_api_surface(skill_dir)
+    if not script_hits and not doc_hits:
+        return [Check("E10 登录与凭证契约", "接口型技能判定", "PASS", "INFO",
+                      "未检测到 API 表面（无脚本 HTTP 调用，文档中也无接口请求/请求头描述），"
+                      "判定为非接口型技能，登录与凭证契约规则不适用。")]
+
+    surface_desc = (
+        f"脚本内 HTTP 调用 {len(script_hits)} 处" if script_hits else ""
+    ) + ("；" if script_hits and doc_hits else "") + (
+        f"文档接口描述 {len(doc_hits)} 处" if doc_hits else ""
+    )
+    surface_locs = (script_hits or doc_hits)[:15]
+
+    # ---- B10a 登录必须走登录 skill ----
+    joined = "\n".join(all_texts.values())
+    login_evidence = []
+    for rel, text in all_texts.items():
+        for i, line in enumerate(scan_lines(text), start=1):
+            if LOGIN_DEP_RE.search(line):
+                login_evidence.append(f"{rel}:{i} → {line.strip()[:120]}")
+    if login_evidence:
+        checks.append(Check(
+            "E10 登录与凭证契约", "登录走登录 skill（依赖 weaver-e10-login）", "PASS", "INFO",
+            f"检测到登录 skill 依赖证据 {len(login_evidence)} 处"
+            f"（示例：{login_evidence[0]}），符合「登录必须走 weaver-e10-login」要求。",
+            locations=login_evidence[:8],
+        ))
+    else:
+        checks.append(Check(
+            "E10 登录与凭证契约", "登录走登录 skill（依赖 weaver-e10-login）", "FAIL", "BLOCK",
+            f"当前技能为 E10 接口型技能（{surface_desc}），但未发现任何登录 skill 依赖证据："
+            "既未在 frontmatter `dependencies` 中声明 `weaver-e10-login`，也未在正文/脚本中引用 "
+            "`weaver-e10-login` / `e10-login` CLI / `E10_LOGIN_ENTRY`。"
+            "「登录必须走登录 skill」为泛微强制红线，未声明即阻断上架。",
+            locations=surface_locs,
+            suggestion="在 SKILL.md frontmatter 增加：\n"
+                       "dependencies:\n"
+                       "  - weaver-e10-login\n"
+                       "或在正文/脚本中明确：认证与会话由 weaver-e10-login 提供"
+                       "（脚本型可调用 `e10-login whoami` 获取 baseUrl/ETEAMSID/cookies）。"
+        ))
+
+    # ---- B10b 禁止自建登录（绕过登录 skill）----
+    self_login_hits = []
+    for rel, text in all_texts.items():
+        for i, line in enumerate(scan_lines(text), start=1):
+            for rx in SELF_LOGIN_RES:
+                if rx.search(line):
+                    self_login_hits.append(f"{rel}:{i} → {line.strip()[:120]}")
+                    break
+    if self_login_hits:
+        checks.append(Check(
+            "E10 登录与凭证契约", "未自建登录（禁止绕过登录 skill）", "FAIL", "BLOCK",
+            f"检测到自建登录/自动登录实现 {len(self_login_hits)} 处"
+            "（Playwright/Selenium 自动登录、扫码登录、账号密码登录、自建 OAuth 等）。"
+            "E10 技能的登录与会话必须统一由 weaver-e10-login 提供，禁止自行实现登录流程。",
+            locations=self_login_hits[:15],
+            suggestion="删除自建登录逻辑，改为调用 weaver-e10-login（或 `e10-login whoami`）"
+                       "获取会话，再使用该会话发起业务请求。"
+        ))
+    else:
+        checks.append(Check(
+            "E10 登录与凭证契约", "未自建登录（禁止绕过登录 skill）", "PASS", "INFO",
+            "未检测到自建登录实现（Playwright/Selenium/扫码/账号密码/自建 OAuth）。"
+        ))
+
+    # ---- B10c 三项用户信息参数完整（文档型技能补充；脚本型由 B9 覆盖，此处不重复阻断）----
+    if not script_hits and doc_hits:
+        has_cookie = bool(COOKIE_HEADER_RE.search(joined))
+        has_eteamsid = bool(ETEAMSID_RE.search(joined))
+        has_ua = bool(UA_RE.search(joined) and AGENT_TYPE_RE.search(joined) and IS_AGENT_RE.search(joined))
+        missing = []
+        if not has_cookie:
+            missing.append("① Cookie 完整原始串（文档中未说明请求头携带 Cookie）")
+        if not has_eteamsid:
+            missing.append("② eteamsid（文档中未出现 eteamsid 字段）")
+        if not has_ua:
+            missing.append("③ User-Agent（AgentType=<agentType>,IsAgent=true）")
+        if missing:
+            checks.append(Check(
+                "E10 登录与凭证契约", "接口文档声明完整凭证（Cookie+eteamsid+User-Agent）", "FAIL", "BLOCK",
+                "当前技能以接口文档形式发起/描述 API 请求，必须明确要求携带 e10-login 返回的三项用户信息参数，"
+                "缺一不可。当前缺失：\n" + "\n".join(f"  · {m}" for m in missing),
+                locations=surface_locs,
+                suggestion="在接口文档的「请求头/认证」章节补充：\n"
+                           "Cookie: <e10-login 返回的完整原始 Cookie 串>（禁止裁剪/去重/改写）\n"
+                           "eteamsid: <e10-login 返回的 ETEAMSID>\n"
+                           "User-Agent: AgentType=<agentType>,IsAgent=true"
+            ))
+        else:
+            checks.append(Check(
+                "E10 登录与凭证契约", "接口文档声明完整凭证（Cookie+eteamsid+User-Agent）", "PASS", "INFO",
+                "接口文档已声明三项强制凭证（Cookie 完整原始串 / eteamsid / User-Agent:AgentType=...,IsAgent=true）。"
+            ))
+    elif script_hits:
+        checks.append(Check(
+            "E10 登录与凭证契约", "接口文档声明完整凭证（Cookie+eteamsid+User-Agent）", "PASS", "INFO",
+            "脚本型技能的三项凭证校验由「API 凭证完整性」规则覆盖，此处不重复判定。"
+        ))
+
+    return checks
+
+
+# ---------------------------------------------------------------------------
+# B11 千问连接器就绪性契约（仅 qwenwork 模式触发，BLOCK）
+# ---------------------------------------------------------------------------
+# 千问「连接器型 skill」硬性要求：执行前必须做 qw_query 连接器就绪性检查，
+# 并在 401/403/token 失效时回到 Step 0 重新认证。本检测检查：
+# ① frontmatter 是否声明连接器依赖；
+# ② 若是，正文/脚本是否包含 qw_query 调用 + 401/403/token 失效处理分支。
+QW_CONNECTOR_RE = re.compile(
+    r"qwenwork\.settings\.connector\."   # 标准连接器 key 格式（前端处理 key）
+    r"|前置\s*依赖.{0,30}连接器"
+    r"|依赖.{0,5}\*\*?\s*连接器"
+    r"|connector_id|connector_key",
+    re.IGNORECASE,
+)
+QW_QUERY_RE = re.compile(r"\bqw_query\b|\bqw_action\b|\bqw_config\b", re.IGNORECASE)
+QW_REFRESH_RE = re.compile(
+    r"401|403|token\s*(?:失效|过期|invalid)|回到\s*Step\s*0|重新认证",
+    re.IGNORECASE,
+)
+
+
+def check_qwenwork_connector_readiness(skill_dir: Path, name: str, platform: str = "weaver"):
+    """B11: 千问连接器就绪性契约（仅在 platform="qwenwork" 触发，weaver 模式直接返回空）。
+
+    千问规范强制要求：依赖连接器的 skill，执行前必须调用 `qw_query` 查询连接器状态，
+    并在 401/403/token 失效时回到 Step 0 重新走认证分支。本检测通过以下信号判定：
+    ① SKILL.md 含连接器依赖声明（`qwenwork.settings.connector.<类别>.<id>` 或「依赖连接器」表述）
+    ② 缺 ① 中任一证据 → 不触发本规则（该 skill 非连接器型，无需校验）
+    ③ 缺 `qw_query` / `qw_action` / `qw_config` 关键词 → BLOCK，提示补 Step 0
+    ④ 缺 401/403/token 失效处理关键词 → WARN，提示补重新认证分支
+    """
+    # 本检查在 main() 中已用 platform=="qwenwork" 守护，但函数体内仍做一次防御
+    checks = []
+    if platform != "qwenwork":
+        return checks
+
+    skill_md_path = skill_dir / "SKILL.md"
+    if not skill_md_path.exists():
+        return checks
+
+    content = skill_md_path.read_text(encoding="utf-8")
+    fm_match = re.search(r"^---\n(.*?)\n---", content, re.DOTALL | re.MULTILINE)
+    fm = fm_match.group(1) if fm_match else ""
+    body = content[fm_match.end():] if fm_match else content
+
+    # ① 检测是否为连接器型 skill
+    full_text = fm + "\n" + body
+    is_connector_skill = bool(QW_CONNECTOR_RE.search(full_text))
+
+    if not is_connector_skill:
+        checks.append(Check(
+            "千问契约", "B11 连接器就绪性契约", "PASS", "INFO",
+            "未检测到连接器依赖声明（无 `qwenwork.settings.connector.*` / 「依赖连接器」表述），"
+            "本 skill 非连接器型，跳过本检查。"
+        ))
+        return checks
+
+    # ② 检查 qw_query / qw_action 调用
+    has_query = bool(QW_QUERY_RE.search(full_text))
+    if not has_query:
+        checks.append(Check(
+            "千问契约", "B11a 连接器就绪性检查(qw_query)", "FAIL", "BLOCK",
+            "frontmatter 含连接器依赖声明（连接器型），但全文未提及 `qw_query` / `qw_action` / `qw_config` 调用。"
+            "千问硬性要求：执行前必须调用 `qw_query` 查询连接器状态（installed/enabled/agentCanEnable）并按结果分支。",
+            suggestion=(
+                "在 SKILL.md 开头「前置依赖 / Step 0」段落增加：\n"
+                "### Step 0 - 连接器就绪性检查（必做，每次执行前）\n"
+                "1. 调用 `qw_query` 查询连接器状态：`key = \"qwenwork.settings.connector.<类别>.<id>\"`\n"
+                "2. 根据返回字段分支处理：\n"
+                "   - `installed=false` → `qw_action execute install`\n"
+                "   - `enabled=false` & `agentCanEnable=true` → `qw_action enable`\n"
+                "   - `enabled=true` & `status!=connected` → `qw_action connect`\n"
+                "   - `enabled=true` & `status==connected` → 直接进入 Step 1"
+            )
+        ))
+    else:
+        checks.append(Check(
+            "千问契约", "B11a 连接器就绪性检查(qw_query)", "PASS", "INFO",
+            "已检测到 `qw_query` / `qw_action` 调用（Step 0 已实现）。"
+        ))
+
+    # ③ 检查 401/403/token 失效处理
+    has_refresh = bool(QW_REFRESH_RE.search(full_text))
+    if not has_refresh:
+        checks.append(Check(
+            "千问契约", "B11b 401/403/token 失效回到 Step 0", "WARN", "MEDIUM",
+            "frontmatter 含连接器依赖声明，但全文未提及 401/403/token 失效处理。"
+            "千问硬性要求：遇到 401/403/token 失效时，必须回到 Step 0 重新走认证分支，不要硬失败。",
+            suggestion=(
+                "在「常见错误与恢复」段落增加：\n"
+                "- **401/403/token 失效** → 回到 Step 0 重新认证分支"
+            )
+        ))
+    else:
+        checks.append(Check(
+            "千问契约", "B11b 401/403/token 失效回到 Step 0", "PASS", "INFO",
+            "已检测到 401/403/token 失效处理分支。"
+        ))
+
+    return checks
+
+
+# ---------------------------------------------------------------------------
+# 结构化文件可解析性检测（对齐官方 A17）
+# ---------------------------------------------------------------------------
+
+def check_structured_files(skill_dir: Path):
+    """A2: 扫描包内所有 .json/.yaml/.yml/.toml 文件，验证可解析性。"""
+    checks = []
+
+    broken_files = []
+    for p in skill_dir.rglob("*"):
+        if not p.is_file():
+            continue
+        if p.suffix.lower() not in STRUCTURED_EXTS:
+            continue
+        rel = str(p.relative_to(skill_dir))
+        if _is_detector_script(rel, "") or _is_detector_doc(rel, ""):
+            continue
+        try:
+            raw = p.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, OSError) as e:
+            broken_files.append(f"{rel} → 编码错误: {e}")
+            continue
+        ext = p.suffix.lower()
+        try:
+            if ext == ".json":
+                json.loads(raw)
+            elif ext in (".yaml", ".yml"):
+                # 无 PyYAML 时做基本语法检查（冒号/缩进明显错误）
+                _basic_yaml_check(raw, rel, broken_files)
+            elif ext == ".toml":
+                # 无 tomllib 时做基本语法检查
+                _basic_toml_check(raw, rel, broken_files)
+        except json.JSONDecodeError as e:
+            broken_files.append(f"{rel} → JSON 解析失败: {e}")
+        except Exception as e:
+            broken_files.append(f"{rel} → 解析失败: {e}")
+
+    if broken_files:
+        checks.append(Check(
+            "基础合规", "结构化文件可解析性", "FAIL", "BLOCK",
+            f"检测到 {len(broken_files)} 个 JSON/YAML/TOML 文件解析失败，"
+            "格式错误会导致平台加载 skill 时直接报错。",
+            locations=broken_files[:20],
+            suggestion="修复格式错误：检查引号配对、逗号尾随、缩进一致性、YAML 冒号后空格等。"
+        ))
+    else:
+        # 检查是否有结构化文件
+        has_structured = any(
+            p.suffix.lower() in STRUCTURED_EXTS
+            for p in skill_dir.rglob("*")
+            if p.is_file() and not _is_detector_script(str(p.relative_to(skill_dir)), "")
+        )
+        if has_structured:
+            checks.append(Check("基础合规", "结构化文件可解析性", "PASS", "INFO",
+                                "包内所有 JSON/YAML/TOML 文件均可正常解析。"))
+        else:
+            checks.append(Check("基础合规", "结构化文件可解析性", "INFO", "INFO",
+                                "包内无 JSON/YAML/TOML 文件，跳过此项。"))
+
+    return checks
+
+
+def _basic_yaml_check(raw, rel, broken_files):
+    """无 PyYAML 依赖时的 YAML 基本语法检查。"""
+    lines = raw.splitlines()
+    for i, line in enumerate(lines, start=1):
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        # 检查 key: value 格式（冒号后须有空格或为空）
+        if ":" in stripped and not stripped.startswith("-"):
+            colon_pos = stripped.index(":")
+            after = stripped[colon_pos + 1:]
+            if after and not after.startswith(" ") and not after.startswith('"') and not after.startswith("'"):
+                # 可能是 URL 中的冒号（http:），跳过
+                if not re.match(r"https?://", stripped[colon_pos - 4:colon_pos + 1] if colon_pos >= 4 else ""):
+                    # 只在明确是 key:value（无空格）时报错
+                    key_part = stripped[:colon_pos]
+                    if re.match(r"^[A-Za-z_\u4e00-\u9fff][\w\u4e00-\u9fff.-]*$", key_part):
+                        broken_files.append(f"{rel}:{i} → YAML 语法警告: 冒号后应有空格")
+
+
+def _basic_toml_check(raw, rel, broken_files):
+    """无 tomllib 时的 TOML 基本语法检查。"""
+    lines = raw.splitlines()
+    for i, line in enumerate(lines, start=1):
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        # 基本 key = value 检查
+        if "=" in stripped and not stripped.startswith("["):
+            if not re.match(r"^[A-Za-z_][\w-]*\s*=", stripped):
+                # 可能是表内键值对，跳过
+                pass
+
+
+# ---------------------------------------------------------------------------
+# 依赖引导完整性检测（对齐官方 G05）
+# ---------------------------------------------------------------------------
+
+def check_dependency_guidance(skill_dir: Path):
+    """A3: 若包内含 scripts/ 或 bin/ 目录，检查是否有依赖安装/使用说明。"""
+    checks = []
+
+    has_scripts = (skill_dir / "scripts").is_dir()
+    has_bin = (skill_dir / "bin").is_dir()
+    has_package_json = (skill_dir / "package.json").exists()
+    has_requirements = any(
+        p.name in ("requirements.txt", "Pipfile", "pyproject.toml")
+        for p in skill_dir.rglob("*") if p.is_file()
+    )
+
+    if not (has_scripts or has_bin or has_package_json or has_requirements):
+        checks.append(Check("基础合规", "依赖引导完整性", "INFO", "INFO",
+                            "包内无 scripts/bin/依赖声明文件，跳过此项。"))
+        return checks
+
+    # 检查 SKILL.md 或 references/ 下是否有安装/使用说明
+    guidance_keywords = [
+        r"安装", r"install", r"pip\s+install", r"npm\s+install",
+        r"依赖", r"requirements", r"环境准备", r"前置条件",
+        r"usage", r"用法", r"运行方式", r"快速开始",
+    ]
+    guidance_found = False
+    for rel, text in iter_text_files(skill_dir):
+        if _is_detector_script(str(rel), text):
+            continue
+        for kw in guidance_keywords:
+            if re.search(kw, text, re.IGNORECASE):
+                guidance_found = True
+                break
+        if guidance_found:
+            break
+
+    if guidance_found:
+        checks.append(Check("基础合规", "依赖引导完整性", "PASS", "INFO",
+                            "包内含脚本/依赖声明，且已提供安装/使用说明。"))
+    else:
+        missing = []
+        if has_scripts:
+            missing.append("scripts/")
+        if has_bin:
+            missing.append("bin/")
+        if has_package_json:
+            missing.append("package.json")
+        if has_requirements:
+            missing.append("Python 依赖声明")
+        checks.append(Check(
+            "基础合规", "依赖引导完整性", "WARN", "MEDIUM",
+            f"包内含 {'、'.join(missing)} 但未找到安装/使用说明。"
+            "用户下载后不知道如何安装依赖、配置环境，可能导致技能无法运行。",
+            suggestion="在 SKILL.md 或 references/ 中补充「环境准备」「安装步骤」「用法说明」章节，"
+                      "列明依赖安装命令、版本要求与配置方法。"
+        ))
+
+    return checks
+
+
+# ---------------------------------------------------------------------------
+# 质量启发式检测（对齐官方 Q 组 + C02）
+# ---------------------------------------------------------------------------
+
+def check_quality_heuristics(skill_dir: Path, skill_md: Path, body: str):
+    """Q 组质量启发式检测：路由触发清晰度、上下文效率、容错降级、字段字数。"""
+    checks = []
+
+    file_texts = {}
+    for rel, text in iter_text_files(skill_dir):
+        if _is_detector_script(str(rel), text) or _is_detector_doc(str(rel), text):
+            continue
+        file_texts[str(rel)] = text
+
+    # Q1: 路由触发清晰度——SKILL.md 是否有明确的触发场景/关键词描述
+    trigger_keywords = [
+        r"当用户", r"触发", r"适用场景", r"使用场景", r"何时使用",
+        r"trigger", r"when to use", r"适用范围", r"使用时机",
+        r"关键词", r"触发词", r"识别条件",
+    ]
+    has_trigger = False
+    if body:
+        for kw in trigger_keywords:
+            if re.search(kw, body, re.IGNORECASE):
+                has_trigger = True
+                break
+    if has_trigger:
+        checks.append(Check("质量评估", "路由触发清晰度", "PASS", "INFO",
+                            "SKILL.md 含明确的触发场景/关键词描述，有利于平台路由匹配。"))
+    else:
+        checks.append(Check(
+            "质量评估", "路由触发清晰度", "WARN", "LOW",
+            "SKILL.md 未检测到明确的触发场景/关键词描述。"
+            "平台依赖描述文本来匹配用户意图，缺少触发词可能导致技能无法被正确路由。",
+            suggestion="在 SKILL.md 中补充「适用场景」「触发条件」章节，列明何时应使用本技能。"
+        ))
+
+    # Q2: 上下文效率——检查是否有超大文件（>100KB 的单个 .md 文件）
+    oversized = []
+    for rel, text in file_texts.items():
+        if rel.suffix.lower() in (".md", ".markdown") if hasattr(rel, 'suffix') else str(rel).lower().endswith((".md", ".markdown")):
+            size = len(text.encode("utf-8"))
+            if size > 100 * 1024:  # 100KB
+                oversized.append(f"{rel} → {_human_size(size)}")
+    if oversized:
+        checks.append(Check(
+            "质量评估", "上下文效率", "WARN", "LOW",
+            f"检测到 {len(oversized)} 个超大 Markdown 文件（>100KB）。"
+            "过大的参考文件会占用大量上下文窗口，影响 Agent 处理效率。",
+            locations=oversized[:10],
+            suggestion="拆分大文件为多个模块化小文件，或使用渐进披露策略按需加载。"
+        ))
+    else:
+        checks.append(Check("质量评估", "上下文效率", "PASS", "INFO",
+                            "未检测到超大文件，上下文负载合理。"))
+
+    # Q3: 容错降级——脚本中是否有 try/catch 或 error handling
+    script_files = {rel: text for rel, text in file_texts.items()
+                    if str(rel).lower().endswith(SCRIPT_EXTS)}
+    if script_files:
+        has_error_handling = False
+        error_handling_patterns = re.compile(
+            r"\btry\s*[:({]|\bcatch\s*\(|\bexcept\b|\bfinally\b|"
+            r"\.catch\s*\(|\bthrow\b|\braise\b|"
+            r"onError|on_error|error_handler|"
+            r"if\s+__name__|if\s+err|if\s+error",
+            re.IGNORECASE)
+        for rel, text in script_files.items():
+            if error_handling_patterns.search(text):
+                has_error_handling = True
+                break
+        if has_error_handling:
+            checks.append(Check("质量评估", "容错降级", "PASS", "INFO",
+                                "脚本中检测到错误处理逻辑（try/catch/except 等）。"))
+        else:
+            checks.append(Check(
+                "质量评估", "容错降级", "WARN", "LOW",
+                "包内含脚本但未检测到错误处理逻辑（try/catch/except 等）。"
+                "缺少容错降级会导致异常时直接崩溃，用户体验不佳。",
+                suggestion="在关键逻辑处添加 try/except（Python）或 try/catch（JS），"
+                          "提供友好的错误提示与降级方案。"
+            ))
+    else:
+        checks.append(Check("质量评估", "容错降级", "INFO", "INFO",
+                            "包内无脚本文件，跳过此项。"))
+
+    # Q4 / C02: display_name 字数检查 + description 字数上限
+    if skill_md and skill_md.exists():
+        content = skill_md.read_text(encoding="utf-8")
+        fm, _, _ = extract_frontmatter(content)
+        if fm:
+            dn = parse_frontmatter_field(fm, "display_name") or ""
+            if len(dn) > 20:
+                checks.append(Check(
+                    "质量评估", "display_name 简洁性", "WARN", "LOW",
+                    f"display_name 长度 {len(dn)} 字，建议控制在 20 字以内以便展示。",
+                    suggestion="精简 display_name，保留核心信息。"
+                ))
+            else:
+                checks.append(Check("质量评估", "display_name 简洁性", "PASS", "INFO",
+                                    f"display_name 长度 {len(dn)} 字，简洁。"))
+
+            desc = parse_frontmatter_field(fm, "description") or ""
+            if len(desc) > 200:
+                checks.append(Check(
+                    "质量评估", "description 字数控制", "WARN", "LOW",
+                    f"description 长度 {len(desc)} 字，建议控制在 200 字以内（一句话概述），"
+                    "详细内容放在 description_zh/description_en。",
+                    suggestion="精简 description 为 1-2 句摘要。"
+                ))
+            else:
+                checks.append(Check("质量评估", "description 字数控制", "PASS", "INFO",
+                                    f"description 长度 {len(desc)} 字。"))
+        else:
+            checks.append(Check("质量评估", "字段字数检查", "INFO", "INFO",
+                                "无 frontmatter，跳过字数检查。"))
+    else:
+        checks.append(Check("质量评估", "字段字数检查", "INFO", "INFO",
+                            "无 SKILL.md，跳过字数检查。"))
+
+    return checks
+
+
+def check_threat_model(skill_dir: Path):
+    """
+    威胁捕获模型视图：将 skill 行为映射到 8 类风险卡片。
+    返回 8 个 Check（PASS/INFO/WARN），分别对应一张风险卡片。
+    """
+    checks = []
+    file_texts = {}
+    for rel, text in iter_text_files(skill_dir):
+        if _is_detector_script(str(rel), text) or _is_detector_doc(str(rel), text):
+            continue
+        file_texts[str(rel)] = text
+
+    def _hits(pattern, script_only=False):
+        out = []
+        for rel, text in file_texts.items():
+            if script_only and not rel.lower().endswith(SCRIPT_EXTS):
+                continue
+            for i, line in enumerate(scan_lines(text), start=1):
+                if pattern.search(line):
+                    out.append(f"{rel}:{i} → {line.strip()[:120]}")
+        return out
+
+    def _any(pattern, script_only=False):
+        return bool(_hits(pattern, script_only))
+
+    # 1) 供应链风险
+    supply_hits = _hits(DEPENDENCY_INSTALL_RE)
+    if supply_hits:
+        checks.append(Check(
+            "威胁模型", "供应链风险", "WARN", "MEDIUM",
+            "检测到 skill 执行依赖包安装或远程脚本拉取，存在供应链投毒 / 恶意依赖风险。",
+            locations=supply_hits[:10],
+            suggestion="固定依赖版本并校验来源；避免安装来源不明的包或执行远程脚本。"
+        ))
+    else:
+        checks.append(Check("威胁模型", "供应链风险", "PASS", "INFO", "未检测到依赖安装 / 远程脚本拉取行为。"))
+
+    # 2) 命令执行风险
+    cmd_hits = _hits(COMMAND_EXEC_RE, script_only=True)
+    if cmd_hits:
+        checks.append(Check(
+            "威胁模型", "命令执行风险", "WARN", "HIGH",
+            "检测到 eval/exec/spawn/subprocess/system 等命令执行点。",
+            locations=cmd_hits[:10],
+            suggestion="避免动态执行外部命令；必须使用时严格限制命令白名单与参数范围。"
+        ))
+    else:
+        checks.append(Check("威胁模型", "命令执行风险", "PASS", "INFO", "未检测到动态命令执行点。"))
+
+    # 3) 网络请求与数据外传
+    net_hits = _hits(NETWORK_RE, script_only=True)
+    if net_hits:
+        checks.append(Check(
+            "威胁模型", "网络请求与数据外传", "WARN", "MEDIUM",
+            "检测到 HTTP / requests / curl / fetch 等网络请求能力，可能将用户数据外传到第三方。",
+            locations=net_hits[:10],
+            suggestion="明确请求目标域名与用途；禁止将用户隐私、会话凭证回传到非授权地址。"
+        ))
+    else:
+        checks.append(Check("威胁模型", "网络请求与数据外传", "PASS", "INFO", "未检测到网络请求能力。"))
+
+    # 4) 文件操作与敏感路径
+    file_hits = _hits(FILE_IO_RE, script_only=True)
+    path_hits = _hits(SENSITIVE_PATH_RE, script_only=False)
+    if file_hits or path_hits:
+        checks.append(Check(
+            "威胁模型", "文件操作与敏感路径", "WARN", "MEDIUM",
+            "检测到文件读写操作或敏感路径引用。",
+            locations=(file_hits + path_hits)[:10],
+            suggestion="限制文件操作范围；禁止读取系统凭证、SSH 私钥、浏览器 Cookie 等敏感路径。"
+        ))
+    else:
+        checks.append(Check("威胁模型", "文件操作与敏感路径", "PASS", "INFO", "未检测到文件操作或敏感路径引用。"))
+
+    # 5) Prompt 注入风险
+    # 否定性安全声明（如「不要要求用户直接粘贴 ETEAMSID」）属合规正向约束，不计入诱导贴凭证
+    cred_hits = [h for h in _hits(PROMPT_CRED_RE) if not NEGATION_SAFE_RE.search(h)]
+    prompt_hits = cred_hits + _hits(PROMPT_INJECTION_RE)
+    if prompt_hits:
+        checks.append(Check(
+            "威胁模型", "Prompt 注入风险", "WARN", "HIGH",
+            "检测到提示词模板诱导用户粘贴会话凭证，或存在典型 prompt 注入话术。",
+            locations=prompt_hits[:10],
+            suggestion="禁止要求用户将 ETEAMSID/token/password 等凭证明文贴入对话；避免使用忽略指令类话术。"
+        ))
+    else:
+        checks.append(Check("威胁模型", "Prompt 注入风险", "PASS", "INFO", "未检测到 prompt 注入或诱导贴凭证行为。"))
+
+    # 6) 远程脚本下载执行
+    remote_hits = _hits(REMOTE_SCRIPT_EXEC_RE)
+    if remote_hits:
+        checks.append(Check(
+            "威胁模型", "远程脚本下载执行", "WARN", "HIGH",
+            "检测到 curl | bash、powershell -enc、远程 .py/.sh 脚本执行等远程代码执行模式。",
+            locations=remote_hits[:10],
+            suggestion="禁止下载并直接执行远程脚本；如需外部脚本应提供内容校验与来源说明。"
+        ))
+    else:
+        checks.append(Check("威胁模型", "远程脚本下载执行", "PASS", "INFO", "未检测到远程脚本下载执行。"))
+
+    # 7) 可疑编码/混淆
+    obf_hits = _hits(OBFUSCATION_RE, script_only=True)
+    if obf_hits:
+        checks.append(Check(
+            "威胁模型", "可疑编码/混淆", "WARN", "MEDIUM",
+            r"检测到 eval(atob/base64)、长串 base64、\x/\u 转义序列等可疑混淆特征。",
+            locations=obf_hits[:10],
+            suggestion="避免使用 eval 执行动态字符串；对外分发前解码并审计混淆内容。"
+        ))
+    else:
+        checks.append(Check("威胁模型", "可疑编码/混淆", "PASS", "INFO", "未检测到可疑编码/混淆特征。"))
+
+    # 8) 其他安全风险（沙箱绕过、隐私采集、反调试等）
+    sandbox_hits = _hits(SANDBOX_BYPASS_RE)
+    privacy_hits = _hits(OTHER_PRIVACY_RE)
+    if sandbox_hits or privacy_hits:
+        checks.append(Check(
+            "威胁模型", "其他安全风险", "WARN", "HIGH",
+            "检测到沙箱绕过参数（--no-sandbox 等）或屏幕截图、录音、剪贴板读取等隐私采集能力。",
+            locations=(sandbox_hits + privacy_hits)[:10],
+            suggestion="禁止默认关闭浏览器沙箱；采集屏幕/剪贴板/录音等敏感能力必须明示用户并获得授权。"
+        ))
+    else:
+        checks.append(Check("威胁模型", "其他安全风险", "PASS", "INFO", "未检测到沙箱绕过或隐私采集特征。"))
+
+    return checks
+
+
+def check_behavior_graph(skill_dir: Path):
+    """
+    威胁行为图谱解析：针对截图中展示的具体跨文件/跨行行为做联合检测。
+    """
+    checks = []
+    file_texts = {}
+    for rel, text in iter_text_files(skill_dir):
+        if _is_detector_script(str(rel), text) or _is_detector_doc(str(rel), text):
+            continue
+        file_texts[str(rel)] = text
+
+    all_text = "\n".join(file_texts.values())
+
+    # 1) 沙箱绕过：dangerouslyDisableSandbox + run_in_background 同时出现
+    has_disable = DISABLE_SANDBOX_FLAG_RE.search(all_text)
+    has_bg = RUN_BACKGROUND_FLAG_RE.search(all_text)
+    if has_disable and has_bg:
+        locations = []
+        for rel, text in file_texts.items():
+            for i, line in enumerate(scan_lines(text), start=1):
+                if DISABLE_SANDBOX_FLAG_RE.search(line) or RUN_BACKGROUND_FLAG_RE.search(line):
+                    locations.append(f"{rel}:{i} → {line.strip()[:120]}")
+        checks.append(Check(
+            "行为图谱", "dangerouslyDisableSandbox + run_in_background 绕过权限确认", "WARN", "HIGH",
+            "检测到 skill 同时出现 dangerouslyDisableSandbox: true 与 run_in_background: true，"
+            "可能用于在跳过默认工具权限确认的 Bash 工具中启动浏览器并关闭沙箱。",
+            locations=locations[:10],
+            suggestion="禁止默认禁用沙箱；浏览器启动须经用户授权，保留沙箱保护。"
+        ))
+    else:
+        checks.append(Check(
+            "行为图谱", "dangerouslyDisableSandbox + run_in_background 绕过权限确认", "PASS", "INFO",
+            "未检测到 dangerouslyDisableSandbox 与 run_in_background 组合。"))
+
+    # 2) 浏览器启动参数关闭沙箱
+    sandbox_arg_hits = []
+    for rel, text in file_texts.items():
+        if not rel.lower().endswith(SCRIPT_EXTS + (".md", ".markdown", ".txt")):
+            continue
+        for i, line in enumerate(scan_lines(text), start=1):
+            if SANDBOX_BYPASS_RE.search(line):
+                sandbox_arg_hits.append(f"{rel}:{i} → {line.strip()[:120]}")
+    if sandbox_arg_hits:
+        checks.append(Check(
+            "行为图谱", "浏览器启动参数关闭沙箱", "WARN", "HIGH",
+            "检测到 --no-sandbox、--disable-gpu、--disable-setuid-sandbox 等浏览器启动参数。",
+            locations=sandbox_arg_hits[:10],
+            suggestion="浏览器自动化应保留沙箱；确需关闭时须向用户明确说明风险并获得授权。"
+        ))
+    else:
+        checks.append(Check(
+            "行为图谱", "浏览器启动参数关闭沙箱", "PASS", "INFO",
+            "未检测到关闭沙箱的浏览器启动参数。"))
+
+    # 3) 提示词诱导用户明文粘贴 ETEAMSID
+    prompt_cred_hits = []
+    for rel, text in file_texts.items():
+        if not rel.lower().endswith((".md", ".markdown", ".txt")):
+            continue
+        for i, line in enumerate(scan_lines(text), start=1):
+            if PROMPT_CRED_RE.search(line):
+                if NEGATION_SAFE_RE.search(line):
+                    continue  # 否定性安全声明（如「不要要求用户直接粘贴」），非诱导贴凭证
+                prompt_cred_hits.append(f"{rel}:{i} → {line.strip()[:120]}")
+    if prompt_cred_hits:
+        checks.append(Check(
+            "行为图谱", "提示词诱导用户明文粘贴会话凭证", "WARN", "HIGH",
+            "检测到提示词模板要求用户将 ETEAMSID / token / session 等会话凭证明文粘贴进对话，"
+            "使可复用会话凭证以明文进入跨主体持久化的 Agent 上下文。",
+            locations=prompt_cred_hits[:20],
+            suggestion="严禁在提示词中要求用户贴出凭证；凭证须通过 E10 命名凭据插件安全获取。"
+        ))
+    else:
+        checks.append(Check(
+            "行为图谱", "提示词诱导用户明文粘贴会话凭证", "PASS", "INFO",
+            "未检测到诱导用户粘贴会话凭证的提示词。"))
+
+    return checks
+
+
+def check_skill_capabilities(skill_dir: Path):
+    """
+    技能能力清单：识别 skill 具备的运行时能力，以 INFO 形式列出，便于上架前透明披露。
+    """
+    file_texts = {}
+    for rel, text in iter_text_files(skill_dir):
+        if _is_detector_script(str(rel), text) or _is_detector_doc(str(rel), text):
+            continue
+        file_texts[str(rel)] = text
+    all_text = "\n".join(file_texts.values()).lower()
+
+    caps = []
+    if re.search(r"\b(requests\.|urllib|http\.client|httpx|aiohttp|axios|fetch\(|curl\b|wget\b)\b", all_text):
+        caps.append("HTTP 请求")
+    if EXTERNAL_API_RE.search(all_text):
+        caps.append("调用外部 API")
+    if re.search(r"\b(open\s*\(|read_text\(|read_file\(|readFileSync|readFile\(|fs\.read|Path\([^)]*\)\.read_text)", all_text):
+        caps.append("读取文件")
+    if re.search(r"\b(write_text\(|write_file\(|writeFileSync|writeFile\(|fs\.write|Path\([^)]*\)\.write_text)", all_text):
+        caps.append("写入文件")
+    if DEPENDENCY_INSTALL_RE.search(all_text):
+        caps.append("安装依赖包")
+    if BROWSER_CONTROL_RE.search(all_text):
+        caps.append("控制浏览器")
+    if ENV_READ_RE.search(all_text):
+        caps.append("读取环境变量")
+    if COMMAND_EXEC_RE.search(all_text):
+        caps.append("执行系统命令")
+    if re.search(r"\b(sqlite3|pymysql|psycopg2|sqlalchemy|\.query\(|SELECT\s+.*FROM)\b", all_text, re.IGNORECASE):
+        caps.append("数据库访问")
+    if re.search(r"\b(socket\.|listen\(|connect\(|bind\(|tcp://|udp://|websocket|ws://|wss://)\b", all_text):
+        caps.append("网络监听 / Socket / WebSocket")
+
+    if not caps:
+        caps.append("未识别到特定运行时能力（可能为纯文档/提示词类 skill）")
+
+    return [Check(
+        "技能能力清单", "识别到的能力", "INFO", "INFO",
+        f"本 skill 源码/文档中识别到以下运行时能力：{', '.join(caps)}。",
+        suggestion="上架时建议在说明中如实披露这些能力，便于用户与平台评估权限范围。"
+    )]
+
+
+SKILL_DEP_FIELDS = ("dependencies", "requires", "depends_on", "depends", "skills", "uses")
+
+# 中文引述场景下的非技能名词，避免把「使用本技能」「结合通用技能」等常见表述误判为依赖
+DEP_STOPWORDS = {
+    "本", "该", "此", "某", "一个", "一种", "多个", "相关", "其他", "其它", "对应",
+    "以下", "上述", "如上", "我们", "你们", "他们", "平台", "工作", "检测", "分析",
+    "通用", "标准", "规范", "基础", "核心", "高级", "专属", "内置", "外部", "已有",
+    "当前", "整个", "所有", "这些", "那些", "这种", "此类", "一切", "全部",
+    "自身", "自己", "本技能", "该技能", "此技能", "其他技能",
+    # 常见路径段，避免把 /tmp、/usr、/data 等误判为技能依赖
+    "tmp", "usr", "home", "var", "etc", "opt", "bin", "lib", "dev", "src", "root",
+    "user", "app", "data", "docs", "doc", "test", "tests", "logs", "cache", "mnt",
+    # 口语/疑问词与通用路径段，避免把「使用哪个技能」「/api/xxx」误判为依赖
+    "哪个", "什么", "如何", "怎么", "哪些", "这个", "那个", "此处",
+    "api", "count", "v1", "v2", "rest", "graphql", "oauth", "openapi", "swagger",
+}
+
+
+def looks_like_skill_name(name: str) -> bool:
+    """
+    稳健判定「看起来像个泛微生态技能名」。仅接受一种高置信形状：
+      weaver-e10- 前缀 + 连字符：weaver-e10- 开头且必须含连字符
+      （如 weaver-e10-login、weaver-e10-hrm）。
+    依赖检测**只关注 weaver-e10- 前缀**的泛微生态技能（合作方要求），weaver- 但非
+    e10-/e10-/eteams- 等前缀视为平台模块名/内部引用，不作为技能依赖识别。
+    这样可排除：weaver-ebuilder-*/weaver-openserver-* 等内部接口模块、单单词
+    （send/list/api）、中文片段（以下外部/调用本）、URL 路径段（/references/、/send/）、
+    文档内函数/参数名（hrm-employee-query、emp-by-ids、to-uid）、全大写常量/环境变量
+    （ETEAMSID、E10_LOGIN_ENTRY，无连字符故不命中）。
+    说明：frontmatter 中**显式声明**的依赖（dependencies/requires 字段）同样受
+    weaver-e10- 前缀约束——非 weaver-e10- 前缀的一律不识别为技能依赖。
+    """
+    s = (name or "").strip().strip('"\'`').strip()
+    if not s or len(s) < 2:
+        return False
+    return bool(re.fullmatch(r"weaver-e10-[\w-]+", s, re.IGNORECASE))
+
+
+def check_skill_dependencies(skill_dir: Path, skill_md: Path = None, market_catalog: dict = None, live_market: bool = False):
+    """
+    技能依赖清单：识别 skill 显式声明（frontmatter dependencies/requires 等字段）
+    或正文引用（skill: 调用、/斜杠命令、「使用 xxx 技能」表述）的其他技能，
+    以 INFO 形式透明披露依赖关系，便于上架前评估依赖面与联动安装。
+
+    market_catalog: 可选，市场已收录技能清单（name(lower) -> info）。传入后对每个依赖标注可达性。
+    live_market:    可选，True 时联网动态核查 skillhub.cn 市场（覆盖 market_catalog，按 slug 精确匹配）。
+                    二者都不传则仅静态列出依赖（零联网）。
+    """
+    deps, seen = [], set()
+    self_names = {Path(skill_dir).name.lower(), "weaver-skill-detector", "validate_skill"}
+
+    def add(name, strict: bool = False):
+        name = (name or "").strip().strip('"\'`').strip()
+        if not name or len(name) < 2:
+            return
+        low = name.lower()
+        if low in seen or low in self_names or low in DEP_STOPWORDS:
+            return
+        # 合作方要求：依赖检测只关注 weaver-e10- 前缀的泛微生态技能。
+        # 所有来源（frontmatter 显式声明 / 斜杠命令 / 中文引述 / 反引号标识符 / 由 xxx 提供）
+        # 一律统一收口于此：非 weaver-e10- 前缀不识别为技能依赖
+        # （weaver-ebuilder-/weaver-openserver-/e10-/eteams- 视为平台模块/内部引用）。
+        if not low.startswith("weaver-e10-"):
+            return
+        # strict=True：启发式命中（斜杠命令/中文引述/由 xxx 提供/反引号标识符）必须通过
+        # 「看起来像技能名」判定，过滤单单词与中文/路径噪声；frontmatter 显式声明走 strict=False。
+        if strict and not looks_like_skill_name(name):
+            return
+        seen.add(low)
+        deps.append(name)
+
+    # 1) SKILL.md frontmatter 显式声明
+    if skill_md is not None and skill_md.exists():
+        text = skill_md.read_text(encoding="utf-8", errors="replace")
+        fm, _, _ = extract_frontmatter(text)
+        if fm:
+            nm = parse_frontmatter_field(fm, "name")
+            if nm:
+                self_names.add(nm.strip().strip('"\'`').lower())
+            for key in SKILL_DEP_FIELDS:
+                # ① 内联值：dependencies: a, b 或 dependencies: [a, b]
+                val = parse_frontmatter_field(fm, key)
+                if val:
+                    for part in re.split(r"[,，;；]", val):
+                        part = part.strip().strip('[]"\'`')
+                        if part and not part.startswith("-"):
+                            add(part)  # frontmatter 显式声明：高置信度，不走 strict 判定
+                # ② YAML 块列表：key: 换行后缩进的 "- item" 行
+                block = re.search(r"^\s*" + re.escape(key) + r"\s*:\s*\n((?:\s*-\s+.*\n?)+)", fm, re.MULTILINE)
+                if block:
+                    for m in re.finditer(r"^\s*-\s+(.+)$", block.group(1), re.MULTILINE):
+                        add(m.group(1))  # frontmatter 显式声明：高置信度，不走 strict 判定
+            # ③ description 中的依赖表述：「接口地址与认证由 weaver-e10-login 提供」
+            for m in re.finditer(r"^\s*description(?:_\w+)?\s*:\s*(.+)$", fm, re.MULTILINE):
+                for dm in re.finditer(r"由\s*([A-Za-z0-9][A-Za-z0-9._-]{1,60})\s*(?:提供|负责|承担)", m.group(1)):
+                    add(dm.group(1), strict=True)
+
+    # 2) 文档引用：仅从 Markdown 文档提取。
+    #    - 主 SKILL.md：提示词所在，识别 skill: 调用 / 斜杠命令 / 中文引述 / 「由 xxx 提供」
+    #    - references/*.md：多为接口手册，/api/xxx 类路径不应误判为技能依赖，仅识别中文引述与「由 xxx 提供」
+    for rel, text in iter_text_files(skill_dir):
+        if _is_detector_script(str(rel), text) or _is_detector_doc(str(rel), text):
+            continue
+        rel_low = str(rel).lower()
+        if not rel_low.endswith((".md", ".markdown")):
+            continue
+        is_main = rel.name.upper() == "SKILL.MD"
+        if is_main:
+            # Skill 工具调用：skill: "xxx" / skill = xxx
+            for m in re.finditer(r"\bskill\s*[:=]\s*['\"]?([A-Za-z0-9][A-Za-z0-9._/-]{1,60})['\"]?", text):
+                add(m.group(1), strict=True)
+            # 斜杠命令 /xxx：真正的 skill 斜杠命令是孤立 token（如 /commit、/review-pr），其后不接 `/`。
+            # 负向前瞻排除 `/`：接 `/` 的是路径/URL 片段（如 /references/、/viewport/、/api/ebuilder/...、
+            # skillhub.cn/skills/...），并非技能依赖，避免误判。命中再经 strict 标识符形状校验。
+            for m in re.finditer(r"(?<![:/\w<>])\/([a-z][a-z0-9_-]{2,40})(?![A-Za-z0-9_/-])", text):
+                add(m.group(1), strict=True)
+            # 依赖清单式列举：「只读依赖：`a`、`b`、`c`」「依赖：`x`」（容错 markdown 加粗 ** 与空格）
+            for m in re.finditer(r"依赖[*\s]*[：:][^。\n]*", text):
+                for part in re.findall(r"[`'](weaver-e10-[\w-]+)[`']", m.group(0)):
+                    add(part, strict=True)
+        # 泛微生态高精度信号：反引号/单引号包裹的 weaver-e10- 前缀带连字符标识符
+        # （如 `weaver-e10-login`）。self_names 已排除检测器自身（weaver-skill-detector）。
+        for m in re.finditer(r"[`'](weaver-e10-[\w-]+)[`']", text, re.IGNORECASE):
+            add(m.group(1), strict=True)
+        # 中文引述：「使用 xxx 技能」「调用 xxx skill」「委托 xxx skill」——命中须通过 strict 标识符形状校验，
+        # 因此「依赖以下外部 skill」「调用本 skill」「结合通用的技能」均不会误判为依赖。
+        for m in re.finditer(r"(?:使用|加载|调用|引用|依赖|基于|借助|通过|结合|委托)\s*([`']?[\u4e00-\u9fa5A-Za-z0-9_-]{2,40}[`']?)\s*(?:技能|skill(?!\.md))\b", text, re.IGNORECASE):
+            g = m.group(1)
+            if g.startswith("的"):
+                continue
+            # 自指片段（调用本/本技能/该技能/此技能等）指称本 skill 自身，非外部依赖，应跳过
+            if re.search(r"(本|该|此|自身|自己|这个|那个)(技能|skill)?\s*$", g):
+                continue
+            # 非反引号中文片段若以「的」结尾（如 执行的/可执行的），属修饰语而非技能名，跳过
+            if not g.startswith("`") and g.endswith("的"):
+                continue
+            # 反引号包裹的视为代码标识符（如 `weaver-e10-login`），不受中文短语长度限制；
+            # 非反引号的中文短语仍限制 ≤16 字，避免长句误判为依赖
+            if not g.startswith("`") and len(g) > 16:
+                continue
+            add(g, strict=True)
+        # 「由 xxx 提供/负责」表述（容错「会话」等中间词：由 weaver-e10-login 会话提供）
+        for m in re.finditer(r"由\s*([A-Za-z0-9][A-Za-z0-9._-]{1,60})\s*(?:会话\s*)?(?:提供|负责|承担)", text):
+            add(m.group(1), strict=True)
+
+    if not deps:
+        detail = "未识别到本 skill 依赖的其他技能（可能为独立技能，无需联动安装）。"
+    else:
+        detail = f"本 skill 显式声明或正文引用以下其他技能：{', '.join(deps)}。"
+
+    # 动态市场核查（联网）：覆盖静态清单，按 slug 精确匹配 skillhub.cn
+    # add() 已统一收口为 weaver-e10- 前缀依赖（合作方要求：只检测 weaver-e10- 开头），
+    # 此处 _is_weaver_dep 作为保险保留，防止未来扩展非前缀依赖时漏掉过滤。
+    def _is_weaver_dep(d: str) -> bool:
+        return d.lower().startswith("weaver-e10-")
+
+    market_deps = [d for d in deps if _is_weaver_dep(d)] if deps else []
+    if live_market and market_deps:
+        try:
+            market_catalog = query_skillhub_market(market_deps)
+            skipped_n = len(deps) - len(market_deps)
+            log(f"已动态核查 skillhub.cn 市场: {len(market_deps)} 个 weaver-e10- 前缀依赖"
+                + (f"（{skipped_n} 个非 weaver-e10- 前缀依赖跳过核查）" if skipped_n else ""))
+        except Exception as e:
+            log(f"⚠️ 市场动态核查失败（将仅静态列出依赖，不标注可达性）: {e}")
+            market_catalog = None
+
+    dep_status = None
+    if market_catalog is not None:
+        dep_status = []
+        for d in deps:
+            if not _is_weaver_dep(d):
+                dep_status.append({"name": d, "in_market": None, "market": "", "url": "",
+                                   "error": "", "skipped": True})
+                continue
+            info = market_catalog.get(d.lower()) or {"found": False, "market": "", "url": "", "error": ""}
+            dep_status.append({
+                "name": d,
+                "in_market": bool(info.get("found")),
+                "market": info.get("market", ""),
+                "url": info.get("url", ""),
+                "error": info.get("error", ""),
+                "skipped": False,
+            })
+    extra = {"deps": dep_status, "market_checked": market_catalog is not None} if dep_status is not None else None
+
+    return [Check(
+        "技能依赖清单", "依赖的其他技能", "INFO", "INFO", detail,
+        suggestion="上架时建议如实披露依赖关系，确保被依赖技能已上架、名称一致且版本兼容。"
+                  + (" 已对照市场清单标注各依赖可达性。" if extra else ""),
+        extra=extra
+    )]
+
+
+def _human_size(num: int) -> str:
+    """把字节数转换为人类可读大小。"""
+    units = ["B", "KB", "MB", "GB", "TB"]
+    size = float(num)
+    for unit in units:
+        if size < 1024 or unit == units[-1]:
+            return f"{size:.2f} {unit}" if unit != "B" else f"{int(size)} B"
+        size /= 1024
+    return f"{size:.2f} TB"
+
+
+def load_market_catalog(path: str) -> dict:
+    """
+    加载「市场已收录技能清单」为 {name(lower): info} 映射，供依赖可达性标注使用。
+
+    info 结构: {"found": bool, "market": str, "url": str}
+      - found : 是否在目标市场可搜（缺失键视为 found=False）
+      - market: 市场/平台名称（如 skillhub.cn），用于报告中展示可达性来源
+      - url   : 可选，技能在市场中的地址
+
+    支持三种 JSON 格式：
+      - 列表   ：["skill-a", "skill-b"]                      -> 均标记 found=True（市场名留空，由图例说明平台）
+      - 简单对象：{"skill-a": true, "skill-b": false}        -> 显式标注可达性
+      - 富对象 ：{"skill-a": {"found": true, "market": "skillhub.cn", "url": "https://..."}}
+        也可简写为 {"skill-a": "skillhub.cn"}（字符串视为市场名，found=True）
+    """
+    p = Path(path).expanduser()
+    if not p.exists():
+        raise FileNotFoundError(f"市场清单文件不存在: {path}")
+    data = json.loads(p.read_text(encoding="utf-8"))
+
+    def norm(v):
+        if isinstance(v, bool):
+            return {"found": v, "market": "", "url": ""}
+        if isinstance(v, str):
+            return {"found": True, "market": v.strip(), "url": ""}
+        if isinstance(v, dict):
+            found = bool(v.get("found", True)) and not bool(v.get("not_found", False))
+            return {"found": found, "market": v.get("market", "") or "", "url": v.get("url", "") or ""}
+        return {"found": False, "market": "", "url": ""}
+
+    catalog = {}
+    if isinstance(data, list):
+        for item in data:
+            if isinstance(item, str) and item.strip():
+                catalog[item.strip().lower()] = {"found": True, "market": "", "url": ""}
+    elif isinstance(data, dict):
+        for k, v in data.items():
+            catalog[str(k).strip().lower()] = norm(v)
+    return catalog
+
+
+def query_skillhub_market(names):
+    """
+    动态联网核查给定技能名是否已在 skillhub.cn 市场发布（依赖可达性）。
+
+    返回 {name(lower): {"found": bool, "market": "skillhub.cn", "url": str, "error": str}}。
+    使用 skillhub.cn 公开检索接口 GET /api/skills?page=1&pageSize=24&sortBy=score&order=desc&keyword=<name>
+    （与 skillhub.cn 前端实际发出的请求一致），按 **slug 精确相等**（或 canonicalName 以 /<name> 结尾）
+    判定，避免子串误命中
+    （例如 keyword=weaver-e10-login 会同时召回 weaver-e10-jucailin，必须精确匹配）。
+
+    设计取舍：本工具默认仍是「纯静态、零联网」。此函数为可选的 --market-live 模式提供
+    联网能力，把「是否可搜」的判定交给 skillhub.cn 实时返回，而非依赖一份写死的清单。
+    """
+    catalog = {}
+    for name in names:
+        low = name.lower()
+        entry = {"found": False, "market": "skillhub.cn", "url": "", "error": ""}
+        try:
+            q = urllib.parse.quote(name)
+            url = f"{SKILLHUB_API}?page=1&pageSize=24&sortBy=score&order=desc&keyword={q}"
+            req = urllib.request.Request(
+                url, headers={"User-Agent": "weaver-skill-detector/1.0 (+https://skillhub.cn)"}
+            )
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                payload = json.loads(resp.read().decode("utf-8"))
+            skills = (payload.get("data") or {}).get("skills") or []
+            for s in skills:
+                slug = (s.get("slug") or "").lower()
+                ns = s.get("namespace") or {}
+                canonical = (ns.get("canonicalName") or "") if isinstance(ns, dict) else ""
+                if slug == low or canonical.lower().endswith("/" + low):
+                    entry = {
+                        "found": True,
+                        "market": "skillhub.cn",
+                        "url": f"https://skillhub.cn/skills/{canonical.lstrip('@')}" if canonical
+                               else f"https://skillhub.cn/skills/{slug}",
+                        "error": "",
+                    }
+                    break
+        except Exception as e:  # 网络/解析失败：标记错误，交由调用方以「核查失败」呈现
+            entry["error"] = str(e)
+        catalog[low] = entry
+    return catalog
+
+
+def calc_file_info(target: Path, source_type: str):
+    """计算被检测对象的基础信息（MD5 / SHA256 / 大小）。"""
+    if not target.exists():
+        return None
+
+    md5 = hashlib.md5()
+    sha = hashlib.sha256()
+
+    if source_type == "directory":
+        total = 0
+        files = sorted(p for p in target.rglob("*") if p.is_file())
+        for f in files:
+            total += f.stat().st_size
+            rel = str(f.relative_to(target)).replace("\\", "/")
+            md5.update(rel.encode("utf-8"))
+            md5.update(b"\x00")
+            sha.update(rel.encode("utf-8"))
+            sha.update(b"\x00")
+            with open(f, "rb") as fh:
+                for chunk in iter(lambda: fh.read(65536), b""):
+                    md5.update(chunk)
+                    sha.update(chunk)
+        return {
+            "md5": md5.hexdigest(),
+            "sha256": sha.hexdigest(),
+            "size": total,
+            "size_human": _human_size(total),
+            "scope": "目录递归",
+        }
+
+    # zip / markdown / 其他文件：对文件本身计算
+    total = target.stat().st_size
+    with open(target, "rb") as fh:
+        for chunk in iter(lambda: fh.read(65536), b""):
+            md5.update(chunk)
+            sha.update(chunk)
+    return {
+        "md5": md5.hexdigest(),
+        "sha256": sha.hexdigest(),
+        "size": total,
+        "size_human": _human_size(total),
+        "scope": "文件本身",
+    }
+
+
+# ---------------------------------------------------------------------------
+# 报告生成
+# ---------------------------------------------------------------------------
+
+def summarize(checks):
+    errors = [c for c in checks if c.severity == "BLOCK" and c.status == "FAIL"]
+    warns = [c for c in checks if c.status == "WARN"]
+    if errors:
+        verdict = "FAIL"
+    elif warns:
+        verdict = "WARN"
+    else:
+        verdict = "PASS"
+    return verdict, len(errors), len(warns)
+
+
+# ---------------------------------------------------------------------------
+# 约束归属（WB = WorkBuddy 平台约束 / WV = 泛微专属约束）
+#   WB    ：skillhub.cn 平台加载器与上传校验要求，任何作者的 skill 都必须满足，违反即被平台拒收。
+#   WV    ：泛微生态内部治理要求（品牌、E10 账号与接口调用契约、安全合规），平台不强制但泛微不放行。
+#   WB+WV ：平台有通用要求，泛微在其上追加了更严的约束。
+# 详见 references/checklist.md 第 0 节「约束归属总览」。
+# ---------------------------------------------------------------------------
+CATEGORY_ORIGIN = {
+    "基础合规": "WB+WV",
+    "专项质检": "WV",
+    "API 凭证完整性": "WV",
+    "E10 登录与凭证契约": "WV",
+    "扩展安全": "WB",
+    "质量评估": "WB",
+    "技能能力清单": "WB",
+    "技能依赖清单": "WB+WV",
+    "威胁模型": "WB",
+    "行为图谱": "WB",
+    "千问契约": "QW",
+}
+ORIGIN_DESC = {
+    "WB": "WorkBuddy 平台约束",
+    "WV": "泛微专属约束",
+    "WB+WV": "平台通用 + 泛微追加",
+    "QW": "千问办公平台约束",
+    "QW+WB": "千问平台 + WorkBuddy 通用",
+    "QW+WV": "千问平台 + 泛微追加",
+}
+ORIGIN_ORDER = ("WB", "WV", "WB+WV", "QW", "QW+WB", "QW+WV")
+
+# ---------------------------------------------------------------------------
+# 多平台规范（千问办公生态接入开发指南 2026 整合）
+# ---------------------------------------------------------------------------
+# 默认 weaver（泛微生态）保持既有行为；--platform qwenwork 时启用千问专属规则。
+# 字段别名机制：千问规范的 frontmatter 字段命名与泛微不一致（如 displayName / name_en），
+# 解析时按当前 platform 自动选用对应 key 集合；缺失信息给出差异化提示。
+PLATFORMS = {
+    "weaver": {
+        "label": "泛微生态",
+        "origin_chip": "WB+WV",
+        "publish_label": "WorkBuddy 泛微上架",
+        # frontmatter 字段：千问与泛微在「中文展示名 / 英文展示名 / 中文描述」上的命名差异
+        "name_cn_field": "display_name",         # 中文展示名
+        "name_cn_prefix_required": "泛微",       # display_name 必须以「泛微」开头
+        "name_en_field": "display_name_en",      # 英文展示名
+        "desc_cn_field": "description_zh",       # 中文描述
+        "desc_en_field": "description_en",       # 英文描述
+        "extra_name_field": None,                # 额外必填名（千问特有 author_name）
+        # 打包硬性
+        "max_entries": 300,                      # zip 内条目数
+        "max_zip_mb": None,                      # zip 大小限制（None = 不限制）
+        "skill_md_path_required": "exists",      # SKILL.md 是否存在即可
+        # 正文长度
+        "max_body_kb": None,                     # SKILL.md 正文 KB 限制（None = 不限制）
+        # 必填 frontmatter 字段集合（用于 frontmatter 完整性 + 语法校验的关键 key 集合）
+        "required_fm_keys": ("author", "version", "name", "description",
+                             "description_zh", "description_en",
+                             "display_name", "display_name_en"),
+        # 是否需要 name 以 weaver- 开头 / 是否需要 author 锁定为「泛微网络科技股份有限公司」
+        "name_prefix_required": "weaver-",
+        "author_locked": "泛微网络科技股份有限公司",
+        # 分类是否限定枚举
+        "category_enum": None,
+    },
+    "qwenwork": {
+        "label": "千问办公生态",
+        "origin_chip": "QW",
+        "publish_label": "千问上架",
+        "name_cn_field": "displayName",          # 千问用 displayName 作为中文展示名
+        "name_cn_prefix_required": None,          # 千问 displayName 无前缀要求
+        "name_en_field": "name_en",              # 千问用 name_en 作为英文展示名
+        "desc_cn_field": "description",          # 千问 description 直接是中文
+        "desc_en_field": "description_en",
+        "extra_name_field": "author_name",       # 千问特有必填 author_name
+        "max_entries": 999,                      # 千问硬性 < 1000
+        "max_zip_mb": 10,                        # 千问硬性 ≤ 10 MB
+        "skill_md_path_required": "exact",       # 千问硬性 <name>/SKILL.md 精确路径
+        "max_body_kb": 64,                       # 千问硬性 ≤ 64 KB
+        "required_fm_keys": ("name", "displayName", "name_en",
+                             "description", "description_en"),
+        "name_prefix_required": None,            # 千问不强求 weaver- 前缀（无品牌前缀要求）
+        "author_locked": None,                   # 千问不锁 author 为固定值
+        "category_enum": ("content_creation", "visual_creative", "data_analysis",
+                         "consulting_research", "productivity", "marketing_sales",
+                         "ecommerce_retail", "product_development", "hr_recruiting",
+                         "finance_accounting", "legal_affairs", "investment",
+                         "education", "other"),
+    },
+}
+VALID_PLATFORMS = tuple(PLATFORMS.keys())
+
+
+def _origin_of(cat: str):
+    return CATEGORY_ORIGIN.get(cat, "")
+
+
+def render_report(target, source_type, checks, verdict, n_err, n_warn, file_info=None,
+                  platform: str = "weaver"):
+    lines = []
+    lines.append("=" * 64)
+    lines.append("泛微技能检测工具 · 检测报告")
+    lines.append("=" * 64)
+    lines.append(f"被检测对象 : {target}")
+    lines.append(f"输入类型   : {source_type}")
+    _spec = PLATFORMS.get(platform, PLATFORMS["weaver"])
+    _default_tag = " · 默认" if platform == "weaver" else " · 显式指定"
+    lines.append(f"检测平台   : {_spec['label']}（--platform {platform}{_default_tag}）")
+    if file_info:
+        lines.append(f"文件大小   : {file_info['size_human']} ({file_info['size']} bytes, {file_info['scope']})")
+        lines.append(f"MD5        : {file_info['md5']}")
+        lines.append(f"SHA256     : {file_info['sha256']}")
+    lines.append("")
+    lines.append("-" * 64)
+
+    by_cat = {}
+    for c in checks:
+        by_cat.setdefault(c.category, []).append(c)
+
+    icon = {"PASS": "✅", "FAIL": "❌", "WARN": "⚠️", "INFO": "ℹ️"}
+    for cat, items in by_cat.items():
+        _org = _origin_of(cat)
+        lines.append(f"【{cat}" + (f" · 归属 {_org}" if _org else "") + "】")
+        for c in items:
+            lines.append(f"  {icon.get(c.status, '·')} [{c.status}] {c.name}")
+            lines.append(f"      说明: {c.detail}")
+            if c.locations:
+                lines.append(f"      位置: {c.locations[0]}")
+                for loc in c.locations[1:5]:
+                    lines.append(f"            {loc}")
+                if len(c.locations) > 5:
+                    lines.append(f"            …等 {len(c.locations)} 处")
+            if c.suggestion:
+                lines.append(f"      建议: {c.suggestion}")
+            if c.category == "技能依赖清单" and getattr(c, "extra", None) and c.extra.get("market_checked"):
+                for d in c.extra.get("deps") or []:
+                    suffix = f"（{d['market']}）" if d.get("market") else ""
+                    if d.get("skipped"):
+                        lines.append(f"      市场可达性: {d['name']} → 跳过（非 weaver-e10- 前缀）")
+                    else:
+                        lines.append(f"      市场可达性: {d['name']} → {'市场可搜' if d['in_market'] else '市场未收录'}{suffix}")
+        lines.append("-" * 64)
+
+    lines.append("综合判定   : " + ("不通过 ❌ FAIL" if verdict == "FAIL"
+                                    else ("通过（含警告）⚠️ WARN" if verdict == "WARN"
+                                          else "通过 ✅ PASS")))
+    lines.append("发布结论   : " + ("✅ 可发布（无阻断性风险）" if n_err == 0
+                                    else f"⛔ 不可发布（含 {n_err} 项阻断性风险）"))
+    if n_err == 0:
+        lines.append("上架提醒   : ⚠️ 提交前请确认市场现有版本号，新版本号必须递增"
+                     "（严格大于市场已发布版本），否则上架不通过。")
+    lines.append(f"阻断项     : {n_err} 项")
+    lines.append(f"警告项     : {n_warn} 项")
+    lines.append("-" * 64)
+    lines.append("归属图例   : WB = WorkBuddy 平台约束（违反即被平台拒收/加载异常）")
+    lines.append("             WV = 泛微专属约束（平台不拦，但泛微发布门禁不放行）")
+    lines.append("             WB+WV = 平台通用要求 + 泛微追加约束")
+    if platform == "qwenwork":
+        lines.append("             QW = 千问办公平台约束（违反即被千问拒收）")
+        lines.append("             QW+WB = 千问独有约束 + WorkBuddy 通用要求")
+        lines.append("             QW+WV = 千问与泛微双平台上架的叠加约束")
+    lines.append("=" * 64)
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# HTML 报告渲染
+# ---------------------------------------------------------------------------
+
+def _esc(s):
+    return (str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;"))
+
+
+def render_html(target, source_type, checks, verdict, n_err, n_warn, file_info=None,
+                platform: str = "weaver"):
+    """生成「腾讯安全云鼎实验室」风格的 HTML 安全评估报告。"""
+    icon = {"PASS": "✅", "FAIL": "❌", "WARN": "⚠️", "INFO": "ℹ️"}
+    platform_label = PLATFORMS.get(platform, PLATFORMS["weaver"])["label"]
+    platform_code = platform
+    # 默认平台为 weaver（泛微 + WorkBuddy + 通用）；千问规范仅在显式指定 --platform qwenwork 时启用
+    platform_default_tag = "，默认" if platform == "weaver" else "，显式指定"
+    # 千问图例仅在千问模式下展示，避免默认报告出现与本次检测无关的规范说明
+    qw_legend_html = "" if platform != "qwenwork" else """
+            <span><span class="origin-chip origin-qw">QW</span> <b>千问办公平台约束</b>：千问生态接入开发指南 2026（zip ≤ 10 MB / 条目 &lt; 1000 / 14 个分类枚举 / 连接器契约等）</span>
+            <span><span class="origin-chip origin-qwwb">QW+WB</span> <b>千问+WorkBuddy 叠加</b>：千问独有约束，且与 WorkBuddy 通用要求共存</span>
+            <span><span class="origin-chip origin-qwwv">QW+WV</span> <b>千问+泛微叠加</b>：同一 skill 既要满足千问上架又要满足泛微上架时的叠加约束</span>
+"""
+    cls = {"PASS": "pass", "FAIL": "fail", "WARN": "warn", "INFO": "info"}
+    verdict_label = {"FAIL": "不通过", "WARN": "通过（含警告）", "PASS": "通过"}[verdict]
+    verdict_tag = {"FAIL": "高危风险", "WARN": "可疑风险", "PASS": "安全"}[verdict]
+    verdict_cls = {"FAIL": "v-fail", "WARN": "v-warn", "PASS": "v-pass"}[verdict]
+
+    # 发布结论：仅以「是否存在阻断性项」为准。有阻断 → 不可发布；无阻断 → 可发布（含警告亦可发布）。
+    n_block = sum(1 for c in checks if c.severity == "BLOCK" and c.status == "FAIL")
+    publishable = n_block == 0
+    publish_label = "可发布" if publishable else "不可发布"
+    publish_cls = "pub-ok" if publishable else "pub-no"
+    publish_icon = "✅" if publishable else "⛔"
+    if publishable:
+        publish_sub = ("未发现阻断性合规/安全问题，可正常上架发布。"
+                       "请注意：提交前请确认市场现有版本号，新版本号必须递增"
+                       "（严格大于市场已发布版本），否则上架不通过。")
+    else:
+        publish_sub = f"存在 {n_block} 项阻断性风险，必须先修复并通过复检后方可提交。"
+
+    cap_check = None
+    dep_check = None
+    by_cat = {}
+    for c in checks:
+        if c.category == "技能能力清单":
+            cap_check = c
+        elif c.category == "技能依赖清单":
+            dep_check = c
+        else:
+            by_cat.setdefault(c.category, []).append(c)
+
+    n_pass = len([c for c in checks if c.status == "PASS"])
+    total = len(checks)
+
+    def _calc_score(checks):
+        score = 100
+        for c in checks:
+            if c.status in ("FAIL", "WARN"):
+                if c.severity == "BLOCK":
+                    score -= 35
+                elif c.severity == "HIGH":
+                    score -= 18
+                elif c.severity == "MEDIUM":
+                    score -= 8
+                elif c.severity == "LOW":
+                    score -= 3
+        return max(0, min(100, score))
+
+    score = _calc_score(checks)
+
+    def _risk_summary():
+        # 检查名多为否定式需求（如「无硬编码凭证」）；WARN/FAIL 表示需求被违反，
+        # 摘要应翻转成正向发现（去掉「无」前缀），避免“无…却是可疑项”的反读歧义。
+        def _positive_label(name: str) -> str:
+            return name[1:] if name.startswith("无") else name
+
+        if verdict == "FAIL":
+            blocks = [_positive_label(c.name) for c in checks if c.severity == "BLOCK" and c.status == "FAIL"]
+            highs = [_positive_label(c.name) for c in checks if c.severity == "HIGH" and c.status in ("FAIL", "WARN")]
+            parts = []
+            if blocks:
+                parts.append(f"阻断项：{', '.join(blocks[:3])}" + ("..." if len(blocks) > 3 else ""))
+            if highs:
+                parts.append(f"高危项：{', '.join(highs[:3])}" + ("..." if len(highs) > 3 else ""))
+            if not parts:
+                parts.append("存在合规或安全隐患")
+            return "检测到" + "；".join(parts) + "。该 skill 存在严重合规或安全隐患，建议立即修复后再提交。"
+        elif verdict == "WARN":
+            warns = [_positive_label(c.name) for c in checks if c.status == "WARN"]
+            return f"检测到可疑项：{', '.join(warns[:4])}" + ("..." if len(warns) > 4 else "") + "。当前无阻断项，但建议在发布前人工复核并修复。"
+        return "未发现阻断项与可疑项，静态检测通过。"
+
+    def _fix_suggestions():
+        sugs, seen = [], set()
+        for c in checks:
+            if c.status in ("FAIL", "WARN") and c.suggestion:
+                key = c.suggestion.strip()
+                if key and key not in seen:
+                    seen.add(key)
+                    sugs.append(c.suggestion)
+        return sugs
+
+    suggestions = _fix_suggestions()
+
+    skill_name = Path(target).stem
+    skill_version = "-"
+    for c in checks:
+        if c.name == "name 命名规范" and c.status == "PASS":
+            m = re.search(r"name='([^']+)'", c.detail)
+            if m:
+                skill_name = m.group(1)
+        if "version" in c.detail.lower():
+            m = re.search(r"version[=:]\s*['\"]?([0-9.]+)", c.detail)
+            if m:
+                skill_version = m.group(1)
+
+    sha256_short = file_info["sha256"][:14] + "..." if file_info and file_info.get("sha256") else "-"
+    content_hash = sha256_short
+
+    n_issues = n_err + n_warn
+    n_malicious = len([c for c in checks if c.severity == "BLOCK" and c.status == "FAIL"])
+    n_suspicious = n_warn
+    n_categories = len(by_cat)
+
+    THREAT_ICONS = {
+        "供应链风险": "📦", "命令执行风险": "⌨️", "网络请求与数据外传": "🌐",
+        "文件操作与敏感路径": "📁", "Prompt 注入风险": "💬", "远程脚本下载执行": "⬇️",
+        "可疑编码/混淆": "🔣", "其他安全风险": "🛡️",
+    }
+
+    def _esc(s):
+        return (str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;"))
+
+    def _locations_html(c):
+        if not c.locations:
+            return ""
+        lis = "".join(f"<li>{_esc(loc)}</li>" for loc in c.locations[:20])
+        more = f"<li class='more'>…等 {len(c.locations)} 处</li>" if len(c.locations) > 20 else ""
+        return f"<ul>{lis}{more}</ul>"
+
+    def _capability_cloud(c):
+        cleaned = c.detail.replace("本 skill 源码/文档中识别到以下运行时能力：", "").replace("。", "")
+        caps = [x.strip() for x in re.split(r"[，,]", cleaned) if x.strip()]
+        chips = "".join(f"<span class='cap-chip'>{_esc(x)}</span>" for x in caps)
+        return chips if chips else "<span class='cap-empty'>未识别到特定运行时能力</span>"
+
+    def _dependency_cloud(c):
+        m = re.search(r"以下其他技能[:：](.*?)[。.]?\s*$", c.detail)
+        if not m:
+            return "<span class='cap-empty'>未识别到显式依赖的其他技能</span>"
+        names = [x.strip() for x in re.split(r"[，,]", m.group(1)) if x.strip()]
+        if not names:
+            return "<span class='cap-empty'>未识别到显式依赖的其他技能</span>"
+        extra = getattr(c, "extra", None) or {}
+        market_checked = extra.get("market_checked")
+        dep_map = {d["name"].lower(): d for d in (extra.get("deps") or [])}
+        chips = []
+        for x in names:
+            if market_checked:
+                d = dep_map.get(x.lower()) or {}
+                if d.get("skipped"):
+                    badge = "<span class='dep-badge skip' title='非 weaver-e10- 前缀依赖，不做市场可达性核查'>跳过核查</span>"
+                elif d.get("error"):
+                    badge = "<span class='dep-badge err'>核查失败</span>"
+                elif d.get("in_market"):
+                    src = f" · {_esc(d['market'])}" if d.get("market") else ""
+                    label = f"市场可搜{src}"
+                    if d.get("url"):
+                        badge = (f"<a class='dep-badge ok' href='{_esc(d['url'])}' "
+                                 f"target='_blank' rel='noopener'>{label}</a>")
+                    else:
+                        badge = f"<span class='dep-badge ok'>{label}</span>"
+                else:
+                    badge = "<span class='dep-badge no'>市场未收录</span>"
+                chips.append(f"<span class='dep-chip'>{_esc(x)}{badge}</span>")
+            else:
+                chips.append(f"<span class='dep-chip'>{_esc(x)}</span>")
+        return "".join(chips)
+
+    # 引擎 chip 颜色：行为安全按 c.status，AI 引擎固定绿占位（未启用独立 AI 模型；扫描器自身作为 AI 引擎对外披露），
+    # 静态引擎按 c.locations 是否非空（命中=蓝，未命中=灰）。
+    ENGINE_CLASSES = {
+        "行为安全": {  # 行为安全 / 行为可疑 / 行为风险 跟随 status
+            "PASS": "engine-pass", "INFO": "engine-pass",
+            "WARN": "engine-warn", "FAIL": "engine-fail",
+        },
+        "AI 引擎": {  # 评估通过 = 占位绿
+            "PASS": "engine-purple", "INFO": "engine-purple",
+            "WARN": "engine-warn", "FAIL": "engine-fail",
+        },
+        "静态引擎": {  # 命中=蓝；空=灰
+            "HIT": "engine-blue", "EMPTY": "engine-grey",
+        },
+    }
+    ENGINE_LABEL = {"行为安全": "行为安全", "AI 引擎": "AI 引擎", "静态引擎": "静态引擎"}
+    ENGINE_REASON = {
+        "行为安全": ("行为可疑" if False else "行为安全"),  # 实际渲染按 cls
+        "AI 引擎": "AI 引擎",
+        "静态引擎": ("静态命中" if False else "静态无命中"),
+    }
+
+    def _engine_label(engine_name: str, status: str, has_static_hit: bool):
+        """返回 (chip_text, css_class)。"""
+        if engine_name == "静态引擎":
+            return ("静态命中" if has_static_hit else "静态无命中",
+                    ENGINE_CLASSES["静态引擎"]["HIT" if has_static_hit else "EMPTY"])
+        if engine_name == "行为安全":
+            text = "行为可疑" if status in ("WARN", "FAIL") else "行为安全"
+            cls = ENGINE_CLASSES["行为安全"][status]
+        else:  # AI 引擎
+            text = ENGINE_LABEL[engine_name]
+            cls = ENGINE_CLASSES[engine_name]["PASS"]
+        return text, cls
+
+    def _threat_card(c):
+        status_tip = {"PASS": "安全", "WARN": "可疑", "FAIL": "风险", "INFO": "提示"}[c.status]
+        ticon = THREAT_ICONS.get(c.name, "🔍")
+        bg_cls = {"PASS": "pass", "WARN": "warn", "FAIL": "fail", "INFO": "info"}[c.status]
+        has_hit = bool(c.locations)
+        chips_html = "".join(
+            f'<span class="engine-chip {_engine_label(eng, c.status, has_hit)[1]}" title="{_esc(eng)}">'
+            f'{_esc(_engine_label(eng, c.status, has_hit)[0])}</span>'
+            for eng in ("行为安全", "AI 引擎", "静态引擎")
+        )
+        return f"""
+        <div class="tcard {bg_cls}">
+          <div class="tcard-icon-bg {bg_cls}-bg">{ticon}</div>
+          <div class="tcard-main">
+            <div class="tcard-name">{_esc(c.name)}{chips_html}</div>
+            <div class="tcard-status"><span class="status-dot {bg_cls}"></span>{status_tip}</div>
+          </div>
+        </div>"""
+
+    def _behavior_card(c):
+        loc_html = _locations_html(c)
+        bg_cls = {"PASS": "pass", "WARN": "warn", "FAIL": "fail", "INFO": "info"}[c.status]
+        has_hit = bool(c.locations)
+        chips_html = "".join(
+            f'<span class="engine-chip {_engine_label(eng, c.status, has_hit)[1]}" title="{_esc(eng)}">'
+            f'{_esc(_engine_label(eng, c.status, has_hit)[0])}</span>'
+            for eng in ("行为安全", "AI 引擎", "静态引擎")
+        )
+        log_li = "<li>" + "&nbsp;</li>"
+        if c.locations:
+            log_li = "".join(
+                f"<li><span class='log-ok'>✓</span><span class='log-text'>{_esc(loc)}</span></li>"
+                for loc in c.locations[:20]
+            )
+            more = f"<li class='more'>…等 {len(c.locations)} 处</li>" if len(c.locations) > 20 else ""
+            log_li = log_li + more
+        else:
+            log_li = f"<li><span class='log-ok'>✓</span><span class='log-text'>未发现{_esc(c.name)}相关的可疑行为。</span></li>"
+        return f"""
+        <div class="behavior-card {bg_cls}">
+          <div class="behavior-head">
+            {chips_html}
+            <span class="behavior-title">{_esc(c.name)}</span>
+          </div>
+          <div class="behavior-detail">{_esc(c.detail)}</div>
+          <div class="behavior-log">
+            <div class="log-title">🔍 检测详情日志</div>
+            <ul>{log_li}</ul>
+          </div>
+        </div>"""
+
+    def _generic_check(c):
+        loc_html = _locations_html(c)
+        sugg_html = f"<div class='suggestion'>💡 建议：{_esc(c.suggestion)}</div>" if c.suggestion else ""
+        return f"""
+        <div class="check {cls.get(c.status, 'info')}">
+          <div class="check-head">
+            <span class="badge">{icon.get(c.status, '·')} {c.status}</span>
+            <span class="check-name">{_esc(c.name)}</span>
+            <span class="sev">{_esc(c.severity)}</span>
+          </div>
+          <div class="check-detail">{_esc(c.detail)}</div>
+          {sugg_html}
+        </div>"""
+
+    sections_html = []
+    threat_cards = by_cat.get("威胁模型") or []
+    beh_cards = by_cat.get("行为图谱") or []
+
+    # ===== 威胁模型 8 卡网格（C. 威胁捕获模型视图）=====
+    threat_grid_html = ""
+    if threat_cards:
+        cards_html = "".join(_threat_card(c) for c in threat_cards)
+        threat_grid_html = f'<div class="threat-grid">{cards_html}</div>'
+
+    # ===== 行为图谱 tab + 卡片列表（D. 威胁行为图谱解析）=====
+    behavior_html = ""
+    if beh_cards:
+        n_mal = sum(1 for c in beh_cards if c.status == "FAIL")
+        n_sus = sum(1 for c in beh_cards if c.status == "WARN")
+        n_safe = sum(1 for c in beh_cards if c.status in ("PASS", "INFO"))
+        tabs = (
+            f'<span class="tab active">全部引擎结果 ({len(beh_cards)})</span>'
+            f'<span class="tab">检出恶意 ({n_mal})</span>'
+            f'<span class="tab">检出可疑 ({n_sus})</span>'
+            f'<span class="tab">评估安全 ({n_safe})</span>'
+        )
+        cards_html = "".join(_behavior_card(c) for c in beh_cards)
+        behavior_html = f"""
+        <section class="block">
+          <div class="section-head">
+            <h2>威胁行为图谱解析<span class="origin-chip origin-wb" title="WorkBuddy 平台约束">WB</span></h2>
+            <div class="section-tabs">{tabs}</div>
+          </div>
+          {cards_html}
+        </section>"""
+
+    # 威胁捕获模型视图（C 组）
+    threat_section_html = ""
+    if threat_cards:
+        threat_section_html = f"""
+        <section class="block">
+          <div class="section-head">
+            <h2>威胁捕获模型视图<span class="origin-chip origin-wb" title="WorkBuddy 平台约束">WB</span><span class="cap-sub" style="font-weight:400;">8 类风险卡片，每类由 行为安全 / AI 引擎 / 静态引擎 三个引擎并行评估</span></h2>
+          </div>
+          {threat_grid_html}
+        </section>"""
+
+    # 行为图谱（D 组）跟在威胁模型区块之后
+    threat_section_html = threat_section_html + behavior_html
+
+    # ===== 其他分组的详细 check 列表 =====
+    for cat, items in by_cat.items():
+        if cat in ("威胁模型", "行为图谱"):
+            continue  # 已单独渲染在上方两个特殊区块
+        else:
+            rows = "".join(_generic_check(c) for c in items)
+            _org = _origin_of(cat)
+            _org_chip = (
+                f'<span class="origin-chip origin-{_org.lower().replace("+", "")}" '
+                f'title="{_esc(ORIGIN_DESC.get(_org, ""))}">{_esc(_org)}</span>'
+                if _org else ""
+            )
+            sections_html.append(f"""
+            <section class="block">
+              <h2>{_esc(cat)}{_org_chip}</h2>
+              {rows}
+            </section>""")
+
+    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    summary_html = _risk_summary()
+    fix_list_html = "".join(f"<li>{_esc(s)}</li>" for s in suggestions) if suggestions else "<li>暂无待修复建议</li>"
+    cap_html = _capability_cloud(cap_check) if cap_check else "<span class='muted'>未生成能力清单</span>"
+    dep_html = _dependency_cloud(dep_check) if dep_check else "<span class='muted'>未生成依赖清单</span>"
+    dep_market_checked = bool(dep_check and getattr(dep_check, "extra", None) and dep_check.extra.get("market_checked"))
+
+    ring_color = "#13a35a" if score >= 80 else "#dd8c0a" if score >= 50 else "#e23b3b"
+    dasharray = 2 * 3.14159 * 70
+    dashoffset = dasharray * (1 - score / 100)
+
+    CSS = """
+    <style>
+      :root {
+        --bg:#f6f8fb; --card:#ffffff; --ink:#1b2436; --muted:#69748a; --line:#e7ecf4;
+        --brand:#2f5cff; --brand2:#6a8bff; --brand-soft:#eef3ff;
+        --pass:#13a35a; --fail:#e23b3b; --warn:#dd8c0a; --info:#1f9bd1;
+        --pass-bg:#e8f8ef; --fail-bg:#fdeded; --warn-bg:#fdf2e1; --info-bg:#e7f4fb;
+        --radius:18px; --shadow:0 8px 28px rgba(27,42,71,.07);
+      }
+      * { box-sizing:border-box; }
+      body { margin:0; color:var(--ink); background:var(--bg);
+        font-family:-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;
+        line-height:1.65; -webkit-font-smoothing:antialiased; padding-bottom:48px; }
+      .wrap { max-width:1100px; margin:0 auto; padding:0 20px; }
+      .report-header { display:flex; align-items:center; justify-content:space-between;
+        padding:22px 4px 18px; }
+      .rh-left { display:flex; align-items:center; gap:10px; font-size:18px; font-weight:800; }
+      .rh-icon { width:36px; height:36px; border-radius:10px;
+        background:linear-gradient(135deg,var(--brand),var(--brand2)); color:#fff;
+        display:flex; align-items:center; justify-content:center; font-size:20px; }
+      .rh-right { font-size:13px; color:var(--muted); font-weight:600; }
+      .dashboard { display:grid; grid-template-columns:340px 1fr; gap:18px; margin-top:18px; }
+      .dash-left { display:flex; flex-direction:column; gap:16px; }
+      .dash-left > .card { flex:1; }
+      .dash-right { display:flex; flex-direction:column; gap:16px; }
+      .card { background:var(--card); border:1px solid var(--line); border-radius:var(--radius);
+        padding:22px; box-shadow:var(--shadow); }
+      .score-card { display:flex; flex-direction:column; align-items:center; text-align:center; }
+      .score-ring { position:relative; width:180px; height:180px; }
+      .score-ring svg { transform:rotate(-90deg); }
+      .score-num { position:absolute; inset:0; display:flex; align-items:center; justify-content:center;
+        font-size:42px; font-weight:800; color:var(--ink); }
+      .score-label { font-size:13px; color:var(--muted); margin-top:10px; }
+      .meta-list { width:100%; margin-top:10px; }
+      .meta-row { display:flex; align-items:center; justify-content:space-between; padding:11px 0;
+        border-bottom:1px solid var(--line); font-size:13px; }
+      .meta-row:last-child { border-bottom:none; }
+      .meta-row .k { color:var(--muted); }
+      .meta-row .v { font-weight:600; max-width:180px; text-align:right; word-break:break-all; }
+      .meta-row code.v { font-family:ui-monospace,SFMono-Regular,Menlo,monospace; font-size:12px;
+        background:#f4f7fb; padding:3px 8px; border-radius:6px; }
+      .verdict-tag { display:inline-block; padding:3px 10px; border-radius:999px; font-size:12px; font-weight:700; }
+      .verdict-tag.pass { background:var(--pass-bg); color:var(--pass); }
+      .verdict-tag.warn { background:var(--warn-bg); color:var(--warn); }
+      .verdict-tag.fail { background:var(--fail-bg); color:var(--fail); }
+      .verdict-tag.pub-ok { background:var(--pass-bg); color:var(--pass); font-size:13px; padding:4px 12px; }
+      .verdict-tag.pub-no { background:var(--fail-bg); color:var(--fail); font-size:13px; padding:4px 12px; }
+      .publish-banner { display:flex; align-items:center; gap:16px; border-radius:var(--radius);
+        padding:20px 26px; margin-top:16px; margin-bottom:22px; box-shadow:0 10px 30px rgba(27,42,71,.12); }
+      .publish-banner .pb-icon { font-size:40px; line-height:1; filter:drop-shadow(0 2px 4px rgba(0,0,0,.15)); }
+      .publish-banner .pb-main { font-size:25px; font-weight:900; letter-spacing:2px; }
+      .publish-banner .pb-sub { font-size:13.5px; margin-top:5px; opacity:.94; line-height:1.6; }
+      .publish-banner.ok { background:linear-gradient(135deg,#13a35a 0%,#1ec07a 100%); color:#fff; }
+      .publish-banner.no { background:linear-gradient(135deg,#e23b3b 0%,#ff5b5b 100%); color:#fff; }
+      .publish-banner .pb-pulse { width:12px; height:12px; border-radius:50%; background:#fff; opacity:.9;
+        box-shadow:0 0 0 0 rgba(255,255,255,.7); animation:pbpulse 1.8s infinite; }
+      @keyframes pbpulse { 0%{box-shadow:0 0 0 0 rgba(255,255,255,.6);} 70%{box-shadow:0 0 0 12px rgba(255,255,255,0);} 100%{box-shadow:0 0 0 0 rgba(255,255,255,0);} }
+      .stat-grid { display:grid; grid-template-columns:repeat(4,1fr); gap:14px; }
+      .stat-card { background:var(--card); border:1px solid var(--line); border-radius:14px;
+        padding:16px; text-align:center; box-shadow:var(--shadow); }
+      .stat-card .n { font-size:28px; font-weight:800; color:var(--ink); }
+      .stat-card .t { font-size:12px; color:var(--muted); margin-top:4px; }
+      .stat-card.fail .n { color:var(--fail); }
+      .stat-card.warn .n { color:var(--warn); }
+      .stat-card.info .n { color:var(--brand); }
+      .summary-box { background:#fff9f0; border:1px solid #ffe4c2; border-radius:14px; padding:16px 18px; }
+      .summary-box h3 { margin:0 0 10px; font-size:14px; display:flex; align-items:center; gap:8px; color:#92400e; }
+      .summary-box p { margin:0; font-size:13.5px; color:#78350f; line-height:1.7; }
+      .fix-box h3 { margin:0 0 12px; font-size:14px; display:flex; align-items:center; gap:8px; }
+      .fix-box ol { margin:0; padding-left:18px; font-size:13px; color:#3a4456; line-height:1.8; }
+      .cap-section { background:var(--card); border:1px solid var(--line); border-radius:var(--radius);
+        padding:18px 22px; box-shadow:var(--shadow); margin-top:0; }
+      .cap-head { display:flex; align-items:baseline; gap:10px; margin-bottom:14px;
+        font-size:15px; font-weight:700; }
+      .cap-sub { font-size:12px; color:var(--muted); font-weight:400; }
+      .cap-chips { display:flex; flex-wrap:wrap; gap:12px; }
+      .cap-chip { display:inline-flex; align-items:center; gap:6px; border:1.5px solid var(--brand);
+        color:var(--brand); background:#fff; font-size:13px; font-weight:600;
+        padding:8px 16px; border-radius:999px; box-shadow:0 2px 8px rgba(47,92,255,.10); }
+      .cap-empty { color:var(--muted); font-size:13px; padding:4px 0; }
+      .dep-head { display:flex; align-items:baseline; gap:10px; margin:18px 0 14px; padding-top:16px;
+        border-top:1px dashed var(--line); font-size:14px; font-weight:700; }
+      .dep-chip { display:inline-flex; align-items:center; gap:6px; border:1.5px solid #dd8c0a;
+        color:#9a6500; background:#fffaf0; font-size:13px; font-weight:600;
+        padding:8px 16px; border-radius:999px; box-shadow:0 2px 8px rgba(221,140,10,.12); }
+      .dep-badge { font-size:11px; font-weight:700; padding:2px 9px; border-radius:999px; white-space:nowrap; }
+      .dep-badge.ok { background:var(--pass-bg); color:var(--pass); }
+      .dep-badge.no { background:#eef2f7; color:#64748b; }
+      .dep-badge.err { background:#fff4e5; color:#b45309; }
+      .dep-badge.skip { background:#eef2f7; color:#94a3b8; font-weight:600; }
+      a.dep-badge.ok { text-decoration:none; }
+      .dep-legend { margin-top:12px; font-size:12px; color:var(--muted); line-height:1.7; }
+      .dep-legend .ok { color:var(--pass); font-weight:700; }
+      .dep-legend .no { color:#64748b; font-weight:700; }
+      .dep-legend .err { color:#b45309; font-weight:700; }
+      .dep-legend .skip { color:#94a3b8; font-weight:700; }
+      .block { background:var(--card); border:1px solid var(--line); border-radius:var(--radius);
+        padding:22px 24px; margin-top:18px; box-shadow:var(--shadow); }
+      .block h2 { margin:0 0 18px; font-size:17px; display:flex; align-items:center; gap:10px; flex-wrap:wrap; }
+      /* 约束归属徽标：WB = WorkBuddy 平台约束 / WV = 泛微专属约束 / WB+WV = 叠加 /
+         QW = 千问办公平台约束 / QW+WB = 千问+WorkBuddy 叠加 / QW+WV = 千问+泛微叠加 */
+      .origin-chip { font-size:11px; font-weight:700; line-height:1; padding:4px 8px; border-radius:999px;
+        border:1px solid transparent; letter-spacing:.02em; }
+      .origin-wb { background:#eef2ff; color:#3730a3; border-color:#c7d2fe; }
+      .origin-wv { background:#fff1e6; color:#9a3412; border-color:#fed7aa; }
+      .origin-wbwv { background:#ecfdf5; color:#065f46; border-color:#a7f3d0; }
+      .origin-qw { background:#fef3c7; color:#92400e; border-color:#fde68a; }
+      .origin-qwwb { background:#ede9fe; color:#5b21b6; border-color:#ddd6fe; }
+      .origin-qwwv { background:#fce7f3; color:#9d174d; border-color:#fbcfe8; }
+      .origin-legend { display:flex; flex-wrap:wrap; gap:10px 18px; margin-top:12px; font-size:12px;
+        color:var(--muted); }
+      .origin-legend b { color:var(--text); }
+      .section-head { display:flex; align-items:center; justify-content:space-between; flex-wrap:wrap;
+        gap:12px; margin-bottom:18px; }
+      .section-head h2 { margin:0; }
+      .section-tabs { display:flex; gap:8px; }
+      .tab { font-size:12px; padding:6px 12px; border-radius:8px; background:#f4f7fb; color:var(--muted);
+        cursor:default; }
+      .tab.active { background:var(--brand-soft); color:var(--brand); font-weight:700; }
+      .threat-grid { display:grid; grid-template-columns:repeat(auto-fill,minmax(180px,1fr)); gap:14px; }
+      .tcard { display:flex; align-items:center; gap:12px; border:1px solid var(--line);
+        border-radius:14px; padding:14px; background:#fff; }
+      .tcard-icon-bg { width:42px; height:42px; border-radius:12px; display:flex; align-items:center;
+        justify-content:center; font-size:20px; flex:none; }
+      .pass-bg { background:var(--pass-bg); }
+      .warn-bg { background:var(--warn-bg); }
+      .fail-bg { background:var(--fail-bg); }
+      .info-bg { background:var(--info-bg); }
+      .tcard-main { flex:1; min-width:0; }
+      .tcard-name { font-weight:700; font-size:14px; margin-bottom:4px; }
+      .tcard-status { font-size:12px; color:var(--muted); display:flex; align-items:center; gap:5px; }
+      .status-dot { width:7px; height:7px; border-radius:50%; display:inline-block; }
+      .status-dot.pass { background:var(--pass); }
+      .status-dot.warn { background:var(--warn); }
+      .status-dot.fail { background:var(--fail); }
+      .status-dot.info { background:var(--info); }
+      .behavior-card { border:1px solid var(--line); border-radius:14px; padding:16px 18px; margin-bottom:14px;
+        background:#fff; }
+      .behavior-head { display:flex; align-items:center; gap:8px; flex-wrap:wrap; margin-bottom:10px; }
+      .tag { font-size:11px; font-weight:700; padding:3px 10px; border-radius:6px; flex:none; }
+      .tag-red { background:#fde8e8; color:var(--fail); }
+      .tag-green { background:#e6f6ec; color:var(--pass); }
+      .tag-purple { background:#ede9fe; color:#7c3aed; }
+      .tag-blue { background:#e7f4fb; color:var(--info); }
+      .behavior-title { font-weight:700; font-size:15px; }
+      .behavior-detail { color:#3a4456; font-size:13.5px; margin-bottom:12px; }
+      .behavior-log { background:#0f172a; color:#e2e8f0; border-radius:12px; padding:14px 16px;
+        font-size:12.5px; }
+      .behavior-log .log-title { color:#94a3b8; font-size:11px; margin-bottom:8px; letter-spacing:1px; }
+      .behavior-log ul { margin:0; padding-left:0; list-style:none; }
+      .behavior-log li { padding:3px 0; font-family:ui-monospace,SFMono-Regular,Menlo,monospace;
+        white-space:pre-wrap; word-break:break-all; }
+      .behavior-log li.more { color:#fbbf24; }
+      .check { display:flex; flex-direction:column; gap:8px; border:1px solid var(--line);
+        border-radius:13px; padding:14px 16px; margin-bottom:12px; background:#fcfdff;
+        border-left:5px solid var(--info); }
+      .check.pass { border-left-color:var(--pass); background:#f7fdf9; }
+      .check.fail { border-left-color:var(--fail); background:var(--fail-bg); }
+      .check.warn { border-left-color:var(--warn); background:var(--warn-bg); }
+      .check-head { display:flex; align-items:center; gap:10px; flex-wrap:wrap; }
+      .check-name { font-weight:700; font-size:15px; }
+      .badge { font-size:12px; font-weight:700; padding:3px 10px; border-radius:999px;
+        background:#eef2fb; color:var(--brand); white-space:nowrap; }
+      .check.fail .badge { background:var(--fail-bg); color:var(--fail); }
+      .check.warn .badge { background:var(--warn-bg); color:var(--warn); }
+      .check.pass .badge { background:var(--pass-bg); color:var(--pass); }
+      .sev { margin-left:auto; font-size:11px; color:var(--muted); border:1px solid var(--line);
+        padding:2px 9px; border-radius:7px; }
+      .check-detail { color:#3a4456; font-size:13.5px; white-space:pre-wrap; }
+      .suggestion { font-size:12.5px; color:#475569; background:#eef3ff; border-radius:9px; padding:9px 12px; margin-top:6px; }
+      .muted { color:var(--muted); font-size:13px; }
+      /* ===== 威胁模型 / 行为图谱：引擎 chip 与深色日志 ===== */
+      .engine-chip { font-size:10.5px; font-weight:700; padding:3px 9px; border-radius:999px;
+        border:1px solid transparent; line-height:1; flex:none; white-space:nowrap; }
+      .engine-pass { background:#e6f6ec; color:#15803d; border-color:#bbf7d0; }
+      .engine-warn { background:#fdf2e1; color:#9a6500; border-color:#fde68a; }
+      .engine-fail { background:#fde8e8; color:#dc2626; border-color:#fecaca; }
+      .engine-purple { background:#ede9fe; color:#7c3aed; border-color:#ddd6fe; }
+      .engine-blue { background:#e7f4fb; color:#1f9bd1; border-color:#bae6fd; }
+      .engine-grey { background:#f4f6fb; color:#94a3b8; border-color:#e2e8f0; }
+      .tcard-name { display:flex; align-items:center; gap:6px; flex-wrap:wrap; }
+      .log-ok { color:#4ade80; margin-right:8px; font-weight:700; }
+      .log-text { font-family:ui-monospace,SFMono-Regular,Menlo,monospace; color:#cbd5e1;
+        white-space:pre-wrap; word-break:break-all; }
+      footer { text-align:center; color:var(--muted); font-size:12px; margin-top:28px; }
+      @media (max-width:900px) { .dashboard { grid-template-columns:1fr; } .stat-grid { grid-template-columns:repeat(2,1fr); } }
+      @media (max-width:540px) { .stat-grid { grid-template-columns:1fr; } .section-head { flex-direction:column; align-items:flex-start; } }
+    </style>
+    """
+
+    BODY = f"""
+    <body>
+      <div class="wrap">
+        <div class="report-header">
+          <div class="rh-left"><div class="rh-icon">🛡️</div> Skills 安全评估报告</div>
+          <div class="rh-right">泛微技能检测工具 · weaver-skill-detector</div>
+        </div>
+
+        <div class="publish-banner {publish_cls}">
+          <div class="pb-icon">{publish_icon}</div>
+          <div>
+            <div class="pb-main">{publish_label}</div>
+            <div class="pb-sub">{publish_sub}</div>
+          </div>
+          <div class="pb-pulse" style="margin-left:auto;"></div>
+        </div>
+
+        <div class="cap-section">
+          <div class="cap-head">🧩 技能能力清单<span class="cap-sub">运行时识别到的能力（上架时建议如实披露权限范围）</span></div>
+          <div class="cap-chips">{cap_html}</div>
+          <div class="dep-head">🔗 依赖的其他技能<span class="cap-sub">{("已动态核查 skillhub.cn 市场可达性（点击徽标跳转）" if dep_market_checked else "frontmatter 声明或正文引用的 weaver-e10- 前缀技能（需同步上架）")}</span></div>
+          <div class="cap-chips">{dep_html}</div>
+          {('<div class="dep-legend"><span class="ok">市场可搜</span>：已在 skillhub.cn 实时核查命中（点击可跳转技能页），消费方可直接获取而无需额外分发 · <span class="no">市场未收录</span>：skillhub.cn 未检索到该 slug，需随包另行分发或内部安装后方可联动 · <span class="skip">跳过核查</span>：非 weaver- 前缀依赖（内部引用/误报），不做市场可达性标注 · <span class="err">核查失败</span>：联网核查异常（如网络受限），请以手动核实为准</div>' if dep_market_checked else "")}
+        </div>
+
+        <div class="dashboard">
+          <div class="dash-left">
+            <div class="card score-card">
+              <div class="score-ring">
+                <svg width="180" height="180" viewBox="0 0 180 180">
+                  <circle cx="90" cy="90" r="70" fill="none" stroke="#e7ecf4" stroke-width="12"/>
+                  <circle cx="90" cy="90" r="70" fill="none" stroke="{ring_color}" stroke-width="12"
+                    stroke-linecap="round" stroke-dasharray="{dasharray:.2f}" stroke-dashoffset="{dashoffset:.2f}"/>
+                </svg>
+                <div class="score-num">{score}</div>
+              </div>
+              <div class="score-label">安全健康度评分</div>
+              <div class="meta-list">
+                <div class="meta-row"><span class="k">Skill 名称</span><span class="v">{_esc(skill_name)}</span></div>
+                <div class="meta-row"><span class="k">版本</span><span class="v">{_esc(skill_version)}</span></div>
+                <div class="meta-row"><span class="k">检测平台</span><span class="v">{_esc(platform_label)}（<code>--platform {_esc(platform_code)}</code>{platform_default_tag}）</span></div>
+                <div class="meta-row"><span class="k">内容 Hash</span><code class="v">{_esc(content_hash)}</code></div>
+                <div class="meta-row"><span class="k">发布结论</span><span class="v"><span class="verdict-tag {publish_cls}">{publish_label}</span></span></div>
+              </div>
+            </div>
+          </div>
+
+          <div class="dash-right">
+            <div class="stat-grid">
+              <div class="stat-card {'fail' if n_issues else 'info'}">
+                <div class="n">{n_issues}</div>
+                <div class="t">发现问题总数</div>
+                <div class="t" style="font-size:11px;color:var(--muted);">需确认点</div>
+              </div>
+              <div class="stat-card fail">
+                <div class="n">{n_malicious}</div>
+                <div class="t">检出恶意行为</div>
+                <div class="t" style="font-size:11px;color:var(--muted);">平台已标记</div>
+              </div>
+              <div class="stat-card warn">
+                <div class="n">{n_suspicious}</div>
+                <div class="t">检出可疑行为</div>
+                <div class="t" style="font-size:11px;color:var(--muted);">平台已标记</div>
+              </div>
+              <div class="stat-card info">
+                <div class="n">{n_categories}</div>
+                <div class="t">引擎覆盖类别</div>
+                <div class="t" style="font-size:11px;color:var(--muted);">安全检测面</div>
+              </div>
+            </div>
+
+            <div class="summary-box">
+              <h3>🛡️ 总体风险摘要</h3>
+              <p>{_esc(summary_html)}</p>
+            </div>
+
+            <div class="card fix-box">
+              <h3>🛠️ 修复建议指南</h3>
+              <ol>{fix_list_html}</ol>
+            </div>
+          </div>
+        </div>
+
+{threat_section_html}
+
+{''.join(sections_html)}
+
+        <section class="block">
+          <h2>约束归属图例</h2>
+          <div class="origin-legend">
+            <span><span class="origin-chip origin-wb">WB</span> <b>WorkBuddy 平台约束</b>：skillhub.cn 加载器与上传校验要求，任何作者的 skill 都必须满足，违反即被平台拒收或加载异常</span>
+            <span><span class="origin-chip origin-wv">WV</span> <b>泛微专属约束</b>：泛微生态内部治理要求（品牌规范、E10 账号与接口调用契约、安全合规），平台不拦但泛微发布门禁不放行</span>
+            <span><span class="origin-chip origin-wbwv">WB+WV</span> <b>叠加</b>：平台有通用要求，泛微在其上追加了更严的约束</span>
+{qw_legend_html}
+          </div>
+        </section>
+
+        <footer>本报告由「泛微技能检测工具 weaver-skill-detector」自动生成 · 生成时间：{_esc(now)} · 仅供提交前安全合规自检参考</footer>
+      </div>
+    </body>
+    """
+
+    HEAD = f"""<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Skills 安全评估报告 · {_esc(publish_label)}</title>
+</head>"""
+
+    return f"<!DOCTYPE html>\n<html lang=\"zh-CN\">\n{HEAD}\n{CSS}\n{BODY}\n</html>"
+
+# ---------------------------------------------------------------------------
+# 入口
+# ---------------------------------------------------------------------------
+
+def main():
+    args = sys.argv[1:]
+    if not args:
+        log("用法: python validate_skill.py <skill.zip|.md|dir> [--json] [--out report.md] "
+            "[--html report.html] [--market-catalog catalog.json] [--market-live] [--no-html]\n"
+            "                                    [--platform {weaver,qwenwork}]")
+        sys.exit(2)
+
+    target_str = args[0]
+    as_json = "--json" in args
+    out_path = None
+    html_path = None
+    no_html = "--no-html" in args
+    market_catalog_path = None
+    market_live = "--market-live" in args
+    platform = "weaver"  # 默认 weaver（保持向后兼容）
+    for i, a in enumerate(args):
+        if a == "--out" and i + 1 < len(args):
+            out_path = args[i + 1]
+        elif a == "--html" and i + 1 < len(args):
+            html_path = args[i + 1]
+        elif a == "--market-catalog" and i + 1 < len(args):
+            market_catalog_path = args[i + 1]
+        elif a == "--platform" and i + 1 < len(args):
+            platform = args[i + 1]
+            if platform not in VALID_PLATFORMS:
+                log(f"❌ --platform 仅支持: {VALID_PLATFORMS}（收到: {platform}）")
+                sys.exit(2)
+
+    target = Path(target_str).expanduser().resolve()
+    root, source_type, cleanup, err, zip_raw_names = prepare_skill_source(target)
+    if err:
+        log(f"❌ {err}")
+        sys.exit(2)
+
+    # 默认 HTML 输出：未显式指定 --html 且未禁用时，自动生成到「输入同目录/<输入名>-report.html」。
+    # zip/md 输入 → 去扩展名 + "-report.html"（如 weaver-e10-hrm.zip → weaver-e10-hrm-report.html）；
+    # 目录输入 → 同级 "<目录名>-report.html"。
+    if html_path is None and not no_html:
+        if target.is_file():
+            html_path = str(target.with_suffix("")) + "-report.html"
+        else:
+            html_path = str(target.parent / (target.name + "-report.html"))
+        log(f"默认 HTML 输出: {html_path}")
+
+    market_catalog = None
+    if market_catalog_path:
+        try:
+            market_catalog = load_market_catalog(market_catalog_path)
+            log(f"已加载市场清单: {len(market_catalog)} 项（依赖可达性标注已启用）")
+        except Exception as e:
+            log(f"❌ 市场清单加载失败: {e}")
+            sys.exit(2)
+
+    try:
+        skill_md, skill_dir = find_skill_md(root)
+        checks = []
+        info = None
+        # A 组打包约束红线：文件总数（按 platform 取阈值）/ 仅纯文本（禁止二进制），与 SKILL.md 是否存在无关，始终执行
+        checks.extend(check_package_constraints(root, platform=platform, target=target))
+        # A 组：SKILL.md 文件名大小写精确（skill.md/Skill.md 等变体 → BLOCK），始终执行
+        checks.extend(check_skill_md_naming(root))
+        if skill_md is not None:
+            struct_checks, info = check_structure(root, skill_md, skill_dir, source_type, zip_raw_names, platform=platform)
+            checks.extend(struct_checks)
+            name, body = info if info else (None, "")
+            if skill_dir is not None:
+                checks.extend(check_weaver_compliance(skill_dir, body or "", source_type))
+                # A2: 结构化文件可解析性（JSON/YAML/TOML）
+                checks.extend(check_structured_files(skill_dir))
+                # A3: 依赖引导完整性
+                checks.extend(check_dependency_guidance(skill_dir))
+                # G 组扩展安全检测（危险命令/个人路径/IDE残留/CDN/内网域名/虚假承诺/BOM/CRLF）
+                checks.extend(check_extended_security(skill_dir))
+                # B 红线补充：API 请求凭证完整性（Cookie+eteamsid+User-Agent，BLOCK）
+                checks.extend(check_api_request_credentials(skill_dir))
+                # B10 红线补充：E10 接口型技能「登录 + 凭证」契约（仅 weaver-e10- 前缀技能，BLOCK）
+                checks.extend(check_weaver_e10_auth_contract(skill_dir, name))
+                # B11：千问连接器就绪性契约（仅 qwenwork 模式，BLOCK；函数内自带平台守护）
+                checks.extend(check_qwenwork_connector_readiness(skill_dir, name, platform=platform))
+                # Q 组质量启发式检测（路由触发/上下文效率/容错降级/字段字数）
+                checks.extend(check_quality_heuristics(skill_dir, skill_md, body or ""))
+                # C 威胁捕获模型视图 + D 威胁行为图谱解析（8 类风险卡片 + 跨文件/跨行具体行为，INFO/WARN）
+                checks.extend(check_threat_model(skill_dir))
+                checks.extend(check_behavior_graph(skill_dir))
+                checks.extend(check_skill_capabilities(skill_dir))
+                checks.extend(check_skill_dependencies(skill_dir, skill_md, market_catalog, live_market=market_live))
+        else:
+            # 无 SKILL.md：若已存在大小写变体（skill.md/Skill.md 等），精确大小写检查已给出 BLOCK，
+            # 此处不再重复「未找到 SKILL.md」，避免提示歧义。
+            has_case_variant = any(
+                p.is_file() and p.name.lower() == "skill.md" and p.name != "SKILL.md"
+                for p in root.rglob("*")
+            )
+            if not has_case_variant:
+                checks.append(Check("基础合规", "SKILL.md 存在", "FAIL", "BLOCK",
+                                    "未找到 SKILL.md。",
+                                    suggestion="提供标准 skill 包（含 SKILL.md）。"))
+
+        file_info = calc_file_info(target, source_type)
+
+        verdict, n_err, n_warn = summarize(checks)
+        report = render_report(target_str, source_type, checks, verdict, n_err, n_warn,
+                               file_info, platform=platform)
+
+        if as_json:
+            payload = {
+                "target": str(target),
+                "source_type": source_type,
+                "verdict": verdict,
+                "blocking": n_err,
+                "warnings": n_warn,
+                "file_info": file_info,
+                "checks": [c.to_dict() for c in checks],
+            }
+            print(json.dumps(payload, ensure_ascii=False, indent=2))
+        else:
+            print(report)
+
+        if out_path:
+            Path(out_path).write_text(report, encoding="utf-8")
+            log(f"报告已写出: {out_path}")
+
+        if html_path:
+            html = render_html(target_str, source_type, checks, verdict, n_err, n_warn,
+                               file_info, platform=platform)
+            Path(html_path).write_text(html, encoding="utf-8")
+            log(f"HTML 报告已写出: {html_path}")
+
+        sys.exit(1 if verdict == "FAIL" else 0)
+    finally:
+        if cleanup:
+            shutil.rmtree(root, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    main()