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

package/parser/index.js

@@ -18,6 +18,8 @@
  *   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/watch.js                                    # 开发态监听 mapping/ 自动重编译（§3.4.3）
  */
 
@@ -33,11 +35,26 @@ const ROOT = path.resolve(__dirname, "..");
 
 /** 定性值（非色彩类语义描述，如 中等/全圆角/宽松）：不参与译表，AI 按字段语义施工，不告警。
  *  注意：模块级常量必须在 main() 调用前声明（TDZ），勿下移到文件底部。 */
-const QUALITATIVE_RE = /^(中等|加粗|常规|细|粗|小圆角|全圆角|直角|宽松|紧凑|标准|大|中|小|等宽数字)$/;
+const QUALITATIVE_RE = /^(中等|加粗|常规|细|粗|小圆角|全圆角|直角|宽松|紧凑|标准|大|中|小|等宽数字|等宽|左对齐|居中|右对齐|两端对齐|不换行|换行)$/;
 /** 数值字面量：带 CSS 单位的精确尺寸（40px / 1.5rem / 50%）——设计侧已消歧的精确值，透传不提示 */
 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 一致） */
+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：审计时跳过的目录（依赖 / 产物 / 缓存） */
+const AUDIT_SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".output", ".vite", ".nuxt", "coverage", "public"]);
+/** V3.2 audit：「模板 / 脚本」扩展名：命中 = 结构挂载 */
+const STRUCT_EXT = new Set([".vue", ".html", ".htm", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+/** V3.2 audit：「样式」扩展名：只命中样式 = 仅样式定义、无结构挂载 */
+const STYLE_EXT = new Set([".scss", ".sass", ".css", ".less", ".styl"]);
+/** V3.2 audit：设计层文件特征（只命中设计层 = 无实际挂载） */
+const DESIGN_LAYER_RE = /design-shell|design-layer|design\.scss/i;
+/** V3.2 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();
 
@@ -63,6 +80,10 @@ function main() {
       return cmdList(args, dataset);
     case "query":
       return cmdQuery(args, dataset);
+    case "audit":
+      return cmdAudit(args, dataset);
+    case "verify":
+      return cmdVerify(args);
     default:
       printHelp();
   }
@@ -75,6 +96,9 @@ function printHelp() {
   node parser/index.js build [--dry]                      校验映射表并生成 dist/ 产物
   node parser/index.js match <changeset.json...>          对设计变更集执行三级匹配（可多文件）
   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）
   node parser/index.js list [--scene admin] [--verbose]   列出全部语义 ID（--verbose 含字段与形态，供下发词汇约束）
   node parser/index.js query <semantic.id>                查询单个 ID 的映射详情
   node parser/watch.js                                    开发态监听 mapping/ 变更自动重编译
@@ -149,12 +173,12 @@ function cmdMatch(args, dataset) {
     }
     if (batchSummary.pendingIds.length > 0) {
       const uniq = [...new Set(batchSummary.pendingIds)];
-      console.log(`待补充映射 ID（去重 ${uniq.length}）：`);
+      console.log(`缺口清单 · 新增点位（去重 ${uniq.length}，须当场落地 + 回写临时映射）：`);
       for (const id of uniq)
         console.log(`  - ${id}`);
     }
     if (batchSummary.fieldPending.length > 0) {
-      console.log(`字段级待补充：`);
+      console.log(`缺口清单 · 字段级（优先当场落设计层，仅意图缺口回流）：`);
       for (const f of batchSummary.fieldPending)
         console.log(`  - ${f.id}: ${f.fields.join("、")}`);
     }
@@ -290,32 +314,49 @@ 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 逐点比对，还原度不可证明，建议回流设计侧补齐。`);
+  }
+
   // 输出转换计划
   console.log(`\n=== 三级匹配结果（scene=${changeset.scene}，${plan.length} 条）===`);
   for (const p of plan) {
     if (p.level === 1) {
       console.log(`\n[L1 完整命中] ${p.id}`);
       checkFormEnum(p.entry, p.change);
+      printApplyPlan(p.entry, p.change, p.id, index);
       printStyleTranslation(p.entry, p.change, p.id, fieldPending, valueDict);
     }
     else if (p.level === 2) {
       console.log(`\n[L2 父模块命中] ${p.id} → 继承 ${p.parent}（${p.entry.selector ?? p.entry.component ?? "?"}）`);
       console.log(`  结构：定位父容器按相对位置增量插入；样式：复用父模块映射 + 全局组件映射`);
+      printApplyPlan(p.entry, p.change, `${p.id}（继承 ${p.parent}）`, index);
       printStyleTranslation(p.entry, p.change, `${p.id}（继承 ${p.parent}）`, fieldPending, valueDict);
     }
     else {
       console.log(`\n[L3 全新模块] ${p.id} → 按场景规范生成默认结构，复用全局原子层映射`);
+      printStructureOps(p.change);
     }
   }
 
   if (pending.length > 0) {
-    console.log(`\n=== 待补充映射清单（${pending.length}）===`);
+    console.log(`\n=== 缺口清单 · 新增点位（${pending.length}）===`);
+    console.log(`  处置：当场按 L3 落地并回写临时映射（词典缺 ID 属能力缺口，不是跳过理由）；仅设计侧未给意图才回流。`);
     for (const id of pending)
       console.log(`  - ${id}`);
   }
 
   if (fieldPending.length > 0) {
-    console.log(`\n=== 字段级待补充（ID 命中但 style 字段两层均未命中，跳过不猜）===`);
+    console.log(`\n=== 缺口清单 · 字段级（${fieldPending.length}，ID 命中但 style 字段两层映射均未命中）===`);
+    console.log(`  处置：优先在条目作用域内生成自定义规则落设计层文件并申报；仅「值非法 / 无法定位 / 设计侧未给值」才回流设计侧。`);
     for (const f of fieldPending)
       console.log(`  - ${f.id}: ${f.fields.join("、")}`);
   }
@@ -376,6 +417,24 @@ function checkBannedWords(changeset) {
       scan(`${label}.form`, c.form);
     if (c.id)
       scan(`${label}.id`, c.id);
+    // V3.2 三个声明维度：禁词扫描 + 结构校验（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")
+      scan(`${label}.layer`, c.layer);
+    if (c.structure_ops !== undefined && c.structure_ops !== null) {
+      if (Array.isArray(c.structure_ops)) {
+        for (const [j, op] of c.structure_ops.entries()) {
+          if (!op || typeof op !== "object")
+            continue;
+          for (const k of ["node", "source", "from", "to"]) {
+            if (op[k] !== undefined)
+              scan(`${label}.structure_ops[${j}].${k}`, op[k]);
+          }
+        }
+      }
+    }
+    checkApplyFields(c, label, violations);
   }
   return violations;
 }
@@ -439,7 +498,7 @@ function checkFormEnum(entry, change) {
   }
 }
 
-/** 两层样式转换：css_vars 优先 → custom_style_map 兜底 → 未匹配记待补充 */
+/** 两层样式转换：css_vars 优先 → custom_style_map 兜底（含落点层级解析）→ 未匹配记缺口清单 */
 function printStyleTranslation(entry, change, idLabel, fieldPending, valueDict) {
   const styles = change.style || {};
   if (Object.keys(styles).length === 0)
@@ -453,7 +512,10 @@ 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]) {
-      lines.push(`  . ${field}: ${valueLabel} → 自定义 ${entry.custom_style_map[field]}（@ ${entry.style_scope} + :deep() 隔离）`);
+      // V3.2：按变更集 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}）`);
     }
     else {
       unmatched.push(field);
@@ -466,12 +528,518 @@ function printStyleTranslation(entry, change, idLabel, fieldPending, valueDict)
   for (const l of lines)
     console.log(l);
   if (unmatched.length > 0) {
-    console.log(`  ⚠ 未匹配字段（跳过）：${unmatched.join("、")}`);
+    console.log(`  ⚠ 未匹配字段：${unmatched.join("、")}（按缺口清单处置：优先在设计层落地并申报，不静默跳过）`);
     if (fieldPending)
       fieldPending.push({ id: idLabel || change.id, fields: unmatched });
   }
 }
 
+// ---- V3.2 · 落点 / 结构施工 / 优先级 解析 ----
+
+/** 取字段的落点层级：change.layer 支持字符串（整条生效）或对象（按字段指认） */
+function layerOf(change, field) {
+  const l = change && change.layer;
+  if (!l)
+    return null;
+  if (typeof l === "string")
+    return l;
+  if (typeof l === "object" && !Array.isArray(l) && !field.startsWith("$"))
+    return l[field] || null;
+  return null;
+}
+
+/** 按落点层级从词典 anchors 中挑承载选择器；无匹配回退条目 selector（此时 layer 为 null 表示未指定） */
+function resolveAnchorTarget(entry, field, layer) {
+  const anchors = Array.isArray(entry.anchors) ? entry.anchors : [];
+  const classAnchors = anchors.filter(a => a && a.kind === "class" && typeof a.target === "string");
+  if (layer) {
+    const hit = classAnchors.find(a => a.layer === layer);
+    if (hit)
+      return { target: hit.target, layer };
+  }
+  const host = classAnchors.find(a => a.layer === "host" || a.layer === undefined);
+  if (host)
+    return { target: host.target, layer: host.layer || null };
+  return { target: entry.selector ?? null, layer: null };
+}
+
+/** apply_via 解析：指认本声明引用的锚点来源条目（缺省 = 自身） */
+function applyViaOf(change, index) {
+  const via = change && change.apply_via;
+  if (!via || typeof via !== "string")
+    return null;
+  return { id: via, resolved: index ? index[via] : undefined };
+}
+
+/** 输出施工上下文：承载通道 anchors / 前置条件 / 覆写优先级 / 结构施工 */
+function printApplyPlan(entry, change, idLabel, index) {
+  const anchors = Array.isArray(entry.anchors) ? entry.anchors : [];
+  if (anchors.length > 0) {
+    const host = anchors.find(a => a.kind === "class" && a.layer === "host");
+    const inner = anchors.find(a => a.kind === "class" && a.layer === "inner");
+    const parts = [];
+    if (host)
+      parts.push(`host=${host.target}`);
+    if (inner)
+      parts.push(`inner=${inner.target}`);
+    const vars = anchors.filter(a => a.kind === "css_var").map(a => a.target);
+    if (vars.length > 0)
+      parts.push(`css_var=${vars.join("、")}`);
+    if (parts.length > 0)
+      console.log(`  ▸ 承载通道 anchors：${parts.join(" | ")}`);
+  }
+
+  const via = applyViaOf(change, index);
+  if (via) {
+    const ok = via.resolved ? "" : "（⚠ 词典中无此条目，锚点来源待补）";
+    console.log(`  ▸ 承载通道来源 apply_via：${via.id}${ok}`);
+  }
+
+  printStructureOps(change);
+
+  if (entry.preconditions && Array.isArray(entry.preconditions) && entry.preconditions.length > 0) {
+    console.log(`  ▸ 前置条件 preconditions（施工前必须满足，否则值对了也不生效）：`);
+    for (const p of entry.preconditions)
+      console.log(`      - ${p}`);
+  }
+
+  if (entry.priority && entry.priority.strategy) {
+    console.log(`  ▸ 覆写优先级 priority：${entry.priority.strategy}${entry.priority.reason ? ` —— ${entry.priority.reason}` : ""}`);
+  }
+}
+
+/** 输出结构施工声明（structure_ops）：数据 / 结构驱动点位，只写 CSS 是无效声明 */
+function printStructureOps(change) {
+  const ops = change && change.structure_ops;
+  if (!Array.isArray(ops) || ops.length === 0)
+    return;
+  console.log(`  ▸ 结构施工 structure_ops（${ops.length} 项，必须改数据 / 模板结构，不能只写 CSS）：`);
+  for (const op of ops) {
+    if (!op || typeof op !== "object") {
+      console.log(`      - （非法条目）`);
+      continue;
+    }
+    const parts = [`op=${op.op || "?"}`];
+    if (op.node)
+      parts.push(`node=${op.node}`);
+    if (op.source)
+      parts.push(`source=${op.source}`);
+    if (op.from)
+      parts.push(`from=${op.from}`);
+    if (op.to)
+      parts.push(`to=${op.to}`);
+    console.log(`      - ${parts.join(" ")}`);
+  }
+}
+
+/** 结构施工 / 落点 / 优先级 声明的协议校验（parse 期，追加进 checkBannedWords 违规列表） */
+function checkApplyFields(change, label, violations) {
+  const STRUCT_OPS = ["add_node", "remove_node", "move_node", "render_branch", "bind_source"];
+  if (change.layer !== undefined && change.layer !== null) {
+    const lv = change.layer;
+    if (typeof lv === "string") {
+      if (!LAYER_VALUES.includes(lv))
+        violations.push(`${label}.layer "${lv}" 不在枚举 [${LAYER_VALUES.join("/")}] 内`);
+    }
+    else if (typeof lv === "object" && !Array.isArray(lv)) {
+      for (const [f, v] of Object.entries(lv)) {
+        if (!LAYER_VALUES.includes(v))
+          violations.push(`${label}.layer.${f} "${v}" 不在枚举 [${LAYER_VALUES.join("/")}] 内`);
+      }
+    }
+    else {
+      violations.push(`${label}.layer 应为字符串或「字段 → 层级」对象`);
+    }
+  }
+  if (change.apply_via !== undefined && change.apply_via !== null) {
+    if (typeof change.apply_via !== "string" || !ID_RE_STRICT.test(change.apply_via))
+      violations.push(`${label}.apply_via "${change.apply_via}" 应为语义锚点名（小写下划线、2~4 段），不是选择器 / 变量名`);
+  }
+  if (change.structure_ops !== undefined && change.structure_ops !== null) {
+    if (!Array.isArray(change.structure_ops)) {
+      violations.push(`${label}.structure_ops 必须为数组`);
+    }
+    else {
+      for (const [i, op] of change.structure_ops.entries()) {
+        const at = `${label}.structure_ops[${i}]`;
+        if (!op || typeof op !== "object") {
+          violations.push(`${at} 必须为对象`);
+          continue;
+        }
+        if (!STRUCT_OPS.includes(op.op))
+          violations.push(`${at}.op "${op.op}" 不在枚举 [${STRUCT_OPS.join("/")}] 内`);
+        if (op.node !== undefined && (typeof op.node !== "string" || op.node.trim() === ""))
+          violations.push(`${at}.node 应为非空语义节点名`);
+        if (op.source !== undefined && (typeof op.source !== "string" || op.source.trim() === ""))
+          violations.push(`${at}.source 应为非空语义数据源名`);
+      }
+    }
+  }
+}
+
+// ---- audit：挂载点存在性 + 死通道（V3.2，静态审计，需目标项目源码） ----
+// 本节的模块级常量（AUDIT_SKIP_DIRS / STRUCT_EXT / STYLE_EXT / DESIGN_LAYER_RE /
+// BUILTIN_BARE_CLASSES）已在文件顶部声明——模块级常量必须在 main() 调用前初始化，勿下移。
+
+function escapeRe(s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** 递归收集目标项目源码（剔除依赖 / 产物目录），返回 [{ file, text, kind }] */
+function collectProjectSources(root) {
+  const out = [];
+  const walk = (dir, depth) => {
+    if (depth > 10)
+      return;
+    let items;
+    try {
+      items = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+      return;
+    }
+    for (const it of items) {
+      const name = it.name;
+      if (name.startsWith("."))
+        continue;
+      const p = path.join(dir, name);
+      if (it.isDirectory()) {
+        if (AUDIT_SKIP_DIRS.has(name))
+          continue;
+        walk(p, depth + 1);
+        continue;
+      }
+      const ext = path.extname(name).toLowerCase();
+      const kind = STRUCT_EXT.has(ext) ? "struct" : (STYLE_EXT.has(ext) ? "style" : null);
+      if (!kind)
+        continue;
+      try {
+        out.push({ file: path.relative(root, p), text: readFileSync(p, "utf-8"), kind });
+      }
+      catch { /* 跳过不可读文件 */ }
+    }
+  };
+  walk(root, 0);
+  return out;
+}
+
+/** 从选择器串提取需「挂载」的 token（类名 / 属性名）；剔除伪类与组件库内置前缀 */
+function extractMountTokens(selector) {
+  const tokens = new Set();
+  if (typeof selector !== "string" || selector.trim() === "")
+    return [];
+  const cleaned = selector.replace(/::?[a-zA-Z-]+(\([^)]*\))?/g, " ");
+  let m;
+  const classRe = /\.([a-zA-Z_][\w-]*)/g;
+  while ((m = classRe.exec(cleaned)) !== null) {
+    const cls = m[1];
+    if (/^(el-|is-|v-modal)/.test(cls) || BUILTIN_BARE_CLASSES.has(cls))
+      continue;
+    tokens.add(cls);
+  }
+  const attrRe = /\[([a-zA-Z_][\w-]*)/g;
+  while ((m = attrRe.exec(cleaned)) !== null)
+    tokens.add(`[${m[1]}]`);
+  return [...tokens];
+}
+
+/** 在源码集中查找 token 的挂载情况 */
+function findMount(token, sources) {
+  const needle = token.startsWith("[") ? token.slice(1, -1) : token;
+  const re = new RegExp(`(^|[^\\w-])${escapeRe(needle)}([^\\w-]|$)`);
+  const hits = sources.filter(s => re.test(s.text));
+  return {
+    struct: hits.filter(h => h.kind === "struct" && !DESIGN_LAYER_RE.test(h.file)),
+    style: hits.filter(h => h.kind === "style" && !DESIGN_LAYER_RE.test(h.file)),
+    designLayer: hits.filter(h => DESIGN_LAYER_RE.test(h.file)),
+  };
+}
+
+/** 死通道检查：CSS 变量在项目中是否有 var() 消费者 */
+function findVariableConsumer(varName, sources) {
+  const re = new RegExp(`var\\(\\s*${escapeRe(varName)}\\s*[,)]`);
+  return sources.filter(s => re.test(s.text)).map(s => s.file);
+}
+
+/** 依据命中情况判定 token 的挂载状态 */
+function judgeMount(token, where, hit) {
+  if (hit.struct.length > 0)
+    return [];
+  if (hit.style.length > 0)
+    return [`挂载点可疑：${where} 的「${token}」只出现在样式文件（${hit.style.slice(0, 2).join("、")}），未在模板 / 脚本里挂载 —— 规则可能永不命中（历史缺口：列未绑 class-name，金额列右对齐 / 缩略图尺寸失效）`];
+  if (hit.designLayer.length > 0)
+    return [`挂载点缺失：${where} 的「${token}」只出现在设计层样式（${hit.designLayer.slice(0, 2).join("、")}），项目里既无结构挂载也无出厂对应 —— 规则不会生效`];
+  return [`挂载点缺失：${where} 的「${token}」在项目中未找到任何出现位置（选择器永不命中）`];
+}
+
+/** 单条目审计：selector / anchors 挂载点 + css_var 消费者 */
+function auditEntry(entry, sources) {
+  const issues = [];
+  for (const t of extractMountTokens(entry.selector))
+    issues.push(...judgeMount(t, "selector", findMount(t, sources)));
+
+  const anchors = Array.isArray(entry.anchors) ? entry.anchors : [];
+  for (const a of anchors) {
+    if (!a || typeof a.target !== "string")
+      continue;
+    if (a.kind === "css_var") {
+      const consumers = findVariableConsumer(a.target, sources);
+      if (consumers.length === 0)
+        issues.push(`死通道：CSS 变量 ${a.target} 在项目中无 var() 消费者（只定义不消费 = 通道死路，翻译再准也不生效）`);
+    }
+    else {
+      for (const t of extractMountTokens(a.target))
+        issues.push(...judgeMount(t, `anchors(${a.layer || "未标层级"})`, findMount(t, sources)));
+    }
+  }
+  return [...new Set(issues)];
+}
+
+function cmdAudit(args, dataset) {
+  const projIdx = args.indexOf("--project");
+  const projectRoot = projIdx > -1 ? args[projIdx + 1] : null;
+  if (!projectRoot) {
+    console.error("✖ 缺少目标项目路径：node parser/index.js audit --project <项目根目录> [<changeset.json…>]");
+    process.exit(1);
+  }
+  const root = path.resolve(projectRoot);
+  let stat;
+  try {
+    stat = statSync(root);
+  }
+  catch {
+    console.error(`✖ 目标项目路径不存在：${root}`);
+    process.exit(1);
+  }
+  if (!stat.isDirectory()) {
+    console.error(`✖ --project 参数应为目录：${root}`);
+    process.exit(1);
+  }
+
+  const files = args.filter((a, i) => !a.startsWith("--") && i !== projIdx + 1);
+  const sources = collectProjectSources(root);
+  const index = buildMergedIndex(dataset);
+
+  // 给了变更集 → 只审被引用的点位（含 apply_via 指向的锚点来源）；否则审词典全量
+  let targetIds;
+  if (files.length > 0) {
+    const wanted = new Set();
+    for (const f of files) {
+      let cs;
+      try {
+        cs = JSON.parse(readFileSync(path.resolve(f), "utf-8"));
+      }
+      catch (e) {
+        console.error(`✖ 变更集读取失败 ${f}：${e.message}`);
+        process.exit(1);
+      }
+      for (const c of cs.changes || []) {
+        if (c.id)
+          wanted.add(c.id);
+        if (typeof c.apply_via === "string")
+          wanted.add(c.apply_via);
+      }
+    }
+    targetIds = [...wanted];
+  }
+  else {
+    targetIds = Object.keys(index);
+  }
+
+  console.log(`审计目标：${root}`);
+  console.log(`源码文件：${sources.length}（已剔除 node_modules / dist 等产物目录）`);
+  console.log(`检查条目：${targetIds.length}${files.length > 0 ? "（仅变更集引用点位）" : "（词典全量）"}`);
+
+  let problems = 0;
+  const clean = [];
+  for (const id of targetIds) {
+    const entry = index[id];
+    if (!entry) {
+      console.log(`\n✘ ${id} —— 词典中无此条目（L3 新增点位，须当场落地并回写临时映射）`);
+      problems++;
+      continue;
+    }
+    const issues = auditEntry(entry, sources);
+    if (issues.length === 0) {
+      clean.push(id);
+      continue;
+    }
+    console.log(`\n✘ ${id}`);
+    for (const it of issues)
+      console.log(`    - ${it}`);
+    problems += issues.length;
+  }
+  if (clean.length > 0)
+    console.log(`\n✔ 通过：${clean.join("、")}`);
+
+  console.log(`\n汇总：${targetIds.length} 条点位，${problems} 个挂载 / 通道问题`);
+  if (problems > 0) {
+    console.log(`处置口径：挂载点缺失 / 死通道属**能力缺口** —— 当场按 structure_ops 补挂载或补消费者，交付说明单列申报；不得以「词典没建」为由跳过。`);
+    process.exitCode = 1;
+  }
+  else {
+    console.log(`✔ 无挂载 / 通道问题（渲染态是否一致仍需 §验收比对确认：静态审计查不出「值对了、位置不对」）`);
+  }
+}
+
+// ---- verify：渲染态逐点验收（V3.2 补丁 3 · 闭环验收回路） ----
+/**
+ * 比对两份 computed style 转储：oracle（效果图期望）vs actual（项目实测）。
+ * 转储格式：{ "<语义ID>": { "<css属性>": "<值>", ... }, ... }
+ * 期望与实测由**浏览器链路**抽取（效果图元素带 data-sid、项目页面同名 data-sid）——
+ * 本命令不做抽取，只做归一化 + 逐点 diff + 三类归因。
+ *
+ * CLI：node parser/index.js verify --oracle <oracle.json> --actual <actual.json> [--sids a,b,c]
+ * 退出码：存在缺口 → 1；全部命中 → 0。
+ */
+function cmdVerify(args) {
+  // 几何 / 盒模型属性：值对不上 = 语境错位（宿主盒 / 内层盒模型 / 层叠上下文不同）
+  const GEOMETRY_PROPS = new Set([
+    "display", "position", "top", "right", "bottom", "left", "box-sizing",
+    "width", "min-width", "max-width", "height", "min-height", "max-height",
+    "padding", "padding-top", "padding-right", "padding-bottom", "padding-left",
+    "padding-block", "padding-inline", "padding-block-start", "padding-block-end",
+    "padding-inline-start", "padding-inline-end",
+    "margin", "margin-top", "margin-right", "margin-bottom", "margin-left",
+    "margin-block", "margin-inline", "gap", "row-gap", "column-gap",
+    "text-align", "vertical-align", "line-height", "letter-spacing", "font-size",
+    "font-family", "white-space", "text-overflow", "overflow",
+    "border-radius", "border-top-left-radius", "border-top-right-radius",
+    "border-bottom-left-radius", "border-bottom-right-radius",
+    "flex", "flex-direction", "flex-grow", "flex-shrink", "flex-basis", "flex-wrap",
+    "justify-content", "align-items", "align-self", "transform", "inset",
+  ]);
+
+  const get = flag => {
+    const i = args.indexOf(flag);
+    return i > -1 ? args[i + 1] : null;
+  };
+  const oraclePath = get("--oracle");
+  const actualPath = get("--actual");
+  if (!oraclePath || !actualPath) {
+    console.error("✖ 缺少参数：node parser/index.js verify --oracle <oracle.json> --actual <actual.json> [--sids a,b,c]");
+    process.exit(1);
+  }
+  const sidsArg = get("--sids");
+  const sidFilter = sidsArg ? new Set(sidsArg.split(",").map(s => s.trim()).filter(Boolean)) : null;
+
+  const readDump = (p, label) => {
+    let raw;
+    try {
+      raw = readFileSync(path.resolve(p), "utf-8");
+    }
+    catch (e) {
+      console.error(`✖ ${label} 读取失败 ${p}：${e.message}`);
+      process.exit(1);
+    }
+    let json;
+    try {
+      json = JSON.parse(raw);
+    }
+    catch (e) {
+      console.error(`✖ ${label} 不是合法 JSON ${p}：${e.message}`);
+      process.exit(1);
+    }
+    // 允许 { sids: {…} } 或直接 { "<sid>": {…} } 两种外形
+    const map = json && json.sids && typeof json.sids === "object" ? json.sids : json;
+    if (!map || typeof map !== "object" || Array.isArray(map)) {
+      console.error(`✖ ${label} 结构非法：应为 { "<语义ID>": { "<属性>": "<值>" } }`);
+      process.exit(1);
+    }
+    return map;
+  };
+
+  const oracle = readDump(oraclePath, "效果图期望");
+  const actual = readDump(actualPath, "项目实测");
+
+  let sids = Object.keys(oracle);
+  if (sidFilter)
+    sids = sids.filter(s => sidFilter.has(s));
+
+  const normProp = p => String(p).trim().toLowerCase().replace(/_/g, "-");
+  const normValue = v => {
+    let s = String(v == null ? "" : v).trim().toLowerCase().replace(/\s+/g, " ");
+    s = s.replace(/\s*,\s*/g, ",");
+    // 3 位 hex 展开为 6 位，消除 "#fff" vs "#ffffff" 假缺口
+    s = s.replace(/#([0-9a-f]{3})\b/g, (_, h) => `#${h[0]}${h[0]}${h[1]}${h[1]}${h[2]}${h[2]}`);
+    return s;
+  };
+
+  console.log(`渲染态验收（computed style 逐点比对）`);
+  console.log(`效果图基线：${path.resolve(oraclePath)}`);
+  console.log(`项目实测：${path.resolve(actualPath)}`);
+  console.log(`比对点位：${sids.length}${sidFilter ? `（--sids 过滤后）` : "（oracle 全量）"}`);
+
+  let hitProps = 0;
+  let missProps = 0;
+  const attr = { selector_miss: 0, weight_override: 0, context_mismatch: 0 };
+  const clean = [];
+
+  for (const sid of sids) {
+    const exp = oracle[sid];
+    if (!exp || typeof exp !== "object") {
+      console.log(`\n⚠ ${sid} —— oracle 条目非法（应为属性对象），跳过`);
+      continue;
+    }
+    const actRaw = actual[sid];
+    if (!actRaw || typeof actRaw !== "object") {
+      console.log(`\n✘ ${sid}\n    - 项目页面未抽取到该点位 —— 选择器落空（挂载点缺失 / 元素未渲染 / data-sid 未标注）`);
+      attr.selector_miss++;
+      missProps++;
+      continue;
+    }
+    const act = {};
+    for (const [k, v] of Object.entries(actRaw))
+      act[normProp(k)] = v;
+
+    const lines = [];
+    for (const [propRaw, expVal] of Object.entries(exp)) {
+      const prop = normProp(propRaw);
+      if (!(prop in act)) {
+        lines.push(`    - ${prop}: 期望 ${expVal} / 实测未取到 —— 选择器落空（该属性所在规则未命中）`);
+        attr.selector_miss++;
+        continue;
+      }
+      if (normValue(expVal) === normValue(act[prop])) {
+        hitProps++;
+        continue;
+      }
+      const isGeom = GEOMETRY_PROPS.has(prop);
+      const kind = isGeom ? "语境错位" : "权重被压";
+      if (isGeom)
+        attr.context_mismatch++;
+      else
+        attr.weight_override++;
+      lines.push(`    - ${prop}: 期望 ${expVal} / 实得 ${act[prop]} —— ${kind}（${
+        isGeom ? "几何值对不上：宿主盒 / 内层盒模型或层叠上下文不同" : "同权重被组件 scoped / 行内样式反压，或令牌未生效"
+      }）`);
+      missProps++;
+    }
+
+    if (lines.length === 0) {
+      clean.push(sid);
+    }
+    else {
+      console.log(`\n✘ ${sid}`);
+      for (const l of lines)
+        console.log(l);
+    }
+  }
+
+  if (clean.length > 0)
+    console.log(`\n✔ 逐点命中：${clean.join("、")}`);
+
+  console.log(`\n汇总：${sids.length} 点位 · ${hitProps} 属性命中 · ${missProps} 缺口`);
+  console.log(`归因：选择器落空 ${attr.selector_miss} / 权重被压 ${attr.weight_override} / 语境错位 ${attr.context_mismatch}`);
+  if (missProps > 0) {
+    console.log(`处置口径：按归因修正 —— 选择器落空补挂载点（属能力缺口，走 structure_ops / 补通道并申报）；权重被压按 priority 声明提权（禁止 !important 掩盖）；语境错位校准 layer（host / inner）。`);
+    process.exitCode = 1;
+  }
+  else {
+    console.log(`✔ 渲染态与效果图基线逐点一致（验收通过）`);
+  }
+}
+
 /** 语义值译表索引：mapping 中 semantic-values.json 摊平为 { 语义名(中/英): 精确值 } */
 function buildSemanticValueIndex(dataset) {
   const dict = {};
@@ -542,6 +1110,11 @@ function cmdList(args, dataset) {
         console.log(`      style 字段：${fields.join(" ")}`);
       if (forms.length > 0)
         console.log(`      form 形态：${forms.join(" / ")}`);
+      // V3.2：落点层级与覆写优先级（设计侧声明 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))
+        console.log(`      落点层级：${layers.length > 0 ? layers.join(" / ") : "—"}；覆写优先级：${(e.priority && e.priority.strategy) || "—"}`);
     }
   }
 }