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

package/parser/index.js

@@ -1,2706 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * index.js — 映射体系解析执行入口
- *
- * 职责：
- *   1. 读取：递归合并 mapping/ 全目录 → 完整映射数据集
- *   2. 校验：调用 validator 全量校验，失败 exit 1
- *   3. 编译：调用 generator 生成 dist/ 产物
- *   4. 匹配：对设计变更集（design-changeset/v1）执行三级匹配，输出逐 ID 转换计划
- *      - 一级匹配：ID 完整命中 mappings
- *      - 二级匹配：父模块（去掉最后一段）命中
- *      - 三级匹配：全新模块 → 待补充映射清单
- *
- * CLI：
- *   node parser/index.js build [--dry]                      # 校验 + 生成产物
- *   node parser/index.js match <changeset.json...>          # 三级匹配（可多文件）
- *   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…>]      # 挂载点存在性 + 死通道静态审计
- *   node parser/index.js verify --oracle <o> --actual <a>    # 渲染态逐点验收：computed style 期望 vs 实测 diff（G12 存在性闸 + 残差豁免 + 快照回归）
- *   node parser/index.js registry <registry.json>            # 登记表通道核验：登记项 sid / dims 是否在词典有落点
- *   node parser/watch.js                                    # 开发态监听 mapping/ 自动重编译（§3.4.3）
- */
-
-import { readFileSync, writeFileSync, statSync, readdirSync, existsSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { buildMappingDataset } from "./loader.js";
-import { validateMappingDataset, buildMergedIndex } from "./validator.js";
-import { generateAll } from "./generator.js";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const ROOT = path.resolve(__dirname, "..");
-
-/** 定性值（非色彩类语义描述，如 中等/全圆角/宽松）：不参与译表，AI 按字段语义施工，不告警。
- *  注意：模块级常量必须在 main() 调用前声明（TDZ），勿下移到文件底部。 */
-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/;
-/**  落点层级枚举（与词典 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}$/;
-/**
- * 内层盒属性族（changeset-schema §layer）：这些文本控制/行高/对齐类属性必须落在 inner 层
- * 才生效。根因：Element Plus 给内层文本盒 .cell 写了 white-space:normal / text-align 等出厂
- * 样式，写在宿主盒（th/td）上会被内层覆盖 —— 这是「表头/内容竖排换行」的根因。
- * 本集合作两处消费：
- *   ① resolveAnchorTarget —— 命中即把该字段自动路由到 inner 锚点（保底落点，杜绝静默落 host）；
- *   ② checkInnerOnlyProps 闸门 —— 条目缺 inner 锚点却声明了此类字段时，报词典完整性缺口。
- */
-const INNER_ONLY_PROPS = new Set(["white_space", "text_overflow", "overflow", "word_break", "text_align", "line_height", "vertical_align", "nowrap", "text_align_last"]);
-/** 几何字段（宿主内边距/外边距族）：落 host 时与出厂内层盒自带 padding 叠加，必须同步清零内层（G5） */
-const GEOMETRY_PAD_RE = /^(padding|padding_x|padding_y|padding_inline|padding_block|margin|margin_x|margin_y|margin_inline|margin_block)$/;
-/** 登记表里唯一允许的「非词典点位」：全局令牌通道（对应变更集顶层 global 节点，无 css selector 故不入词典）。
- *  ⚠ 必须在 main() 调用前初始化（registry/match 命令运行时即访问；下移会触发 TDZ ReferenceError） */
-const GLOBAL_PSEUDO_ID = "global";
-
-/**  audit：审计时跳过的目录（依赖 / 产物 / 缓存） */
-const AUDIT_SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".output", ".vite", ".nuxt", "coverage", "public"]);
-/**  audit：「模板 / 脚本」扩展名：命中 = 结构挂载 */
-const STRUCT_EXT = new Set([".vue", ".html", ".htm", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
-/**  audit：「样式」扩展名：只命中样式 = 仅样式定义、无结构挂载 */
-const STYLE_EXT = new Set([".scss", ".sass", ".css", ".less", ".styl"]);
-/**  audit：设计层文件特征（只命中设计层 = 无实际挂载） */
-const DESIGN_LAYER_RE = /design-shell|design-layer|design\.scss/i;
-/**  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();
-
-function main() {
-  const [cmd, ...args] = process.argv.slice(2);
-
-  // 每个命令先构建 + 校验（保证在任何操作前映射数据可信）
-  const dataset = buildMappingDataset();
-  const { errors, warnings } = validateMappingDataset(dataset);
-  if (errors.length > 0) {
-    console.error(`✖ 映射表校验失败（${errors.length} 项）：`);
-    for (const e of errors)
-      console.error(`  ✘ ${e}`);
-    process.exit(1);
-  }
-
-  switch (cmd) {
-    case "build":
-      return cmdBuild(args, warnings);
-    case "match":
-      return cmdMatch(args, dataset);
-    case "list":
-      return cmdList(args, dataset);
-    case "query":
-      return cmdQuery(args, dataset);
-    case "audit":
-      return cmdAudit(args, dataset);
-    case "verify":
-      return cmdVerify(args, dataset);
-    case "registry":
-      return cmdRegistry(args, dataset);
-    default:
-      printHelp();
-  }
-}
-
-function printHelp() {
-  console.log(`vue3-temp-skill mapping parser
-
-用法：
-  node parser/index.js build [--dry]                      校验映射表并生成 dist/ 产物
-  node parser/index.js match <changeset.json...>          对设计变更集执行三级匹配（可多文件；mode 唯一合法值 restore——G8 模式闸强制 oracle.mockup + coverage.registry 齐备，显式 design 直接拒绝）
-                                                          主题身份：changeset.theme（优先）→ global.brand_primary（回退）；
-                                                          基线图色板：图内 data-mockup-theme（优先）→ 文件名主题词（回退）。
-                                                          二者不一致时须声明 oracle.theme_mapping（只做色值归一，不减声明）。
-  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（oracle.absent 存在性闸 G12 + residual_accepted 残差豁免 + oracle.states 状态断言闸 G14 + 孤儿点位对账闸 G15）
-  node parser/index.js verify --oracle <o.json> --actual <a.json> --baseline <snap.json> [--snapshot <out.json>]
-                                                          快照回归：与上轮快照比对基线漂移（上轮命中本轮退步 = 红）；--snapshot 导出本轮快照
-  node parser/index.js verify --oracle <o.json> --resolve [--sids a,b]
-                                                          实测端定位计划：sid → 词典 selector（项目页不打 data-sid 时按此抽取）
-  node parser/index.js verify … --from-theme 钴蓝 --to-theme 橘橙
-                                                          同构异色归一：按语义槽位把基线图色值归一为本主题色值再比（配合 oracle.theme_mapping）
-  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/ 变更自动重编译
-  node parser/override.js <overrides.json>                业务级映射覆写调试（API 见 parser/override.js）`);
-}
-
-// ---- build ----
-function cmdBuild(args, warnings) {
-  const dry = args.includes("--dry");
-  for (const w of warnings)
-    console.warn(`  ⚠ ${w}`);
-  const { written, tokenCount } = generateAll(path.join(ROOT, "dist"), dry);
-  console.log(`✔ 映射表校验通过（token ${tokenCount} 项）`);
-  if (dry)
-    console.log(`[dry-run] 将生成：${written.join("、")}`);
-  else
-    console.log(`✔ 产物已生成 → dist/：${written.join("、")}`);
-}
-
-// ---- match：三级匹配 ----
-function cmdMatch(args, dataset) {
-  // --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);
-  }
-
-  // --batch 目录模式：批量读取目录下全部变更集（设计侧项目级模式产出
-  // 「一份全局变更集 + 各页面变更集」，项目侧需一次性匹配）
-  let targets = [];
-  if (args.includes("--batch")) {
-    const dir = files[0];
-    const stat = statSync(path.resolve(dir));
-    if (!stat.isDirectory()) {
-      console.error(`✖ --batch 参数应为目录：${dir}`);
-      process.exit(1);
-    }
-    targets = readdirSync(path.resolve(dir))
-      .filter(f => f.endsWith(".json") && !f.startsWith("_"))
-      .sort()
-      .map(f => path.join(path.resolve(dir), f));
-    if (targets.length === 0) {
-      console.error(`✖ 目录内无变更集 JSON：${dir}`);
-      process.exit(1);
-    }
-    console.log(`── 批量模式：${targets.length} 份变更集（${dir}）──`);
-  }
-  else {
-    targets = files.map(f => path.resolve(f));
-  }
-
-  // 跨文件汇总（项目级模式对账用）
-  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, { 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} 份变更集）════════`);
-    console.log(`L1=${batchSummary.l1}（100%） L2=${batchSummary.l2}（85-90%） L3=${batchSummary.l3}（70-80%，补映射后 100%）`);
-    if (batchSummary.invalid.length > 0) {
-      console.log(`✖ 校验失败文件：${batchSummary.invalid.join("、")}`);
-    }
-    if (batchSummary.pendingIds.length > 0) {
-      const uniq = [...new Set(batchSummary.pendingIds)];
-      console.log(`缺口清单 · 新增点位（去重 ${uniq.length}，须当场落地 + 回写临时映射）：`);
-      for (const id of uniq)
-        console.log(`  - ${id}`);
-    }
-    if (batchSummary.fieldPending.length > 0) {
-      console.log(`缺口清单 · 字段级（优先当场落设计层，仅意图缺口回流）：`);
-      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, opts = {}) {
-  let changeset;
-  try {
-    changeset = JSON.parse(readFileSync(file, "utf-8"));
-  }
-  catch (e) {
-    console.error(`✖ 变更集读取/解析失败：${e.message}`);
-    batchSummary?.invalid.push(path.basename(file));
-    if (!batchSummary)
-      process.exit(1);
-    return;
-  }
-
-  // 协议校验（canonical：design.changeset/1.0，见 project-ui-design references/changeset-schema.md v1.0；
-  // 兼容历史值 design-changeset/v1，仅告警不阻断）
-  const SUPPORTED_SCHEMAS = ["design.changeset/1.0", "design-changeset/v1"];
-  if (!SUPPORTED_SCHEMAS.includes(changeset.schema)) {
-    console.error(`✖ schema 应为 "design.changeset/1.0"，实际 "${changeset.schema ?? "缺失"}"`);
-    batchSummary?.invalid.push(path.basename(file));
-    if (!batchSummary)
-      process.exit(1);
-    return;
-  }
-  if (changeset.schema === "design-changeset/v1") {
-    console.warn(`  ⚠ schema "${changeset.schema}" 为历史值，建议设计侧升级为 "design.changeset/1.0"`);
-  }
-
-  // G8 模式闸：变更集顶层 mode 声明交付模式。
-  //   mode=restore（场景还原）→ oracle + coverage 强制齐备，缺失 = exit 1。
-  //   事故背景：还原项目后重跑技能，产出「只换主题色」的轻量变更集却以还原之名交付——
-  //   186 条登记表、oracle 基线、coverage 记账全部缺席，parser 只打提示不阻断，一路绿灯
-  //   落地后用户看到「只变了主题、布局细节零变化」。教训文档化 ≠ 机器闸门：
-  //   「场景还原应给」的软提示升级为「mode=restore 必须给」的硬闸。
-  //   强化一：oracle/coverage 须有「芯」——oracle.mockup 与 coverage.registry 非空，
-  //   堵住空壳伪基线（有对象无内容）继续蒙混。
-  //   强化二：降级通道废除——mode 唯一合法值 restore，显式 "design" 直接拒绝。
-  //   mode 缺省按旧协议兼容（legacy 变更集无 scheme/page_types，由下方 G8b 基线命中闸兜底）。
-  const mode = changeset.mode === undefined || changeset.mode === null ? null : changeset.mode;
-  if (mode === "design") {
-    console.error(`✖ mode="design" 不是合法交付模式：还原任务的目标是把设计 100% 落地到项目——环境受限 / 覆盖不足 / 意图不明时唯一正确动作是停下向用户多轮询问确认，不得缩水交付；用户显式只要小改动时，不产出还原变更集（按普通需求直接修改）。基线三件套（oracle.mockup + coverage.registry）是还原交付的固有组成，任何 mode 形态都不得移除。`);
-    batchSummary?.invalid.push(path.basename(file));
-    if (!batchSummary)
-      process.exit(1);
-    return;
-  }
-  if (mode !== null && mode !== "restore") {
-    console.error(`✖ mode 应为 "restore"（唯一合法值），实际 "${mode}"`);
-    batchSummary?.invalid.push(path.basename(file));
-    if (!batchSummary)
-      process.exit(1);
-    return;
-  }
-  if (mode === "restore") {
-    // G8 强化：不只看「有没有 oracle/coverage 这两个对象」，
-    //   还要看**芯**在不在——oracle.mockup 与 coverage.registry 是基线的两根承重梁：
-    //   · oracle.mockup 空 → 效果图无从抽取，还原度不可证明；
-    //   · coverage.registry 空 → A/C 无法以登记表为权威当场重算，自报数字即可蒙混，「完备性可数」形同虚设。
-    //   空壳写法（{ oracle:{sids:[]}, coverage:{applicable:0,covered:0} }）过去能一路绿灯，现予拦截。
-    const hasStr = v => typeof v === "string" && v.trim().length > 0;
-    const missing = [];
-    if (!hasStr(changeset.scheme))
-      missing.push("scheme（设计方案标识——缺它无法定位「方案 × 场景」的清单 / 登记表，还原范围失去锚点）");
-    if (!changeset.oracle || typeof changeset.oracle !== "object")
-      missing.push("oracle（验收基线：mockup + sids，效果图即 1:1 的验收凭证）");
-    else if (!hasStr(changeset.oracle.mockup))
-      missing.push("oracle.mockup（效果图路径——空则基线抽不出来，还原度无从证明）");
-    if (!changeset.coverage || typeof changeset.coverage !== "object")
-      missing.push("coverage（登记表覆盖率记账：registry + registrable/applicable/covered + gaps）");
-    else if (!hasStr(changeset.coverage.registry))
-      missing.push("coverage.registry（登记表路径——空则 parser 无法以登记表为权威重算 A/C，自报数字形同虚设）");
-    if (missing.length > 0) {
-      console.error(`\n✖ G8 模式闸：mode=restore（场景还原）但缺少 ${missing.join(" 与 ")} → 拒绝执行。`);
-      console.error(`  场景还原的完备性以登记表覆盖率为分母、以 oracle 为验收基线——缺任一项即「伪还原变更集」：`);
-      console.error(`  只换主题色也能一路绿灯落地，但布局细节点位从未被声明，还原度不可证明。`);
-      console.error(`  处置：补齐后重跑——mode=design 不是合法出口；范围确需缩小时停下向用户多轮询问确认。`);
-      batchSummary?.invalid.push(path.basename(file));
-      if (!batchSummary)
-        process.exit(1);
-      return;
-    }
-    console.log(`  ✔ G8 模式闸：mode=restore，oracle + coverage 齐备（基线三件套完整）`);
-  }
-
-  // G8 强化：基线命中 ⇒ 不得以缺 mode / 降级形态移除基线三件套。
-  //   事故形态：执行会话把「环境无浏览器」读成降级许可，以 6 条品牌色变更交差，
-  //   notes 自述「未强制绑定基线登记表与 oracle.json」。显式 mode=design 已被上方硬拒，
-  //   本闸兜底「缺 mode 但带 scheme + page_types」的现代形态：三件套缺一即拒。
-  if (mode !== "restore") {
-    const covG8b = changeset.coverage && typeof changeset.coverage === "object" ? changeset.coverage : {};
-    const pageTypesG8b = Array.isArray(covG8b.page_types) ? covG8b.page_types : [];
-    const hasCoreG8b =
-      typeof changeset.oracle?.mockup === "string" && changeset.oracle.mockup.trim().length > 0 &&
-      typeof covG8b.registry === "string" && covG8b.registry.trim().length > 0;
-    if (pageTypesG8b.length && changeset.scheme && !hasCoreG8b) {
-      // 方案注册表（含 baseline 登记）在设计侧技能内；跨技能同机部署时按兄弟目录解析
-      const schemeRegistryG8b = path.resolve(__dirname, "..", "..", "project-ui-design", "references", "page-specs", "styles", "registry.json");
-      let baselineHitsG8b = [];
-      try {
-        const srG8b = JSON.parse(readFileSync(schemeRegistryG8b, "utf-8"));
-        for (const schG8b of srG8b.schemes || []) {
-          if (schG8b.id !== changeset.scheme) continue;
-          for (const [ptG8b, bG8b] of Object.entries(schG8b.baseline || {})) {
-            if (ptG8b.startsWith("$") || !bG8b || typeof bG8b !== "object" || !bG8b.mockup) continue;
-            if (pageTypesG8b.includes(ptG8b)) baselineHitsG8b.push(ptG8b);
-          }
-        }
-      } catch { /* 设计侧技能未检出（非同机部署）时跳过——设计侧 D15 为权威闸 */ }
-      if (baselineHitsG8b.length) {
-        console.error(`\n✖ G8 模式闸（基线命中判定）：还原目标存在注册基线（scheme="${changeset.scheme}" × scene="${changeset.scene || "?"}" × 页型 ${baselineHitsG8b.join("/")}），却以 mode=${mode || "(缺省)"} 且缺基线三件套交付 → 拒绝执行。`);
-        console.error(`  环境受限 / 覆盖不足 / 意图不明时唯一正确动作是停下向用户多轮询问确认，基线三件套（oracle.mockup + coverage.registry）照交；`);
-        console.error(`  严禁借任何 mode 形态把还原缩水成主题色变更。`);
-        batchSummary?.invalid.push(path.basename(file));
-        if (!batchSummary)
-          process.exit(1);
-        return;
-      }
-    }
-  }
-
-  // G13 页面绑定闸：效果图页面是设计角色坐标系，不是页面增量。
-  //   事故背景：效果图演示页「运单管理」被误落地为项目新菜单/新页面——效果图标题只是
-  //   设计侧为承载设计语言虚构的演示名，落地动作恒为「映射已有页面 + 在其上同步结构与样式」，
-  //   「图上有这个页面」不构成新增依据。
-  //   机检范围（diff 级「不得出现新路由/菜单/页面文件」由第 5 步合规闸人工+AI 对账）：
-  //   ① page_bindings 结构校验（数组、mockup/target 必填）；
-  //   ② target:"new" 必须 notes 申报——未申报 = 效果图演示页被静默实体化，exit 1；
-  //   ③ 每次输出页面绑定声明，让施工 AI 与交付说明都有映射口径可依。
-  const DEFAULT_BINDING_POLICY = "效果图页面默认映射已有页面（设计角色坐标系≠页面增量）：禁止新增页面/路由/菜单，落地=在已有页面上同步结构与样式";
-  if (changeset.page_bindings !== undefined && changeset.page_bindings !== null) {
-    if (!Array.isArray(changeset.page_bindings)) {
-      console.error(`✖ G13 页面绑定闸：page_bindings 应为数组（{ mockup, target, note }），实际 ${typeof changeset.page_bindings} → 拒绝执行。`);
-      batchSummary?.invalid.push(path.basename(file));
-      if (!batchSummary)
-        process.exit(1);
-      return;
-    }
-    console.log(`\n=== 页面绑定声明（G13 · ${changeset.page_bindings.length} 条）===`);
-    for (const [i, b] of changeset.page_bindings.entries()) {
-      if (!b || typeof b !== "object" || !b.mockup || !b.target) {
-        console.error(`✖ G13 页面绑定闸：page_bindings[${i}] 缺 mockup 或 target → 拒绝执行。`);
-        batchSummary?.invalid.push(path.basename(file));
-        if (!batchSummary)
-          process.exit(1);
-        return;
-      }
-      if (b.target === "new") {
-        const notes = typeof changeset.notes === "string" ? changeset.notes : "";
-        if (!notes.includes("新增页面") && !notes.includes("new 页面") && !notes.includes("target:\"new\"")) {
-          console.error(`✖ G13 页面绑定闸：${b.mockup} 声明 target:"new"（新增业务页面）但 notes 未申报 → 拒绝执行。`);
-          console.error(`  处置：确需落成新业务页面时，在 notes 显式写明「新增页面：<mockup> → <路由名>，理由…」后重跑；`);
-          console.error(`  否则该效果图页面按默认口径映射已有页面落地。`);
-          batchSummary?.invalid.push(path.basename(file));
-          if (!batchSummary)
-            process.exit(1);
-          return;
-        }
-        console.log(`  - ${b.mockup} → 新增页面（notes 已申报）`);
-      }
-      else {
-        console.log(`  - ${b.mockup} → 已有页面 ${b.target}${b.note ? `（${b.note}）` : ""}`);
-      }
-    }
-  }
-  else {
-    console.log(`  ✔ G13 页面绑定闸：page_bindings 缺省 → ${DEFAULT_BINDING_POLICY}`);
-  }
-
-  // 版本校验（mapping_version 缺失或不匹配 → 拒绝。版本恒定 1.0.0，此校验为破坏性升级保险丝：仅双侧同步升版时才会拦截）
-  const versions = new Set(
-    Object.values(dataset.files).map(d => d.meta?.version).filter(Boolean),
-  );
-  const required = changeset.mapping_version;
-  if (!required) {
-    console.error(`✖ 缺少 mapping_version（v1.0 协议必填；恒填 "1.0.0"——词典版本恒定策略）`);
-    batchSummary?.invalid.push(path.basename(file));
-    if (!batchSummary)
-      process.exit(1);
-    return;
-  }
-  if (!versions.has(required)) {
-    console.error(`✖ 变更集依赖映射表版本 ${required}，当前映射集版本为 ${[...versions].join("/")}，不兼容 → 拒绝执行（正常应恒填 "1.0.0"；出现此错误通常意味着词典已发生破坏性协议升级，请与项目侧核对）`);
-    batchSummary?.invalid.push(path.basename(file));
-    if (!batchSummary)
-      process.exit(1);
-    return;
-  }
-
-  // 禁词校验（v1.0：双侧文档承诺「协议违规 = parser 阻断」，此处实现）
-  const banned = checkBannedWords(changeset);
-  if (banned.length > 0) {
-    console.error(`✖ 协议违规（禁词出现即阻断，共 ${banned.length} 处）：`);
-    for (const b of banned)
-      console.error(`  ✘ ${b}`);
-    batchSummary?.invalid.push(path.basename(file));
-    if (!batchSummary)
-      process.exit(1);
-    return;
-  }
-
-  const index = buildMergedIndex(dataset);
-  const valueDict = buildSemanticValueIndex(dataset);
-  const plan = [];
-  const pending = [];
-  const fieldPending = []; // 字段级待补充：ID 命中但 style 字段两层映射均未命中
-  const gateViolations = []; // 词典驱动硬闸：suppress 收口（G1）+ 几何语境（G5），违规 = 协议违规同级阻断
-
-  // global 令牌翻译（design-apply 第 3 步：走 basic/ 词典，主色另需 setEpThemeColor 链路）
-  if (changeset.global && Object.keys(changeset.global).length > 0) {
-    const tokenDict = buildTokenIndex(dataset);
-    console.log(`\n=== global 令牌翻译（basic/ 词典 + 语义值译表）===`);
-    const gPending = [];
-    for (const [field, value] of Object.entries(changeset.global)) {
-      const def = tokenDict[field];
-      const resolved = resolveSemanticValue(value, valueDict);
-      if (def)
-        console.log(`  . ${field}: ${value} → 令牌 ${def.token}${resolved ? `（精确值 ${resolved}）` : ""}${def.hook ? `（钩子 ${def.hook}）` : ""} @ ${def.file}`);
-      else
-        gPending.push(field);
-      if (!resolved && def && !QUALITATIVE_RE.test(String(value).trim()) && !/^(#|rgb|hsl)/.test(String(value).trim()))
-        console.log(`    ⚠ 值 "${value}" 未命中语义值译表且非 hex，施工前需确认精确值`);
-    }
-    if (gPending.length > 0) {
-      console.error(`\n✖ global 令牌缺口（共 ${gPending.length} 处 → 拒绝执行）：词典 basic/ 无此令牌字段 —— ${gPending.join("、")}`);
-      console.error(`  处置：先在 mapping/basic/ 令牌词典补齐该字段的 css_vars/hook 映射，再重跑；主题基座令牌不走「未匹配即跳过」通道。`);
-      batchSummary?.invalid.push(path.basename(file));
-      if (!batchSummary)
-        process.exit(1);
-      return;
-    }
-  }
-
-  // layout_type 枚举校验（shell-geometry layout_modes）
-  // 兼容读取：设计侧 v0.2 曾误用顶层 `layout` 键——读出来并告警，防止布局意图静默丢失
-  let layoutValue = changeset.layout_type;
-  if (!layoutValue && changeset.layout !== undefined) {
-    layoutValue = changeset.layout;
-    console.warn(`  ⚠ 顶层字段名 "layout" 已废弃（v1.0 协议为 "layout_type"），本次按值 "${changeset.layout}" 兼容处理；请上游更正字段名`);
-  }
-  if (layoutValue) {
-    const layoutModes = collectLayoutModes(dataset);
-    if (layoutModes.size > 0 && !layoutModes.has(layoutValue)) {
-      console.warn(`  ⚠ layout_type "${layoutValue}" 不在标准枚举 [${[...layoutModes].join("/")}] 内 → 按变体/定制布局流程处理（design-apply §4.3）`);
-    }
-  }
-
-  for (const change of changeset.changes || []) {
-    const id = change.id;
-    // 一级：完整命中
-    if (index[id]) {
-      plan.push({ level: 1, id, entry: index[id], change });
-      continue;
-    }
-    // 二级：父模块命中
-    const parentId = id.split(".").slice(0, -1).join(".");
-    if (parentId && index[parentId]) {
-      plan.push({ level: 2, id, parent: parentId, entry: index[parentId], change });
-      continue;
-    }
-    // 三级：全新模块
-    plan.push({ level: 3, id, change });
-    pending.push(id);
-  }
-
-  // pending[] 解析（v1.0：设计侧新 ID 通道，function/parent 供 L3 施工与临时映射生成）
-  if (Array.isArray(changeset.pending) && changeset.pending.length > 0) {
-    console.log(`\n=== pending 新增 ID（${changeset.pending.length} 条，归入 L3 施工，携带功能描述）===`);
-    for (const p of changeset.pending) {
-      if (!p || !p.proposed_id)
-        continue;
-      const hit = pending.includes(p.proposed_id);
-      console.log(`  - ${p.proposed_id}${hit ? "" : "（注意：未出现在 changes[] 中，本次不落地）"}`);
-      console.log(`    功能：${p.function || "（未提供）"}；父模块：${p.parent || "（未提供）"}`);
-    }
-  }
-
-  // oracle 验收基线（：设计侧给的效果图 + 待比对点位；项目侧落地后跑 verify 逐点 diff）
-  // mockup 相对路径解析以「变更集同目录」为第一基准（协议约定 oracle 产物与变更集同目录），
-  // 其次 cwd / 技能根（历史行为兼容）。
-  // G11 oracle 基线闸：restore 模式下返回值非 0 = 阻断（与 G8 同级）
-  const oracleGaps = checkOracle(changeset, plan, valueDict, { strict: mode === "restore", filePath: file }) || 0;
-  checkCoverage(changeset, { strict: mode === "restore" });
-  // 登记表覆盖率（子项级细闸）：以登记表为权威、当场重算 A/C，设计侧自报的 coverage 不参与
-  // strict（mode=restore）同时驱动 G9 登记表身份闸与 G10 dims 兑现闸
-  const regGaps = checkRegistryCoverage(changeset, plan, { ...opts, strict: mode === "restore" });
-  if (batchSummary)
-    batchSummary.registryGaps += regGaps + oracleGaps;
-  else if (regGaps + oracleGaps > 0)
-    process.exitCode = 1;
-
-  // 输出转换计划
-  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, gateViolations, p.id);
-      checkSuppress(p.change, p.entry, p.id, gateViolations);
-      checkGeometryContext(p.change, p.entry, p.id, gateViolations);
-      checkTokenChainContext(p.change, p.entry, p.id, gateViolations);
-      checkInnerOnlyProps(p.change, p.entry, p.id, gateViolations);
-      checkFieldForms(p.change, p.entry, p.id, gateViolations);
-      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(`  结构：定位父容器按相对位置增量插入；样式：复用父模块映射 + 全局组件映射`);
-      checkFormEnum(p.entry, p.change, gateViolations, p.id);
-      checkSuppress(p.change, p.entry, p.id, gateViolations);
-      checkGeometryContext(p.change, p.entry, p.id, gateViolations);
-      checkTokenChainContext(p.change, p.entry, p.id, gateViolations);
-      checkFieldForms(p.change, p.entry, p.id, gateViolations);
-      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}）→ exit 1（词典缺 ID = 交付不完整）===`);
-    console.log(`  处置：当场按 L3 落地并回写临时映射后重跑（词典缺 ID 属能力缺口，不是跳过理由）；仅设计侧未给意图才回流。`);
-    for (const id of pending)
-      console.log(`  - ${id}`);
-  }
-
-  if (fieldPending.length > 0) {
-    console.log(`\n=== 缺口清单 · 字段级（${fieldPending.length}，ID 命中但 style 字段两层映射均未命中）→ exit 1（字段缺口 = 细节必丢）===`);
-    console.log(`  处置：在条目作用域内生成自定义规则落设计层文件并申报后重跑；仅「值非法 / 无法定位 / 设计侧未给值」才回流设计侧。`);
-    for (const f of fieldPending)
-      console.log(`  - ${f.id}: ${f.fields.join("、")}`);
-  }
-
-  // 缺口清单 = 交付不完整，与词典硬闸同权重：新增点位 / 字段级缺口存在即 exit 1。
-  // 「点位在、细节丢」正是字段级缺口被静默放行的机制成因——缺口只有两种合法出口：补齐，或回流设计侧。
-  const gapCount = pending.length + fieldPending.length;
-  if (gapCount > 0) {
-    if (batchSummary) {
-      batchSummary.pendingIds.push(...pending);
-      batchSummary.fieldPending.push(...fieldPending);
-      batchSummary.invalid.push(path.basename(file));
-      return;
-    }
-    process.exit(1);
-  }
-
-  const l1 = plan.filter(p => p.level === 1).length;
-  const l2 = plan.filter(p => p.level === 2).length;
-  const l3 = plan.filter(p => p.level === 3).length;
-  console.log(`\n汇总：L1=${l1}（还原度 100%） L2=${l2}（85-90%） L3=${l3}（70-80%，补映射后可达 100%）`);
-
-  // 词典驱动硬闸（suppress 收口 / 几何语境）：违规 = 交付不完整，与禁词同级阻断
-  if (gateViolations.length > 0) {
-    console.error(`\n✖ 词典硬闸违规（共 ${gateViolations.length} 处 → 拒绝执行）：`);
-    for (const v of gateViolations)
-      console.error(`  ✘ ${v}`);
-    console.error(`  处置：回变更集补齐 suppress / suppress_inner / layer 声明后重跑；判据均来自词典条目自身，不接受「我观感上对了」。`);
-    batchSummary?.invalid.push(path.basename(file));
-    if (!batchSummary)
-      process.exit(1);
-    return;
-  }
-
-  // 汇入跨文件统计（项目级批量模式）
-  if (batchSummary) {
-    batchSummary.l1 += l1;
-    batchSummary.l2 += l2;
-    batchSummary.l3 += l3;
-    batchSummary.pendingIds.push(...pending);
-    batchSummary.fieldPending.push(...fieldPending);
-  }
-}
-
-/** 禁词校验（v1.0 守门员）：DOM/CSS/技术栈词与 hex 位置违规 → 违规描述数组（空 = 通过）
- *  口径与 project-ui-design changeset-schema.md §禁词校验 一致：
- *  - hex 仅允许出现在 changes[].style 值与 notes 中
- *  - id/position/form/visible 等字段出现 hex、CSS 变量名（--el-* / --vts-* / --*）、
- *    选择器写法（.xxx / #xxx 开头）、伪类（::v-deep / :deep()）即阻断
- *  - 语义 ID 命名合法性（小写下划线 2~4 段） */
-function checkBannedWords(changeset) {
-  const violations = [];
-  const HEX_RE = /#[0-9a-fA-F]{3,8}\b/;
-  const CSSVAR_RE = /--[a-z][a-z0-9-]*/i;
-  const DEEP_RE = /::?(v-)?deep\(/;
-  const SEL_RE = /^[.#]|[\s]+[.][a-z]|[\s]+#[a-z0-9]/i;
-  const TECH_WORDS = [":deep", "::v-deep", "!important", "el-button", "el-menu", "el-input", "element-plus", "querySelector"];
-  const ID_RE = /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*){1,3}$/;
-
-  const scan = (label, value) => {
-    const s = String(value);
-    if (HEX_RE.test(s))
-      violations.push(`${label}：出现 hex 色值 "${s}"（hex 仅允许在 style 值与 notes）`);
-    if (CSSVAR_RE.test(s))
-      violations.push(`${label}：出现 CSS 变量名 "${s}"`);
-    if (DEEP_RE.test(s))
-      violations.push(`${label}：出现穿透写法 "${s}"`);
-    if (SEL_RE.test(s))
-      violations.push(`${label}：疑似选择器写法 "${s}"`);
-    for (const w of TECH_WORDS) {
-      if (s.toLowerCase().includes(w.toLowerCase()))
-        violations.push(`${label}：出现技术栈词 "${w}"`);
-    }
-  };
-
-  for (const [i, c] of (changeset.changes || []).entries()) {
-    const label = `changes[${i}]`;
-    // global 为设计侧伪点位（对应变更集顶层 global 节点，同 match 路径口径），豁免 ID 命名规范
-    if (!c.id || (c.id !== GLOBAL_PSEUDO_ID && !ID_RE.test(c.id)))
-      violations.push(`${label}.id "${c.id}" 不符合语义 ID 命名规范（小写下划线、2~4 段点分层级）`);
-    if (c.position !== undefined && c.position !== null)
-      scan(`${label}.position`, c.position);
-    if (c.form !== undefined && c.form !== null)
-      scan(`${label}.form`, c.form);
-    if (c.id)
-      scan(`${label}.id`, c.id);
-    //  三个声明维度：禁词扫描 + 结构校验（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;
-}
-
-function extractForms(e) {
-  if (!e.forms)
-    return [];
-  if (Array.isArray(e.forms))
-    return e.forms.map(f => (typeof f === "string" ? f : f[0])).filter(Boolean);
-  // 对象形态：{ chrome: "说明", card: "说明" } 取键；{ mode: [a,b,c] } 取数组值
-  const out = [];
-  for (const v of Object.values(e.forms)) {
-    if (Array.isArray(v))
-      out.push(...v.filter(x => typeof x === "string"));
-    else if (typeof v === "string" && /^[a-z][a-z0-9_]*$/.test(v))
-      out.push(v);
-  }
-  return out.length > 0 ? out : Object.keys(e.forms);
-}
-
-/** 全局令牌索引：basic/ + layout/ 词典摊平为 { abstractField: {token, hook, file} } */
-function buildTokenIndex(dataset) {
-  const dict = {};
-  for (const [file, data] of Object.entries(dataset.files)) {
-    if (!data.tokens)
-      continue;
-    for (const [field, def] of Object.entries(data.tokens)) {
-      if (field.startsWith("$") || typeof def !== "object")
-        continue;
-      dict[field] = {
-        token: Array.isArray(def.token) ? def.token.join(" → ") : (def.token || "(value token)"),
-        hook: def.hook || null,
-        file: `mapping/${file}`,
-      };
-    }
-  }
-  return dict;
-}
-
-/** 标准布局枚举集合：取 layout 域文件的 layout_modes 键 */
-function collectLayoutModes(dataset) {
-  const modes = new Set();
-  for (const data of Object.values(dataset.files)) {
-    if (data.layout_modes) {
-      for (const k of Object.keys(data.layout_modes)) {
-        if (!k.startsWith("$"))
-          modes.add(k);
-      }
-    }
-  }
-  return modes;
-}
-
-/** form 枚举校验：条目定义了 forms 时，form 值必须在其枚举内（词典硬闸：枚举外的形态无处落地，违规即阻断） */
-function checkFormEnum(entry, change, gateViolations, idLabel) {
-  if (!change.form || !entry.forms)
-    return;
-  const formKeys = extractForms(entry);
-  if (formKeys.length > 0 && !formKeys.includes(change.form)) {
-    const msg = `${idLabel || change.id}：form "${change.form}" 不在条目枚举 [${formKeys.join("/")}] 内（G3 枚举闸）→ 报告不猜，回变更集改为枚举内形态或先扩词典 forms`;
-    if (gateViolations)
-      gateViolations.push(msg);
-    else
-      console.error(`  ✘ ${msg}`);
-  }
-}
-
-/** 两层样式转换：css_vars 优先 → custom_style_map 兜底（含落点层级解析）→ 未匹配记缺口清单 */
-function printStyleTranslation(entry, change, idLabel, fieldPending, valueDict) {
-  const styles = change.style || {};
-  if (Object.keys(styles).length === 0)
-    return;
-  const lines = [];
-  const unmatched = [];
-  for (const [field, value] of Object.entries(styles)) {
-    const resolved = resolveSemanticValue(value, valueDict);
-    const valueLabel = resolved ? `${value} → ${resolved}` : value;
-    if (entry.css_vars && entry.css_vars[field]) {
-      lines.push(`  . ${field}: ${valueLabel} → var 覆盖 ${entry.css_vars[field]}（@ ${entry.style_scope}）`);
-    }
-    else if (entry.custom_style_map && entry.custom_style_map[field]) {
-      // ：按变更集 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 if (entry.data_channels && entry.data_channels[field]) {
-      // 数据/结构通道：值走业务页 prop / 数据 / 模板（禁 CSS 仿冒），非缺口
-      lines.push(`  . ${field}: ${valueLabel} → 数据/结构通道（${entry.data_channels[field].slice(0, 60)}…）`);
-    }
-    else {
-      unmatched.push(field);
-      continue;
-    }
-    // 字段命中但值未消歧：非 hex、非定性值、不在译表 → 提示（不阻断，AI 施工前须确认）
-    if (!resolved && !QUALITATIVE_RE.test(String(value).trim()) && !/^(#|rgb|hsl|var\(|calc\()/.test(String(value).trim()))
-      lines.push(`    ⚠ 值 "${value}" 未命中语义值译表且非 hex，施工前需确认精确值`);
-  }
-  for (const l of lines)
-    console.log(l);
-  if (unmatched.length > 0) {
-    console.log(`  ⚠ 未匹配字段：${unmatched.join("、")}（按缺口清单处置：优先在设计层落地并申报，不静默跳过）`);
-    if (fieldPending)
-      fieldPending.push({ id: idLabel || change.id, fields: unmatched });
-  }
-}
-
-// ----  · 落点 / 结构施工 / 优先级 解析 ----
-
-/** 取字段的落点层级：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");
-  // 内层盒属性族保底路由：nowrap / text_align / line_height 等即使未显式声明 layer，
-  // 也强制落到 inner 锚点（EP 内层 .cell 出厂样式会覆盖 host 层声明，裸落 host = 竖排换行）。
-  if (INNER_ONLY_PROPS.has(field)) {
-    const innerHit = classAnchors.find(a => a.layer === "inner");
-    if (innerHit)
-      return { target: innerHit.target, layer: "inner" };
-  }
-  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}` : ""}`);
-    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 → 未声明 oracle.theme_mapping 时
- *     逐点比对必然全红（搬错基线）。注意：**基线图是「场景基线」、与主题无关，任何主题都读同一张**；
- *     不一致只影响「色值归一」，正确动作是声明 theme_mapping 后继续读图，**不是换图、更不是跳过读取**。
- *  ② 覆盖度缺口：效果图里有、changes[] 却未声明的点位 → 永远不可能被还原（欠声明）；
- *     反之声明了却不在 sids 里的点位 → 落地后无法机器验收。
- * 两者都属「交付不完整」，与颜色红线同级，必须回流设计侧补齐。
- * 主题身份读取口径（与设计侧 mockup-extraction-spec.md §1.1 同源）：
- *   本次主题 = changeset.theme（优先）→ global.brand_primary（回退）；
- *   基线图色板 = 图内 data-mockup-theme（优先）→ 文件名主题词（回退）。
- *   历史缺口：主题只能从 global.brand_primary 反推、基线图身份只能从文件名猜 → 「图名带钴蓝」
- *   被读成「可还原主题白名单」，换橘橙时误判无基线 → 跳过读图、只改主题色。
- */
-function checkOracle(changeset, plan, valueDict, opts = {}) {
-  const oracle = changeset.oracle;
-  if (!oracle || typeof oracle !== "object") {
-    if (opts.strict) {
-      console.error(`\n✖ mode=restore 下 oracle 缺失（G8 模式闸要求，见变更集校验段）——基线三件套不完整，先回设计侧补齐。`);
-      return 1; // G11：restore 下基线缺失 = 阻断，不再是提示后继续
-    }
-    console.log(`\n提示：变更集未提供 oracle 验收基线（场景还原应给）—— 落地后无法做 computed style 逐点比对，还原度不可证明，建议回流设计侧补齐。`);
-    return 0;
-  }
-
-  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 = [];
-
-  // ① 主题一致性：本次主题（changeset.theme 优先，回退 global.brand_primary）
-  //    vs 基线图色板（图内 data-mockup-theme 优先，回退文件名主题词）。
-  //    为什么要两端回退：主题身份以前只能从 global.brand_primary 反推、基线图身份只能从文件名猜——
-  //    于是「主题」被绑进 global 的取值收敛语义，而「图的名字」被读成了「可还原主题白名单」，
-  //    换非基线主题时被误判为无基线 → 跳过读图、只改主题色。
-  //    权威口径见设计侧 mockup-extraction-spec.md §1.1：基线图是场景基线，与主题无关。
-  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 themeDeclaredRaw = typeof changeset.theme === "string" ? changeset.theme.trim() : "";
-  const declaredTheme = themeDeclaredRaw || themeFromValue(changeset.global && changeset.global.brand_primary);
-  const themeSource = themeDeclaredRaw
-    ? "changeset.theme"
-    : (declaredTheme ? "global.brand_primary（回退——建议改在顶层声明 changeset.theme）" : "未声明");
-
-  // 基线图色板：图内元数据为权威（基线图与主题无关，文件名主题词仅供参考）
-  const mockupResolvedEarly = resolveFirstExisting(mockup, opts.filePath);
-  let mockupTheme = null;
-  let mockupThemeSource = null;
-  if (mockupResolvedEarly) {
-    try {
-      const html = readFileSync(mockupResolvedEarly, "utf-8");
-      const m = /\bdata-mockup-theme\s*=\s*["']([^"']+)["']/i.exec(html);
-      if (m) { mockupTheme = m[1].trim(); mockupThemeSource = "图内 data-mockup-theme"; }
-    } catch { /* 图不可读，回退文件名 */ }
-  }
-  if (!mockupTheme) {
-    const byName = [...themes].find(t => mockup.includes(t)) || null;
-    if (byName) { mockupTheme = byName; mockupThemeSource = "文件名主题词（旧图回退——建议补 data-mockup-theme）"; }
-  }
-
-  console.log(`  本次主题：${declaredTheme || "（未声明）"}（来源：${themeSource}）`);
-  console.log(`  基线图色板：${mockupTheme || "（未标注）"}${mockupThemeSource ? `（来源：${mockupThemeSource}）` : ""}`);
-
-  // 同构异色归一：theme_mapping { "from": "<基线图色板>", "to": "<本次主题>" } 只描述
-  // 「基线图色值 → 本次主题语义槽位（-1..-10）」的归一映射，verify 用 --from-theme/--to-theme 执行；
-  // **它与「是否读取该图 / 是否逐条声明」无关**——任何主题都读同一张场景基线图并逐点抽取。
-  const tm = oracle.theme_mapping && typeof oracle.theme_mapping === "object" ? oracle.theme_mapping : null;
-  const declaredReuse = !!(tm && tm.from && tm.to
-    && themes.has(tm.from) && themes.has(tm.to)
-    && declaredTheme === tm.to && mockupTheme === tm.from);
-
-  if (declaredReuse) {
-    console.log(`  ↺ 同构异色归一已声明：基线图色板「${tm.from}」→ 本次主题「${tm.to}」（oracle.theme_mapping）。verify 需带 --from-theme ${tm.from} --to-theme ${tm.to} 做色值归一；几何 / 结构 / 字号逐点照比。`);
-  }
-  else if (declaredTheme && mockupTheme && declaredTheme !== mockupTheme) {
-    if (!themes.has(declaredTheme)) {
-      // 库外临时主题：语义槽位表里没有它的槽位，theme_mapping 的按槽位归一不适用
-      console.log(`  ℹ 本次为库外临时主题「${declaredTheme}」：基线图色板「${mockupTheme}」无对应语义槽位，verify 不做色值归一（几何 / 结构 / 字号仍逐点照比）；色值按设计侧 notes 申报的派生口径落地。`);
-    } else {
-      issues.push(`主题错配（本次主题 ≠ 基线图色板）：基线图是「${mockupTheme}」、本次主题是「${declaredTheme}」（来源：${themeSource}）。**基线图是场景基线、与主题无关——正确动作是继续读这张图并逐点抽取**，同时声明 oracle.theme_mapping: { "from": "${mockupTheme}", "to": "${declaredTheme}" }（它只做色值归一，不减任何声明与读取动作）；若结构 / 形态确实也不同，则另立基线图后登记 baseline。**不得把"主题不匹配"读成"该主题没有基线图"而跳过读取。**`);
-    }
-  }
-  if (!mockupTheme && mockup) {
-    const hint = themeDeclaredRaw
-      ? `已在 changeset.theme 声明「${themeDeclaredRaw}」——基线图身份未标注不影响读取：按注册表 baseline.<页型>.mockup 取该页型基线图即可，请在该图 <html> 上补 data-mockup-theme（含 scene / page-type）后再验。`
-      : `无法确认基线图色板 —— 请核对该图是否为本页型的场景基线图，并在 <html> 上补 data-mockup-theme / data-mockup-scene / data-mockup-page-type。`;
-    console.log(`  ℹ 基线图未带主题身份元数据：${hint}`);
-  }
-
-  // ② 覆盖度（双向）
-  const declaredIds = plan.map(p => p.id);
-  const sidSet = new Set(sids);
-  // 仅 visible:false 的隐藏点位在效果图上没有可见元素可标 data-sid —— 豁免「无基线」判定
-  const hiddenOnly = new Set(
-    plan.filter(p => p.change && p.change.visible === false).map(p => p.id),
-  );
-  // 实物闭合兜底（G3）：带登记表时由 checkRegistryCoverage 做权威实物对账；
-  // 未带登记表时此处直接打开 mockup 数 data-sid，防止「sids 自报全绿、实物基线为空」。
-  // mockup 路径解析复用 resolveFirstExisting（变更集同目录 → cwd → 技能根）。
-  if (!changeset.coverage?.registry && mockup) {
-    const mockupPath = resolveFirstExisting(mockup, opts.filePath);
-    let physical = null;
-    if (mockupPath) {
-      try {
-        const stripped = readFileSync(mockupPath, "utf-8").replace(/<!--[\s\S]*?-->/g, "");
-        physical = new Set([...stripped.matchAll(/data-sid\s*=\s*["']([^"']+)["']/g)].map(m => m[1]));
-      }
-      catch { /* mockup 不可读，physical 保持 null */ }
-    }
-    if (physical) {
-      const sidNoPhysical = sids.filter(s => !physical.has(s) && !hiddenOnly.has(s));
-      if (sidNoPhysical.length > 0)
-        issues.push(`实物缺口 ${sidNoPhysical.length} 处：oracle.sids 声明了、效果图 HTML 实物里无对应 data-sid（剥注释后数点）→ 基线抽不出来。\n      ${sidNoPhysical.join("、")}`);
-    }
-  }
-  const sidNotDeclared = sids.filter(s => !declaredIds.includes(s));
-  const declaredWithoutSid = declaredIds.filter(id => !sidSet.has(id) && !hiddenOnly.has(id));
-  if (hiddenOnly.size > 0)
-    console.log(`  ℹ 隐藏点位（仅 visible:false）${hiddenOnly.size} 处豁免 sid 标注：${[...hiddenOnly].join("、")}`);
-  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 0;
-  }
-  // G11 oracle 基线硬闸：restore 模式下基线问题从「⚠ 软提示」升格为阻断。
-  //   历史缺口：主题错配 / 欠声明 / 无基线只打 ⚠ 就继续——基线断了仍绿灯交付，
-  //   verify 无从做 1:1 证明，「细节没还原到位」在交付时不可见。
-  if (opts.strict) {
-    console.error(`\n✖ oracle 基线问题（G11 · ${issues.length} 类 → 拒绝执行）：`);
-    for (const it of issues)
-      console.error(`  ✘ ${it}`);
-    console.error(`  处置：按上列各条回设计侧补齐基线（补 sids 声明 / 声明 theme_mapping 做色值归一；基线图缺失时先补图）后重跑。注意「换主题」不等于「换图」——任何主题都读同一张场景基线图。`);
-    return 1;
-  }
-  console.log(`\n⚠ oracle 基线问题（${issues.length} 类）：`);
-  for (const it of issues)
-    console.log(`  ✘ ${it}`);
-  return 0;
-}
-
-/**
- * 覆盖率校验（场景还原子项级细闸）
- * 设计侧用「登记表」把规范里每条带样式结论的子项变成必登项，交付时以 coverage 记账。
- * 这里只做结构一致性校验：covered 必须等于 applicable、gaps 必须为空。
- * 缺 coverage 时无法判断「是否有组内子项被静默丢失」——属交付完整性的信号缺口。
- */
-function checkCoverage(changeset, opts = {}) {
-  const cov = changeset.coverage;
-  if (!cov || typeof cov !== "object") {
-    if (opts.strict)
-      console.error(`\n✖ mode=restore 下 coverage 缺失（G8 模式闸要求，见变更集校验段）——186 条登记表口径的完备性无从计数，先回设计侧补齐。`);
-    else
-      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}`);
-}
-
-/** 依次尝试候选路径，返回首个存在者（相对路径基准：变更集所在目录 → 当前工作目录 → 技能仓库根 → 兄弟设计技能 project-ui-design 根） */
-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);
-  // 兄弟技能根：真实设计侧登记表/效果图沉淀在 project-ui-design（设计侧 page-specs），
-  // 跨库引用时允许相对该根解析（两侧技能目录同级部署是标准布局）。
-  const sibling = path.resolve(ROOT, "..", "project-ui-design");
-  bases.push(sibling);
-  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] : [];
-}
-
-/**
- * 登记表覆盖率（子项级细闸，）
- * 组级台账（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;
-    }
-    if (opts.strict) {
-      // G9 前置缺口：mode=restore 却解析不到登记表实物（G8 只验了字符串非空）
-      console.error(`\n✖ G9 登记表身份闸：mode=restore 但登记表实物不存在（coverage.registry="${raw}" 解析失败）→ 拒绝执行。`);
-      console.error(`  覆盖率分母必须来自「方案 × 场景」的真实登记表，否则壳层/表格细粒度点位从分母消失，欠声明不可数。`);
-      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;
-  }
-
-  // G9 登记表身份闸：restore 模式下，登记表必须属于「本变更集声明的方案 × 场景」，
-  //   且必须是有 items 的真登记表。历史缺口：G8 只验 coverage.registry 是非空字符串——
-  //   拿 6 条的回归夹具 registry-sample.json、甚至别的方案/场景的登记表都能过 G8，
-  //   覆盖率分母（R=186 的壳层+表格子项）被偷换成小表，「面包屑/顶栏图标/表头 nowrap」这类点位
-  //   从分母里消失 → 欠声明不可数 → 细节还原缺口一路绿灯。凡「身份对不上的表」视同没有表。
-  const scheme = typeof changeset.scheme === "string" ? changeset.scheme : "";
-  const scene = typeof changeset.scene === "string" ? changeset.scene : "";
-  const regScheme = typeof registry.design_scheme === "string" ? registry.design_scheme : "";
-  const regScene = typeof registry.scene === "string" ? registry.scene : "";
-  const identityMismatch = (regScheme && scheme && regScheme !== scheme) || (regScene && scene && regScene !== scene);
-  if (opts.strict && (identityMismatch || !regScheme || !regScene)) {
-    console.error(`\n✖ G9 登记表身份闸：登记表 ${path.basename(registryPath)} 属于 scheme="${regScheme || "?"}"/scene="${regScene || "?"}"，与变更集 scheme="${scheme || "?"}"/scene="${scene || "?"}" 不一致（或缺身份字段）→ 拒绝执行。`);
-    console.error(`  处置：coverage.registry 改指「${scheme} × ${scene}」方案的登记表（如设计侧 page-specs/styles/<方案>/scenes/<场景>/restore-registry.json）。`);
-    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 declaredSids = new Set(Array.isArray(changeset.oracle?.sids) ? changeset.oracle.sids : []);
-
-  // 实物闭合：打开 oracle.mockup 这个 HTML，数真实存在的 data-sid（不只看设计侧自报的 oracle.sids）
-  // mockup 路径解析复用 resolveFirstExisting（变更集同目录 → cwd → 技能根）。
-  const mockupRef = changeset.oracle?.mockup;
-  let physicalSids = null;
-  let mockupFile = null;
-  const mockupResolved = resolveFirstExisting(typeof mockupRef === "string" ? mockupRef : null, opts.filePath);
-  if (mockupResolved) {
-    try {
-      const html = readFileSync(mockupResolved, "utf-8");
-      // 先剥离 HTML 注释再数 data-sid：注释内的同形串是说明文字、不是点位。
-      // 不剥离 → 注释可「兜住」一个实际缺失的标注，闸门全绿而基线为空（详见 mockup-extraction-spec.md §7.1）。
-      const stripped = html.replace(/<!--[\s\S]*?-->/g, "");
-      physicalSids = new Set([...stripped.matchAll(/data-sid\s*=\s*["']([^"']+)["']/g)].map(m => m[1]));
-      mockupFile = mockupResolved;
-    }
-    catch { /* mockup 不可读，physicalSids 保持 null */ }
-  }
-  // 比对基准：优先效果图实物；实物读不到时退化为自报清单（并在下方告警）
-  const mockupSids = physicalSids || declaredSids;
-
-  const applicable = items.filter(it => it.always === true || registrySids(it).some(s => mockupSids.has(s)));
-
-  // G10 dims 兑现闸：「兑现」从「ID 出现」升格为「ID 出现 且 dims 维度全部出现」。
-  //   历史缺口：只数 ID——声明了 admin.content.table.header_cell 却漏掉 nowrap / font_weight /
-  //   text_align 等关键维度也算「已兑现」→ 表头竖排（nowrap 丢失）、字重不对（font_weight 丢失）
-  //   这类「点位在、细节丢」的症状一路绿灯。核对口径：dims 中的 form 看 change.form；
-  //   其余维度看 change.style ∪ change.layer 的键；source:none（登记即兑现）、global 伪点位
-  //   （全局通道字段名与登记 dims 不同构）、visible:false 隐藏点位不做 dims 机检。
-  const hiddenIds = new Set((changeset.changes || []).filter(c => c && c.visible === false).map(c => c.id));
-  const missingDimsOf = (it, change) => {
-    const dims = it.dims || [];
-    const styleKeys = new Set([...Object.keys(change.style || {}), ...Object.keys(change.layer || {})]);
-    const missing = [];
-    if (dims.includes("form") && change.form === undefined)
-      missing.push("form");
-    for (const d of dims.filter(d => d !== "form")) {
-      if (!styleKeys.has(d))
-        missing.push(d);
-    }
-    return missing;
-  };
-  const dimsGaps = []; // { item, missing }
-  const gaps = applicable.filter(it => {
-    const sids = registrySids(it);
-    if (!sids.every(s => declared.has(s)))
-      return true; // ID 级欠声明（原有缺口口径）
-    if (it.source === "none")
-      return false;
-    const primary = sids.find(s => s !== GLOBAL_PSEUDO_ID);
-    if (!primary)
-      return false; // global 伪点位条目
-    if (hiddenIds.has(primary))
-      return false; // visible:false 点位 dims 豁免（与 oracle 隐藏点位豁免同口径）
-    const change = (changeset.changes || []).find(c => c.id === primary);
-    if (!change)
-      return false; // 经 pending/visible 兑现且无 style 意图条目 → dims 由台账人工闸承载
-    const missing = missingDimsOf(it, change);
-    if (missing.length === 0)
-      return false;
-    dimsGaps.push({ item: it, missing });
-    return false;
-  });
-
-  console.log(`\n=== 登记表覆盖率（子项级细闸 · 当场重算）===`);
-  console.log(`  登记表：${registryPath}（登记项 R=${items.length}）`);
-  console.log(`  适用 A=${applicable.length} / 已兑现 C=${applicable.length - gaps.length} / 缺口 ${gaps.length}${dimsGaps.length > 0 ? ` / dims 缺口 ${dimsGaps.length}（G10）` : ""}`);
-  if (dimsGaps.length > 0) {
-    console.log(`  ⚠ dims 兑现缺口 ${dimsGaps.length} 条（ID 已声明、dims 维度未给全）：`);
-    for (const { item, missing } of dimsGaps.slice(0, 10))
-      console.log(`      ${item.rule}  ${registrySids(item).join(" + ")}  缺 dims=[${missing.join(",")}]`);
-  }
-
-  // 实物校验：标注缺口的权威来源是效果图 HTML 里的 data-sid，而不是自报的 oracle.sids。
-  // 两类合法豁免（与 mockup-extraction-spec §7.1 / 设计侧 D3b 同源）：
-  //   ① hiddenSids：visible:false 隐藏点设计本身不渲染，基线图上无元素可标；
-  //   ② 令牌通道 sid 无元素锚点，由同登记项内已标注的兄弟 sid 以 some 语义覆盖。
-  let physicalGap = false;
-  const hiddenSids = new Set(plan.filter(p => p.change && p.change.visible === false).map(p => p.id));
-  const sidCoveredByItem = new Map();
-  for (const it of items) {
-    const sids = registrySids(it);
-    const anyAnnotated = sids.some(s => mockupSids.has(s));
-    for (const s of sids)
-      sidCoveredByItem.set(s, anyAnnotated);
-  }
-  if (physicalSids) {
-    console.log(`  效果图实物：${mockupFile}（实测 data-sid ${physicalSids.size} 个）`);
-    const declaredNoPhysical = [...declaredSids].filter(
-      s => !physicalSids.has(s) && !hiddenSids.has(s) && !sidCoveredByItem.get(s),
-    );
-    const physicalNoDeclared = [...physicalSids].filter(s => !declaredSids.has(s));
-    if (declaredNoPhysical.length > 0) {
-      console.log(`  ⚠ oracle.sids 声明了 ${declaredNoPhysical.length} 个点位，但效果图实物里没有对应 data-sid（无基线）：${declaredNoPhysical.join("、")}`);
-      physicalGap = true;
-    }
-    if (physicalNoDeclared.length > 0) {
-      console.log(`  ✘ 效果图实物另有 ${physicalNoDeclared.length} 个 data-sid 未列入 oracle.sids（自报清单不全 → 基线中存在的细节不得排除在验收外）：${physicalNoDeclared.join("、")}`);
-      physicalGap = true;
-    }
-  }
-  else if (opts.strict && changeset.oracle && changeset.oracle.mockup) {
-    console.log(`  ✘ 未能打开效果图实物（oracle.mockup 不可读）→ 基线不可用 = 不可验收，禁止退化为按自报 oracle.sids 校验`);
-    physicalGap = true;
-  }
-
-  // 效果图标注完整性：恒存在的子项必须能在效果图上找到同名 data-sid，否则基线根本抽不出来
-  const unannotated = items.filter(
-    it => it.always === true
-      && !registrySids(it).every(s => hiddenSids.has(s))
-      && !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("、")}`);
-    physicalGap = true;
-  }
-
-  if (gaps.length === 0 && dimsGaps.length === 0 && !physicalGap) {
-    console.log(`  ✔ 覆盖率通过：C = A，无子项被静默丢失；dims 维度全兑现（G10）；效果图实物标注闭合`);
-    return 0;
-  }
-
-  if (gaps.length === 0 && dimsGaps.length === 0 && physicalGap) {
-    console.log(`\n✘ 效果图实物标注不闭合 → exit 1（oracle.sids 与效果图 HTML 的 data-sid 不一致 / 恒存在子项缺标注）`);
-    console.log(`  处置：给效果图对应元素补 data-sid，或把该登记项降级 source: spec（见 mockup-extraction-spec.md §7）`);
-    return 1;
-  }
-
-  if (dimsGaps.length > 0 && opts.strict) {
-    console.log(`\n✘ dims 兑现缺口（G10 · ID 已声明但 dims 维度未给全，共 ${dimsGaps.length} 条 → exit 1）：`);
-    for (const { item, missing } of dimsGaps)
-      console.log(`      ${item.rule}  ${registrySids(item).join(" + ")}  缺 dims=[${missing.join(",")}]`);
-    console.log(`  处置：在对应 changes[] 条目的 style/layer 补齐所缺维度取值（值来源见 source 字段）；「点位在、细节丢」正是样式细节不还原的机制成因。`);
-  }
-
-  if (gaps.length > 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 展开）`);
-    }
-  }
-  // G10 dims 缺口计入返回值：strict 模式下 =「交付不完整」与欠声明同级
-  return gaps.length + (opts.strict ? dimsGaps.length : 0);
-}
-
-/**
- * 登记表通道核验
- * 与 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 是无效声明 */
-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 应为非空语义数据源名`);
-      }
-    }
-  }
-}
-
-// ---- 词典驱动硬闸：suppress 收口（G1）+ 几何语境（G5） ----
-// 与 checkApplyFields（协议自洽性校验）不同，这两个闸的判据来自**词典条目自身**：
-//   · suppress_rules：条目声明某 form 时必须收口的出厂互斥通道（声明 form = 换掉旧形态，不是叠加）
-//   · preconditions 含「几何语境随值迁移」：几何值落宿主时必须同步清零内层盒同向属性
-// 缺失即「新旧形态叠加 / 两层 padding 相加」——值都对、观感错，是「还原度连乘公式」里
-// 通道正确率的天花板级杀手，因此与禁词同级（阻断，不是提示）。
-
-/** 提取条目 suppress_rules：优先结构化字段；回落解析 forms 描述与 $note 中的「suppress 必含 xxx」内联标记 */
-function extractSuppressRules(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") : [];
-    }
-  }
-  // 兜底：从 forms 描述文本提取「suppress 必含 名1/名2」标记（历史条目未结构化时仍能机检）
-  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;
-}
-
-/** G1：声明 form 时，词典 suppress_rules 要求的出厂互斥通道必须逐项声明在条目 suppress 数组 */
-function checkSuppress(change, entry, idLabel, violations) {
-  if (typeof change.form !== "string" || !change.form || !entry)
-    return;
-  const rules = extractSuppressRules(entry);
-  const required = rules[change.form];
-  if (!required || required.length === 0)
-    return;
-  const declared = Array.isArray(change.suppress) ? change.suppress : [];
-  const missing = required.filter(ch => !declared.includes(ch));
-  if (missing.length > 0) {
-    violations.push(
-      `${idLabel}.suppress 缺口：词典要求 form="${change.form}" 必须收口出厂互斥通道 [${required.join("、")}]，`
-      + `实际声明 [${declared.join("、") || "无"}]，缺 [${missing.join("、")}]`
-      + ` —— 声明 form = 换掉旧形态而不是叠加；不收口 = 出厂旧装饰残留（失效模式：旧形态未收口时新旧装饰并存，如侧栏 pill 残留右竖条 → 双竖条）。`
-      + `通道名取该条目 forms/css_vars 的键名。`,
-    );
-  }
-}
-
-/**
- * G5：几何语境自检 —— 宿主 + 内层之和必须等于设计值。
- * 词典 preconditions 含「几何语境随值迁移」标记的条目：style 声明几何字段且 layer 未显式
- * 指到 inner（即默认落 host）时，必须同步声明 suppress_inner（内层清零口径，纯语义描述），
- * 否则实际内边距 = 设计值 + 出厂内层自带值（失效模式：内层出厂 padding 未清零时设计值与出厂值相加，如 16px + 12px = 28px/侧 → 列挤坏）。
- */
-function checkGeometryContext(change, entry, idLabel, violations) {
-  if (!entry || !Array.isArray(entry.preconditions))
-    return;
-  if (!entry.preconditions.some(p => typeof p === "string" && p.includes("几何语境随值迁移")))
-    return;
-  const style = change.style && typeof change.style === "object" ? change.style : null;
-  if (!style)
-    return;
-  const layer = change.layer && typeof change.layer === "object" && !Array.isArray(change.layer) ? change.layer : {};
-  const geometryFields = Object.keys(style).filter(k => GEOMETRY_PAD_RE.test(k));
-  if (geometryFields.length === 0)
-    return;
-  // 内层属性族字段（white-space/text-align 等）已逐字段声明 inner → 施工方已知内层结构，不重复拦截
-  const hasInnerAware = Object.keys(layer).some(f => layer[f] === "inner") || geometryFields.every(f => layer[f] === "inner");
-  if (hasInnerAware)
-    return;
-  const hostGeometry = geometryFields.filter(f => layer[f] !== "inner");
-  if (hostGeometry.length === 0)
-    return;
-  const declaredInner = typeof change.suppress_inner === "string" ? change.suppress_inner.trim() : "";
-  if (!declaredInner) {
-    violations.push(
-      `${idLabel}.suppress_inner 缺口：条目 preconditions 标记「几何语境随值迁移」（出厂内层文本盒自带内边距），`
-      + `style 几何字段 [${hostGeometry.join("、")}] 落宿主时必须同步声明 suppress_inner（内层清零口径）`
-      + ` —— 否则实际间距 = 设计值 + 出厂内层值，两层之和 ≠ 设计值（失效模式：设计值与出厂内层值相加，如 16px + 12px = 28px/侧 → 列宽被挤、标题截断）。`,
-    );
-  }
-}
-
-/**
- * G6：层间令牌链对账 —— 跨条目的父子两层盒共享同一条令牌链时，同一间距只允许一个权威来源。
- * 词典 preconditions 含「层间令牌链对账」标记的条目：style 声明几何字段（padding/margin 族）
- * 时必须同步声明 suppress_inner（同链邻层接管/清零口径），否则父层设计值 + 子层同链令牌值
- * 物理叠加（失效模式：设计 24px 落父层 .app-main，子层 .main-content 的 --vts-margin 出厂 8px
- * 原样保留 → 24+8=32px/侧，「边距很大」且与效果图不符）。与 G5 的分工：G5 管「同一条目内
- * host+inner 两层盒」，本闸管「跨条目的父子两层盒 + 同链令牌」。
- */
-function checkTokenChainContext(change, entry, idLabel, violations) {
-  if (!entry || !Array.isArray(entry.preconditions))
-    return;
-  if (!entry.preconditions.some(p => typeof p === "string" && p.includes("层间令牌链对账")))
-    return;
-  const style = change.style && typeof change.style === "object" ? change.style : null;
-  if (!style)
-    return;
-  const geometryFields = Object.keys(style).filter(k => GEOMETRY_PAD_RE.test(k));
-  if (geometryFields.length === 0)
-    return;
-  const declaredInner = typeof change.suppress_inner === "string" ? change.suppress_inner.trim() : "";
-  if (!declaredInner) {
-    violations.push(
-      `${idLabel}.suppress_inner 缺口：条目 preconditions 标记「层间令牌链对账」（父子两层盒共享同一条间距令牌链，同一间距只允许一个权威来源），`
-      + `style 几何字段 [${geometryFields.join("、")}] 必须同步声明 suppress_inner（同链邻层接管/清零口径：写明间距由哪层承载、另一层如何归零）`
-      + ` —— 否则父层设计值 + 子层同链令牌值物理叠加（失效模式：设计 24px 落父层，子层 --vts-margin 出厂 8px 原样保留 → 24+8=32px/侧，内容区边距显著大于效果图）。`
-      + `施工建议：优先走令牌通道（在消费点作用域重映射同链令牌，两层同变），不抢写物理 padding。`,
-    );
-  }
-}
-
-/**
- * G5b：内层盒属性族 · 词典完整性闸 —— INNER_ONLY_PROPS 字段（nowrap/text_align/line_height 等）
- * 必须能落到 inner 层，否则这些文本控制属性无处可落、必然被 EP 内层 .cell 出厂样式吞掉。
- * 触发条件（零误报）：仅当条目本身「声明了 INNER_ONLY_PROPS 字段」却「没有 inner 锚点」时报警
- * —— 这是词典侧的能力缺口（缺 inner 锚点），须补 anchors 里的 inner 条目，而非设计侧能补救。
- * 条目带 inner 锚点时由 resolveAnchorTarget 自动路由兜底，本闸不重复拦截（避免噪音）。
- */
-function checkInnerOnlyProps(change, entry, idLabel, violations) {
-  if (!entry || !Array.isArray(entry.anchors))
-    return;
-  const hasInner = entry.anchors.some(a => a && a.kind === "class" && a.layer === "inner");
-  if (hasInner)
-    return;
-  const style = change.style && typeof change.style === "object" ? change.style : null;
-  if (!style)
-    return;
-  const offenders = Object.keys(style).filter(f => INNER_ONLY_PROPS.has(f));
-  if (offenders.length === 0)
-    return;
-  violations.push(
-    `${idLabel}.anchors 完整性缺口：条目 style 声明了内层盒属性族 [${offenders.join("、")}]`
-    + `（文本控制/行高/对齐类，必须落 inner 层才不被 EP 内层 .cell 出厂样式覆盖），`
-    + `但本条目 anchors 无 inner 锚点 —— 这些字段无处可落，将出现「竖排换行 / 对齐失效」。`
-    + `修复：在 anchors 补 { kind:"class", layer:"inner", target:"… > .cell" } 承载选择器。`,
-  );
-}
-
-/**
- * G7：field_forms 声明-消费闭合 —— style 字段必须被当前 form 消费。
- * 词典条目声明 field_forms（字段 → 合法 form 枚举）后：变更集 style 里的字段若不在
- * 当前 form 的合法集内 = 字段无消费者、将被静默丢弃（失效模式：变更集声明 pill +
- * active_indicator_* 三字段，设计层按 pill 施工把竖条令牌置透明，效果图要求的左竖条消失——
- * 「声明了却不消费」此前无任何闸门拦截）。修复路径：换 form（含组合形态）或删字段。
- */
-function checkFieldForms(change, entry, idLabel, violations) {
-  if (!entry || typeof entry.field_forms !== "object" || entry.field_forms === null)
-    return;
-  const style = change.style && typeof change.style === "object" ? change.style : null;
-  if (!style)
-    return;
-  const form = typeof change.form === "string" && change.form ? change.form : null;
-  // 无 form 声明时跳过（纯样式条目，字段消费不依赖形态）；无该字段映射时跳过
-  if (!form)
-    return;
-  for (const [field, legalForms] of Object.entries(entry.field_forms)) {
-    if (!(field in style))
-      continue;
-    if (!Array.isArray(legalForms) || legalForms.length === 0)
-      continue;
-    if (!legalForms.includes(form)) {
-      violations.push(
-        `${idLabel}.field_forms 闭合违规：style 字段「${field}」仅在 form [${legalForms.join("、")}] 下有消费者，`
-        + `当前 form="${form}" 不消费该字段 → 声明将被静默丢弃`
-        + ` —— 修复：换用消费该字段的 form（含组合形态），或删除该字段。禁止「声明字段 + 互斥 form」的组合（失效模式：pill + 指示条通道未收口 → 指示条被设计层置透明，视觉消失）。`,
-      );
-    }
-  }
-}
-
-
-// 本节的模块级常量（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 [];
-  const fmt = arr => arr.map(h => (typeof h === "string" ? h : `${h.file}（${(h.reasons || []).join("；")}）`)).slice(0, 2).join("、");
-  if (hit.style.length > 0)
-    return [`挂载点可疑：${where} 的「${token}」只出现在样式文件（${fmt(hit.style)}），未在模板 / 脚本里挂载 —— 规则可能永不命中（历史缺口：列未绑 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 = [];
-  const miss = (token) => {
-    // 设计层已承载同类名 → 挂载点可疑降级为提示（不阻断）：C 通道由 design-shell.scss 兜底
-    if (hasDesignLayerTakeover(token, sources))
-      return null;
-    return true;
-  };
-  for (const t of extractMountTokens(entry.selector)) {
-    if (miss(t))
-      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) {
-        // 两类合法豁免（防误报）：
-        // ① --el-* 组件库变量：消费者在 element-plus 主题库（node_modules 不在扫描范围），
-        //    项目源码无 var() 属正常 —— EP runtime 必然消费。
-        // ② 设计层已接管变量定义（design-shell 显式赋值）：suppress / 接管属故意行为
-        //    （词典 preconditions 有明示的条目，如 --vts-theme-menu-active-before）。
-        if (a.target.startsWith("--el-")) {
-          console.log(`  ℹ ${a.target} 项目源码无 var() 消费者 —— 由组件库运行时消费（node_modules 不在扫描范围），不按死通道处理`);
-        }
-        else if (designLayerDefines(a.target, sources)) {
-          console.log(`  ℹ ${a.target} 项目源码无 var() 消费者 —— 设计层已接管该变量定义（suppress / 接管属故意行为），不按死通道处理`);
-        }
-        else {
-          issues.push(`死通道：CSS 变量 ${a.target} 在项目中无 var() 消费者（只定义不消费 = 通道死路，翻译再准也不生效）`);
-        }
-      }
-    }
-    else {
-      for (const t of extractMountTokens(a.target)) {
-        if (miss(t))
-          issues.push(...judgeMount(t, `anchors(${a.layer || "未标层级"})`, findMount(t, sources)));
-      }
-    }
-  }
-  return [...new Set(issues)];
-}
-
-/** 判定「设计层已承载」的豁免：条目 anchors/selector 的类词元在设计层文件出现时，
- *  挂载点可疑可降级为提示 —— 设计层覆写本身就是合法落点（design-shell.scss 是 C 通道终点）。 */
-function hasDesignLayerTakeover(token, sources) {
-  const needle = token.startsWith("[") ? token.slice(1, -1) : token;
-  const re = new RegExp(`(^|[^\\w-])${escapeRe(needle)}([^\\w-]|$)`);
-  return sources.some(s => DESIGN_LAYER_RE.test(s.file) && re.test(s.text));
-}
-
-/** 设计层是否显式定义了该 CSS 变量（suppress / 接管动作），定义在非设计层的令牌宿主不算 */
-function designLayerDefines(varName, sources) {
-  const re = new RegExp(`${escapeRe(varName)}\\s*:`);
-  return sources.some(s => DESIGN_LAYER_RE.test(s.file) && re.test(s.text));
-}
-
-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;
-  const loadedChangesets = []; // G2/G4：保留完整变更集供施工证据与 T 通道对账
-  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);
-      }
-      loadedChangesets.push(cs);
-      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 ? "（仅变更集引用点位）" : "（词典全量）"}`);
-
-  // ---- G2：structure_ops 施工证据（台账落地断言）----
-  // 数据 / 结构驱动点位必须在项目源码里找到施工痕迹，纯 CSS 落点声明 structure_ops = 冒充施工：
-  //   add_node/remove_node/move_node/render_branch/bind_source → 按条目 selector/anchors 的语义类名
-  //   在**非设计层**源码（含模板与数据脚本）里查证该节点/绑定的存在性（结构文件命中才算兑现）。
-  // 失效模式：结构操作只声明不施工、以 CSS 覆写冒充 → 按钮间距 / 列宽永不达标。
-  let structIssues = 0;
-  if (loadedChangesets.length > 0) {
-    console.log(`\n=== structure_ops 施工证据（G2 · 模板 diff 取证）===`);
-    for (const cs of loadedChangesets) {
-      for (const [i, c] of (cs.changes || []).entries()) {
-        const ops = Array.isArray(c.structure_ops) ? c.structure_ops : [];
-        if (ops.length === 0 || !c.id)
-          continue;
-        const entry = index[c.id];
-        const probes = collectStructProbes(entry, c);
-        const evidence = probes
-          .map(p => ({ probe: p, hits: findStructEvidence(p, sources) }))
-          .filter(x => x.hits.length > 0);
-        if (probes.length === 0) {
-          console.log(`  ⚠ changes[${i}] ${c.id}：structure_ops ${ops.length} 项，但词典条目无 selector/anchors 可提取证据探针 → 人工核验施工台账（design-apply §施工台账）`);
-          continue;
-        }
-        if (evidence.length === 0) {
-          console.log(`  ✘ ${c.id}：structure_ops 声明 [${ops.map(o => o.op).join("/")}]，但源码中找不到任何施工证据探针 [${probes.join("、")}]（非设计层结构文件零命中）`);
-          console.log(`      → 纯 CSS 覆写不能兑现结构操作；须改模板/数据并在交付说明附施工台账，或从变更集移除该声明`);
-          structIssues++;
-        }
-        else {
-          const files1 = [...new Set(evidence.flatMap(x => x.hits.map(h => h.file)))];
-          console.log(`  ✔ ${c.id}：structure_ops 证据命中 ${evidence.length}/${probes.length} 探针（${files1.slice(0, 3).join("、")}）`);
-        }
-      }
-    }
-    if (structIssues === 0)
-      console.log(`  ✔ 全部 structure_ops 均有源码施工证据`);
-  }
-
-  // ---- G4：T 通道对账（运行时令牌 ↔ 变更集主题/形态声明）----
-  // T 通道（platform-config.json / 运行时令牌）优先级最高、也最易被遗忘：
-  // 主题色不一致 → 全局主色错；页签 ShowModel 与 form 叠加 → 新旧形态并存。
-  let tIssues = 0;
-  if (loadedChangesets.length > 0) {
-    console.log(`\n=== T 通道对账（G4 · platform-config ↔ 变更集声明）===`);
-    const pcPath = path.join(root, "public", "platform-config.json");
-    let pc = null;
-    try {
-      pc = JSON.parse(readFileSync(pcPath, "utf-8"));
-      console.log(`  platform-config：${pcPath}`);
-    }
-    catch {
-      console.log(`  ⚠ 未能读取 ${pcPath}（无 public/platform-config.json）→ 跳过 T 通道对账`);
-    }
-    if (pc) {
-      const tChecks = [];
-      // ① 主题色：global.brand_primary（语义值经译表解析为 hex）↔ EpThemeColor
-      const declaredBrand = loadedChangesets.map(cs => cs.global?.brand_primary).find(Boolean);
-      if (declaredBrand && typeof declaredBrand === "string") {
-        const allDict = buildSemanticValueIndex(dataset);
-        const hex = resolveSemanticValue(declaredBrand, allDict) || (/^#/.test(declaredBrand) ? declaredBrand : null);
-        if (hex && pc.EpThemeColor && String(pc.EpThemeColor).toLowerCase() !== String(hex).toLowerCase()) {
-          tChecks.push(`✘ 主题色不一致：变更集 brand_primary=${declaredBrand}（解析 ${hex}），platform-config.EpThemeColor=${pc.EpThemeColor} → 改 platform-config 或运行时令牌持久化（T 通道先于 C 通道）`);
-        }
-      }
-      // ② 页签形态：tabs form ↔ ShowModel（出厂 flat/chrome 形态都运行在 ShowModel=card 结构上）
-      const tabsForm = loadedChangesets
-        .flatMap(cs => (cs.changes || []).filter(c => c.id === "admin.layout.tabs" && typeof c.form === "string").map(c => c.form))
-        .find(Boolean);
-      if (tabsForm && pc.ShowModel && !["flat", "chrome", "card"].includes(pc.ShowModel) === false) {
-        // flat 与 card 共用 card 结构，chrome 形态要求 ShowModel=chrome
-        if (tabsForm === "chrome" && pc.ShowModel !== "chrome") {
-          tChecks.push(`✘ 页签形态不一致：变更集 form=chrome 需 ShowModel=chrome，platform-config.ShowModel=${pc.ShowModel}`);
-        }
-        else if (tabsForm !== "chrome" && pc.ShowModel === "chrome") {
-          tChecks.push(`✘ 页签形态不一致：变更集 form=${tabsForm}（card/flat 结构），platform-config.ShowModel=chrome → 运行时仍是梯形页签，设计层覆写不改变结构形态`);
-        }
-      }
-      // ③ 显隐类 D 通道开关：变更集 visible:false 的点位若词典标了 visible_prop，必须核对开关
-      const visibleProps = [];
-      for (const cs of loadedChangesets) {
-        for (const c of (cs.changes || [])) {
-          if (c.visible !== false || !c.id)
-            continue;
-          const entry = index[c.id] || index[String(c.id).split(".").slice(0, -1).join(".")];
-          if (entry?.visible_prop)
-            visibleProps.push({ id: c.id, prop: entry.visible_prop });
-        }
-      }
-      for (const vp of visibleProps) {
-        const m = /^(\w+)（platform-config\.json）$/.exec(vp.prop) || /^(\w+)$/.exec(vp.prop.split("（")[0].trim());
-        const key = m ? m[1] : null;
-        if (key && key in pc && pc[key] === true) {
-          tChecks.push(`✘ 显隐不一致：${vp.id} 声明 visible:false，但词典 visible_prop=${vp.prop} 且 platform-config.${key}=${pc[key]} → 开关未关，点位仍渲染（D 通道先于 S/C 通道）`);
-        }
-      }
-      if (tChecks.length === 0) {
-        console.log(`  ✔ T/D 通道一致：主题色、页签形态、显隐开关均与变更集声明对齐`);
-      }
-      else {
-        for (const t of tChecks) {
-          console.log(`  ${t}`);
-          tIssues++;
-        }
-        console.log(`  处置：T 通道（platform-config / 运行时令牌持久化）优先级最高，先清 T 再谈 S/C；存量 localStorage 持久化值须一并断言清零。`);
-      }
-    }
-  }
-
-  let problems = 0;
-  const clean = [];
-  for (const id of targetIds) {
-    if (id === GLOBAL_PSEUDO_ID) {
-      // 与 match 路径同口径：伪点位对应变更集顶层 global 节点（brand_primary 等基座令牌），
-      // 走 :root/design-tokens 令牌通道对账，不入词典、不做词典点检。
-      console.log(`\nℹ ${id} —— 设计侧伪点位（变更集顶层 global 节点，不入词典）：基座令牌走 T 通道对账，词典点检豁免`);
-      continue;
-    }
-    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(`✔ 无挂载 / 通道问题（渲染态是否一致仍需 §验收比对确认：静态审计查不出「值对了、位置不对」）`);
-  }
-  // G2/G4 违规同样置退出码（与挂载/通道问题同级 —— 施工没兑现、T 通道没清零 = 交付不完整）
-  if (structIssues > 0) {
-    console.log(`✖ structure_ops 施工证据缺失 ${structIssues} 处（G2）`);
-    process.exitCode = 1;
-  }
-  if (tIssues > 0) {
-    console.log(`✖ T 通道对账不一致 ${tIssues} 处（G4）`);
-    process.exitCode = 1;
-  }
-}
-
-/** G2 辅助：从词典条目与 structure_ops 声明中提取「施工证据探针」（语义类名 / 节点名，不含技术词）。
- *  探针来源优先级：条目 anchors 的 class target 词元 → selector 词元 → op.node 语义名。 */
-function collectStructProbes(entry, change) {
-  const probes = new Set();
-  const pushTokens = (sel) => {
-    if (typeof sel !== "string")
-      return;
-    for (const m of sel.matchAll(/\.([a-zA-Z][\w-]*__(?:divider|tag|icon|close|title|badge|arrow)[\w-]*|[a-zA-Z][\w-]*-divider[\w-]*|vts-[\w-]+|re-table-operate__[\w-]+)/g))
-      probes.add(m[1]);
-  };
-  if (entry) {
-    for (const a of (Array.isArray(entry.anchors) ? entry.anchors : [])) {
-      if (a && a.kind === "class" && typeof a.target === "string")
-        pushTokens(a.target);
-    }
-    pushTokens(entry.selector);
-  }
-  // op.node 语义名（如 tab_divider）：既可能是设计层伪元素名（tab_divider → ::before 不可探测），
-  // 也可能是真实类名（status_tag）；转词元时保留下划线形式，匹配源码任意出现（类名/常量名/注释均可）
-  for (const op of (Array.isArray(change.structure_ops) ? change.structure_ops : [])) {
-    if (op && typeof op.node === "string" && op.node.trim())
-      probes.add(op.node.trim());
-  }
-  return [...probes];
-}
-
-/** G2 辅助：在非设计层源码中查找探针出现（结构文件命中 = 施工痕迹；仅样式文件命中不算） */
-function findStructEvidence(probe, sources) {
-  const re = new RegExp(`(?:class|className|classList|node|name|id|label|key|prop)["']?\\s*[:=]\\s*["']${escapeRe(probe)}["']|${escapeRe(probe)}`);
-  return sources.filter(h => h.kind === "struct" && !DESIGN_LAYER_RE.test(h.file) && re.test(h.text))
-    .map(h => ({ file: h.file }));
-}
-
-// ---- verify：渲染态逐点验收（ 补丁 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]
- *      实测端定位计划：node parser/index.js verify --oracle <oracle.json> --resolve [--sids a,b,c]
- *      快照回归：… --snapshot <path>   导出本次实测 + 判定结果为快照（json），供下轮 --baseline 比对
- *               … --baseline <path>   与上一轮快照比对：上轮命中、本轮缺口的属性 = 基线漂移（红），治「上一轮改对的这一轮漂回」
- * 退出码：存在缺口（含存在性缺口 G12 / 基线漂移）→ 1；全部命中 → 0。
- *
- * G12 存在性闸（oracle.absent）：效果图上**不存在的**出厂点位（面包屑 / 设置铃铛等收口项）
- * 列入 oracle.absent: ["sid", …]，verify 逐个断言「实测转储中不存在，或 display:none / visibility:hidden」。
- * 治「该消失的没消失」——这类缺口在效果图上无可见元素 → 无 data-sid → 无期望值，逐点 diff 永远验不到。
- *
- * G14 状态断言闸（oracle.states）：交互态（disabled / active / hover…）在静态页面快照上取不到——
- * 效果图上「批量按钮置灰」标注了 opacity:.4，页面静态抽取却是激活态值 → 状态性差异逐点 diff 永远验不到。
- * 设计侧在 oracle.json 顶层声明 states: { "<sid>@<state>": { "<css属性>": "<期望值>" } }（state 取值见
- * 设计侧 mockup-extraction-spec §3.1：disabled / active / hover / focus / checked），
- * verify 逐键断言；actual 侧同键形态抽取（sid 查表 + state 属性覆盖/筛选，见下文 G14 段）。
- *
- * G15 孤儿点位对账闸：actual 中存在、oracle 全集（sids ∪ absent ∪ residual_accepted ∪ states）均无申报
- * 的点位 = 孤儿 ——「效果图没有、验收范围外」的页面元素。G12 只断言「已申报的该消失」，孤儿闸补齐
- * 「未申报的出现了」——这是效果图级完备性检查（申报缺一个 = 漏网一个），存在孤儿 → exit 1，逼迫设计侧
- * 把该点位收进 absent（该消失）或补基线（该还原）。
- *
- * 残差豁免（oracle.residual_accepted）：机制推算值 / 业务资产等**申报过的固有残差**点位不计缺口，
- * 每条 { "sid": …, "reason": … }，reason 必填——防止把真缺口装进接受清单蒙混过关。
- */
-function cmdVerify(args, dataset) {
-  // 几何 / 盒模型属性：值对不上 = 语境错位（宿主盒 / 内层盒模型 / 层叠上下文不同）
-  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");
-  const resolveOnly = args.includes("--resolve");
-  const snapshotPath = get("--snapshot");
-  const baselinePath = get("--baseline");
-  if (!oraclePath || (!resolveOnly && !actualPath)) {
-    console.error("✖ 缺少参数：node parser/index.js verify --oracle <oracle.json> --actual <actual.json> [--sids a,b,c]");
-    console.error("    或输出实测端定位计划：node parser/index.js verify --oracle <oracle.json> --resolve [--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, "效果图期望");
-  // oracle 顶层扩展字段（readDump 摊平后丢顶层，这里从原始文件补读）
-  const oracleRaw = JSON.parse(readFileSync(path.resolve(oraclePath), "utf-8"));
-  const absentSids = Array.isArray(oracleRaw.absent) ? oracleRaw.absent.filter(s => typeof s === "string" && s.trim()) : [];
-  const residualAccepted = Array.isArray(oracleRaw.residual_accepted)
-    ? oracleRaw.residual_accepted
-        .map(r => (typeof r === "string" ? { sid: r, reason: "（未填 reason）" } : r))
-        .filter(r => r && typeof r.sid === "string" && r.sid.trim())
-    : [];
-  // G14 状态断言闸：oracle.states = { "<sid>@<state>": { 属性: 期望值 } }（state ∈ disabled/active/hover/focus/checked）
-  const stateEntries = [];
-  if (oracleRaw.states && typeof oracleRaw.states === "object" && !Array.isArray(oracleRaw.states)) {
-    for (const [key, exp] of Object.entries(oracleRaw.states)) {
-      const m = /^(.+)@(disabled|active|hover|focus|checked)$/.exec(String(key).trim());
-      if (!m || !exp || typeof exp !== "object" || Array.isArray(exp)) {
-        console.error(`✖ oracle.states 键非法：「${key}」——应为 "<sid>@<state>"（state ∈ disabled/active/hover/focus/checked），值为属性对象`);
-        process.exit(1);
-      }
-      stateEntries.push({ key: String(key).trim(), sid: m[1].trim(), state: m[2], expected: exp });
-    }
-  }
-  else if (oracleRaw.states !== undefined) {
-    console.error(`✖ oracle.states 应为对象 { "<sid>@<state>": { 属性: 期望值 } }，实际类型：${Array.isArray(oracleRaw.states) ? "array" : typeof oracleRaw.states}`);
-    process.exit(1);
-  }
-
-  let sids = Object.keys(oracle);
-  if (sidFilter)
-    sids = sids.filter(s => sidFilter.has(s));
-
-  // 实测端定位闭合：--resolve 输出「sid → 词典 selector」抽取计划。
-  // 效果图端用 data-sid（设计侧自控）；项目页端不要求打 data-sid —— 浏览器按本计划的 selector 抽取。
-  if (resolveOnly) {
-    const index = buildMergedIndex(dataset || {});
-    console.log(`\n=== 实测端定位计划（sid → 词典 selector）===`);
-    console.log(`用途：项目页不要求打 data-sid —— 浏览器抽取脚本按下列 selector 定位元素取 computed style 生成 actual.json`);
-    console.log(`selector 挂载点存在性由 audit 静态校验；本计划只回答「按什么定位」。\n`);
-    let missing = 0;
-    for (const sid of sids) {
-      if (sid === GLOBAL_PSEUDO_ID)
-        continue; // 伪点位不入词典（同 match / audit 路径口径），基座令牌不走 selector 抽取
-      const entry = index[sid];
-      if (!entry) {
-        console.log(`  ✘ ${sid} —— 词典无此条目（L3 新点位，先落地并回写临时映射）`);
-        missing++;
-        continue;
-      }
-      const sels = [];
-      if (Array.isArray(entry.anchors)) {
-        for (const a of entry.anchors) {
-          if (a && a.kind === "class" && a.target)
-            sels.push(`[${a.layer || "host"}] ${a.target}`);
-        }
-      }
-      if (sels.length === 0 && entry.selector)
-        sels.push(`[host] ${entry.selector}`);
-      if (sels.length === 0) {
-        console.log(`  ✘ ${sid} —— 词典条目无 selector / anchors，无法定位`);
-        missing++;
-        continue;
-      }
-      console.log(`  · ${sid}`);
-      for (const s of sels)
-        console.log(`      ${s}`);
-    }
-    console.log(`\n汇总：${sids.length} 点位，${missing} 个无法定位`);
-    console.log(`抽取属性白名单两端必须一致（padding / font-size / font-weight / text-align / color / background-color / border-radius / gap 等，见 mockup-extraction-spec §3）；主题色板与基线图不同时再加 --from-theme/--to-theme 做色值归一（几何 / 结构 / 字号照比）。`);
-    if (missing > 0)
-      process.exitCode = 1;
-    return;
-  }
-
-  const actual = readDump(actualPath, "项目实测");
-  // actual 顶层扩展字段：states 子对象（G14 实测端状态值，键形态 <sid>@<state>，与 oracle.states 对称）
-  const actualRawFile = JSON.parse(readFileSync(path.resolve(actualPath), "utf-8"));
-  const actualStatesMap = actualRawFile && actualRawFile.states && typeof actualRawFile.states === "object" && !Array.isArray(actualRawFile.states)
-    ? actualRawFile.states
-    : null;
-
-  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;
-  };
-
-  // 同构异色主题归一：--from-theme 钴蓝 --to-theme 橘橙 时，把效果图的主题色族色值
-  // 按语义译表的槽位（-1..-10）映射为本主题同槽位色值再比对；译表之外的值原样保留。
-  const fromTheme = get("--from-theme");
-  const toTheme = get("--to-theme");
-  let themeAlias = null;
-  if (fromTheme && toTheme) {
-    try {
-      const sv = JSON.parse(readFileSync(path.join(ROOT, "mapping", "basic", "semantic-values.json"), "utf-8"));
-      const slotOf = {};
-      const hexOf = {};
-      for (const t of Object.values(sv.themes || {})) {
-        for (const [name, hex] of Object.entries(t.values || {})) {
-          const m = /^(.+?)-(\d+)$/.exec(name);
-          if (!m)
-            continue;
-          const key = String(hex).toLowerCase();
-          slotOf[`${t.label}|${key}`] = m[2];
-          hexOf[`${t.label}|${m[2]}`] = key;
-        }
-      }
-      themeAlias = (v) => {
-        let s = String(v == null ? "" : v).toLowerCase();
-        s = s.replace(/#([0-9a-f]{3})\b/g, (_, h) => `#${h[0]}${h[0]}${h[1]}${h[1]}${h[2]}${h[2]}`);
-        return s.replace(/#[0-9a-f]{6}/g, (hex) => {
-          const lvl = slotOf[`${fromTheme}|${hex}`];
-          return lvl ? (hexOf[`${toTheme}|${lvl}`] || hex) : hex;
-        });
-      };
-      console.log(`主题归一：效果图「${fromTheme}」→ 本主题「${toTheme}」（按语义槽位映射色值后比对，几何 / 结构照比）`);
-    }
-    catch (e) {
-      console.log(`⚠ 主题译表读取失败（${e.message}）—— 本轮不做主题色归一，色值类属性可能出现假缺口`);
-    }
-  }
-
-  console.log(`渲染态验收（computed style 逐点比对）`);
-  console.log(`效果图基线：${path.resolve(oraclePath)}`);
-  console.log(`项目实测：${path.resolve(actualPath)}`);
-  console.log(`比对点位：${sids.length}${sidFilter ? `（--sids 过滤后）` : "（oracle 全量）"}`);
-  if (absentSids.length > 0)
-    console.log(`存在性闸（G12）：${absentSids.length} 点位应已收口 —— ${absentSids.join("、")}`);
-  if (stateEntries.length > 0)
-    console.log(`状态断言闸（G14）：${stateEntries.length} 个交互态期望 —— ${stateEntries.map(s => s.key).join("、")}`);
-  if (residualAccepted.length > 0)
-    console.log(`残差豁免：${residualAccepted.length} 点位已申报接受 —— ${residualAccepted.map(r => r.sid).join("、")}`);
-
-  // G15 孤儿点位对账：actual 顶层（原始文件外形）中存在、oracle 全集（sids ∪ absent ∪ residual ∪ states）均无
-  // 申报的点位 = 孤儿。readDump 会把 { sids: {…} } 外形摊平成 sids 子对象，所以孤儿必须从原始文件算，
-  // 排除结构性键（$ 前缀注释 / sids / states 子对象）。G12 断言「已申报的该消失」；孤儿闸补齐「未申报的出现了」。
-  const oracleCovered = new Set([
-    ...Object.keys(oracle),
-    ...absentSids,
-    ...residualAccepted.map(r => r.sid.trim()),
-    ...stateEntries.map(s => s.sid),
-  ]);
-  const orphans = Object.keys(actualRawFile).filter(k => !k.startsWith("$") && k !== "sids" && k !== "states" && !oracleCovered.has(k));
-
-  // 残差豁免索引：sid → reason。命中豁免的属性缺口降级为「已申报残差」提示行，不进 missProps。
-  const residualMap = new Map(residualAccepted.map(r => [r.sid.trim(), r.reason || "（未填 reason）"]));
-
-  let hitProps = 0;
-  let missProps = 0;
-  let residualProps = 0;
-  const attr = { selector_miss: 0, weight_override: 0, context_mismatch: 0 };
-  const clean = [];
-  // 快照收集：sid → { 属性: { expected, actual, verdict } }；verdict: hit | miss | residual | absent-hit | absent-miss | selector-miss
-  const snapshot = { generated_at: new Date().toISOString(), oracle: path.resolve(oraclePath), actual: path.resolve(actualPath), points: {} };
-
-  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++;
-      snapshot.points[sid] = { verdict: "selector-miss" };
-      continue;
-    }
-    const act = {};
-    for (const [k, v] of Object.entries(actRaw))
-      act[normProp(k)] = v;
-
-    const lines = [];
-    const snapProps = {};
-    for (const [propRaw, expVal] of Object.entries(exp)) {
-      const prop = normProp(propRaw);
-      if (!(prop in act)) {
-        lines.push(`    - ${prop}: 期望 ${expVal} / 实测未取到 —— 选择器落空（该属性所在规则未命中）`);
-        attr.selector_miss++;
-        snapProps[prop] = { expected: expVal, actual: null, verdict: "selector-miss" };
-        continue;
-      }
-      const expNorm = themeAlias ? themeAlias(expVal) : expVal;
-      if (normValue(expNorm) === normValue(act[prop])) {
-        hitProps++;
-        snapProps[prop] = { expected: expVal, actual: act[prop], verdict: "hit" };
-        continue;
-      }
-      const isGeom = GEOMETRY_PROPS.has(prop);
-      const kind = isGeom ? "语境错位" : "权重被压";
-      if (isGeom)
-        attr.context_mismatch++;
-      else
-        attr.weight_override++;
-      snapProps[prop] = { expected: expVal, actual: act[prop], verdict: "miss", kind };
-      if (residualMap.has(sid)) {
-        // 申报过的固有残差：降级为提示行，不进缺口计数
-        residualProps++;
-        snapProps[prop].verdict = "residual";
-        lines.push(`    ○ ${prop}: 期望 ${expVal} / 实得 ${act[prop]} —— 已申报固有残差（${residualMap.get(sid)}），不计缺口`);
-        continue;
-      }
-      lines.push(`    - ${prop}: 期望 ${expVal} / 实得 ${act[prop]} —— ${kind}（${
-        isGeom ? "几何值对不上：宿主盒 / 内层盒模型或层叠上下文不同" : "同权重被组件 scoped / 行内样式反压，或令牌未生效"
-      }）`);
-      missProps++;
-    }
-
-    if (lines.length === 0) {
-      clean.push(sid);
-      snapshot.points[sid] = { verdict: "hit", props: snapProps };
-    }
-    else {
-      console.log(`\n✘ ${sid}`);
-      for (const l of lines)
-        console.log(l);
-      snapshot.points[sid] = { verdict: "miss", props: snapProps };
-    }
-  }
-
-  // ---- G12 存在性闸：oracle.absent 点位必须「不存在或已隐藏」----
-  let absentMiss = 0;
-  if (absentSids.length > 0) {
-    console.log(`\n── 存在性闸（G12）：以下点位效果图上不存在，页面必须收口 ──`);
-    for (const sid of absentSids) {
-      if (sidFilter && !sidFilter.has(sid))
-        continue;
-      const actRaw = actual[sid];
-      let gone = true;
-      let evidence = "页面无此元素（未抽取到）";
-      if (actRaw && typeof actRaw === "object") {
-        const disp = normValue(actRaw["display"] ?? actRaw["display_style"] ?? "");
-        const vis = normValue(actRaw["visibility"] ?? "");
-        if (disp === "none" || vis === "hidden") {
-          evidence = `display=${disp || "-"} visibility=${vis || "-"}`;
-        }
-        else {
-          gone = false;
-          evidence = `仍渲染可见（display=${disp || "?"}）`;
-        }
-      }
-      if (gone) {
-        console.log(`  ✔ ${sid} —— 已收口（${evidence}）`);
-        snapshot.points[sid] = { verdict: "absent-hit", evidence };
-      }
-      else {
-        absentMiss++;
-        console.log(`  ✘ ${sid} —— ${evidence}：效果图无此元素，应 visible:false 收口（G12 存在性缺口）`);
-        snapshot.points[sid] = { verdict: "absent-miss", evidence };
-      }
-    }
-  }
-
-  // ---- G14 状态断言闸：oracle.states（<sid>@<state>）逐键比对交互态 computed style ----
-  // actual 侧两种合法形态：① states 子对象同名键（推荐，浏览器脚本对 hover/focus 等态主动触发后抽取）；
-  // ② sid 主条目属性覆盖（仅 disabled/checked 等「属性可静态反映」的态——设计侧未给 states 子对象时的降级口径）。
-  // 计数口径：stateMiss = 键级（每个状态键最多计 1 次缺口，供「状态断言 X/Y 命中」）；
-  // 属性级归因仍进统一四类（选择器落空 / 权重被压 / 语境错位），处置口径不因状态位分裂。
-  let stateMiss = 0;
-  if (stateEntries.length > 0) {
-    console.log(`\n── 状态断言闸（G14）：交互态期望逐键比对 ──`);
-    for (const st of stateEntries) {
-      if (sidFilter && !sidFilter.has(st.sid))
-        continue;
-      let actVal = null;
-      const stDump = actualStatesMap ? actualStatesMap[st.key] : null;
-      if (stDump && typeof stDump === "object" && !Array.isArray(stDump)) {
-        actVal = stDump; // 形态①：该状态下的完整属性转储
-      }
-      else {
-        // 形态②降级：sid 主条目里的属性值（disabled/checked 可静态反映；hover/active 等瞬态在此口径下取不到）
-        const main = actual[st.sid];
-        if (main && typeof main === "object") {
-          const covered = {};
-          let any = false;
-          for (const [p, e] of Object.entries(st.expected)) {
-            const np = normProp(p);
-            if (np in main) {
-              covered[p] = main[np];
-              any = true;
-            }
-          }
-          if (any)
-            actVal = covered;
-        }
-      }
-      if (!actVal) {
-        stateMiss++;
-        const why = (st.state === "hover" || st.state === "focus" || st.state === "active")
-          ? `瞬态（${st.state}）须由浏览器脚本触发后抽取到 actual.states["${st.key}"]——主条目静态值不能代表交互态`
-          : `actual 未抽取到该状态（缺 actual.states["${st.key}"] 或 sid 主条目）`;
-        console.log(`  ✘ ${st.key} —— 状态期望未取到实测值：${why}`);
-        snapshot.points[st.key] = { verdict: "state-miss", state: st.state };
-        continue;
-      }
-      const stLines = [];
-      const snapProps = {};
-      let stKeyMiss = false;
-      for (const [propRaw, expVal] of Object.entries(st.expected)) {
-        const prop = normProp(propRaw);
-        const actV = actVal[propRaw] ?? actVal[prop];
-        if (actV === undefined || actV === null) {
-          stLines.push(`    - ${prop}: 期望 ${expVal} / 实测未取到 —— 状态抽取缺属性`);
-          attr.selector_miss++;
-          stKeyMiss = true;
-          snapProps[prop] = { expected: expVal, actual: null, verdict: "selector-miss" };
-          continue;
-        }
-        const expNorm = themeAlias ? themeAlias(expVal) : expVal;
-        if (normValue(expNorm) === normValue(actV)) {
-          snapProps[prop] = { expected: expVal, actual: actV, verdict: "hit" };
-        }
-        else {
-          const isGeom = GEOMETRY_PROPS.has(prop);
-          stLines.push(`    - ${prop}: 期望 ${expVal} / 实得 ${actV} —— ${isGeom ? "语境错位" : "权重被压"}（${st.state} 态）`);
-          if (isGeom)
-            attr.context_mismatch++;
-          else
-            attr.weight_override++;
-          stKeyMiss = true;
-          snapProps[prop] = { expected: expVal, actual: actV, verdict: "miss", kind: "状态缺口" };
-        }
-      }
-      if (stKeyMiss) {
-        stateMiss++;
-        console.log(`\n  ✘ ${st.key}`);
-        for (const l of stLines)
-          console.log(l);
-        snapshot.points[st.key] = { verdict: "miss", state: st.state, props: snapProps };
-      }
-      else {
-        console.log(`  ✔ ${st.key} —— 状态期望全部命中`);
-        snapshot.points[st.key] = { verdict: "hit", state: st.state, props: snapProps };
-      }
-    }
-  }
-
-  // ---- G15 孤儿点位对账：actual 有、oracle 全集无申报 = 效果图级完备性缺口 ----
-  let orphanMiss = 0;
-  if (orphans.length > 0) {
-    console.log(`\n── 孤儿点位对账（G15）：以下点位页面渲染了、oracle 全集（sids/absent/residual/states）均无申报 ──`);
-    for (const sid of orphans) {
-      orphanMiss++;
-      console.log(`  ✘ ${sid} —— 效果图上无此角色坐标：要么应 visible:false 收口（补进 oracle.absent），要么该还原（回流设计侧补基线 oracle.sids + 效果图 data-sid）`);
-      snapshot.points[sid] = { verdict: "orphan" };
-    }
-  }
-
-  if (clean.length > 0)
-    console.log(`\n✔ 逐点命中：${clean.join("、")}`);
-
-  // ---- 快照回归：--snapshot 导出 / --baseline 漂移比对 ----
-  let driftCount = 0;
-  if (baselinePath) {
-    let baseline;
-    try {
-      baseline = JSON.parse(readFileSync(path.resolve(baselinePath), "utf-8"));
-    }
-    catch (e) {
-      console.error(`✖ 基线快照读取失败 ${baselinePath}：${e.message}`);
-      process.exit(1);
-    }
-    const basePoints = baseline.points || {};
-    const drifts = [];
-    for (const [sid, cur] of Object.entries(snapshot.points)) {
-      const prev = basePoints[sid];
-      if (!prev)
-        continue;
-      // 点位级漂移：上轮命中/收口/状态命中、本轮缺口（G12/G14/G15 各 verdict 均纳入红绿判定）
-      const okVerdicts = new Set(["hit", "absent-hit", "orphan-absolved"]);
-      const prevOk = okVerdicts.has(prev.verdict);
-      const curOk = okVerdicts.has(cur.verdict);
-      if (prevOk && !curOk) {
-        drifts.push(`${sid}（${prev.verdict} → ${cur.verdict}）`);
-      }
-      else if (prevOk && curOk && prev.props && cur.props) {
-        for (const [prop, pv] of Object.entries(prev.props)) {
-          if (pv.verdict === "hit" && cur.props[prop] && cur.props[prop].verdict !== "hit" && cur.props[prop].verdict !== "residual")
-            drifts.push(`${sid}.${prop}（hit → ${cur.props[prop].verdict}）`);
-        }
-      }
-    }
-    driftCount = drifts.length;
-    if (driftCount > 0) {
-      console.log(`\n✘ 基线漂移 ${driftCount} 处（上一轮已命中、本轮退步——每轮动工前先跑 verify 存快照，交付前比对）：`);
-      for (const d of drifts)
-        console.log(`    - ${d}`);
-    }
-    else {
-      console.log(`\n✔ 基线快照比对：无漂移（上轮命中点位本轮全部保持）`);
-    }
-  }
-  if (snapshotPath) {
-    try {
-      writeFileSync(path.resolve(snapshotPath), JSON.stringify(snapshot, null, 2), "utf-8");
-      console.log(`\n快照已导出：${path.resolve(snapshotPath)}（下轮验证带 --baseline <本文件> 比对漂移）`);
-    }
-    catch (e) {
-      console.error(`✖ 快照写入失败 ${snapshotPath}：${e.message}`);
-      process.exitCode = 1;
-    }
-  }
-
-  console.log(`\n汇总：${sids.length} 点位 · ${hitProps} 属性命中 · ${missProps} 缺口${residualProps > 0 ? ` · ${residualProps} 已申报残差` : ""}${absentSids.length > 0 ? ` · 存在性 ${absentSids.length - absentMiss}/${absentSids.length} 收口` : ""}${stateEntries.length > 0 ? ` · 状态断言 ${stateEntries.length - stateMiss}/${stateEntries.length} 命中` : ""}${orphans.length > 0 ? ` · 孤儿 ${orphans.length}` : ""}`);
-  console.log(`归因：选择器落空 ${attr.selector_miss} / 权重被压 ${attr.weight_override} / 语境错位 ${attr.context_mismatch}${absentSids.length > 0 ? ` / 存在性缺口 ${absentMiss}` : ""}${stateEntries.length > 0 ? ` / 状态缺口 ${stateMiss}` : ""}${orphanMiss > 0 ? ` / 孤儿点位 ${orphanMiss}` : ""}${driftCount > 0 ? ` / 基线漂移 ${driftCount}` : ""}`);
-  if (missProps > 0 || absentMiss > 0 || stateMiss > 0 || orphanMiss > 0 || driftCount > 0) {
-    console.log(`处置口径：按归因修正 —— 选择器落空补挂载点（属能力缺口，走 structure_ops / 补通道并申报）；权重被压按 priority 声明提权（禁止 !important 掩盖）；语境错位校准 layer（host / inner）；存在性缺口补 visible:false 收口并按词典 priority 提权；状态缺口由浏览器脚本触发交互态后抽到 actual.states（G14）；孤儿点位回流设计侧收进 oracle.absent 或补基线（G15）；基线漂移逐条回归上轮修法。`);
-    process.exitCode = 1;
-  }
-  else {
-    console.log(`✔ 渲染态与效果图基线逐点一致（验收通过）`);
-  }
-}
-
-/** 语义值译表索引：mapping 中 semantic-values.json 摊平为 { 语义名(中/英): 精确值 } */
-function buildSemanticValueIndex(dataset) {
-  const dict = {};
-  for (const data of Object.values(dataset.files)) {
-    if (!data.themes)
-      continue;
-    for (const theme of Object.values(data.themes)) {
-      if (theme && theme.values && typeof theme.values === "object" && !theme.values.$comment) {
-        const label = theme.label || "";
-        for (const [name, hex] of Object.entries(theme.values)) {
-          dict[name] = hex;
-          // 英文别名：钴蓝-5 ↔ cobalt-5（主题 label 的拼音对应 themes 键名）
-        }
-      }
-    }
-    // 英文拼写别名：theme 键名（cobalt/emerald/...）+ 级别号
-    for (const [key, theme] of Object.entries(data.themes)) {
-      if (key.startsWith("$") || !theme || !theme.values)
-        continue;
-      for (let i = 1; i <= 10; i++)
-        dict[`${key}-${i}`] = theme.values[`${theme.label}-${i}`] || "";
-      dict[`${key}-success`] = theme.values["成功色"] || "";
-      dict[`${key}-error`] = theme.values["错误色"] || "";
-      dict[`${key}-warning`] = theme.values["警告色"] || "";
-      dict[`${key}-info`] = theme.values["信息色"] || "";
-      dict[`${key}-link`] = theme.values["链接色"] || "";
-    }
-  }
-  // 清空串
-  for (const k of Object.keys(dict))
-    if (!dict[k])
-      delete dict[k];
-  return dict;
-}
-
-/** 语义值解析：hex/rgb/hsl 透传 → 数值/复合字面量透传 → 中文名查表 → 英文名查表 → null（未命中） */
-function resolveSemanticValue(value, valueDict) {
-  const v = String(value).trim();
-  if (/^#([0-9a-fA-F]{3,8})$/.test(v) || /^(rgb|hsl)a?\(/i.test(v))
-    return v;
-  if (NUMERIC_VALUE_RE.test(v) || COMPOSITE_VALUE_RE.test(v))
-    return v;
-  if (valueDict && valueDict[v])
-    return valueDict[v];
-  return null;
-}
-
-// ---- list ----
-function cmdList(args, dataset) {
-  const sceneIdx = args.indexOf("--scene");
-  const scene = sceneIdx > -1 ? args[sceneIdx + 1] : null;
-  const verbose = args.includes("--verbose") || args.includes("-v");
-  const index = buildMergedIndex(dataset);
-  const ids = Object.keys(index).sort();
-  const filtered = scene ? ids.filter(id => id.startsWith(`${scene}.`) || !/^(admin|portal|dashboard)\./.test(id)) : ids;
-  // v1.0：头部输出映射集版本（版本恒定 1.0.0，由 SKILL.md 体系版本统一管理；此处仅健康检查展示）
-  const versions = [...new Set(Object.values(dataset.files).map(d => d.meta?.version).filter(Boolean))];
-  console.log(`映射集版本：${versions.join(" / ")}（变更集 mapping_version 恒填 1.0.0）`);
-  console.log(`共 ${filtered.length} 条语义 ID${scene ? `（scene=${scene} + 全局）` : ""}：`);
-  for (const id of filtered) {
-    const e = index[id];
-    console.log(`  ${id.padEnd(46)} [${e.type}] ${e.selector ?? e.component ?? ""}`);
-    if (verbose) {
-      // 词汇约束模式：输出设计侧可用的 style 字段与 form 形态枚举（供下发词汇约束）
-      const fields = [...Object.keys(e.css_vars || {}), ...Object.keys(e.custom_style_map || {})];
-      const forms = extractForms(e);
-      if (fields.length > 0)
-        console.log(`      style 字段：${fields.join(" ")}`);
-      if (forms.length > 0)
-        console.log(`      form 形态：${forms.join(" / ")}`);
-      // ：落点层级与覆写优先级（设计侧声明 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) || "—"}`);
-    }
-  }
-}
-
-// ---- query ----
-function cmdQuery(args, dataset) {
-  const id = args.find(a => !a.startsWith("--"));
-  const index = buildMergedIndex(dataset);
-  const entry = index[id];
-  if (!entry) {
-    console.error(`✖ 语义 ID「${id}」未在映射表中定义`);
-    process.exit(1);
-  }
-  console.log(JSON.stringify({ id, ...entry }, null, 2));
-}