@qilitt-mickey/vue3-temp-skill 1.1.65 → 1.1.67

package/scripts/design-audit.mjs

@@ -27,6 +27,11 @@
  *   E8 浮层残留      form 要求收口下拉浮层，但组件仍消费 #dropdown
  *   E9 形态收口缺件  form=icon_only 只显图标、未在同一作用域内收口文案（且不被兄弟变体规则骗过）
  *   E10 scoped 挂空  组件 scoped 规则依赖运行时并不存在的类（重构残留，永不命中）
+ *   E11 交付完整性   mode=restore 时 covered<applicable / gaps 非空 / 缺口未台账化 / 分母漂移 / notes 与字段矛盾
+ *   E12 设计层累积性  变更集点位或设计层行数相对历史骤降（上一轮成果被覆盖）→ 写交付台账 .codebuddy/design/ledger.json
+ *   E13 固定尺寸内容度量 固定 width 小于内容需求且无收口兜底 → 文字换行/压缩/重叠
+ *   E14 列宽预算链自洽  列宽（含公式）扣掉实际 td 内边距后装不下内容 → 操作列按钮被压
+ *   E16 引用完整性   变更集引用的实物不存在（改名未同步）/ restore 缺顶层 theme
  */
 
 import fs from "fs";
@@ -249,19 +254,42 @@ const designRules = DESIGN_FILES.flatMap((f) =>
 const PRIMARY_LAYER = path.resolve(PROJECT, argValue("--design-layer", "src/styles/design-shell.scss"));
 const isPrimary = (file) => path.resolve(file) === PRIMARY_LAYER;
 
-// 变更集（取 .codebuddy/design 下第一个 changeset-*.json）
-const designDir = path.join(PROJECT, ".codebuddy", "design");
+// 变更集发现：落点历史上不唯一（.codebuddy/design 与项目根 design/ 都出现过）。
+// 硬编码单一目录的代价是「变更集搬家 → 闸门静默跳过」（2026-09-23 实证：E6/E8/E9 全跳过而无人察觉）。
+const CHANGESET_DIRS = [".codebuddy/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 (fs.existsSync(designDir)) {
-  const cand = fs.readdirSync(designDir).filter((f) => /^changeset.*\.json$/i.test(f)).sort();
-  if (cand.length) {
-    changesetFile = path.join(designDir, cand[0]);
-    try {
-      changeset = JSON.parse(fs.readFileSync(changesetFile, "utf-8"));
-    } catch (e) {
-      err("E0", `变更集解析失败：${changesetFile} — ${e.message}`);
-    }
+if (changesetCandidates.length > 1) {
+  warn(
+    "E11",
+    `多份变更集并存：${changesetCandidates.map(relp).join("、")} —— 无法判定哪份是「本轮」交付物，暂取最近修改的一份。落点应唯一为 .codebuddy/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}`);
   }
 }
 
@@ -584,7 +612,29 @@ function matchArrayLiteral(text, anchorRe) {
       }
     }
 
-    const realNoWidth = noWidth.filter((c) => !OPS.includes(c.prop));
+    // 模板里按 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",
@@ -792,6 +842,381 @@ const lastClassOutsideNot = (sel) => {
 })();
 
 // ── 输出 ────────────────────────────────────────────────────
+// ── E11 交付完整性 ──────────────────────────────────────────
+// 「落地后只剩主题色」不是落点问题，是上游交付残缺口 + 下游挑拣落地。本项把这两件事都变成 ERROR。
+(function checkE11() {
+  if (!changeset) {
+    warn(
+      "E11",
+      `未发现变更集（搜索 ${CHANGESET_DIRS.join(" / ")}）—— 本轮交付完整性、收口断言、浮层残留、形态收口均无法判定（闸门静默跳过）。设计还原项目跑不出变更集，本身就是交付缺失。`,
+    );
+    return;
+  }
+  const mode = changeset.mode || "design";
+  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") {
+    info("E11", `交付模式 mode=${mode}（规范设计 / 显式轻量调整），跳过覆盖率硬闸；但若本次本意是场景还原，则「还原被降级为 design」= 交付失败。`);
+    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} 条 —— 自报数与实物不一致（曾发生 186 对 190）。分母错则该报的欠声明数也不可信。`);
+        } 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, ".codebuddy", "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 || "design" : 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%）—— 上一轮已落地的规则被覆盖/丢失。设计层是累积产物，禁止按「出厂空文件」重建；重建必须合并既有规则。（2026-09-23 实证：620 行被覆盖为 75 行，用户侧表现为「布局样式全不对，只剩主题色」。）`,
+      );
+    }
+    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),
+    ];
+    if (!cands.some((p) => fs.existsSync(p))) {
+      err(
+        "E16",
+        `变更集 \`${field}\` 指向的实物不存在：${val} —— 标识变更（改名 / 换目录）后未同步引用，` +
+          `闸门与 parser 都取不到基线（会静默降级为无基线还原）。请同步引用方（变更集字段 / 方案注册表 baseline / 登记表路径）。`,
+      );
+    }
+  }
+  // restore 模式的顶层 theme 字段：缺失会让「本次主题」回落到 global.brand_primary 反推，
+  // 重新引入「换主题 = 换读取路径」的分叉
+  if ((changeset.mode || "design") === "restore" && !changeset.theme) {
+    warn(
+      "E16",
+      "变更集 mode=restore 但缺顶层 `theme` 字段 —— 本次主题只能回落按 `global.brand_primary` 反推（旧口径）。补 `theme` 可让「本次主题」与「基线图色板」两个身份各自可机读、互不推断。",
+    );
+  }
+  if (checked && !errors.some((e) => e.id === "E16")) info("E16", `引用完整性：${checked} 个路径引用均可解析到实物 ✓`);
+})();
+
 const result = { project: PROJECT, errors, warnings, infos };
 
 const CHECK_TITLES = {
@@ -805,6 +1230,11 @@ const CHECK_TITLES = {
   E8: "浮层残留",
   E9: "形态收口缺件",
   E10: "scoped 规则挂空",
+  E11: "交付完整性",
+  E12: "设计层累积性",
+  E13: "固定尺寸内容度量",
+  E14: "列宽预算链自洽",
+  E16: "引用完整性",
   SID: "@sid 覆盖率",
 };