@qilitt-mickey/vue3-temp-skill 1.1.76 → 1.2.1

package/scripts/design-audit.mjs

@@ -1,1707 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * 设计层闭环审计 — 「样式逻辑 → 效果」的生效性断言。
- *
- * 发布闸（scripts/validate.mjs）校验的是技能包自身结构；本脚本校验的是
- * **一次落地是否真的把变更集落成了有效样式**：声明了不等于生效，生效了不等于对。
- * 它只做静态分析，不依赖浏览器与开发服务器。
- *
- * 用法：
- *   node scripts/design-audit.mjs                        # 审计当前目录（落地项目根）
- *   node scripts/design-audit.mjs --project <dir>         # 指定落地项目
- *   node scripts/design-audit.mjs --json                  # 机器可读输出
- *   node scripts/design-audit.mjs --container-width 1624  # 表格容器可用宽（列宽预算用）
- *   node scripts/design-audit.mjs --report <file.md>      # 另存 Markdown 报告（可选，便于交付留档）
- *
- * 退出码：0 = 无 ERROR；1 = 存在 ERROR。
- *
- * 审计项：
- *   E1 变量悬空      设计层 var(--x) 项目内无定义且无回退
- *   E2 层错位        内层盒属性族写在表格宿主盒上（会被 EP 内层 .cell 覆盖）
- *   E3 层叠败北      设计层声明特指度低于组件 scoped 同名类规则（含 [data-v] 加成）→ 不生效
- *   E4 选择器挂空    设计层使用的项目类名在 src 中不存在（假锚点）
- *   E5 列宽预算      存在无宽列（既无 width 又无 min-width）；Σ列宽超出容器
- *   E6 收口断言      visible:false 的 sid 必须有 display:none（+提权）落点
- *   E7 激活态越层    分组标题被写入叶子项的激活态（胶囊/指示条）
- *   E8 浮层残留      form 要求收口下拉浮层，但组件仍消费 #dropdown
- *   E9 形态收口缺件  form=icon_only 只显图标、未在同一作用域内收口文案（且不被兄弟变体规则骗过）
- *   E10 scoped 挂空  组件 scoped 规则依赖运行时并不存在的类（重构残留，永不命中）
- *   E11 交付完整性   mode=restore 时 covered<applicable / gaps 非空 / 缺口未台账化 / 分母漂移 / notes 与字段矛盾
- *   E12 设计层累积性  变更集点位或设计层行数相对历史骤降（上一轮成果被覆盖）→ 写交付台账 .design/ledger.json
- *   E13 固定尺寸内容度量 固定 width 小于内容需求且无收口兜底 → 文字换行/压缩/重叠
- *   E14 列宽预算链自洽  列宽（含公式）扣掉实际 td 内边距后装不下内容 → 操作列按钮被压
- *   E16 引用完整性   变更集引用的实物不存在（改名未同步）/ restore 缺顶层 theme
- *   E17 层间令牌链对账  父子两层盒共享同链间距令牌：绕过令牌通道抢写物理 padding 且同链令牌幸存 → 双层叠加
- *   E18 激活态消费者成对落地  indicator_* 形态声明后：消费者缺失 / 令牌仍透明 / 伪元素对决权重不足 → 竖条不可见
- *   E15 结构声明兑现  form 值 / suppress 通道名必须在词典枚举内，且设计层有 @sid / @closed 落点证据（G3 双向对账）
- */
-
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SKILL_ROOT = path.resolve(__dirname, "..");
-
-const argv = process.argv.slice(2);
-const argValue = (name, def) => {
-  const i = argv.indexOf(name);
-  return i >= 0 && argv[i + 1] ? argv[i + 1] : def;
-};
-const PROJECT = path.resolve(argValue("--project", process.cwd()));
-const AS_JSON = argv.includes("--json");
-const CONTAINER_EXPLICIT = argv.includes("--container-width");
-const CONTAINER_WIDTH = Number(argValue("--container-width", "1200")) || 1200;
-
-const DESIGN_LAYER_GLOBS = [
-  "src/styles/design-shell.scss",
-  "src/styles/design-tokens.scss",
-  "src/styles/dark.scss",
-];
-const SRC_DIRS = ["src"];
-const IGNORES = new Set(["node_modules", ".git", "dist", "build", ".vite", "public"]);
-const SRC_EXT = new Set([".vue", ".ts", ".tsx", ".js", ".mjs", ".scss", ".css", ".html"]);
-const JSON_EXT = new Set([".json"]);
-
-/** 内层盒属性族：必须落 EP 内层 .cell，落宿主 th/td 会被 .cell 覆盖 */
-const INNER_ONLY_PROPS = new Set([
-  "white-space",
-  "text-overflow",
-  "overflow",
-  "word-break",
-  "text-align",
-  "line-height",
-  "vertical-align",
-  "text-align-last",
-]);
-
-/** 项目自有变量前缀（--el-* 为出厂，不参与悬空判定） */
-const OWNED_VAR_PREFIXES = ["--ds-", "--vts-", "--re-", "--brand-", "--table-", "--pagination-", "--filter-", "--page-", "--action-bar-", "--empty-", "--menu-", "--sidebar-"];
-
-/** 项目自有类名前缀（用于选择器挂空判定） */
-const OWNED_CLASS_PREFIXES = ["vts-", "re-", "col-", "navbar-", "header-", "sider-", "sidebar-", "menu-", "card-tab", "tab-", "language-", "app-", "list-"];
-
-const errors = [];
-const warnings = [];
-const infos = [];
-
-const err = (id, msg) => errors.push({ id, msg });
-const warn = (id, msg) => warnings.push({ id, msg });
-const info = (id, msg) => infos.push({ id, msg });
-
-// ── 文件工具 ────────────────────────────────────────────────
-function walk(dir, out = [], exts = SRC_EXT) {
-  if (!fs.existsSync(dir)) return out;
-  for (const name of fs.readdirSync(dir)) {
-    if (IGNORES.has(name)) continue;
-    const full = path.join(dir, name);
-    let st;
-    try {
-      st = fs.statSync(full);
-    } catch {
-      continue;
-    }
-    if (st.isDirectory()) walk(full, out, exts);
-    else if (exts.has(path.extname(name))) out.push(full);
-  }
-  return out;
-}
-
-const readIf = (p) => (fs.existsSync(p) ? fs.readFileSync(p, "utf-8") : null);
-
-// ── 迷你 CSS/SCSS 展平器 ────────────────────────────────────
-function stripComments(css) {
-  return css
-    .replace(/\/\*[\s\S]*?\*\//g, "")
-    .replace(/(^|[\s;}])[/]{2}[^\n]*/g, "$1");
-}
-
-function addDecls(decls, chunk) {
-  const text = String(chunk);
-  if (!text.trim()) return;
-  for (const piece of text.split(";")) {
-    const t = piece.trim();
-    if (!t || t.startsWith("$") || t.startsWith("@")) continue;
-    const idx = t.indexOf(":");
-    if (idx <= 0) continue;
-    const prop = t.slice(0, idx).trim().toLowerCase();
-    const value = t.slice(idx + 1).trim();
-    if (!prop || /[{}]/.test(prop)) continue;
-    decls[prop] = value;
-  }
-}
-
-const splitList = (s) => String(s).split(",").map((x) => x.trim()).filter(Boolean);
-
-function joinSelector(parent, child) {
-  const parts = splitList(child);
-  if (!parent) return parts.join(", ");
-  const parents = splitList(parent);
-  const out = [];
-  for (const part of parts) {
-    if (part.includes("&")) {
-      for (const p of parents) out.push(part.replace(/&/g, p));
-    } else {
-      for (const p of parents) out.push(`${p} ${part}`);
-    }
-  }
-  return out.join(", ");
-}
-
-/**
- * 把一段 SCSS 正文拆成「本层声明」与「子块」。
- * 关键：声明与子块是交错的，必须逐字符按 `;` / `{}` 切分，
- * 否则「先声明后嵌套」的规则会把声明粘到下一个子选择器上（错位出幽灵规则）。
- */
-function parseRule(body) {
-  const blocks = [];
-  let declText = "";
-  let buf = "";
-  let i = 0;
-  while (i < body.length) {
-    const ch = body[i];
-    if (ch === '"' || ch === "'") {
-      let j = i + 1;
-      while (j < body.length && body[j] !== ch) j += body[j] === "\\" ? 2 : 1;
-      buf += body.slice(i, j + 1);
-      i = j + 1;
-    } else if (ch === "{" && buf.endsWith("#")) {
-      buf += ch; // SCSS 插值 #{}，不是块
-      i++;
-    } else if (ch === "{") {
-      const sel = buf.trim();
-      buf = "";
-      let depth = 1;
-      let j = i + 1;
-      let inner = "";
-      while (j < body.length && depth > 0) {
-        const c = body[j];
-        if (c === "{") depth++;
-        else if (c === "}") {
-          depth--;
-          if (depth === 0) break;
-        }
-        inner += c;
-        j++;
-      }
-      if (sel) blocks.push({ sel, body: inner });
-      i = j + 1;
-    } else if (ch === ";") {
-      declText += buf + ";";
-      buf = "";
-      i++;
-    } else if (ch === "}") {
-      i++;
-    } else {
-      buf += ch;
-      i++;
-    }
-  }
-  declText += buf;
-  return { declText, blocks };
-}
-
-const AT_SKIP = /^@(keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes|font-face|import|use|forward|charset|tailwind|apply|extend)/i;
-
-function flattenCss(css, parentSel = "", acc = []) {
-  const { declText, blocks } = parseRule(stripComments(css));
-  if (parentSel && declText.trim()) {
-    const decls = {};
-    addDecls(decls, declText);
-    if (Object.keys(decls).length) acc.push({ selector: parentSel, decls });
-  }
-  for (const b of blocks) {
-    const sel = b.sel.trim();
-    if (!sel || AT_SKIP.test(sel)) continue;
-    if (sel.startsWith("@")) {
-      flattenCss(b.body, parentSel, acc);
-      continue;
-    }
-    flattenCss(b.body, joinSelector(parentSel, sel), acc);
-  }
-  return acc;
-}
-
-const classTokens = (selector) => [...selector.matchAll(/\.(-?[A-Za-z_][\w-]*)/g)].map((m) => m[1]);
-/** 去掉伪元素后的「末位复合选择器」——它才是这条规则真正作用的那一层元素 */
-const lastCompound = (sel) => {
-  const parts = String(sel)
-    .replace(/::[a-z-]+(\([^)]*\))?/gi, "")
-    .split(/[\s>+~]+/)
-    .filter(Boolean);
-  return parts[parts.length - 1] || "";
-};
-const allVars = (text) => [...text.matchAll(/var\(\s*(--[\w-]+)\s*(,)?/g)].map((m) => ({ name: m[1], hasFallback: !!m[2] }));
-
-// ── 采集：设计层 / 项目源 / 变更集 / 词典 ────────────────────
-const designFiles = DESIGN_LAYER_GLOBS.map((g) => path.join(PROJECT, g)).filter((p) => fs.existsSync(p));
-const extraDesign = walk(path.join(PROJECT, "src", "styles")).filter((p) => /design-.*\.(scss|css)$/i.test(path.basename(p)));
-const DESIGN_FILES = [...new Set([...designFiles, ...extraDesign])];
-
-const srcFiles = SRC_DIRS.flatMap((d) => walk(path.join(PROJECT, d)));
-const srcTextByFile = new Map();
-for (const f of srcFiles) srcTextByFile.set(f, readIf(f) ?? "");
-
-const designSet = new Set(DESIGN_FILES.map((p) => path.resolve(p)));
-const projectText = [...srcTextByFile.entries()]
-  .filter(([f]) => !designSet.has(path.resolve(f)))
-  .map(([, t]) => t)
-  .join("\n");
-
-const designCss = DESIGN_FILES.map((f) => srcTextByFile.get(f) ?? readIf(f) ?? "").join("\n");
-// 每条规则带上来源文件：用于区分「本轮落地设计层」与「此前存量设计层」的告警级别
-const designRules = DESIGN_FILES.flatMap((f) =>
-  flattenCss(srcTextByFile.get(f) ?? readIf(f) ?? "").map((r) => ({ ...r, file: f })),
-);
-const PRIMARY_LAYER = path.resolve(PROJECT, argValue("--design-layer", "src/styles/design-shell.scss"));
-const isPrimary = (file) => path.resolve(file) === PRIMARY_LAYER;
-
-// 变更集发现：规范落点 .design/，兼容 design/ 与 .changeset/。
-// 硬编码单一目录的代价是「变更集搬家 → 闸门静默跳过」。
-const CHANGESET_DIRS = [".design", "design", ".changeset"];
-const relp = (p) => path.relative(PROJECT, p).replace(/\\/g, "/");
-const changesetCandidates = [];
-{
-  const explicit = argValue("--changeset", "");
-  if (explicit) {
-    const p = path.resolve(PROJECT, explicit);
-    if (fs.existsSync(p)) changesetCandidates.push(p);
-    else err("E0", `--changeset 指定的变更集不存在：${p}`);
-  } else {
-    for (const d of CHANGESET_DIRS) {
-      const dir = path.join(PROJECT, d);
-      if (!fs.existsSync(dir)) continue;
-      for (const f of fs.readdirSync(dir).filter((x) => /changeset.*\.json$/i.test(x)).sort()) {
-        const full = path.join(dir, f);
-        if (!changesetCandidates.includes(full)) changesetCandidates.push(full);
-      }
-    }
-  }
-}
-let changeset = null;
-let changesetFile = null;
-if (changesetCandidates.length > 1) {
-  warn(
-    "E11",
-    `多份变更集并存：${changesetCandidates.map(relp).join("、")} —— 无法判定哪份是「本轮」交付物，暂取最近修改的一份。落点应唯一为 .design/ 并在交付台账登记。`,
-  );
-}
-if (changesetCandidates.length) {
-  changesetFile = changesetCandidates.map((p) => ({ p, t: fs.statSync(p).mtimeMs })).sort((a, b) => b.t - a.t)[0].p;
-  try {
-    changeset = JSON.parse(fs.readFileSync(changesetFile, "utf-8"));
-  } catch (e) {
-    err("E0", `变更集解析失败：${changesetFile} — ${e.message}`);
-  }
-}
-
-// 词典（技能包自带 mapping/）
-const dictSidMap = new Map();
-const dictEntries = [];
-(function loadMapping() {
-  const roots = ["mapping/scenes", "mapping/component", "mapping/layout", "mapping/basic"].map((r) => path.join(SKILL_ROOT, r));
-  const files = roots.flatMap((r) => walk(r, [], JSON_EXT));
-  for (const f of files) {
-    try {
-      const json = JSON.parse(fs.readFileSync(f, "utf-8"));
-      for (const [sid, entry] of Object.entries(json.mappings || {})) {
-        if (!entry || typeof entry !== "object") continue;
-        dictSidMap.set(sid, { ...entry, __file: f });
-        dictEntries.push({ sid, entry });
-      }
-    } catch {
-      /* 忽略无法解析的映射文件 */
-    }
-  }
-})();
-
-// ── E1 变量悬空 ─────────────────────────────────────────────
-(function checkE1() {
-  if (!designCss) return;
-  const defined = new Set();
-  for (const t of [designCss, projectText].filter(Boolean)) {
-    for (const m of t.matchAll(/(--[\w-]+)\s*:/g)) defined.add(m[1]);
-  }
-  if (changeset) {
-    // 令牌名可能只在变更集里出现（由项目侧再映射），一并视为已声明
-    for (const m of JSON.stringify(changeset).matchAll(/--[\w-]+/g)) defined.add(m[0]);
-  }
-  const missing = new Map();
-  for (const { name, hasFallback } of allVars(designCss)) {
-    if (hasFallback || defined.has(name)) continue;
-    if (!OWNED_VAR_PREFIXES.some((p) => name.startsWith(p))) continue;
-    missing.set(name, (missing.get(name) || 0) + 1);
-  }
-  for (const [name, count] of missing) {
-    err("E1", `变量悬空：设计层使用了 ${name}（${count} 处），但项目内无定义、也无 var() 回退 —— 该声明整条失效。`);
-  }
-  if (!missing.size) info("E1", `变量悬空：0 处（受检前缀 ${OWNED_VAR_PREFIXES.join(" ")}）`);
-})();
-
-// ── E2 层错位 ───────────────────────────────────────────────
-(function checkE2() {
-  const hits = [];
-  for (const rule of designRules) {
-    const sel = rule.selector;
-    if (!/el-table|(^|[\s,>])(th|td)(\.|[\s,:{]|$)/.test(sel)) continue;
-    if (/\.cell\b/.test(sel)) continue; // 已锚定内层文本盒
-    const offenders = Object.keys(rule.decls).filter((p) => INNER_ONLY_PROPS.has(p));
-    if (offenders.length) hits.push({ sel, offenders });
-  }
-  for (const h of hits.slice(0, 12)) {
-    err("E2", `层错位：${h.sel} 声明了内层盒属性族 [${h.offenders.join(", ")}]，但未锚定 > .cell —— 会被 Element Plus 内层 .cell 覆盖，等于没写。`);
-  }
-  if (hits.length > 12) err("E2", `层错位：另有 ${hits.length - 12} 处未列出。`);
-  if (!hits.length) info("E2", "层错位：0 处");
-})();
-
-// ── E3 层叠胜负 / E10 scoped 挂空 ───────────────────────────
-// 组件 scoped 规则编译后末位选择器会追加 [data-v-xxx] 属性选择器，等价 +1 个类级特指度。
-// 因此「设计层声明是否真的生效」必须算特指度，不能只看有没有同名类。
-const SCOPED_ATTR = 1000;
-const STATE_PSEUDO = /:(hover|focus|active|visited|disabled|checked|focus-within|focus-visible|first-child|last-child|nth-[\w-]+)/i;
-
-const pseudoElOf = (sel) => (sel.match(/::([a-z-]+)/i) || [])[1] || "";
-
-function specOf(selector) {
-  const s = selector
-    .replace(/::[a-z-]+(\([^)]*\))?/gi, " ")
-    .replace(/:not\(([^)]*)\)/g, ":not");
-  const ids = (s.match(/#[\w-]+/g) || []).length;
-  const classes =
-    (s.match(/\.[\w-]+/g) || []).length +
-    (s.match(/\[[^\]]*\]/g) || []).length +
-    (s.match(/:(?!:)[\w-]+(\([^)]*\))?/g) || []).length;
-  const elems = (s.match(/(?:^|[\s>+~])[a-zA-Z][\w-]*/g) || []).length;
-  return ids * 1e6 + classes * 1e3 + elems;
-}
-
-/** 状态类 / 第三方类不属于「项目自有挂载点」，挂空判定不参与 */
-const isOwnedClass = (c) =>
-  OWNED_CLASS_PREFIXES.some((p) => c.startsWith(p)) && !/^(is|has|van|el|n)-/.test(c);
-const IGNORE_DEAD = new Set(["language-text", "language-text__item"]);
-
-// 模板/脚本源码（剔掉 style 块，避免样式里的类名自证「已挂载」）
-const markupText = [...srcTextByFile.entries()]
-  .filter(([f]) => f.endsWith(".vue"))
-  .map(([, t]) => t.replace(/<style[\s\S]*?<\/style>/g, ""))
-  .join("\n");
-
-// 收集组件 scoped 规则，并标记「挂空」的（选择器链条上存在运行时不存在的类）
-const scopedRules = [];
-const scopedDead = [];
-for (const [f, t] of srcTextByFile) {
-  if (!f.endsWith(".vue")) continue;
-  for (const m of t.matchAll(/<style[^>]*scoped[^>]*>([\s\S]*?)<\/style>/g)) {
-    for (const r of flattenCss(m[1])) {
-      const cls = [...new Set(classTokens(r.selector))];
-      if (!cls.length) continue;
-      if (/:deep\(|::v-deep|:global\(/.test(r.selector)) continue;
-      const owned = cls.filter(isOwnedClass);
-      const missing = owned.filter((c) => !markupText.includes(c));
-      const dead = missing.length > 0;
-      scopedRules.push({ ...r, file: f, dead });
-      if (dead) scopedDead.push({ sel: r.selector, file: f, missing });
-    }
-  }
-}
-
-// 竞争者索引：只登记「与目标同一元素（同末位复合选择器）」且非挂空的规则
-const scopedIdx = new Map();
-for (const r of scopedRules) {
-  if (r.dead) continue; // 挂空的规则永不命中，不能算作竞争者
-  if (STATE_PSEUDO.test(r.selector)) continue; // 状态态不参与基态竞争
-  const pe = pseudoElOf(r.selector);
-  const spec = specOf(r.selector) + SCOPED_ATTR;
-  for (const cls of new Set(classTokens(lastCompound(r.selector)))) {
-    for (const prop of Object.keys(r.decls)) {
-      const key = `${cls}|${prop}|${pe}`;
-      const cur = scopedIdx.get(key);
-      if (!cur || spec > cur.spec) scopedIdx.set(key, { spec, selector: r.selector, file: r.file });
-    }
-  }
-}
-
-(function checkE3() {
-  if (!scopedIdx.size) {
-    info("E3", "层叠胜负：无同属性竞争的组件 scoped 规则");
-    return;
-  }
-  // 出厂暗色主题层（dark.scss）不属于「本次设计落地」：它与组件 scoped 的对决是出厂内部
-  // 行为（架构红线也禁止改出厂文件来「修复」），按设计层宣判会永久卡死交付闸。
-  const FACTORY_THEME_LAYERS = new Set(["dark.scss"]);
-  const isFactoryLayer = (file) => FACTORY_THEME_LAYERS.has(path.basename(String(file || "")));
-  const hits = [];
-  const seen = new Set();
-  for (const r of designRules) {
-    if (isFactoryLayer(r.file)) continue;
-    const pe = pseudoElOf(r.selector);
-    for (const part of splitList(r.selector)) {
-      const last = lastCompound(part);
-      const clsList = [...new Set(classTokens(last))];
-      if (!clsList.length) continue;
-      const mine = specOf(part);
-      for (const prop of Object.keys(r.decls)) {
-        for (const cls of clsList) {
-          const comp = scopedIdx.get(`${cls}|${prop}|${pe}`);
-          if (!comp || mine > comp.spec) continue;
-          const key = `${part}|${prop}`;
-          if (seen.has(key)) continue;
-          seen.add(key);
-          hits.push({ sel: part, prop, cls, mine, comp });
-        }
-      }
-    }
-  }
-  const shown = hits.slice(0, 12);
-  for (const h of shown) {
-    const rel = path.relative(PROJECT, h.comp.file).replace(/\\/g, "/");
-    err(
-      "E3",
-      `层叠败北：${h.sel} 的 ${h.prop} 特指度 ${h.mine} ≤ 组件 scoped 竞争者 ${h.comp.selector}（${rel}）的 ${h.comp.spec}（scoped 追加 [data-v] 属性选择器，等价 +1 类级）—— 该声明不会生效：收口类提权加 !important，形态类须提高锚定层级（补上 .is-active / .card-item 等对方使用的限定类）。`,
-    );
-  }
-  if (hits.length > shown.length) {
-    const byFile = new Map();
-    for (const h of hits.slice(shown.length)) {
-      const rel = path.relative(PROJECT, h.comp.file).replace(/\\/g, "/");
-      byFile.set(rel, (byFile.get(rel) || 0) + 1);
-    }
-    const detail = [...byFile.entries()].sort((a, b) => b[1] - a[1]).map(([f, n]) => `${f}(${n})`).join("、");
-    err("E3", `层叠败北：另有 ${hits.length - shown.length} 处未列出，集中在 ${detail} —— 同一文件成片败北说明该区域的锚定层级整体偏低，应按文件批量提权。`);
-  }
-  if (!hits.length) info("E3", `层叠胜负：0 处败北（竞争者 ${scopedIdx.size} 组）`);
-})();
-
-// ── E10 组件 scoped 规则挂空（重构残留） ────────────────────
-(function checkE10() {
-  const dead = scopedDead.filter((d) => d.missing.some((c) => !IGNORE_DEAD.has(c)));
-  if (!dead.length) {
-    info("E10", "组件 scoped 挂空：0 处");
-    return;
-  }
-  for (const d of dead.slice(0, 15)) {
-    const rel = path.relative(PROJECT, d.file).replace(/\\/g, "/");
-    warn(
-      "E10",
-      `scoped 规则挂空：${rel} 的 ${d.sel} 依赖运行时并不存在的类 [${d.missing.join(", ")}] —— 整条规则永不命中（多在结构重构后残留），既不会生效也会误导后续收口判断。`,
-    );
-  }
-  if (dead.length > 15) warn("E10", `scoped 规则挂空：另有 ${dead.length - 15} 处未列出。`);
-})();
-
-// ── E4 选择器挂空 ───────────────────────────────────────────
-(function checkE4() {
-  const used = new Map(); // 类名 → 声明它的设计层文件集合
-  for (const rule of designRules) {
-    for (const c of classTokens(rule.selector)) {
-      if (!OWNED_CLASS_PREFIXES.some((p) => c.startsWith(p))) continue;
-      if (!used.has(c)) used.set(c, new Set());
-      used.get(c).add(rule.file);
-    }
-  }
-  const phantom = [...used.keys()].filter((c) => !projectText.includes(c));
-  const hard = phantom.filter((c) => [...used.get(c)].some(isPrimary));
-  const soft = phantom.filter((c) => !hard.includes(c));
-  for (const c of hard.slice(0, 15)) {
-    err("E4", `选择器挂空：设计层选择器使用了 .${c}，但 src/ 全量源码里没有该类的挂载点 —— 规则命中不到任何元素（锚点必须锚「实际在」，不能锚「应该在」）。`);
-  }
-  if (hard.length > 15) err("E4", `选择器挂空：另有 ${hard.length - 15} 个未列出。`);
-  for (const c of soft.slice(0, 10)) {
-    const files = [...used.get(c)].map((f) => path.basename(f)).join(", ");
-    warn("E4", `选择器挂空（历史层）：.${c} 只出现在 ${files}，项目内无挂载点 —— 静态遗留，非本次落地引入，但同样永不命中。`);
-  }
-  if (soft.length > 10) warn("E4", `选择器挂空（历史层）：另有 ${soft.length - 10} 个未列出。`);
-  if (!phantom.length) info("E4", `选择器挂空：0 个（受检类名 ${used.size} 个）`);
-})();
-
-// ── E5 列宽预算 ─────────────────────────────────────────────
-function extractObjectLiterals(arrSrc) {
-  const out = [];
-  let depth = 0;
-  let start = -1;
-  for (let i = 0; i < arrSrc.length; i++) {
-    const ch = arrSrc[i];
-    if (ch === "{") {
-      if (depth === 0) start = i;
-      depth++;
-    } else if (ch === "}") {
-      depth--;
-      if (depth === 0 && start >= 0) {
-        out.push(arrSrc.slice(start, i + 1));
-        start = -1;
-      }
-    }
-  }
-  return out;
-}
-
-function matchArrayLiteral(text, anchorRe) {
-  const m = anchorRe.exec(text);
-  if (!m) return null;
-  const open = text.indexOf("[", m.index);
-  if (open < 0) return null;
-  let depth = 0;
-  for (let i = open; i < text.length; i++) {
-    if (text[i] === "[") depth++;
-    else if (text[i] === "]") {
-      depth--;
-      if (depth === 0) return text.slice(open + 1, i);
-    }
-  }
-  return null;
-}
-
-(function checkE5() {
-  const tableFiles = [...srcTextByFile.entries()].filter(([, t]) => t.includes("el-table-column"));
-  if (!tableFiles.length) {
-    info("E5", "列宽预算：未在 src 中发现 el-table-column");
-    return;
-  }
-  const pxOf = (s) => {
-    const m = String(s).match(/(\d+(?:\.\d+)?)\s*(px)?/);
-    return m ? Number(m[1]) : null;
-  };
-  // 表头文案最小占宽：CJK ≈ 1em，ASCII ≈ 0.6em；两侧各留 16px 宿主内边距
-  const HEADER_FS = 14;
-  const CELL_PAD = 16;
-  const textWidth = (label) => {
-    let w = 0;
-    for (const ch of String(label)) w += /[\u2e80-\u9fff\uff00-\uffef]/.test(ch) ? HEADER_FS : HEADER_FS * 0.6;
-    return Math.ceil(w);
-  };
-  const minFit = (label) => textWidth(label) + CELL_PAD * 2;
-  // 列名可能是 $t('类型') 这类 i18n 调用，需取出引号内的真实文案
-  const cleanLabel = (raw) => {
-    const s = String(raw).trim();
-    const q = s.match(/[`'"]([^`'"]+)[`'"]/);
-    return ((q ? q[1] : s).trim() || "?");
-  };
-  const labelOf = (src) => {
-    const m =
-      src.match(/label:\s*([^,\n}]+)/) || src.match(/\blabel="([^"]*)"/) || src.match(/\blabel='([^']*)'/);
-    return m ? cleanLabel(m[1]) : "?";
-  };
-  const OPS = ["operate", "operation", "actions"];
-
-  for (const [file, text] of tableFiles) {
-    const rel = path.relative(PROJECT, file).replace(/\\/g, "/");
-    const declared = [];
-    const noWidth = [];
-
-    // 1) 列定义数组（模板常用动态列）
-    const arr = matchArrayLiteral(text, /(?:const|let|var)\s+\w*[Cc]olumn\w*\s*(?::[^=]+)?=\s*\[/);
-    if (arr) {
-      for (const objSrc of extractObjectLiterals(arr)) {
-        const label = labelOf(objSrc);
-        const prop = (objSrc.match(/prop:\s*[`'"]([^`'"]+)/) || [])[1] || "?";
-        const w = objSrc.match(/\bwidth:\s*[`'"]?([\d.]+)/);
-        const mw = objSrc.match(/\bminWidth:\s*[`'"]?([\d.]+)/);
-        if (w) declared.push({ label, prop, w: pxOf(w[1]) });
-        else if (mw) declared.push({ label, prop, mw: pxOf(mw[1]) });
-        else noWidth.push({ label, prop });
-      }
-    }
-
-    // 2) 内联列（selection / index / 手工列）
-    for (const tag of text.matchAll(/<el-table-column\b[\s\S]*?(?:\/>|>)/g)) {
-      const src = tag[0];
-      const type = (src.match(/:?type="['"]([^'"]+)/) || [])[1] || "";
-      const label = (src.match(/:?label="([^"]*)"/) || src.match(/:?label='([^']*)'/) || [])[1];
-      const labelText = label ? cleanLabel(label) : type || "?";
-      const hasW = /(^|\s):?width=/.test(src) || /\bwidth=/.test(src);
-      const hasMw = /:?min-width=/.test(src) || /:?minWidth=/.test(src);
-      if (hasW || hasMw) continue;
-      if (type === "selection" || type === "index") {
-        warn("E5", `${rel}：${type === "selection" ? "选择列" : "序号列"}（${labelText}）未声明 width / min-width，只能按出厂兜底宽度参与布局（§11.132 要求逐列声明意图）。`);
-      } else if (type) {
-        noWidth.push({ label: labelText, prop: type });
-      }
-    }
-
-    // 模板里按 prop 条件绑定的列宽（如
-    //   :min-width="column.prop === 'minCategoryName' ? '120' : undefined"
-    // ）会覆盖列定义数组里那次「无宽」——不识别就会把已有下限的列误报成无宽列。
-    const tplBind = new Map(); // prop → { width?, minWidth? }
-    for (const attr of ["width", "min-width"]) {
-      for (const m of text.matchAll(new RegExp(`:${attr}="([^"]+)"`, "g"))) {
-        for (const c of m[1].matchAll(/[\w.]*prop\s*===\s*['"]([^'"]+)['"]\s*\?\s*['"]?([\d.]+)(?:px)?['"]?/g)) {
-          const cur = tplBind.get(c[1]) || {};
-          if (attr === "width") cur.width = Number(c[2]);
-          else cur.minWidth = Number(c[2]);
-          tplBind.set(c[1], cur);
-        }
-      }
-    }
-    for (const [prop, v] of tplBind) {
-      if (noWidth.some((c) => c.prop === prop)) {
-        const label = (noWidth.find((c) => c.prop === prop) || {}).label || prop;
-        if (v.width != null) declared.push({ label, prop, w: v.width });
-        else if (v.minWidth != null) declared.push({ label, prop, mw: v.minWidth });
-      }
-    }
-
-    const realNoWidth = noWidth.filter((c) => !OPS.includes(c.prop) && !tplBind.has(c.prop));
-    for (const c of realNoWidth) {
-      err(
-        "E5",
-        `${rel}：列「${c.label}」(prop=${c.prop}) 既无 width 也无 min-width —— 无宽列由出厂兜底宽度参与布局，会被相邻固定宽列挤压；本列表头文案需 ≥ ${minFit(c.label)}px（文案 ${textWidth(c.label)}px + 内边距 ${CELL_PAD * 2}px），请按此反推 width / min-width（换行与省略号截断都源于此）。`,
-      );
-    }
-
-    // 3) 已声明 min-width 的列：min-width 必须容得下自己的表头文案
-    for (const c of declared) {
-      if (c.mw == null) continue;
-      const need = minFit(c.label);
-      if (c.mw < need) {
-        err(
-          "E5",
-          `${rel}：列「${c.label}」min-width=${c.mw}px < 表头文案最小占宽 ${need}px —— 布局算法压缩到 min-width 时表头必然换行或截断（「${c.label}」→「${c.label.slice(0, 2)}…」）。`,
-        );
-      }
-    }
-
-    const total = declared.reduce((s, c) => s + (c.w ?? 0), 0);
-    const minTotal = declared.reduce((s, c) => s + (c.mw ?? 0), 0);
-    const fixedCount = declared.filter((c) => c.w).length;
-    const flexCount = declared.filter((c) => c.mw).length;
-    const budget = total + minTotal;
-    const noWidthNeed = realNoWidth.reduce((s, c) => s + minFit(c.label), 0);
-    const line = `${rel}：固定宽 ${fixedCount} 列(${total}px) / 伸缩列 ${flexCount} 列(${minTotal}px) / 无宽列 ${realNoWidth.length} 列(需 ${noWidthNeed}px)`;
-    if (CONTAINER_EXPLICIT && budget + noWidthNeed > CONTAINER_WIDTH) {
-      err(
-        "E5",
-        `${line} —— 合计 ${budget + noWidthNeed}px > 容器可用宽 ${CONTAINER_WIDTH}px：列宽预算溢出，必须在设计侧收敛（减少列 / 降 min-width / 显式声明横向滚动），不允许靠静默压缩消化。`,
-      );
-    } else if (!CONTAINER_EXPLICIT && budget + noWidthNeed > CONTAINER_WIDTH) {
-      warn(
-        "E5",
-        `${line} —— 合计 ${budget + noWidthNeed}px 超出假定容器宽 ${CONTAINER_WIDTH}px。容器宽为估值，请用 --container-width <px> 传入实际内容区宽度后复跑，据以判定是否溢出。`,
-      );
-    } else {
-      info("E5", `${line}，合计 ${budget + noWidthNeed}px ≤ ${CONTAINER_WIDTH}px`);
-    }
-  }
-})();
-
-// ── E6 visible:false 收口断言 ──────────────────────────────
-(function checkE6() {
-  if (!changeset) {
-    info("E6", "未发现变更集（.design/changeset*.json），跳过收口断言");
-    return;
-  }
-  const changes = changeset.changes || [];
-  const closable = changes.filter((c) => c.visible === false || c.style?.visible === false);
-  if (!closable.length) {
-    info("E6", "收口断言：变更集无 visible:false 项");
-    return;
-  }
-  for (const change of closable) {
-    const entry = dictSidMap.get(change.id);
-    const selector = entry?.selector;
-    if (!selector) {
-      warn("E6", `${change.id} 声明 visible:false，但词典无 selector，无法断言收口落点。`);
-      continue;
-    }
-    const target = classTokens(selector).slice(-1)[0];
-    if (!target) {
-      warn("E6", `${change.id} 的词典 selector「${selector}」不含类名，无法断言收口落点。`);
-      continue;
-    }
-    const rule = designRules.find(
-      (r) => r.selector.includes(`.${target}`) && /none/i.test(r.decls.display || ""),
-    );
-    if (!rule) {
-      err("E6", `${change.id} 声明 visible:false，但设计层没有任何「命中 .${target} 且 display:none」的收口规则 —— 元素会照旧显示。`);
-    } else if (!/!important/i.test(rule.decls.display)) {
-      warn("E6", `${change.id} 的收口规则 ${rule.selector} 的 display:none 未加 !important，存在被组件 scoped 同权重反压的风险。`);
-    } else {
-      info("E6", `${change.id} → ${rule.selector} display:none !important ✓`);
-    }
-  }
-})();
-
-// ── E7 激活态越层 ───────────────────────────────────────────
-(function checkE7() {
-  const hits = designRules.filter((r) => {
-    const sel = r.selector;
-    const onGroup = /el-sub-menu|__title/.test(sel);
-    const active = /is-active|\.active\b|\[aria-current|\.is-opened/.test(sel);
-    if (!onGroup || !active) return false; // 必须同时命中「分组标题」与「激活态」才是越层
-    const setsSurface = Object.keys(r.decls).some(
-      (p) => p === "background" || p.startsWith("background") || p === "box-shadow" || p === "border-inline-start",
-    );
-    const pseudoBar = /::?(before|after)/.test(sel);
-    return setsSurface || pseudoBar;
-  });
-  for (const r of hits.slice(0, 10)) {
-    err("E7", `激活态越层：${r.selector} 把激活态（胶囊/指示条）写到了可展开分组的标题上 —— 分组标题会同时长出胶囊与竖向指示条，并与右侧展开箭头叠压（§6.15/§6.16 要求激活态只作用叶子项，分组标题须以 :not(.el-sub-menu__title) 排除）。`);
-  }
-  if (!hits.length) info("E7", "激活态越层：0 处");
-})();
-
-// ── E8 浮层残留 ─────────────────────────────────────────────
-(function checkE8() {
-  if (!changeset) {
-    info("E8", "未发现变更集，跳过浮层残留检查");
-    return;
-  }
-  for (const change of changeset.changes || []) {
-    const form = change.form;
-    if (!form) continue;
-    const entry = dictSidMap.get(change.id);
-    if (!entry) continue;
-    const required = entry.suppress_rules?.[form] || [];
-    const structural = [...required, ...(entry.structure_ops_required?.[form] || [])].join(" ");
-    if (!/popper|dropdown|浮层/i.test(structural)) continue;
-    const compFile = entry.file && typeof entry.file === "string" ? entry.file.match(/(src\/[\w./-]+\.vue)/) : null;
-    if (!compFile) continue;
-    const p = path.join(PROJECT, compFile[1]);
-    const t = readIf(p);
-    if (!t) continue;
-    if (/#dropdown|ElDropdown|el-dropdown/.test(t)) {
-      err("E8", `${change.id} 的 form=${form} 要求收口下拉浮层，但 ${compFile[1]} 仍保留 ElDropdown / #dropdown 消费 —— 点击触发器仍会弹出浮层（浮层属 teleport popper，样式层收不掉）。`);
-    } else {
-      info("E8", `${change.id} 浮层收口 ✓`);
-    }
-  }
-})();
-
-// ── E9 形态收口缺件 ─────────────────────────────────────────
-// 形态类 form（如 icon_only）落地必须「成对」：显图标 + 隐文案，且收口要落回该语义元素
-// 自己的作用域内。只按「全局有没有 .tag-title{display:none}」判断会被兄弟变体规则骗过。
-const normSel = (s) => String(s).replace(/\s+/g, " ").trim();
-const lastClassOutsideNot = (sel) => {
-  const cleaned = String(sel).replace(/:not\([^)]*\)/g, "");
-  const parts = splitList(cleaned);
-  const last = parts.length ? lastCompound(parts[parts.length - 1]) : "";
-  const cls = classTokens(last);
-  if (cls.length) return cls[cls.length - 1];
-  const all = classTokens(cleaned);
-  return all.length ? all[all.length - 1] : null;
-};
-
-(function checkE9() {
-  if (!changeset) {
-    info("E9", "未发现变更集，跳过形态收口检查");
-    return;
-  }
-  for (const change of changeset.changes || []) {
-    if (!/^(icon_only|icon)$/.test(change.form || "")) continue;
-    const entry = dictSidMap.get(change.id);
-    if (!entry) {
-      warn("E9", `${change.id} 的 form=${change.form} 在词典里找不到条目，无法断言形态收口。`);
-      continue;
-    }
-    const scope = normSel(entry.selector || "");
-    const subs = entry.sub_selectors || {};
-    const textSub = subs.title || subs.text;
-    const iconSub = subs.icon || subs.leading_icon;
-    if (!scope || !textSub) {
-      warn("E9", `${change.id} 的词典缺少 selector 或 sub_selectors.title，无法断言「显图标 + 隐文案」是否成对。`);
-      continue;
-    }
-    const textTarget = lastClassOutsideNot(textSub);
-    const iconTarget = iconSub ? lastClassOutsideNot(iconSub) : null;
-    const inScope = (r) => {
-      const s = normSel(r.selector);
-      return s.includes(scope);
-    };
-    const closed = designRules.filter(
-      (r) => inScope(r) && /none/i.test(r.decls.display || "") && (!textTarget || normSel(r.selector).includes(`.${textTarget}`)),
-    );
-    const shown =
-      (iconTarget &&
-        designRules.find((r) => inScope(r) && normSel(r.selector).includes(`.${iconTarget}`) && /(block|inline-flex|flex|inline-block)/i.test(r.decls.display || ""))) ||
-      null;
-    const closedIcon = designRules.find((r) => inScope(r) && /\.card-tab-icon|\.tag-icon|icon/i.test(normSel(r.selector)) && /none/i.test(r.decls.display || ""));
-    // 图标与文案至少要有一边在本作用域内被显式声明，否则说明该形态未在本层落地
-    const landed = shown || closedIcon || closed.length;
-    if (!landed) continue;
-    if (!closed.length) {
-      err(
-        "E9",
-        `${change.id} 的 form=${change.form} 只落了「显图标」，没有在同一作用域 ${scope} 内收口文案（需要 .${textTarget} 的 display:none，锚定 ${scope}）—— 图标与文案并存会把固定窄宽挤爆，文案被截断（如「工作台」→「工…」）。注意：作用域外的兄弟变体收口（如 :not(:nth-child(1))）不算成对。`,
-      );
-      continue;
-    }
-    if (!/!important/i.test(closed[0].decls.display || "")) {
-      warn("E9", `${change.id} 的文案收口 ${closed[0].selector} 未加 !important，存在被组件 scoped 同权反压的风险。`);
-    } else {
-      info("E9", `${change.id} 图标/文案收口成对 ✓（${closed[0].selector}）`);
-    }
-  }
-})();
-
-// ── E15 结构声明兑现闸（G3：@sid 强制 + form/suppress 双向对账）──
-// 结构性声明（form / suppress / suppress_inner / structure_ops / text_visible:none /
-// visible:false）不能停留在台账上——项目侧必须有可指认的落点证据。实证缺口
-// 失效模式样例：collapse_trigger.form=header_inline 声明了，但词典 forms
-// 只有 bottom_bar / center_edge —— 壳层零规则，落地端静默无效，而 E6/E8/E9 的
-// 特判窗口都盖不住它。
-// 证据通道（按优先级）：
-//   ① /* @sid: <语义ID> */      —— 逐条落点标记（@sid 强制的机读载体）
-//   ② /* @closed: <通道名> */   —— suppress 收口证据（与 @sid 同构）
-//   ③ 通道为 css_vars 键时，设计层对该 var 写入关闭值（transparent / none / hidden / 0）
-//   ④ visible:false 的 display:none 收口规则（E6 同源）
-// 判定：
-//   · form 值不在词典 forms 枚举内 / suppress 通道名不是 forms∪css_vars∪custom_style_map
-//     的键 → ERROR（声明悬空 = 项目侧无规则可挂）
-//   · suppress_rules[form] 与 suppress[] 要求的通道无任何兑现证据 → ERROR
-//   · 有落点证据但缺 @sid → WARN（补标记使逐条对账可机读）
-//   · 出厂默认形态且无其他结构载荷 → WARN（保持现状无需规则，但仍需标记）
-//   · 反向：设计层 @closed 了变更集未声明的通道 → WARN（台账失真，收口记录进不了 D13 继承链）
-const CLOSING_VALUE_RE = /^(transparent|none|hidden|0(?:px)?)(\s|$)/i;
-const markedSids = new Set([...designCss.matchAll(/@sid\s*:\s*([\w.$-]+)/g)].map((m) => m[1]));
-const closedMarkers = new Set([...designCss.matchAll(/@closed\s*:\s*([\w.-]+)/g)].map((m) => m[1]));
-
-/** 与 parser extractSuppressRules 同源：结构化 suppress_rules 优先，forms 描述「suppress 必含」兜底 */
-function extractSuppressRulesAudit(entry) {
-  const rules = {};
-  if (entry && typeof entry.suppress_rules === "object" && entry.suppress_rules !== null) {
-    for (const [form, channels] of Object.entries(entry.suppress_rules)) {
-      rules[form] = Array.isArray(channels) ? channels.filter((c) => typeof c === "string") : [];
-    }
-  }
-  const forms = entry?.forms;
-  if (forms && typeof forms === "object" && !Array.isArray(forms)) {
-    for (const [form, desc] of Object.entries(forms)) {
-      if (typeof desc !== "string") continue;
-      for (const m of desc.matchAll(/suppress\s*必含\s*([a-z][a-z0-9_]*(?:[、,/][a-z][a-z0-9_]*)*)/gi)) {
-        const channels = m[1].split(/[、,/]/).map((s) => s.trim()).filter(Boolean);
-        rules[form] = [...new Set([...(rules[form] || []), ...channels])];
-      }
-    }
-  }
-  return rules;
-}
-
-const channelNamesOf = (entry) => {
-  const names = new Set([
-    ...Object.keys(entry?.forms || {}),
-    ...Object.keys(entry?.css_vars || {}),
-    ...Object.keys(entry?.custom_style_map || {}),
-  ]);
-  // suppress_rules 的「值域通道」也是合法收口目标（与 parser G1 同源）：如 dropdown_popper / tool_divider
-  for (const channels of Object.values(entry?.suppress_rules || {})) {
-    if (Array.isArray(channels)) for (const ch of channels) if (typeof ch === "string") names.add(ch);
-  }
-  // forms 描述里「suppress 必含 x」内联标记的通道同样合法
-  for (const desc of Object.values(entry?.forms || {})) {
-    if (typeof desc !== "string") continue;
-    for (const m of desc.matchAll(/suppress\s*必含\s*([a-z][a-z0-9_]*)/gi)) names.add(m[1]);
-  }
-  return names;
-};
-
-/** 通道收口证据：@closed 标记 或（css_vars 键）关闭值覆写 */
-function channelEvidence(entry, ch) {
-  if (closedMarkers.has(ch)) return `@closed:${ch}`;
-  const varName = entry?.css_vars?.[ch];
-  if (varName) {
-    const re = new RegExp(`${varName}\\s*:\\s*([^;\\n}]+)`, "i");
-    const m = re.exec(designCss);
-    if (m && CLOSING_VALUE_RE.test(m[1].trim())) return `${varName} 关闭值覆写`;
-  }
-  return null;
-}
-
-/** visible:false 落点证据（E6 同源口径） */
-function visibleClosureRule(change) {
-  const entry = dictSidMap.get(change.id);
-  const target = classTokens(entry?.selector || "").slice(-1)[0];
-  if (!target) return null;
-  return (
-    designRules.find((r) => r.selector.includes(`.${target}`) && /none/i.test(r.decls.display || "")) || null
-  );
-}
-
-(function checkE15() {
-  if (!changeset) {
-    info("E15", "未发现变更集，跳过结构声明兑现对账");
-    return;
-  }
-  const isStructural = (c) =>
-    typeof c?.form === "string" ||
-    (Array.isArray(c?.suppress) && c.suppress.length > 0) ||
-    (typeof c?.suppress_inner === "string" && c.suppress_inner.trim()) ||
-    (Array.isArray(c?.structure_ops) && c.structure_ops.length > 0) ||
-    c?.style?.text_visible === "none" ||
-    c?.visible === false;
-
-  const changes = changeset.changes || [];
-  for (const change of changes) {
-    if (!isStructural(change)) continue;
-    const entry = dictSidMap.get(change.id);
-    if (!entry) {
-      warn("E15", `${change.id} 声明结构语义（form/suppress 等），但词典无该条目 —— 项目侧无挂载点，无法兑现（match 会拦截）。`);
-      continue;
-    }
-
-    // ① form 值真实性：悬空 form 值 = 壳层零规则（header_inline 实证）
-    if (typeof change.form === "string" && change.form) {
-      const forms = entry.forms && typeof entry.forms === "object" ? Object.keys(entry.forms) : [];
-      const rules = entry.suppress_rules || {};
-      // modes 型条目（forms 值为数组的枚举字典，如 admin.content.container 的 mode: ["fixed","scroll","auto"]）：
-      // form 合法值取数组并集
-      const modeValues = [];
-      for (const v of Object.values(entry.forms || {})) {
-        if (Array.isArray(v)) for (const x of v) if (typeof x === "string") modeValues.push(x);
-      }
-      if (
-        forms.length &&
-        !forms.includes(change.form) &&
-        !(change.form in rules) &&
-        !modeValues.includes(change.form)
-      ) {
-        err(
-          "E15",
-          `${change.id} 的 form="${change.form}" 不在词典 forms 枚举 [${forms.join("、")}] 内 —— 项目侧无规则可挂（壳层零规则），声明悬空。形态值只能取词典已支持的枚举；确需新形态先走 pending 补词典。`,
-        );
-      }
-    }
-
-    // ② suppress 通道名真实性（「声明 → 词典」对账）
-    const declared = Array.isArray(change.suppress) ? change.suppress : [];
-    const known = channelNamesOf(entry);
-    const unknown = declared.filter((ch) => !known.has(ch));
-    if (unknown.length) {
-      err(
-        "E15",
-        `${change.id}.suppress 引用了词典不认识的通道 [${unknown.join("、")}]（可用通道：${[...known].join("、")}）—— 通道名以该条目 forms/css_vars/custom_style_map 的键为准。`,
-      );
-    }
-
-    // ③ suppress_rules[form] 与已声明通道的兑现证据（「声明 → 设计层」对账）
-    const required = extractSuppressRulesAudit(entry)[change.form] || [];
-    const demanded = [...new Set([...required, ...declared])];
-    let allClosed = true;
-    for (const ch of demanded) {
-      const ev = channelEvidence(entry, ch);
-      if (!ev) {
-        allClosed = false;
-        const varHint = entry.css_vars?.[ch]
-          ? `，或（通道为 css_vars 键）在设计层覆写 ${entry.css_vars[ch]} 为关闭值（transparent / none / 0）`
-          : "";
-        err(
-          "E15",
-          `${change.id} 要求收口通道「${ch}」，但设计层无任何兑现证据 —— 需要 /* @closed: ${ch} */ 标记${varHint}。声明了不收口 = 出厂旧装饰残留（双竖条并存类症状）。`,
-        );
-      }
-    }
-
-    // ④ @sid 强制（零证据 = 壳层零规则；有证据缺标记 = 降级 WARN 促标记）
-    const hasSid = markedSids.has(change.id);
-    if (!hasSid) {
-      const visRule = change.visible === false ? visibleClosureRule(change) : null;
-      if (change.visible === false && !visRule) {
-        // E6 已就同一根因报 ERROR，此处不重复
-      } else if (demanded.length && allClosed) {
-        warn("E15", `${change.id} 的收口已有落点证据，但缺 /* @sid: ${change.id} */ 标记 —— 补标记使「变更集 ↔ 设计层」逐条对账可机读（G3）。`);
-      } else if (change.visible === false && visRule) {
-        warn("E15", `${change.id} 的 display:none 收口已落（E6 ✓），但缺 /* @sid: ${change.id} */ 标记 —— 补标记使逐条对账可机读。`);
-      } else {
-        const forms = entry.forms && typeof entry.forms === "object" ? entry.forms : {};
-        const isDefaultForm = typeof change.form === "string" && /出厂默认|默认形态|default/i.test(String(forms[change.form] || ""));
-        const hasOps = Array.isArray(change.structure_ops) && change.structure_ops.length > 0;
-        const hasInner = typeof change.suppress_inner === "string" && change.suppress_inner.trim().length > 0;
-        const hasTextNone = change.style?.text_visible === "none";
-        const otherPayload = hasOps || hasInner || hasTextNone || demanded.length > 0;
-        if (isDefaultForm && !otherPayload) {
-          warn("E15", `${change.id} 的 form="${change.form}" 是出厂默认形态（无需新增规则），但缺 /* @sid: ${change.id} */ 标记 —— 建议补标记。`);
-        } else if (hasOps && !otherPayload) {
-          warn("E15", `${change.id} 的 structure_ops 由 parser G2 施工证据闸取证；设计层建议补 /* @sid: ${change.id} */ 标记。`);
-        } else {
-          err(
-            "E15",
-            `${change.id} 的结构性声明在设计层零落点证据（无 @sid 标记、无 @closed 兑现标记、无收口规则）—— 壳层零规则，声明悬空（例：collapse_trigger.form=header_inline 声明后壳层无任何规则）。每条结构性声明必须在设计层留机读标记：/* @sid: <语义ID> */。`,
-          );
-        }
-      }
-    }
-  }
-
-  // ⑤ 反向对账：设计层收口了变更集未声明的通道 → 台账失真
-  for (const ch of closedMarkers) {
-    const owners = changes
-      .map((c) => ({ c, e: dictSidMap.get(c?.id) }))
-      .filter(({ e }) => e && channelNamesOf(e).has(ch));
-    if (!owners.length) continue; // 不属于本变更集涉及的点位（历史层），不判
-    const accounted = owners.some(
-      ({ c, e }) =>
-        (Array.isArray(c.suppress) ? c.suppress.includes(ch) : false) ||
-        (extractSuppressRulesAudit(e)[c.form] || []).includes(ch),
-    );
-    if (!accounted) {
-      warn(
-        "E15",
-        `设计层 /* @closed: ${ch} */ 收口了通道，但变更集未声明该收口（涉及点位：${owners.map((o) => o.c.id).join("、")}）—— 台账失真：收口记录进不了 D13 继承链，下轮漏抄即出厂形态复现。`,
-      );
-    }
-  }
-  if (!errors.some((e) => e.id === "E15") && !warnings.some((w) => w.id === "E15")) {
-    info("E15", "结构声明兑现：form/suppress 全部落在词典已知通道且设计层有落点证据 ✓");
-  }
-})();
-
-// ── @sid 标记覆盖率（可选增强） ─────────────────────────────
-(function checkSidCoverage() {
-  const marked = new Set([...designCss.matchAll(/@sid\s*:\s*([\w.$-]+)/g)].map((m) => m[1]));
-  if (!marked.size) {
-    info("SID", "设计层未使用 @sid 标记；建议每条设计层规则上方标注 /* @sid: <语义ID> */，即可启用「变更集 ↔ 设计层」逐条覆盖对账。");
-    return;
-  }
-  const declared = new Set((changeset?.changes || []).map((c) => c.id));
-  const missing = [...declared].filter((sid) => !marked.has(sid));
-  for (const sid of missing) {
-    warn("SID", `变更集声明了 ${sid}，但设计层没有对应 @sid 标记 —— 无法证明该条已落到样式/结构。`);
-  }
-  info("SID", `@sid 覆盖率：${declared.size - missing.length}/${declared.size}`);
-})();
-
-// ── 输出 ────────────────────────────────────────────────────
-// ── E11 交付完整性 ──────────────────────────────────────────
-// 「落地后只剩主题色」不是落点问题，是上游交付残缺口 + 下游挑拣落地。本项把这两件事都变成 ERROR。
-(function checkE11() {
-  if (!changeset) {
-    warn(
-      "E11",
-      `未发现变更集（搜索 ${CHANGESET_DIRS.join(" / ")}）—— 本轮交付完整性、收口断言、浮层残留、形态收口均无法判定（闸门静默跳过）。设计还原项目跑不出变更集，本身就是交付缺失。`,
-    );
-    return;
-  }
-  const mode = changeset.mode;
-  const cov = changeset.coverage;
-  const gaps = (cov && cov.gaps) || [];
-  const pending = changeset.pending || [];
-  const changes = changeset.changes || [];
-  const notesText = JSON.stringify(changeset.notes || []);
-
-  if (mode !== "restore") {
-    err(
-      "E11",
-      `mode 必须为 "restore"（实为 ${JSON.stringify(changeset.mode ?? null)}）：` +
-        `还原任务的目标是把设计 100% 落地到项目，环境受限 / 覆盖不足 / 意图不明时唯一正确动作是停下向用户多轮询问确认，不得缩水交付。`,
-    );
-    return;
-  }
-  if (!cov) {
-    err("E11", "mode=restore 但缺少 coverage 通道 —— 还原交付必须有覆盖率记账；缺失即无法判定登记项是否逐条兑现，落地只会剩下主题色一类全局项。");
-    return;
-  }
-  const R = cov.registrable;
-  const A = cov.applicable;
-  const C = cov.covered;
-  const numeric = typeof A === "number" && typeof C === "number";
-  if (numeric && C < A) {
-    err(
-      "E11",
-      `欠声明：coverage.covered=${C} < applicable=${A}（登记项 registrable=${R}）—— 有 ${A - C} 条登记项未落进 changes[] / visible / pending。落地端只能兑现已声明的那部分，其余点位零变化，这就是「和设计对不上、只变了主题色」的机制成因。`,
-    );
-  }
-  if (gaps.length) {
-    err("E11", `coverage.gaps 非空（${gaps.length} 条）—— 交付契约要求 gaps 为空才可交付（自由文本理由不算闭合资质）。`);
-    if (!pending.length) {
-      err(
-        "E11",
-        `缺口未台账化：gaps 有 ${gaps.length} 条理由，但 pending[] 为空 —— 缺口没有变成可执行工作项，所以「继续」时无任何东西可做，复跑也不可能收敛（症状：多轮继续后效果不变）。`,
-      );
-    } else {
-      const declared = new Set(changes.map((c) => c.id));
-      const orphan = pending.filter((p) => p && p.proposed_id && !declared.has(p.proposed_id));
-      if (orphan.length) {
-        err("E11", `pending 中 ${orphan.length} 条未在 changes[] 双写（${orphan.slice(0, 5).map((p) => p.proposed_id).join("、")}）—— 只写 pending 的点位不会被施工。`);
-      }
-    }
-  }
-  // 分母漂移：自报 registrable 必须与设计侧登记表实物一致
-  if (typeof R === "number" && cov.registry) {
-    const cands = [
-      path.join(SKILL_ROOT, "..", "project-ui-design", "references", "page-specs", String(cov.registry)),
-      path.join(SKILL_ROOT, "..", "project-ui-design", String(cov.registry)),
-    ].map((p) => path.resolve(p));
-    const real = cands.find((p) => fs.existsSync(p));
-    if (real) {
-      try {
-        const reg = JSON.parse(fs.readFileSync(real, "utf-8"));
-        const items = reg.items || reg.registry || [];
-        if (Array.isArray(items) && items.length && items.length !== R) {
-          err("E11", `登记表分母漂移：coverage.registrable=${R}，登记表实物为 ${items.length} 条 —— 自报数与实物不一致。分母错则该报的欠声明数也不可信。`);
-        } else if (Array.isArray(items) && items.length) {
-          info("E11", `登记表分母对账：registrable=${R} = 实物 ${items.length} 条 ✓`);
-        }
-      } catch {
-        /* 解析异常忽略 */
-      }
-    } else {
-      warn("E11", `登记表实物未解析到（coverage.registry="${cov.registry}"）—— 项目侧 G9 身份闸会以「登记表实物不存在」拒绝执行；覆盖率分母必须来自「方案 × 场景」的真实登记表。`);
-    }
-  }
-  // 交付说明失真：notes 的成功话术与机器可读字段矛盾
-  const claimsComplete = /covered\s*[=＝]\s*applicable|gaps\s*[=＝]\s*\[\s*\]|覆盖率\s*100|全量覆盖/.test(notesText);
-  if (claimsComplete && ((numeric && C < A) || gaps.length)) {
-    err(
-      "E11",
-      `交付说明失真：notes 含「覆盖率 C=A / gaps=[] / 全量覆盖」类完成结论，而字段实为 covered=${C}/applicable=${A}、gaps=${gaps.length} 条 —— 成功话术与机器可读字段互相矛盾，会直接误导下游判定「已交付、无事可做」。`,
-    );
-  }
-  if (!errors.some((e) => e.id === "E11") && !warnings.some((w) => w.id === "E11")) {
-    info("E11", `交付完整性：mode=restore，covered=${C}=applicable=${A}，gaps 空，台账闭合 ✓`);
-  }
-})();
-
-// ── E12 设计层累积性（跨轮回退检测 + 交付台账） ──────────────
-// 「继续一次处理不完、继续了也没变化」的根治：把每轮落地状态落成机器可读台账，
-// 使「本轮是否把上一轮成果覆盖掉」可被断言，而不是靠人记得。
-const LEDGER_PATH = path.join(PROJECT, ".design", "ledger.json");
-const WRITE_LEDGER = !process.argv.includes("--no-ledger");
-(function checkE12() {
-  const primaryText = srcTextByFile.get(PRIMARY_LAYER) ?? readIf(PRIMARY_LAYER) ?? "";
-  const primaryLines = primaryText ? primaryText.split("\n").length : 0;
-  const appliedSids = changeset ? (changeset.changes || []).map((c) => c.id).sort() : [];
-  const cov = changeset && changeset.coverage;
-  const cur = {
-    at: new Date().toISOString(),
-    changeset: changesetFile ? relp(changesetFile) : null,
-    mode: changeset ? changeset.mode ?? null : null,
-    covered: cov ? cov.covered : null,
-    applicable: cov ? cov.applicable : null,
-    design_shell_lines: primaryLines,
-    applied_sids: appliedSids,
-  };
-
-  let ledger = null;
-  if (fs.existsSync(LEDGER_PATH)) {
-    try {
-      ledger = JSON.parse(fs.readFileSync(LEDGER_PATH, "utf-8"));
-    } catch {
-      ledger = null;
-    }
-  }
-  const history = (ledger && ledger.history) || [];
-  const priorRounds = ledger ? [ledger, ...history] : [];
-
-  if (!ledger) {
-    info("E12", `无交付台账（${relp(LEDGER_PATH)}）—— 无法检测「本轮是否覆盖掉上一轮设计层」；已写入本轮台账作为基线。`);
-  } else {
-    // 与历史峰值比较，避免「坏一轮 → 台账被改写 → 下轮检测不出」的掩盖效应
-    const peakLines = Math.max(0, ...priorRounds.map((r) => r.design_shell_lines || 0));
-    if (peakLines && primaryLines && primaryLines < peakLines * 0.6) {
-      err(
-        "E12",
-        `交付回退：设计层 ${argValue("--design-layer", "src/styles/design-shell.scss")} 行数 ${peakLines} → ${primaryLines}（骤降 >40%）—— 上一轮已落地的规则被覆盖/丢失。设计层是累积产物，禁止按「出厂空文件」重建；重建必须合并既有规则（否则用户侧表现为「布局样式全不对，只剩主题色」）。`,
-      );
-    }
-    const priorSids = new Set(priorRounds.flatMap((r) => r.applied_sids || []));
-    const lost = [...priorSids].filter((s) => !appliedSids.includes(s));
-    if (priorSids.size && lost.length > Math.max(3, priorSids.size * 0.3)) {
-      err("E12", `交付回退：本轮变更集比历史已声明点位少 ${lost.length} 条（${lost.slice(0, 6).join("、")}${lost.length > 6 ? "…" : ""}）—— 本轮只覆盖了更小范围，按现状落地会把上一轮成果清掉。`);
-    } else if (priorSids.size && lost.length) {
-      warn(
-        "E12",
-        `本轮未覆盖历史已声明点位 ${lost.length} 条（${lost.slice(0, 6).join("、")}${lost.length > 6 ? "…" : ""}）—— 若本轮 scope（coverage.page_types）确实不含这些点位可忽略；否则它们会从项目里静默消失。`,
-      );
-    } else if (priorSids.size) {
-      info("E12", `累积性：本轮 ${appliedSids.length} 条 vs 历史已声明 ${priorSids.size} 条，未检出回退`);
-    }
-  }
-
-  if (WRITE_LEDGER) {
-    const next = { round: ledger ? (ledger.round || 1) + 1 : 1, ...cur, history: [...history, ...(ledger ? [ledger] : [])].slice(0, 20) };
-    for (const r of next.history) delete r.history;
-    fs.mkdirSync(path.dirname(LEDGER_PATH), { recursive: true });
-    fs.writeFileSync(LEDGER_PATH, JSON.stringify(next, null, 2), "utf-8");
-  }
-})();
-
-// 列名提取（供 E5/E14 共用）：兼容 `label: $t('类型')` / `label="类型"` 两种写法
-const labelOfRaw = (src) => {
-  const m =
-    src.match(/label:\s*([^,\n}]+)/) || src.match(/\blabel="([^"]*)"/) || src.match(/\blabel='([^']*)'/);
-  if (!m) return "?";
-  const s = String(m[1]).trim();
-  const q = s.match(/[`'"]([^`'"]+)[`'"]/);
-  return ((q ? q[1] : s).trim() || "?");
-};
-
-// ── E13 固定尺寸 vs 内容度量 ─────────────────────────────────
-// 「设计说 40px，代码就固定 40px」是本闸治理的对象：像素值不是照抄依据，
-// 而是「该容器要装多少内容」的结论。固定宽容器装不下内容、又没声明收口/截断
-// 兜底时，文字会换行、被压缩、甚至字符重叠渲染成畸形。
-// 判据分两档：① 选择器语义指向文本容器 → 最小需求 = 2 CJK + 左右内边距；
-//            ② 其余固定宽 → 低于 24px 连一个字形都放不下。
-// 文本承载语义：只认「这个盒子本身要装字」的选择器；图形载体（图标 / 伪元素 /
-// 分割线 / 开关）不承载文本，不参与内容度量，否则会成片误报。
-const TEXTY_SEL = /(text|title|label|button|tab|span|desc)/i;
-const GRAPHIC_LAST = /(el-icon|icon|svg|img|checkbox|radio|switch|avatar|divider|arrow|star|loading|spinner)|::(before|after|placeholder|marker|selection)/i;
-const MIN_TEXT_BOX = 44;
-const MIN_ANY_BOX = 24;
-(function checkE13() {
-  if (!designRules.length) {
-    info("E13", "固定尺寸内容度量：无设计层规则");
-    return;
-  }
-  // 项目源码里真实存在的类名（排除设计层自身）——用于剔除「挂空选择器」，
-  // 挂空由 E4 单独报，此处只管「锚点存在但装不下内容」。
-  const projectClasses = new Set();
-  for (const [f, t] of srcTextByFile) {
-    if (designSet.has(path.resolve(f))) continue;
-    for (const m of t.matchAll(/class\s*[:=]\s*["'`]([^"'`]+)["'`]/g)) {
-      for (const c of m[1].split(/[\s{}(),:$'"]+/)) if (/^[A-Za-z][\w-]*$/.test(c)) projectClasses.add(c);
-    }
-  }
-  // 同一选择器上的「兄弟规则」也算保护来源（收口常写成独立规则块）
-  const hasProtect = (decls) =>
-    String(decls.overflow || "").match(/hidden|clip/) ||
-    String(decls["text-overflow"] || "").match(/ellipsis/) ||
-    String(decls.display || "").match(/none/);
-  const protectBySel = new Set();
-  for (const r of designRules) {
-    if (hasProtect(r.decls)) protectBySel.add(r.selector);
-  }
-  const hits = [];
-  for (const r of designRules) {
-    const raw = r.decls.width;
-    if (raw == null) continue;
-    if (r.decls["min-width"] != null || r.decls["max-width"] != null) continue;
-    const m = String(raw).match(/^(\d+(?:\.\d+)?)\s*px$/i);
-    if (!m) continue;
-    const n = Number(m[1]);
-    const isTexty = TEXTY_SEL.test(r.selector);
-    const floor = isTexty ? MIN_TEXT_BOX : MIN_ANY_BOX;
-    if (n >= floor) continue;
-    if (hasProtect(r.decls)) continue;
-    if (protectBySel.has(r.selector)) continue;
-    if (GRAPHIC_LAST.test(lastCompound(r.selector)) || GRAPHIC_LAST.test(r.selector)) continue;
-    const toks = classTokens(r.selector);
-    if (toks.length && !toks.some((c) => projectClasses.has(c))) continue; // 挂空 → 交 E4
-    hits.push({ r, n, floor, isTexty });
-  }
-  for (const h of hits.slice(0, 8)) {
-    err(
-      "E13",
-      `${relp(h.r.file)}：\`${h.r.selector}\` 固定 width:${h.n}px —— ` +
-        (h.isTexty
-          ? `该选择器指向文本容器，装下 2 个汉字 + 内边距至少需 ${h.floor}px`
-          : `低于任何字形盒子的下限 ${h.floor}px`) +
-        `；且未声明收口兜底（overflow:hidden / text-overflow:ellipsis / display:none）。` +
-        `固定宽小于内容需求时文字会换行、被压缩或重叠渲染 —— ` +
-        `请改为内容驱动（min-width / 自适应），或在同一作用域内显式写出收口策略（形态收容 + 文案隐藏成对）。`,
-    );
-  }
-  if (hits.length > 8) err("E13", `固定尺寸内容度量：另有 ${hits.length - 8} 处未列出。`);
-  if (!hits.length) info("E13", `固定尺寸内容度量：${designRules.length} 条设计层规则中未检出「固定宽 < 内容下限且无收口」`);
-})();
-
-// ── E14 列宽预算链自洽（列定义宽 vs 实际 td 内边距）──────────
-// 列宽与内容需求必须用同一套「可用宽」口径。实例：列宽公式按单元格留白 24px
-// 推算，而设计层把 td padding 设为 16px（左右共 32px）→ 列宽比真实可用宽多算
-// 8px，内容必然溢出、被内层盒压缩 → 操作按钮文字换行 / 重叠。
-(function checkE14() {
-  const tableFiles = [...srcTextByFile.entries()].filter(([, t]) => t.includes("el-table-column"));
-  if (!tableFiles.length) {
-    info("E14", "列宽预算链：未在 src 中发现 el-table-column");
-    return;
-  }
-  // 设计层对数据格宿主的水平内边距（实际生效值）
-  let tdPadX = null;
-  for (const r of designRules) {
-    if (!/td\.el-table__cell|\.el-table__body\s+td/.test(r.selector)) continue;
-    const p = r.decls.padding;
-    if (!p) continue;
-    const parts = String(p).replace(/!important/g, "").trim().split(/\s+/);
-    const px = (v) => {
-      const mm = String(v).match(/(\d+(?:\.\d+)?)px/);
-      return mm ? Number(mm[1]) : null;
-    };
-    const vals = parts.map(px).filter((v) => v != null);
-    if (!vals.length) continue;
-    // padding: A → 四边 A；A B → 上下 A 左右 B；A B C → 上 A 左右 B 下 C
-    const x = vals.length === 1 ? vals[0] : vals.length === 2 ? vals[1] : vals.length === 3 ? vals[1] : vals[3];
-    tdPadX = x * 2;
-    break;
-  }
-  // 操作列：内容需求 = 平铺槽数 × 槽宽（与组件同源公式）
-  const slotW = (() => {
-    const src = readIf(path.join(PROJECT, "src", "components", "ReTableOperate", "utils.ts"));
-    if (!src) return null;
-    const moreChars = Number((src.match(/MORE_LABEL_CHARS\s*=\s*(\d+)/) || [])[1] || 3);
-    const fsMatch = src.match(/default:\s*(\d+)/);
-    const fs = fsMatch ? Number(fsMatch[1]) : 14;
-    const btnSrc = [...srcTextByFile.entries()].find(([, t]) => /operateButtons\s*(?::[^=]+)?=\s*\[/.test(t));
-    let maxChars = 2;
-    if (btnSrc) {
-      const arr = matchArrayLiteral(btnSrc[1], /operateButtons\s*(?::[^=]+)?=\s*\[/);
-      if (arr) for (const obj of extractObjectLiterals(arr)) {
-        const lm = obj.match(/label\s*:\s*(?:\$t\()?['"`]([^'"`]+)/);
-        if (lm) maxChars = Math.max(maxChars, [...lm[1]].length);
-      }
-    }
-    maxChars = Math.max(maxChars, moreChars);
-    return Math.ceil(fs + 4 + maxChars * fs);
-  })();
-  for (const [file, text] of tableFiles) {
-    const rel = relp(file);
-    const arr = matchArrayLiteral(text, /(?:const|let|var)\s+\w*[Cc]olumn\w*\s*(?::[^=]+)?=\s*\[/);
-    if (!arr) continue;
-    const limMatch = text.match(/operateLimit\s*=\s*(\d+)/);
-    const limit = limMatch ? Number(limMatch[1]) : null;
-    for (const objSrc of extractObjectLiterals(arr)) {
-      const prop = (objSrc.match(/prop:\s*[`'"]([^`'"]+)/) || [])[1];
-      if (!prop) continue;
-      const label = labelOfRaw(objSrc);
-      const ops = /^(operate|operation|actions)$/.test(prop);
-      const wLit = (objSrc.match(/\bwidth\s*:\s*[`'"]([\d.]+)px/) || [])[1];
-      const colW = wLit ? Number(wLit) : null;
-      if (!ops) continue;
-      // 模板是否用公式覆盖了列定义字面量 —— 「同一尺寸两个来源」的第一现场
-      const usesFormula = /resolveOperateColumnWidth\s*\(/.test(text);
-      if (colW == null && !usesFormula) continue;
-      if (slotW == null || limit == null) {
-        warn("E14", `${rel}：操作列「${label}」无法解析槽宽/平铺上限（ReTableOperate/utils.ts 或 operateLimit 缺失），跳过列宽预算链核对。`);
-        continue;
-      }
-      const utilSrc = readIf(path.join(PROJECT, "src", "components", "ReTableOperate", "utils.ts")) || "";
-      const padInFormula = Number((utilSrc.match(/cellPadding\s*=\s*options\.cellPadding\s*\?\?\s*(\d+)/) || [])[1] || 24);
-      const formulaW = limit * slotW + padInFormula;
-      const effectiveW = usesFormula ? formulaW : colW != null ? colW : formulaW;
-      const contentNeed = limit * slotW;
-      const available = tdPadX != null ? effectiveW - tdPadX : effectiveW - padInFormula;
-      if (usesFormula && colW != null && colW !== formulaW) {
-        err(
-          "E14",
-          `${rel}：操作列「${label}」列宽有两个来源且不一致 —— 列定义写死 width="${wLit}px"，` +
-            `但模板用 \`resolveOperateColumnWidth()\` 覆盖为 ${formulaW}px（${limit}×${slotW}+${padInFormula}），实际生效 ${effectiveW}px。` +
-            `同一尺寸不得有两个权威来源：请删掉列定义里的死值，只保留公式（或反之），否则改一处不生效、排查时按死值反推必然误判。`,
-        );
-      }
-      if (contentNeed > available) {
-        err(
-          "E14",
-          `${rel}：操作列「${label}」列宽预算链断裂 —— 列宽 ${effectiveW}px（${colW != null ? `列定义 width="${wLit}px"` : `公式 ${limit}×${slotW}+${padInFormula}`}）` +
-            `扣掉实际单元格水平内边距 ${tdPadX != null ? `${tdPadX}px（设计层 td padding）` : `${padInFormula}px（公式默认）`} 后可用 ${available}px，` +
-            `而平铺 ${limit} 个等宽槽需 ${contentNeed}px → 溢出 ${contentNeed - available}px。` +
-            `列宽公式的内置留白必须与实际生效的 td padding 同口径；此处请把列宽抬到 ≥ ${contentNeed + (tdPadX ?? padInFormula)}px，或同步下调内边距，` +
-            `否则按钮文字会被内层盒压缩、换行甚至字符重叠。`,
-        );
-      } else if (tdPadX != null && padInFormula !== tdPadX) {
-        warn(
-          "E14",
-          `${rel}：操作列「${label}」列宽公式内置单元格留白 ${padInFormula}px ≠ 设计层实际 td 水平内边距 ${tdPadX}px —— 当前差额 ${Math.abs(padInFormula - tdPadX)}px 尚未导致溢出，但任一参数变动即越界；建议统一为同一来源。`,
-        );
-      } else {
-        info("E14", `${rel}：操作列「${label}」列宽 ${effectiveW}px，可用 ${available}px ≥ 内容 ${contentNeed}px ✓`);
-      }
-    }
-  }
-})();
-
-// ── E16 引用完整性（交付物指向的实物必须存在）────────────────
-// 标识（文件名 / 路径）变更后未同步引用 = 静默断链：闸门找不到基线图、
-// 项目侧 parser 取不到登记表，全链路降级为「凭印象还原」。
-(function checkE16() {
-  if (!changeset) {
-    info("E16", "引用完整性：未发现变更集");
-    return;
-  }
-  const probes = [
-    ["oracle.mockup", changeset.oracle?.mockup],
-    ["coverage.registry", changeset.coverage?.registry],
-    ["oracle.theme_mapping.mockup", changeset.oracle?.theme_mapping?.mockup],
-  ];
-  let checked = 0;
-  for (const [field, val] of probes) {
-    if (!val || typeof val !== "string") continue;
-    if (/^https?:\/\//.test(val)) continue;
-    checked++;
-    const cands = [
-      path.resolve(PROJECT, val),
-      path.resolve(SKILL_ROOT, val),
-      path.resolve(SKILL_ROOT, "..", val),
-      path.resolve(PROJECT, "..", val),
-      // 设计侧 page-specs 根（效果图 / 登记表以 page-specs 根为相对基座交付）
-      path.resolve(SKILL_ROOT, "..", "project-ui-design", "references", "page-specs", val),
-    ];
-    if (!cands.some((p) => fs.existsSync(p))) {
-      err(
-        "E16",
-        `变更集 \`${field}\` 指向的实物不存在：${val} —— 标识变更（改名 / 换目录）后未同步引用，` +
-          `闸门与 parser 都取不到基线（会静默降级为无基线还原）。请同步引用方（变更集字段 / 方案注册表 baseline / 登记表路径）。`,
-      );
-    }
-  }
-  // restore 模式的顶层 theme 字段：缺失会让「本次主题」回落到 global.brand_primary 反推，
-  // 重新引入「换主题 = 换读取路径」的分叉
-  if (changeset.mode === "restore" && !changeset.theme) {
-    warn(
-      "E16",
-      "变更集 mode=restore 但缺顶层 `theme` 字段 —— 本次主题只能回落按 `global.brand_primary` 反推（旧口径）。补 `theme` 可让「本次主题」与「基线图色板」两个身份各自可机读、互不推断。",
-    );
-  }
-  if (checked && !errors.some((e) => e.id === "E16")) info("E16", `引用完整性：${checked} 个路径引用均可解析到实物 ✓`);
-})();
-
-// ── E17 层间令牌链对账（双层内边距叠加断言）──────────────────
-// 失效模式：父子两层盒共享同一条间距令牌链（--layout-content-padding → --vts-margin），
-// 设计层绕过令牌通道在父层抢写物理 padding，子层同链令牌幸存 → 设计值 + 令牌出厂值叠加
-// （24px + 8px = 32px/侧，「边距很大」）。判据（词典「层间令牌链对账」标记驱动）：
-//   ① 设计层在标记条目的 selector 上抢写物理 padding/margin 属性（非 var 消费）；
-//   ② 该条目同链令牌在项目内仍存在非零定义（子层消费者会叠加取值）。
-// 修复方向：改走令牌通道（重映射 --layout-content-padding / --vts-margin），或归零另一层。
-(function checkE17() {
-  // 从词典收集「层间令牌链对账」条目：selector 主类 ↔ 同链令牌（css_vars 值）与字段名
-  const chainEntries = dictEntries
-    .filter(({ entry }) =>
-      Array.isArray(entry.preconditions) &&
-      entry.preconditions.some((p) => typeof p === "string" && p.includes("层间令牌链对账")))
-    .map(({ sid, entry }) => ({
-      sid,
-      classes: (String(entry.selector || "").match(/\.[\w-]+/g) || []).map((c) => c.slice(1)),
-      vars: Object.values(entry.css_vars || {}).filter((v) => typeof v === "string"),
-      fields: Object.keys(entry.css_vars || {}).filter((k) => /pad|margin/i.test(k)),
-    }))
-    .filter((e) => e.classes.length && e.vars.length);
-
-  if (!chainEntries.length) {
-    info("E17", "层间令牌链对账：词典无标记条目，跳过");
-    return;
-  }
-
-  // 同链令牌在项目内（含设计层）的当前定义值（后者覆盖前者，按样式层叠顺序近似取最后定义）
-  const varValueOf = (name) => {
-    let last = null;
-    for (const t of [projectText, designCss].filter(Boolean)) {
-      const re = new RegExp(`${name.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&")}\\s*:\\s*([^;]+);`, "g");
-      for (const m of t.matchAll(re)) last = m[1].trim();
-    }
-    return last;
-  };
-
-  let checked = 0;
-  for (const { sid, classes, vars, fields } of chainEntries) {
-    for (const rule of designRules) {
-      // 命中条目 selector 的主类（末位复合选择器含任一标记类）
-      const ruleClasses = new Set((rule.selector.match(/\.[\w-]+/g) || []).map((c) => c.slice(1)));
-      if (!classes.some((c) => ruleClasses.has(c))) continue;
-      for (const prop of Object.keys(rule.decls)) {
-        if (!/^(padding|margin)(-(top|right|bottom|left|inline|block))?$/.test(prop)) continue;
-        checked++;
-        const val = String(rule.decls[prop]);
-        // 写的就是 var() 消费 = 令牌通道，合法
-        if (/var\(/.test(val)) continue;
-        // 抢写物理值：同链任一令牌在项目内仍有非零定义 → 双层叠加
-        const survivors = vars
-          .map((v) => ({ v, def: varValueOf(v) }))
-          .filter(({ def }) => def && !/^(0|0px|initial|unset)$/.test(def) && !/var\(/.test(def));
-        if (survivors.length) {
-          err(
-            "E17",
-            `层间令牌链对账：${rule.selector} 的 ${prop}: ${val} 绕过令牌通道抢写物理间距，但同链令牌 ` +
-              `${survivors.map((s) => `${s.v}（当前定义 ${s.def}）`).join("、")} 仍非零 —— 父层设计值与子层令牌值叠加，` +
-              `实际边距 = 两者之和（如 24px + 8px = 32px/侧）。修复：改走令牌通道（在该点位或消费点作用域重映射 ` +
-              `${vars.join(" / ")}，两层同变），或把另一层同链间距归零；仅保留一个权威来源。`,
-          );
-        }
-      }
-    }
-  }
-  if (checked) {
-    if (!errors.some((e) => e.id === "E17")) info("E17", `层间令牌链对账：${checked} 处几何声明均走令牌通道或邻层已归零 ✓`);
-  } else {
-    info("E17", "层间令牌链对账：标记条目无物理几何声明，跳过");
-  }
-})();
-
-// ── E18 激活态消费者存活断言（成对落地 + 伪元素对决）──────────
-// 失效模式：菜单激活态令牌 --vts-theme-menu-active-before 出厂 transparent 且全项目无消费者。
-// 设计侧声明 indicator_* 形态（或 menu_active_indicator 字段）后：
-//   ① 设计层不新建 ::before/::after 消费者 → 令牌仍透明、无消费点，竖条不可见；
-//   ② 建了消费者但令牌从未供值（仍 transparent）→ 消费者渲染但不可见；
-//   ③ 消费者与出厂 sidebar.scss 的同名 ::before 胶囊（specificity 更高 + !important 背景）
-//      对决输了 → 竖条几何整体不渲染。
-// 判据（词典「激活态消费者成对落地」标记驱动）：三者缺一即 ERROR。
-(function checkE18() {
-  const marked = dictEntries
-    .filter(({ entry }) =>
-      Array.isArray(entry.preconditions) &&
-      entry.preconditions.some((p) => typeof p === "string" && p.includes("激活态消费者成对落地")))
-    .map(({ sid, entry }) => ({ sid, entry }));
-  if (!marked.length) {
-    info("E18", "激活态消费者成对落地：词典无标记条目，跳过");
-    return;
-  }
-
-  // 令牌最终定义值（projectText → designCss 顺序近似层叠，取最后定义；支持一层 var 链解析）
-  const finalVarValue = (name, seen = new Set()) => {
-    let last = null;
-    for (const t of [projectText, designCss].filter(Boolean)) {
-      const re = new RegExp(`${name.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&")}\\s*:\\s*([^;]+);`, "g");
-      for (const m of t.matchAll(re)) last = m[1].trim();
-    }
-    if (last == null) return null;
-    const varRef = last.match(/^var\(\s*(--[\w-]+)/);
-    if (varRef && !seen.has(name)) {
-      seen.add(name);
-      const inner = finalVarValue(varRef[1], seen);
-      return inner != null ? inner : last;
-    }
-    return last;
-  };
-
-  for (const { sid, entry } of marked) {
-    const change = (changeset?.changes || []).find((c) => c.id === sid);
-    if (!change) continue;
-    const form = String(change.form || "");
-    const style = change.style && typeof change.style === "object" ? change.style : {};
-    const declaresIndicator =
-      /indicator/.test(form) ||
-      "menu_active_indicator" in style ||
-      Object.keys(style).some((k) => /^active_indicator/.test(k));
-    if (!declaresIndicator) continue;
-
-    const vars = Object.values(entry.css_vars || {})
-      .filter((v) => typeof v === "string" && /active/.test(v));
-    const indicatorVar = vars.find((v) => /before/.test(v)) || vars[0];
-    if (!indicatorVar) continue;
-
-    // 断言①：设计层存在该令牌的消费者（var() 引用）
-    const consumedInDesign = designRules.some((r) =>
-      Object.values(r.decls).some((v) => String(v).includes(`var(${indicatorVar}`)),
-    );
-    if (!consumedInDesign) {
-      err(
-        "E18",
-        `激活态消费者成对落地：${sid} 声明了指示条形态（form=${form || "—"}），但设计层没有任何规则消费 ` +
-          `${indicatorVar} —— 只供值不建消费者 = 未施工（令牌出厂 transparent，全项目无消费点），竖条不可见。` +
-          `修复：在 design-shell 新建 ::before/::after 消费者引用 var(${indicatorVar})。`,
-      );
-      continue;
-    }
-
-    // 断言②：令牌最终定义非 transparent/none/初始值
-    const finalVal = finalVarValue(indicatorVar);
-    if (finalVal && /^(transparent|none|initial|unset|inherit)$/i.test(finalVal.replace(/!important\s*$/i, "").trim())) {
-      err(
-        "E18",
-        `激活态消费者成对落地：${indicatorVar} 消费者已建，但最终定义仍为 ${finalVal.trim()}（出厂中性基线）——` +
-          `消费者在渲染，色值透明 = 竖条不可见。修复：在条目 style_scope（如 .sidebar-container）内显式供值 ` +
-          `（非透明设计色），或在对应 html[data-theme] 主题块确认已有非透明定义。`,
-      );
-    }
-
-    // 断言③（警告级）：消费者是伪元素规则且与出厂胶囊对决——无 !important 背景 / 无提权链则提示
-    const consumerRules = designRules.filter((r) =>
-      Object.values(r.decls).some((v) => String(v).includes(`var(${indicatorVar}`)),
-    );
-    for (const r of consumerRules) {
-      const isPseudo = /::(before|after)/.test(r.selector);
-      const bgImportant = /important/i.test(String(r.decls["background"] || r.decls["background-color"] || ""));
-      const elevated = /(^|\s)html\b[\s>]*body\b/.test(r.selector) || /body\s+\./.test(r.selector);
-      if (isPseudo && !bgImportant && !elevated) {
-        warn(
-          "E18",
-          `激活态消费者成对落地：${r.selector} 消费 ${indicatorVar} 但既无 !important 背景也无 html body 提权链——` +
-            `出厂 sidebar.scss 的同名 ::before 胶囊（!important 背景）对决大概率获胜，指示条几何可能整体不渲染。` +
-            `修复：背景加 !important 或用 html body 前缀提权（词典 priority.strategy=deep_qualified）。`,
-        );
-      }
-    }
-  }
-  const checkedAny = marked.some(({ sid }) => (changeset?.changes || []).some((c) => c.id === sid));
-  if (checkedAny && !errors.some((e) => e.id === "E18") && !warnings.some((w) => w.id === "E18")) {
-    info("E18", "激活态消费者成对落地：消费者存在、令牌非透明、对决权重足够 ✓");
-  }
-})();
-
-const result = { project: PROJECT, errors, warnings, infos };
-
-const CHECK_TITLES = {
-  E1: "变量悬空",
-  E2: "层错位",
-  E3: "层叠败北",
-  E4: "选择器挂空",
-  E5: "列宽预算",
-  E6: "visible:false 收口断言",
-  E7: "激活态越层",
-  E8: "浮层残留",
-  E9: "形态收口缺件",
-  E10: "scoped 规则挂空",
-  E11: "交付完整性",
-  E12: "设计层累积性",
-  E13: "固定尺寸内容度量",
-  E14: "列宽预算链自洽",
-  E16: "引用完整性",
-  E17: "层间令牌链对账",
-  E18: "激活态消费者成对落地",
-  SID: "@sid 覆盖率",
-};
-
-const REPORT_PATH = argValue("--report", null);
-if (REPORT_PATH) {
-  const rel = (p) => path.relative(PROJECT, p).replace(/\\/g, "/");
-  const rows = Object.keys(CHECK_TITLES)
-    .map((id) => {
-      const e = errors.filter((x) => x.id === id).length;
-      const w = warnings.filter((x) => x.id === id).length;
-      return { id, title: CHECK_TITLES[id], e, w };
-    })
-    .filter((r) => r.e || r.w);
-
-  const lines = [
-    "# 设计层闭环审计报告",
-    "",
-    `- 项目：\`${PROJECT}\``,
-    `- 设计层文件：${DESIGN_FILES.map(rel).join("、") || "(未发现)"}`,
-    `- 变更集：${changesetFile ? rel(changesetFile) : "(未发现)"}`,
-    `- 词典条目：${dictEntries.length} ｜ 设计层规则：${designRules.length} ｜ 容器可用宽：${CONTAINER_WIDTH}px${CONTAINER_EXPLICIT ? "" : "（估值，用 --container-width 校准）"}`,
-    `- 结论：**ERROR ${errors.length} ｜ WARN ${warnings.length}**`,
-    "",
-    "## 命中分布",
-    "",
-    "| 检查项 | 含义 | ERROR | WARN |",
-    "|---|---|---|---|",
-    ...rows.map((r) => `| ${r.id} | ${r.title} | ${r.e} | ${r.w} |`),
-    "",
-    "## 待修项（ERROR）",
-    "",
-    ...(errors.length ? errors.map((e, i) => `${i + 1}. **[${e.id}] ${CHECK_TITLES[e.id] || ""}** — ${e.msg}`) : ["（无）"]),
-    "",
-    "## 提示项（WARN）",
-    "",
-    ...(warnings.length ? warnings.map((w, i) => `${i + 1}. **[${w.id}] ${CHECK_TITLES[w.id] || ""}** — ${w.msg}`) : ["（无）"]),
-    "",
-    "## 已通过项",
-    "",
-    ...(infos.length ? infos.map((i) => `- [${i.id}] ${i.msg}`) : ["（无）"]),
-    "",
-    `> 复跑：\`node scripts/design-audit.mjs --project "${PROJECT}" --container-width ${CONTAINER_WIDTH}\``,
-    "",
-  ];
-  const out = path.resolve(REPORT_PATH);
-  fs.mkdirSync(path.dirname(out), { recursive: true });
-  fs.writeFileSync(out, lines.join("\n"), "utf-8");
-  console.log(`\n审计报告已写入：${out}`);
-}
-
-if (AS_JSON) {
-  console.log(JSON.stringify(result, null, 2));
-} else {
-  console.log("\n设计层闭环审计\n");
-  console.log(`项目: ${PROJECT}`);
-  console.log(`设计层文件: ${DESIGN_FILES.map((f) => path.relative(PROJECT, f).replace(/\\/g, "/")).join(", ") || "(未发现)"}`);
-  console.log(`变更集: ${changesetFile ? path.relative(PROJECT, changesetFile) : "(未发现)"}`);
-  console.log(`词典条目: ${dictEntries.length} | 设计层规则: ${designRules.length}\n`);
-  for (const i of infos) console.log(`  · [${i.id}] ${i.msg}`);
-  for (const w of warnings) console.log(`  ! [${w.id}] ${w.msg}`);
-  for (const e of errors) console.log(`  \u2717 [${e.id}] ${e.msg}`);
-  console.log(`\n${"=".repeat(50)}`);
-  console.log(`闭环审计：ERROR ${errors.length} | WARN ${warnings.length}`);
-  if (errors.length) {
-    console.log("\n\u2717 设计层存在「声明了却不会生效 / 形态未落地」的问题，修复后重跑。\n");
-  } else {
-    console.log("\n\u2713 设计层闭环审计通过（样式声明均已具备生效条件）。\n");
-  }
-}
-
-process.exit(errors.length ? 1 : 0);