@qilitt-mickey/vue3-temp-skill 1.1.43 → 1.1.45

package/parser/index.js

@@ -18,12 +18,13 @@
  *   node parser/index.js match --batch <dir>                # 项目级批量匹配目录下全部变更集
  *   node parser/index.js list [--scene admin] [--verbose]   # 列出全部语义 ID（--verbose 含字段与形态）
  *   node parser/index.js query <semantic.id>                # 查询单个 ID 映射详情
- *   node parser/index.js audit --project <dir> [<cs…>]      # 挂载点存在性 + 死通道静态审计（V3.2）
- *   node parser/index.js verify --oracle <o> --actual <a>    # 渲染态逐点验收：computed style 期望 vs 实测 diff（V3.2）
+ *   node parser/index.js audit --project <dir> [<cs…>]      # 挂载点存在性 + 死通道静态审计（）
+ *   node parser/index.js verify --oracle <o> --actual <a>    # 渲染态逐点验收：computed style 期望 vs 实测 diff（）
+ *   node parser/index.js registry <registry.json>            # 登记表通道核验：登记项 sid / dims 是否在词典有落点（）
  *   node parser/watch.js                                    # 开发态监听 mapping/ 自动重编译（§3.4.3）
  */
 
-import { readFileSync, statSync, readdirSync } from "node:fs";
+import { readFileSync, statSync, readdirSync, existsSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { buildMappingDataset } from "./loader.js";
@@ -40,20 +41,20 @@ const QUALITATIVE_RE = /^(中等|加粗|常规|细|粗|小圆角|全圆角|直
 const NUMERIC_VALUE_RE = /^\d+(\.\d+)?(px|rem|em|%|vh|vw|pt)$/i;
 /** 复合样式字面量：含空格的多段值（如 1px solid #F0F0F0）按已消歧处理（hex 已被禁词校验限定位置） */
 const COMPOSITE_VALUE_RE = /\s/;
-/** V3.2 落点层级枚举（与词典 validator 的 LAYER_ENUM 一致） */
+/**  落点层级枚举（与词典 validator 的 LAYER_ENUM 一致） */
 const LAYER_VALUES = ["host", "inner"];
 /** 语义 ID 严格格式（apply_via 锚点名须符合） */
 const ID_RE_STRICT = /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*){1,3}$/;
 
-/** V3.2 audit：审计时跳过的目录（依赖 / 产物 / 缓存） */
+/**  audit：审计时跳过的目录（依赖 / 产物 / 缓存） */
 const AUDIT_SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".output", ".vite", ".nuxt", "coverage", "public"]);
-/** V3.2 audit：「模板 / 脚本」扩展名：命中 = 结构挂载 */
+/**  audit：「模板 / 脚本」扩展名：命中 = 结构挂载 */
 const STRUCT_EXT = new Set([".vue", ".html", ".htm", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
-/** V3.2 audit：「样式」扩展名：只命中样式 = 仅样式定义、无结构挂载 */
+/**  audit：「样式」扩展名：只命中样式 = 仅样式定义、无结构挂载 */
 const STYLE_EXT = new Set([".scss", ".sass", ".css", ".less", ".styl"]);
-/** V3.2 audit：设计层文件特征（只命中设计层 = 无实际挂载） */
+/**  audit：设计层文件特征（只命中设计层 = 无实际挂载） */
 const DESIGN_LAYER_RE = /design-shell|design-layer|design\.scss/i;
-/** V3.2 audit：组件库运行时渲染的裸类名（无 el- 前缀，但不由业务源码挂载） */
+/**  audit：组件库运行时渲染的裸类名（无 el- 前缀，但不由业务源码挂载） */
 const BUILTIN_BARE_CLASSES = new Set(["cell", "cell-group", "row", "header", "body", "caret-wrapper", "sort-caret", "ascending", "descending", "expanded-cell", "el-tooltip", "text", "value", "label"]);
 
 main();
@@ -84,6 +85,8 @@ function main() {
       return cmdAudit(args, dataset);
     case "verify":
       return cmdVerify(args);
+    case "registry":
+      return cmdRegistry(args, dataset);
     default:
       printHelp();
   }
@@ -95,10 +98,14 @@ function printHelp() {
 用法：
   node parser/index.js build [--dry]                      校验映射表并生成 dist/ 产物
   node parser/index.js match <changeset.json...>          对设计变更集执行三级匹配（可多文件）
+  node parser/index.js match <cs.json> --registry <reg.json>
+                                                          匹配 + 登记表覆盖率当场重算（子项级细闸，有缺口 exit 1）
   node parser/index.js match --batch <dir>                项目级批量匹配：目录下全部变更集 + 跨文件汇总
   node parser/index.js audit --project <dir> [<cs.json…>] 挂载点存在性 + 死通道静态审计（需目标项目源码）
   node parser/index.js verify --oracle <o.json> --actual <a.json> [--sids a,b]
-                                                          渲染态逐点验收：computed style 期望 vs 实测 diff（V3.2）
+                                                          渲染态逐点验收：computed style 期望 vs 实测 diff（）
+  node parser/index.js registry <registry.json> [--verbose]
+                                                          登记表通道核验：登记项 sid 是否在词典、dims 是否有落点（）
   node parser/index.js list [--scene admin] [--verbose]   列出全部语义 ID（--verbose 含字段与形态，供下发词汇约束）
   node parser/index.js query <semantic.id>                查询单个 ID 的映射详情
   node parser/watch.js                                    开发态监听 mapping/ 变更自动重编译
@@ -120,7 +127,11 @@ function cmdBuild(args, warnings) {
 
 // ---- match：三级匹配 ----
 function cmdMatch(args, dataset) {
-  const files = args.filter(a => !a.startsWith("--"));
+  // --registry <path>：登记表路径（子项级覆盖率细闸）。缺省时回落到 changeset.coverage.registry / oracle.registry。
+  const regIdx = args.indexOf("--registry");
+  const registryArg = regIdx >= 0 ? args[regIdx + 1] : null;
+  const consumed = new Set(registryArg ? [registryArg] : []);
+  const files = args.filter(a => !a.startsWith("--") && !consumed.has(a));
   if (files.length === 0) {
     console.error("✖ 缺少变更集文件参数：node parser/index.js match <changeset.json...|--batch <dir>>");
     process.exit(1);
@@ -151,19 +162,23 @@ function cmdMatch(args, dataset) {
   }
 
   // 跨文件汇总（项目级模式对账用）
-  const batchSummary = { files: 0, l1: 0, l2: 0, l3: 0, pendingIds: [], fieldPending: [], invalid: [] };
+  const batchSummary = { files: 0, l1: 0, l2: 0, l3: 0, pendingIds: [], fieldPending: [], invalid: [], registryGaps: 0 };
 
   for (const target of targets) {
     batchSummary.files++;
     if (targets.length > 1)
       console.log(`\n════ 变更集 ${batchSummary.files}/${targets.length}：${path.basename(target)} ════`);
-    matchOne(target, dataset, batchSummary);
+    matchOne(target, dataset, batchSummary, { registryArg, filePath: target, verbose: args.includes("--verbose") });
   }
 
   // 任一文件被拒（schema/版本/禁词校验失败）→ 进程退出码 1（v1.0 修正：单文件模式此前误返回 0）
   if (batchSummary.invalid.length > 0)
     process.exitCode = 1;
 
+  // 登记表覆盖率有缺口（子项被静默丢失）→ 也是「交付不完整」，退出码 1
+  if (batchSummary.registryGaps > 0)
+    process.exitCode = 1;
+
   // 项目级汇总输出
   if (targets.length > 1) {
     console.log(`\n════════ 项目级汇总（${targets.length} 份变更集）════════`);
@@ -182,11 +197,13 @@ function cmdMatch(args, dataset) {
       for (const f of batchSummary.fieldPending)
         console.log(`  - ${f.id}: ${f.fields.join("、")}`);
     }
+    if (batchSummary.registryGaps > 0)
+      console.log(`✖ 登记表覆盖率缺口合计 ${batchSummary.registryGaps} 条（子项级欠声明，详见各文件段落）`);
   }
 }
 
 /** 单份变更集匹配（cmdMatch 内部复用） */
-function matchOne(file, dataset, batchSummary) {
+function matchOne(file, dataset, batchSummary, opts = {}) {
   let changeset;
   try {
     changeset = JSON.parse(readFileSync(file, "utf-8"));
@@ -314,17 +331,13 @@ function matchOne(file, dataset, batchSummary) {
     }
   }
 
-  // oracle 验收基线（V3.2：设计侧给的效果图 + 待比对点位；项目侧落地后跑 verify 逐点 diff）
-  const oracle = changeset.oracle;
-  if (oracle && typeof oracle === "object") {
-    const sids = Array.isArray(oracle.sids) ? oracle.sids : [];
-    console.log(`\n=== 验收基线 oracle（落地后跑 verify 逐点比对）===`);
-    console.log(`  效果图：${oracle.mockup || "（未给 mockup 路径）"}`);
-    console.log(`  待比对点位：${sids.length} 条${sids.length ? ` —— ${sids.join("、")}` : ""}`);
-  }
-  else {
-    console.log(`\n提示：变更集未提供 oracle 验收基线（场景还原应给）—— 落地后无法做 computed style 逐点比对，还原度不可证明，建议回流设计侧补齐。`);
-  }
+  // oracle 验收基线（：设计侧给的效果图 + 待比对点位；项目侧落地后跑 verify 逐点 diff）
+  checkOracle(changeset, plan, valueDict);
+  checkCoverage(changeset);
+  // 登记表覆盖率（子项级细闸）：以登记表为权威、当场重算 A/C，设计侧自报的 coverage 不参与
+  const regGaps = checkRegistryCoverage(changeset, plan, opts);
+  if (batchSummary)
+    batchSummary.registryGaps += regGaps;
 
   // 输出转换计划
   console.log(`\n=== 三级匹配结果（scene=${changeset.scene}，${plan.length} 条）===`);
@@ -417,7 +430,7 @@ function checkBannedWords(changeset) {
       scan(`${label}.form`, c.form);
     if (c.id)
       scan(`${label}.id`, c.id);
-    // V3.2 三个声明维度：禁词扫描 + 结构校验（apply_via / layer / structure_ops）
+    //  三个声明维度：禁词扫描 + 结构校验（apply_via / layer / structure_ops）
     if (c.apply_via !== undefined && c.apply_via !== null)
       scan(`${label}.apply_via`, c.apply_via);
     if (typeof c.layer === "string")
@@ -512,7 +525,7 @@ function printStyleTranslation(entry, change, idLabel, fieldPending, valueDict)
       lines.push(`  . ${field}: ${valueLabel} → var 覆盖 ${entry.css_vars[field]}（@ ${entry.style_scope}）`);
     }
     else if (entry.custom_style_map && entry.custom_style_map[field]) {
-      // V3.2：按变更集 layer 指认落点（host 宿主盒 / inner 内层文本盒），从词典 anchors 取真实选择器
+      // ：按变更集 layer 指认落点（host 宿主盒 / inner 内层文本盒），从词典 anchors 取真实选择器
       const spot = resolveAnchorTarget(entry, field, layerOf(change, field));
       const layerLabel = spot.layer ? ` · ${spot.layer} 层` : "";
       lines.push(`  . ${field}: ${valueLabel} → 自定义 ${entry.custom_style_map[field]}（@ ${spot.target}${layerLabel}）`);
@@ -534,7 +547,7 @@ function printStyleTranslation(entry, change, idLabel, fieldPending, valueDict)
   }
 }
 
-// ---- V3.2 · 落点 / 结构施工 / 优先级 解析 ----
+// ----  · 落点 / 结构施工 / 优先级 解析 ----
 
 /** 取字段的落点层级：change.layer 支持字符串（整条生效）或对象（按字段指认） */
 function layerOf(change, field) {
@@ -605,7 +618,379 @@ function printApplyPlan(entry, change, idLabel, index) {
 
   if (entry.priority && entry.priority.strategy) {
     console.log(`  ▸ 覆写优先级 priority：${entry.priority.strategy}${entry.priority.reason ? ` —— ${entry.priority.reason}` : ""}`);
+    console.log(`      落地要求：${priorityRequirement(entry.priority.strategy)}`);
+  }
+}
+
+/**
+ * 覆写优先级 → 落地写法要求（）
+ * 该维度不是「提示」，是硬要求：写错写法 = 规则写了也不生效（同权重被组件 scoped 后注入覆盖，或被出厂 !important 压制）。
+ */
+function priorityRequirement(strategy) {
+  switch (strategy) {
+    case "scope_qualified":
+      return "词典 selector 已含作用域限定，按原样落；若实测仍被覆盖，按 deep_qualified 处理。";
+    case "deep_qualified":
+      return "禁止裸类名。必须 ≥3 层作用域限定（如 html .a .b）或叠加属性/伪类，否则与组件 scoped 平手、被后注入覆盖 → 选择器“写了不生效”。";
+    case "self_plus_important":
+      return "对手带 !important，本点位也必须 !important（或改走通道变量）；只抬特异度无法取胜。";
+    default:
+      return "（未知策略，按 deep_qualified 保守处理）";
+  }
+}
+
+/**
+ * oracle 验收基线校验（）
+ * 两类事故都出在「基线本身不可用」，而不是落地写法：
+ *  ① 主题错配：效果图是 A 主题、变更集是 B 主题 → 逐点比对必然全红（搬错基线）。
+ *  ② 覆盖度缺口：效果图里有、changes[] 却未声明的点位 → 永远不可能被还原（欠声明）；
+ *     反之声明了却不在 sids 里的点位 → 落地后无法机器验收。
+ * 两者都属「交付不完整」，与颜色红线同级，必须回流设计侧补齐。
+ */
+function checkOracle(changeset, plan, valueDict) {
+  const oracle = changeset.oracle;
+  if (!oracle || typeof oracle !== "object") {
+    console.log(`\n提示：变更集未提供 oracle 验收基线（场景还原应给）—— 落地后无法做 computed style 逐点比对，还原度不可证明，建议回流设计侧补齐。`);
+    return;
+  }
+
+  const sids = Array.isArray(oracle.sids) ? oracle.sids : [];
+  const mockup = typeof oracle.mockup === "string" ? oracle.mockup : "";
+  console.log(`\n=== 验收基线 oracle（落地后跑 verify 逐点比对）===`);
+  console.log(`  效果图：${mockup || "（未给 mockup 路径）"}`);
+  console.log(`  待比对点位：${sids.length} 条${sids.length ? ` —— ${sids.join("、")}` : ""}`);
+
+  const issues = [];
+
+  // ① 主题一致性：效果图文件名中的主题词 vs global.brand_primary 的主题词
+  const themes = new Set(
+    Object.keys(valueDict || {})
+      .map(k => /^(.+?)-\d+$/.exec(k))
+      .filter(Boolean)
+      .map(m => m[1]),
+  );
+  const themeFromValue = (v) => {
+    const m = typeof v === "string" ? /^(.+?)-\d+$/.exec(v.trim()) : null;
+    return m ? m[1] : null;
+  };
+  const declaredTheme = themeFromValue(changeset.global && changeset.global.brand_primary);
+  const mockupTheme = [...themes].find(t => mockup.includes(t)) || null;
+  if (declaredTheme && mockupTheme && declaredTheme !== mockupTheme) {
+    issues.push(`主题错配：效果图是「${mockupTheme}」、本变更集主色是「${declaredTheme}」—— 跨主题复用效果图会让 verify 逐点比对必然全红，请换成本主题自己的效果图。`);
+  }
+  if (!mockupTheme && mockup)
+    issues.push(`效果图文件名不含任何已知主题词（${[...themes].join("/")}），无法确认主题一致性 —— 请核对是否复用了其它主题的效果图。`);
+
+  // ② 覆盖度（双向）
+  const declaredIds = plan.map(p => p.id);
+  const sidSet = new Set(sids);
+  const sidNotDeclared = sids.filter(s => !declaredIds.includes(s));
+  const declaredWithoutSid = declaredIds.filter(id => !sidSet.has(id));
+  if (sidNotDeclared.length > 0)
+    issues.push(`欠声明 ${sidNotDeclared.length} 处：效果图里有、changes[] 未声明 → 该点位永远不可能被还原。\n      ${sidNotDeclared.join("、")}`);
+  if (declaredWithoutSid.length > 0)
+    issues.push(`无基线 ${declaredWithoutSid.length} 处：changes[] 已声明、效果图 sids 未覆盖 → 落地后无法机器验收。\n      ${declaredWithoutSid.join("、")}`);
+
+  if (issues.length === 0) {
+    console.log(`  ✔ oracle 校验通过：主题一致、覆盖度双向闭合`);
+    return;
+  }
+  console.log(`\n⚠ oracle 基线问题（${issues.length} 类）：`);
+  for (const it of issues)
+    console.log(`  ✘ ${it}`);
+}
+
+/**
+ * 覆盖率校验（场景还原子项级细闸）
+ * 设计侧用「登记表」把规范里每条带样式结论的子项变成必登项，交付时以 coverage 记账。
+ * 这里只做结构一致性校验：covered 必须等于 applicable、gaps 必须为空。
+ * 缺 coverage 时无法判断「是否有组内子项被静默丢失」——属交付完整性的信号缺口。
+ */
+function checkCoverage(changeset) {
+  const cov = changeset.coverage;
+  if (!cov || typeof cov !== "object") {
+    console.log(`\n提示：变更集未提供 coverage 覆盖率记账（场景还原应给）—— 无法判断是否有规范子项被静默丢失，完备性不可数，建议回流设计侧补齐。`);
+    return;
+  }
+  const num = v => (typeof v === "number" && Number.isFinite(v) ? v : null);
+  const R = num(cov.registrable);
+  const A = num(cov.applicable);
+  const C = num(cov.covered);
+  const gaps = Array.isArray(cov.gaps) ? cov.gaps : [];
+  console.log(`\n=== 覆盖率 coverage（子项级细闸）===`);
+  console.log(`  登记表：${cov.registry || "（未给路径）"}`);
+  console.log(`  登记项 R=${R ?? "?"} / 适用 A=${A ?? "?"} / 已兑现 C=${C ?? "?"}`);
+
+  const issues = [];
+  if (A === null || C === null)
+    issues.push("缺 applicable / covered 计数，无法核验完备性。");
+  else if (C < A)
+    issues.push(`欠声明：已兑现 ${C} < 适用 ${A} —— 有 ${A - C} 条登记项未落进 changes[] / visible / pending。`);
+  if (gaps.length > 0)
+    issues.push(`gaps 非空（${gaps.length} 条）：${gaps.join("、")}`);
+
+  if (issues.length === 0) {
+    console.log(`  ✔ 覆盖率校验通过：C = A 且无缺口`);
+    return;
+  }
+  console.log(`\n⚠ 覆盖率问题（${issues.length} 类）：`);
+  for (const it of issues)
+    console.log(`  ✘ ${it}`);
+}
+
+/** 依次尝试候选路径，返回首个存在者（相对路径基准：变更集所在目录 → 当前工作目录 → 技能仓库根） */
+function resolveFirstExisting(raw, filePath) {
+  if (!raw || typeof raw !== "string")
+    return null;
+  if (path.isAbsolute(raw))
+    return existsSync(raw) ? raw : null;
+  const bases = [];
+  if (filePath)
+    bases.push(path.dirname(filePath));
+  bases.push(process.cwd(), ROOT);
+  for (const base of bases) {
+    const candidate = path.resolve(base, raw);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+
+/** 词典条目的可用字段集：css_vars + custom_style_map + forms 键 + 结构/存在维度 */
+function entryFieldSet(entry) {
+  const fields = new Set(["form", "visible", "position"]);
+  for (const bag of ["css_vars", "custom_style_map", "forms"]) {
+    for (const k of Object.keys(entry?.[bag] || {}))
+      fields.add(k);
+  }
+  return fields;
+}
+
+/** 登记项引用的语义 ID（支持单 sid 与多 sids 两种写法） */
+function registrySids(item) {
+  if (Array.isArray(item?.sids))
+    return item.sids;
+  return item?.sid ? [item.sid] : [];
+}
+
+/** 登记表里唯一允许的「非词典点位」：全局令牌通道（对应变更集顶层 global 节点，无 css selector 故不入词典） */
+const GLOBAL_PSEUDO_ID = "global";
+
+/**
+ * 登记表覆盖率（子项级细闸，）
+ * 组级台账（restore-checklist）只能防「整组忘光」；组内子项是否被静默丢失，必须由登记表
+ * （规范里每条带样式结论的子项 → 一条登记项）来计数。这里以登记表为权威**当场重算**：
+ *   适用 A = always 子项 ∪ 效果图已标注同名 data-sid 的子项
+ *   兑现 C = A 中在 changes[] / visible:false / pending[].proposed_id 出现者
+ * 设计侧自报的 coverage 数字不参与计算，因此无法用「把 applicable 写小」蒙混过关。
+ * 有缺口 → 返回缺口数（调用方置退出码 1）。
+ */
+function checkRegistryCoverage(changeset, plan, opts = {}) {
+  const raw = opts.registryArg || changeset.coverage?.registry || changeset.oracle?.registry;
+  const registryPath = resolveFirstExisting(raw, opts.filePath);
+  if (!registryPath) {
+    if (opts.registryArg) {
+      console.error(`\n✖ 登记表文件不存在：${opts.registryArg}`);
+      return 1;
+    }
+    console.log(`\n提示：未提供登记表（--registry 或 coverage.registry）—— 组级台账只防「整组忘光」，组内子项被静默丢失无法计数，建议场景还原带登记表。`);
+    return 0;
+  }
+
+  let registry;
+  try {
+    registry = JSON.parse(readFileSync(registryPath, "utf-8"));
+  }
+  catch (e) {
+    console.error(`\n✖ 登记表读取/解析失败：${registryPath} —— ${e.message}`);
+    return 1;
+  }
+  const items = Array.isArray(registry.items) ? registry.items : [];
+  if (items.length === 0) {
+    console.error(`\n✖ 登记表不含 items：${registryPath}`);
+    return 1;
+  }
+
+  // 兑现集合 = changes[] ∪ visible:false ∪ pending[].proposed_id ∪ 顶层 global 节点
+  const declared = new Set(plan.map(p => p.id));
+  for (const p of plan) {
+    if (p.change && p.change.visible === false)
+      declared.add(p.id);
+  }
+  for (const p of Array.isArray(changeset.pending) ? changeset.pending : []) {
+    if (p && p.proposed_id)
+      declared.add(p.proposed_id);
+  }
+  if (changeset.global && Object.keys(changeset.global).length > 0)
+    declared.add(GLOBAL_PSEUDO_ID);
+  const mockupSids = new Set(Array.isArray(changeset.oracle?.sids) ? changeset.oracle.sids : []);
+
+  const applicable = items.filter(it => it.always === true || registrySids(it).some(s => mockupSids.has(s)));
+  const gaps = applicable.filter(it => !registrySids(it).every(s => declared.has(s)));
+
+  console.log(`\n=== 登记表覆盖率（子项级细闸 · 当场重算）===`);
+  console.log(`  登记表：${registryPath}（登记项 R=${items.length}）`);
+  console.log(`  适用 A=${applicable.length} / 已兑现 C=${applicable.length - gaps.length} / 缺口 ${gaps.length}`);
+
+  // 效果图标注完整性：恒存在的子项必须能在效果图上找到同名 data-sid，否则基线根本抽不出来
+  const unannotated = items.filter(it => it.always === true && !registrySids(it).some(s => mockupSids.has(s)));
+  if (unannotated.length > 0) {
+    const bySid = new Map();
+    for (const it of unannotated) {
+      for (const s of registrySids(it))
+        bySid.set(s, (bySid.get(s) || 0) + 1);
+    }
+    console.log(`  ⚠ 效果图标注缺口 ${unannotated.length} 条：这些子项恒存在，却无同名 data-sid → 基线抽取不全`);
+    console.log(`     涉及点位：${[...bySid.entries()].map(([s, n]) => `${s}(${n})`).join("、")}`);
+  }
+
+  if (gaps.length === 0) {
+    console.log(`  ✔ 覆盖率通过：C = A，无子项被静默丢失`);
+    return 0;
+  }
+
+  const byGroup = new Map();
+  for (const it of gaps) {
+    const g = it.group || "（未分组）";
+    if (!byGroup.has(g))
+      byGroup.set(g, []);
+    byGroup.get(g).push(it);
+  }
+  console.log(`\n✘ 登记表覆盖率缺口（子项级欠声明，共 ${gaps.length} 条 → exit 1）：`);
+  for (const [group, list] of byGroup) {
+    console.log(`  · ${group}（${list.length}）`);
+    const shown = opts.verbose ? list : list.slice(0, 6);
+    for (const it of shown)
+      console.log(`      ${it.rule}  ${registrySids(it).join(" + ")}  [${(it.dims || []).join(",")}]`);
+    if (!opts.verbose && list.length > shown.length)
+      console.log(`      …（同组其余 ${list.length - shown.length} 条，加 --verbose 展开）`);
+  }
+  return gaps.length;
+}
+
+/**
+ * 登记表通道核验（）
+ * 与 match 的覆盖率校验互补：不需要变更集，直接拿登记表对词典，回答一件事——
+ * 「这张登记表里的必登项，有多少在项目侧真有承载字段」。这是 1:1 对接的**通道缺口清单**：
+ *   · sid 词典无此 ID 且未标 pending → 硬缺口（登记表引用了不存在的点位，exit 1）
+ *   · dims 是设计侧通用维度（adjustable-elements 口径），词典无对应字段 → 通道缺口（列出，供补词典）
+ */
+function cmdRegistry(args, dataset) {
+  const verbose = args.includes("--verbose");
+  const file = args.find(a => !a.startsWith("--"));
+  if (!file) {
+    console.error("✖ 缺少登记表文件参数：node parser/index.js registry <restore-registry.json> [--verbose]");
+    process.exit(1);
+  }
+  const p = path.resolve(file);
+  let registry;
+  try {
+    registry = JSON.parse(readFileSync(p, "utf-8"));
+  }
+  catch (e) {
+    console.error(`✖ 登记表读取/解析失败：${e.message}`);
+    process.exit(1);
+  }
+  const items = Array.isArray(registry.items) ? registry.items : [];
+  if (items.length === 0) {
+    console.error(`✖ 登记表不含 items：${file}`);
+    process.exit(1);
+  }
+
+  const index = buildMergedIndex(dataset);
+  const SOURCES = new Set(["spec", "mockup", "both", "none"]);
+  const CHANNELS = new Set(["form", "style", "layer", "structure_ops", "apply_via"]);
+
+  const hard = [];
+  const chanMissing = [];
+  const seenRule = new Set();
+  const pendingIds = new Set();
+  let sidOk = 0;
+  let dimTotal = 0;
+  let dimOk = 0;
+
+  for (const it of items) {
+    const rule = it.rule || "（无 rule）";
+    if (seenRule.has(rule))
+      hard.push(`rule 重复：${rule}`);
+    seenRule.add(rule);
+    if (it.source && !SOURCES.has(it.source))
+      hard.push(`${rule}: source "${it.source}" 非法（应为 ${[...SOURCES].join("/")}）`);
+    for (const c of Array.isArray(it.channel) ? it.channel : []) {
+      if (!CHANNELS.has(c))
+        hard.push(`${rule}: channel "${c}" 非法（应为 ${[...CHANNELS].join("/")}）`);
+    }
+    const sids = registrySids(it);
+    if (sids.length === 0)
+      hard.push(`${rule}: 未给 sid / sids`);
+    for (const sid of sids) {
+      if (sid === GLOBAL_PSEUDO_ID) {
+        sidOk++;
+        continue; // 全局令牌通道：对应变更集顶层 global 节点，不入词典
+      }
+      if (it.pending) {
+        pendingIds.add(sid);
+        if (index[sid])
+          hard.push(`${rule}: ${sid} 已标 pending，但词典已有该 ID → 应撤掉 pending 标注`);
+      }
+      const entry = index[sid];
+      if (!entry) {
+        if (!it.pending)
+          hard.push(`${rule}: ${sid} 词典无此 ID 且未标 pending → 须补词典或改标 pending`);
+        continue;
+      }
+      sidOk++;
+      const fields = entryFieldSet(entry);
+      for (const d of Array.isArray(it.dims) ? it.dims : []) {
+        dimTotal++;
+        if (fields.has(d))
+          dimOk++;
+        else
+          chanMissing.push(`${rule}  ${sid}.${d}`);
+      }
+    }
+  }
+
+  console.log(`=== 登记表通道核验（${path.basename(p)}）===`);
+  console.log(`  登记项 ${items.length} 条 / 引用点位 ${sidOk} 个命中词典${pendingIds.size ? ` / ${pendingIds.size} 个标 pending（待补词典）` : ""}`);
+  console.log(`  维度落点：${dimOk}/${dimTotal} 在词典有对应字段`);
+
+  if (pendingIds.size > 0) {
+    console.log(`\n  待补词典的新点位（设计侧须 changes[] + pending 双写）：`);
+    for (const id of pendingIds)
+      console.log(`    - ${id}`);
+  }
+  if (chanMissing.length > 0) {
+    const bySid = new Map();
+    for (const line of chanMissing) {
+      const sid = line.split(/\s+/)[1].split(".").slice(0, -1).join(".") || "?";
+      if (!bySid.has(sid))
+        bySid.set(sid, []);
+      bySid.get(sid).push(line.split(".").pop());
+    }
+    console.log(`\n  通道缺口 ${chanMissing.length} 处（设计侧通用维度在词典无字段 → 须补字段或换用已有字段）：`);
+    for (const [sid, dims] of bySid) {
+      const uniq = [...new Set(dims)];
+      console.log(`    - ${sid}: ${uniq.slice(0, verbose ? uniq.length : 8).join("、")}${!verbose && uniq.length > 8 ? ` …+${uniq.length - 8}` : ""}`);
+    }
+    if (verbose) {
+      console.log(`\n  明细：`);
+      for (const line of chanMissing)
+        console.log(`    ${line}`);
+    }
+  }
+
+  if (hard.length === 0 && chanMissing.length === 0) {
+    console.log(`\n✔ 登记表通道核验通过：点位全部命中、维度全部有落点`);
+    return;
+  }
+  if (hard.length > 0) {
+    console.error(`\n✖ 硬缺口 ${hard.length} 处（登记表引用了不存在的点位 / 元数据非法）→ exit 1：`);
+    for (const h of hard)
+      console.error(`  ✘ ${h}`);
+    process.exit(1);
   }
+  console.log(`\n⚠ 存在通道缺口（属「项目侧补词典」事项，不阻断匹配；补齐后还原度才可达 100%）。`);
 }
 
 /** 输出结构施工声明（structure_ops）：数据 / 结构驱动点位，只写 CSS 是无效声明 */
@@ -677,7 +1062,7 @@ function checkApplyFields(change, label, violations) {
   }
 }
 
-// ---- audit：挂载点存在性 + 死通道（V3.2，静态审计，需目标项目源码） ----
+// ---- audit：挂载点存在性 + 死通道（，静态审计，需目标项目源码） ----
 // 本节的模块级常量（AUDIT_SKIP_DIRS / STRUCT_EXT / STYLE_EXT / DESIGN_LAYER_RE /
 // BUILTIN_BARE_CLASSES）已在文件顶部声明——模块级常量必须在 main() 调用前初始化，勿下移。
 
@@ -882,7 +1267,7 @@ function cmdAudit(args, dataset) {
   }
 }
 
-// ---- verify：渲染态逐点验收（V3.2 补丁 3 · 闭环验收回路） ----
+// ---- verify：渲染态逐点验收（ 补丁 3 · 闭环验收回路） ----
 /**
  * 比对两份 computed style 转储：oracle（效果图期望）vs actual（项目实测）。
  * 转储格式：{ "<语义ID>": { "<css属性>": "<值>", ... }, ... }
@@ -1110,7 +1495,7 @@ function cmdList(args, dataset) {
         console.log(`      style 字段：${fields.join(" ")}`);
       if (forms.length > 0)
         console.log(`      form 形态：${forms.join(" / ")}`);
-      // V3.2：落点层级与覆写优先级（设计侧声明 layer / 项目侧选提权策略时可见）
+      // ：落点层级与覆写优先级（设计侧声明 layer / 项目侧选提权策略时可见）
       const anchors = Array.isArray(e.anchors) ? e.anchors : [];
       const layers = [...new Set(anchors.filter(a => a.kind === "class" && a.layer).map(a => a.layer))];
       if (layers.length > 0 || (e.priority && e.priority.strategy))

package/parser/regression.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * A-L 端到端一键回归（作者侧维护工具，不随技能分发）
+ * A-O 端到端一键回归（作者侧维护工具，不随技能分发）
  *
  * 用法（cwd 任意，脚本内部已固定为 skill 根目录执行）：
  *   node parser/regression.js
@@ -17,9 +17,12 @@
  *   G  match 旧协议兼容                    → exit 0 且输出含 ⚠ 告警
  *   H  match 整页场景还原样例              → exit 0 且输出含 #245BFF（壳层+内容区全模块 L1）
  *   I  build --dry 产物链自检              → exit 0 且输出含 dry-run
- *   J  match V3.2 三声明维度                → exit 0 且输出含「结构施工 structure_ops」
+ *   J  match  三声明维度                → exit 0 且输出含「结构施工 structure_ops」
  *   K  audit 挂载点 / 死通道审计            → exit 1（夹具项目故意存在挂载点缺失 / 死通道）
  *   L  verify 渲染态逐点验收                → exit 1 且三类归因各计其数（夹具含故意缺口）
+ *   M  match 登记表覆盖率细闸               → exit 1（夹具故意欠声明两条恒存在子项）
+ *   N  registry 登记表通道核验              → exit 0 且输出含「登记表通道核验」
+ *   O  registry 硬缺口负例                  → exit 1（引用了不存在且未标 pending 的点位）
  *
  * 任一步骤失败 → 本脚本 exit 1，并回显该步骤完整输出便于定位。
  */
@@ -109,10 +112,10 @@ const steps = [
   },
   {
     key: "J",
-    name: "match V3.2 三声明维度（apply_via / layer / structure_ops）",
+    name: "match  三声明维度 + coverage 覆盖率（apply_via / layer / structure_ops / coverage）",
     script: INDEX,
     args: ["match", path.join(FIXTURES, "changeset-v32-fields.json")],
-    expect: { code: 0, includes: ["结构施工 structure_ops", "验收基线 oracle"] },
+    expect: { code: 0, includes: ["结构施工 structure_ops", "验收基线 oracle", "覆盖率 coverage"] },
   },
   {
     key: "K",
@@ -128,12 +131,33 @@ const steps = [
     args: ["verify", "--oracle", path.join(FIXTURES, "verify", "oracle.json"), "--actual", path.join(FIXTURES, "verify", "actual.json")],
     expect: { code: 1, includes: "选择器落空 1 / 权重被压 1 / 语境错位 2" },
   },
+  {
+    key: "M",
+    name: "match 登记表覆盖率细闸（夹具故意欠声明两条恒存在子项 → exit 1）",
+    script: INDEX,
+    args: ["match", "--registry", path.join(FIXTURES, "registry-sample.json"), path.join(FIXTURES, "changeset-registry-gap.json")],
+    expect: { code: 1, includes: ["登记表覆盖率", "缺口 2"] },
+  },
+  {
+    key: "N",
+    name: "registry 登记表通道核验（点位全部命中 → exit 0）",
+    script: INDEX,
+    args: ["registry", path.join(FIXTURES, "registry-sample.json")],
+    expect: { code: 0, includes: ["登记表通道核验", "登记项 6 条"] },
+  },
+  {
+    key: "O",
+    name: "registry 硬缺口负例（引用不存在且未标 pending 的点位 → exit 1）",
+    script: INDEX,
+    args: ["registry", path.join(FIXTURES, "registry-bad.json")],
+    expect: { code: 1, includes: "硬缺口" },
+  },
 ];
 
 const results = [];
 let failed = 0;
 
-console.log("=== A-L 端到端一键回归 ===\n");
+console.log("=== A-O 端到端一键回归 ===\n");
 
 for (const step of steps) {
   const { status, stdout, stderr } = spawnSync(
@@ -170,4 +194,4 @@ if (failed > 0) {
   console.error(`\n✖ ${failed} 步未通过，见上方详情`);
   process.exit(1);
 }
-console.log("\n✔ A-L 全部通过，mapping/parser 可提交或发版");
+console.log("\n✔ A-O 全部通过，mapping/parser 可提交或发版");