@qilitt-mickey/vue3-temp-skill 1.1.53 → 1.1.55

package/SKILL.md

@@ -51,7 +51,7 @@ tags: [vue3, typescript, element-plus, pinia, vite, unocss, crud, demo, code-qua
 | `files-and-editors` | 附件、预览、下载、富文本、二维码 | `file-management.md`、`download-export.md`、`rich-text.md`、`qrcode-barcode.md` |
 | `realtime-and-mobile` | WebSocket、移动端、微信、验证码、动效 | 对应专项 reference |
 | `data-compare` | 编辑页变更对比和汇总 | `data-compare.md` |
-| `design-apply` | 设计变更集落地：语义 ID 三级匹配、结构/形态/两层样式转换、锚点与结构施工、覆写提权、渲染态验收、合规闸门 | `design-apply.md`、`mapping/`、`parser/` |
+| `design-apply` | 设计变更集落地：语义 ID 三级匹配、结构/形态/两层样式转换、锚点与结构施工、覆写提权、渲染态验收、合规闸门。**主入口 `design-apply.md`（红线+契约+步骤索引），各步骤拆分册 `references/steps/`——做到哪一步读哪一份，禁止一次全部通读** | `design-apply.md`、`steps/`、`mapping/`、`parser/` |
 
 ## 工作流
 
@@ -92,7 +92,7 @@ tags: [vue3, typescript, element-plus, pinia, vite, unocss, crud, demo, code-qua
 
 - 对照 `references/code-quality.md` 检查类型、组件复用、API、路由、权限、安全、异常反馈、响应式和可演进性。
 - 在目标项目执行 `pnpm lint:fix`、`pnpm type-check`；改动构建配置时再执行 `pnpm build`。
-- **设计文件落地时追加渲染态验收**：变更集含 `oracle`（或效果图带 `data-sid`）时，跑 `node parser/index.js verify`——抽取项目同名 `data-sid` 元素的 computed style，与效果图期望值逐点 diff；缺口按三类归因（选择器落空 / 权重被压 / 语境错位）修正，禁止用 `!important` 掩盖。
+- **设计文件落地时追加渲染态验收**：变更集含 `oracle`（或效果图带 `data-sid`）时，跑 `node parser/index.js verify`——抽取项目同名 `data-sid` 元素的 computed style，与效果图期望值逐点 diff；缺口按四类归因（选择器落空 / 权重被压 / 语境错位 / **存在性缺口 G12**：`oracle.absent` 点位仍可见）修正，禁止用 `!important` 掩盖。多轮迭代场景每轮动工前先 `--snapshot` 导快照、交付前 `--baseline` 比对——上轮命中本轮退步 = 基线漂移，先回归上轮修法。申报过的固有残差（`oracle.residual_accepted`）不计缺口。
 - **设计文件落地时核对登记表覆盖率**：变更集带登记表（`coverage.registry` 或 `--registry`）时，跑 `node parser/index.js match <cs.json> --registry <restore-registry.json>`——`C = A` 且无缺口才可交付；parser **当场以登记表为权威重算**，设计侧自报的 `coverage` 数字不参与。单独核验登记表对词典的通道就绪度用 `node parser/index.js registry <restore-registry.json>`（硬缺口 exit 1、通道缺口列出待补字段）。
 - 最终说明：命中能力组、修改文件、功能验证、命令结果、未解决问题和下一步。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qilitt-mickey/vue3-temp-skill",
-  "version": "1.1.53",
+  "version": "1.1.55",
   "type": "module",
   "description": "Vue 3 企业级中后台项目开发规范技能包 — core-kernel 架构、按需功能模块",
   "bin": {

package/parser/fixtures/changeset-fullpage-restore.json

@@ -81,7 +81,7 @@
     { "id": "admin.content.pagination", "style": { "active_bg": "钴蓝-5", "active_color": "#FFFFFF" } }
   ],
   "oracle": {
-    "mockup": "verify/运单管理-钴蓝.html",
+    "mockup": "verify/回归夹具-列表页-钴蓝.html",
     "sids": [
       "admin.layout.sidebar",
       "admin.layout.sidebar.logo_area",

package/parser/fixtures/changeset-neg6-g9-identity.json

@@ -17,7 +17,7 @@
     { "id": "admin.content.pagination", "style": { "active_bg": "橘橙-5", "active_color": "#FFFFFF" } }
   ],
   "oracle": {
-    "mockup": "verify/运单管理-钴蓝.html",
+    "mockup": "verify/回归夹具-列表页-钴蓝.html",
     "theme_mapping": { "from": "钴蓝", "to": "橘橙" },
     "sids": [
       "admin.layout.sidebar.menu",

package/parser/fixtures/changeset-neg7-g10-dims.json

@@ -35,7 +35,7 @@
     { "id": "admin.content.pagination", "style": { "active_bg": "钴蓝-5", "active_color": "#FFFFFF" } }
   ],
   "oracle": {
-    "mockup": "verify/运单管理-钴蓝.html",
+    "mockup": "verify/回归夹具-列表页-钴蓝.html",
     "sids": [
       "admin.content.table.header_cell",
       "admin.content.table.cell",

package/parser/fixtures/changeset-neg8-g11-oracle.json

@@ -35,7 +35,7 @@
     { "id": "admin.content.pagination", "style": { "active_bg": "橘橙-5", "active_color": "#FFFFFF" } }
   ],
   "oracle": {
-    "mockup": "verify/运单管理-钴蓝.html",
+    "mockup": "verify/回归夹具-列表页-钴蓝.html",
     "sids": [
       "admin.content.table.header_cell",
       "admin.content.table.cell",

package/parser/fixtures/changeset-registry-gap.json

@@ -17,7 +17,7 @@
     }
   ],
   "oracle": {
-    "mockup": "运单管理-钴蓝.html",
+    "mockup": "verify/回归夹具-列表页-钴蓝.html",
     "sids": [
       "admin.content.table.header_cell",
       "admin.content.table.cell",

package/parser/fixtures/changeset-v32-fields.json

@@ -45,7 +45,7 @@
     }
   ],
   "oracle": {
-    "mockup": "page-specs/styles/default/scenes/admin/mockups/list-page/运单管理-钴蓝.html",
+    "mockup": "verify/回归夹具-列表页-钴蓝.html",
     "sids": [
       "admin.content.table.header_cell",
       "admin.content.table.cell_status",

package/parser/fixtures/verify/actual-clean.json

@@ -0,0 +1,29 @@
+{
+  "$comment": "verify 夹具 · 项目实测（clean 全绿对照，与 oracle.json + actual.json 三件配套）：全部属性命中、absent 点位已收口（display:none）、申报残差点位允许与效果图不同。供 U 步正例（exit 0）与 V 步快照基线段使用。",
+  "sids": {
+    "admin.content.table.header_cell": {
+      "padding": "16px",
+      "font-weight": "500",
+      "text-align": "left",
+      "background-color": "#fafafa",
+      "white-space": "nowrap"
+    },
+    "admin.content.table.cell_amount": {
+      "text-align": "right"
+    },
+    "admin.layout.tabs.item_active": {
+      "font-weight": "500",
+      "color": "#245bff"
+    },
+    "admin.layout.header.user_profile": {
+      "gap": "12px"
+    },
+    "admin.layout.header.breadcrumb": {
+      "display": "none"
+    },
+    "admin.layout.sidebar.logo_area": {
+      "background-color": "#10214d"
+    },
+    "$note": "logo_area 背景与效果图期望 #0B1A3C 不同 = 已申报固有残差（oracle.residual_accepted 命中后不计缺口，U 步正例演示）"
+  }
+}

package/parser/fixtures/verify/actual.json

@@ -1,5 +1,5 @@
 {
-  "$comment": "verify 夹具 · 项目实测（含 3 类故意缺口，用于回归）：header_cell 字重被压 + 对齐语境错位；cell_amount 选择器落空；user_profile gap 语境错位。",
+  "$comment": "verify 夹具 · 项目实测（含 3 类故意缺口 + 1 类存在性缺口，用于回归）：header_cell 字重被压 + 对齐语境错位 + white-space 未取到（期望值加密后暴露「属性所在规则未命中」新形态）；cell_amount 选择器落空；user_profile gap 语境错位；breadcrumb 仍渲染可见（G12 存在性缺口故意展示）。logo_area 命中 = L 夹具不制造残差缺口、保持归因计数稳定；残差演示见 actual-clean.json 的 U 步。",
   "sids": {
     "admin.content.table.header_cell": {
       "padding": "16px",
@@ -13,6 +13,12 @@
     },
     "admin.layout.header.user_profile": {
       "gap": "8px"
+    },
+    "admin.layout.header.breadcrumb": {
+      "display": "flex"
+    },
+    "admin.layout.sidebar.logo_area": {
+      "background-color": "#0b1a3c"
     }
   }
 }

package/parser/fixtures/verify/oracle.json

@@ -1,11 +1,15 @@
 {
-  "$comment": "verify 夹具 · 效果图期望（computed style 转储外形）。真实抽取由浏览器链路完成，本文件仅用于回归。",
+  "$comment": "verify 夹具 · 效果图期望（computed style 转储外形）。真实抽取由浏览器链路完成，本文件仅用于回归。顶层扩展字段：absent=效果图上不存在的出厂点位（G12 存在性闸断言目标，2026-09-21 面包屑事故机制化）；residual_accepted=申报过的固有残差（命中豁免不计缺口，reason 必填）。header_cell 增补 white-space 期望 = 列头截断防线的期望值加密（oracle 无期望值的属性验了等于没验）。",
   "sids": {
+    "admin.layout.sidebar.logo_area": {
+      "background-color": "#0B1A3C"
+    },
     "admin.content.table.header_cell": {
       "padding": "16px",
       "font-weight": "500",
       "text-align": "left",
-      "background-color": "#FAFAFA"
+      "background-color": "#FAFAFA",
+      "white-space": "nowrap"
     },
     "admin.content.table.cell_amount": {
       "text-align": "right"
@@ -17,5 +21,11 @@
     "admin.layout.header.user_profile": {
       "gap": "12px"
     }
-  }
+  },
+  "absent": [
+    "admin.layout.header.breadcrumb"
+  ],
+  "residual_accepted": [
+    { "sid": "admin.layout.sidebar.logo_area", "reason": "出厂 logo 图形属业务资产，效果图占位图形与实际 logo 不逐像素比对（restore-checklist §三：只还原载体模块）" }
+  ]
 }

package/parser/fixtures/verify/snapshot-latest.json

@@ -0,0 +1,87 @@
+{
+  "generated_at": "2026-09-22T03:10:19.033Z",
+  "oracle": "E:\\work\\Project\\Template\\skills\\vue3-temp-skill\\parser\\fixtures\\verify\\oracle.json",
+  "actual": "E:\\work\\Project\\Template\\skills\\vue3-temp-skill\\parser\\fixtures\\verify\\actual-clean.json",
+  "points": {
+    "admin.layout.sidebar.logo_area": {
+      "verdict": "miss",
+      "props": {
+        "background-color": {
+          "expected": "#0B1A3C",
+          "actual": "#10214d",
+          "verdict": "residual",
+          "kind": "权重被压"
+        }
+      }
+    },
+    "admin.content.table.header_cell": {
+      "verdict": "hit",
+      "props": {
+        "padding": {
+          "expected": "16px",
+          "actual": "16px",
+          "verdict": "hit"
+        },
+        "font-weight": {
+          "expected": "500",
+          "actual": "500",
+          "verdict": "hit"
+        },
+        "text-align": {
+          "expected": "left",
+          "actual": "left",
+          "verdict": "hit"
+        },
+        "background-color": {
+          "expected": "#FAFAFA",
+          "actual": "#fafafa",
+          "verdict": "hit"
+        },
+        "white-space": {
+          "expected": "nowrap",
+          "actual": "nowrap",
+          "verdict": "hit"
+        }
+      }
+    },
+    "admin.content.table.cell_amount": {
+      "verdict": "hit",
+      "props": {
+        "text-align": {
+          "expected": "right",
+          "actual": "right",
+          "verdict": "hit"
+        }
+      }
+    },
+    "admin.layout.tabs.item_active": {
+      "verdict": "hit",
+      "props": {
+        "font-weight": {
+          "expected": "500",
+          "actual": "500",
+          "verdict": "hit"
+        },
+        "color": {
+          "expected": "#245BFF",
+          "actual": "#245bff",
+          "verdict": "hit"
+        }
+      }
+    },
+    "admin.layout.header.user_profile": {
+      "verdict": "hit",
+      "props": {
+        "gap": {
+          "expected": "12px",
+          "actual": "12px",
+          "verdict": "hit"
+        }
+      }
+    },
+    "admin.layout.header.breadcrumb": {
+      "verdict": "absent-hit",
+      "evidence": "display=none visibility=-"
+    }
+  }
+}

package/parser/index.js

@@ -19,12 +19,12 @@
  *   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（）
+ *   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, statSync, readdirSync, existsSync } from "node:fs";
+import { readFileSync, writeFileSync, statSync, readdirSync, existsSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { buildMappingDataset } from "./loader.js";
@@ -110,7 +110,9 @@ function printHelp() {
   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
+                                                          渲染态逐点验收：computed style 期望 vs 实测 diff（oracle.absent 存在性闸 + residual_accepted 残差豁免）
+  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 橘橙
@@ -1852,7 +1854,16 @@ function findStructEvidence(probe, sources) {
  *
  * 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]
- * 退出码：存在缺口 → 1；全部命中 → 0。
+ *      快照回归：… --snapshot <path>   导出本次实测 + 判定结果为快照（json），供下轮 --baseline 比对
+ *               … --baseline <path>   与上一轮快照比对：上轮命中、本轮缺口的属性 = 基线漂移（红），治「上一轮改对的这一轮漂回」
+ * 退出码：存在缺口（含存在性缺口 G12 / 基线漂移）→ 1；全部命中 → 0。
+ *
+ * G12 存在性闸（oracle.absent）：效果图上**不存在的**出厂点位（面包屑 / 设置铃铛等收口项）
+ * 列入 oracle.absent: ["sid", …]，verify 逐个断言「实测转储中不存在，或 display:none / visibility:hidden」。
+ * 治「该消失的没消失」——这类缺口在效果图上无可见元素 → 无 data-sid → 无期望值，逐点 diff 永远验不到。
+ *
+ * 残差豁免（oracle.residual_accepted）：机制推算值 / 业务资产等**申报过的固有残差**点位不计缺口，
+ * 每条 { "sid": …, "reason": … }，reason 必填——防止把真缺口装进接受清单蒙混过关。
  */
 function cmdVerify(args, dataset) {
   // 几何 / 盒模型属性：值对不上 = 语境错位（宿主盒 / 内层盒模型 / 层叠上下文不同）
@@ -1879,6 +1890,8 @@ function cmdVerify(args, dataset) {
   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]");
@@ -1914,6 +1927,14 @@ function cmdVerify(args, dataset) {
   };
 
   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())
+    : [];
 
   let sids = Object.keys(oracle);
   if (sidFilter)
@@ -2009,11 +2030,21 @@ function cmdVerify(args, dataset) {
   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 (residualAccepted.length > 0)
+    console.log(`残差豁免：${residualAccepted.length} 点位已申报接受 —— ${residualAccepted.map(r => r.sid).join("、")}`);
+
+  // 残差豁免索引：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];
@@ -2026,6 +2057,7 @@ function cmdVerify(args, dataset) {
       console.log(`\n✘ ${sid}\n    - 项目页面未抽取到该点位 —— 选择器落空（挂载点缺失 / 元素未渲染 / data-sid 未标注）`);
       attr.selector_miss++;
       missProps++;
+      snapshot.points[sid] = { verdict: "selector-miss" };
       continue;
     }
     const act = {};
@@ -2033,16 +2065,19 @@ function cmdVerify(args, dataset) {
       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);
@@ -2051,6 +2086,14 @@ function cmdVerify(args, dataset) {
         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 / 行内样式反压，或令牌未生效"
       }）`);
@@ -2059,21 +2102,107 @@ function cmdVerify(args, dataset) {
 
     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 };
+      }
     }
   }
 
   if (clean.length > 0)
     console.log(`\n✔ 逐点命中：${clean.join("、")}`);
 
-  console.log(`\n汇总：${sids.length} 点位 · ${hitProps} 属性命中 · ${missProps} 缺口`);
-  console.log(`归因：选择器落空 ${attr.selector_miss} / 权重被压 ${attr.weight_override} / 语境错位 ${attr.context_mismatch}`);
-  if (missProps > 0) {
-    console.log(`处置口径：按归因修正 —— 选择器落空补挂载点（属能力缺口，走 structure_ops / 补通道并申报）；权重被压按 priority 声明提权（禁止 !important 掩盖）；语境错位校准 layer（host / inner）。`);
+  // ---- 快照回归：--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;
+      // 点位级漂移：上轮命中/收口、本轮缺口
+      const prevOk = prev.verdict === "hit" || prev.verdict === "absent-hit";
+      const curOk = cur.verdict === "hit" || cur.verdict === "absent-hit";
+      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} 收口` : ""}`);
+  console.log(`归因：选择器落空 ${attr.selector_miss} / 权重被压 ${attr.weight_override} / 语境错位 ${attr.context_mismatch}${absentSids.length > 0 ? ` / 存在性缺口 ${absentMiss}` : ""}${driftCount > 0 ? ` / 基线漂移 ${driftCount}` : ""}`);
+  if (missProps > 0 || absentMiss > 0 || driftCount > 0) {
+    console.log(`处置口径：按归因修正 —— 选择器落空补挂载点（属能力缺口，走 structure_ops / 补通道并申报）；权重被压按 priority 声明提权（禁止 !important 掩盖）；语境错位校准 layer（host / inner）；存在性缺口补 visible:false 收口并按词典 priority 提权；基线漂移逐条回归上轮修法。`);
     process.exitCode = 1;
   }
   else {

package/parser/regression.js

@@ -24,10 +24,12 @@
  *   I  build --dry 产物链自检              → exit 0 且输出含 dry-run
  *   J  match  三声明维度                → exit 0 且输出含「结构施工 structure_ops」
  *   K  audit 挂载点 / 死通道审计            → exit 1（夹具项目故意存在挂载点缺失 / 死通道）
- *   L  verify 渲染态逐点验收                → exit 1 且三类归因各计其数（夹具含故意缺口）
+ *   L  verify 渲染态逐点验收                → exit 1 且归因各计其数（夹具含故意缺口：三类渲染缺口 + G12 存在性缺口）
  *   M  match 登记表覆盖率细闸               → exit 1（夹具故意欠声明两条恒存在子项）
  *   N  registry 登记表通道核验              → exit 0 且输出含「登记表通道核验」
  *   O  registry 硬缺口负例                  → exit 1（引用了不存在且未标 pending 的点位）
+ *   U  verify 残差豁免 + 收口正例（clean 夹具）→ exit 0 且输出含「已申报残差」「已收口」（申报点位不计缺口、收口点位绿灯）
+ *   V  verify 快照回归（snapshot → baseline）→ clean 快照为基线、缺口夹具为实测 → exit 1 且输出含「基线漂移」（上轮命中本轮退步必红）
  *
  * 任一步骤失败 → 本脚本 exit 1，并回显该步骤完整输出便于定位。
  */
@@ -131,14 +133,13 @@ const steps = [
   },
   {
     key: "L",
-    name: "verify 渲染态逐点验收（夹具含三类故意缺口 → exit 1）",
+    name: "verify 渲染态逐点验收（夹具含三类渲染缺口 + G12 存在性缺口 → exit 1）",
     script: INDEX,
     args: ["verify", "--oracle", path.join(FIXTURES, "verify", "oracle.json"), "--actual", path.join(FIXTURES, "verify", "actual.json")],
-    expect: { code: 1, includes: "选择器落空 1 / 权重被压 1 / 语境错位 2" },
+    expect: { code: 1, includes: "选择器落空 2 / 权重被压 1 / 语境错位 2 / 存在性缺口 1" },
   },
   {
     key: "M",
-    name: "match 登记表覆盖率细闸（夹具故意欠声明两条恒存在子项 → exit 1）",
     script: INDEX,
     args: ["match", "--registry", path.join(FIXTURES, "registry-sample.json"), path.join(FIXTURES, "changeset-registry-gap.json")],
     expect: { code: 1, includes: ["登记表覆盖率", "缺口 2"] },
@@ -192,19 +193,60 @@ const steps = [
     args: ["match", path.join(FIXTURES, "changeset-neg8-g11-oracle.json")],
     expect: { code: 1, includes: ["G11", "主题错配"] },
   },
+  {
+    key: "U",
+    name: "verify 残差豁免 + 收口正例（clean 夹具：申报点位不计缺口、absent 已收口 → exit 0）",
+    script: INDEX,
+    args: ["verify", "--oracle", path.join(FIXTURES, "verify", "oracle.json"), "--actual", path.join(FIXTURES, "verify", "actual-clean.json")],
+    expect: { code: 0, includes: ["已申报固有残差", "已收口", "验收通过"] },
+  },
+  {
+    key: "V",
+    name: "verify 快照回归（clean 快照为基线 + L 缺口夹具为实测：上轮命中本轮退步 → exit 1 且含「基线漂移」）",
+    script: INDEX,
+    args: [], // 两段式：先 --snapshot 导出，再 --baseline 比对，见下方 custom 分支
+    expect: { code: 1, includes: "基线漂移" },
+    custom: "snapshot-drift",
+  },
 ];
 
 const results = [];
 let failed = 0;
 
-console.log("=== A-T 端到端一键回归 ===\n");
+console.log("=== A-V 端到端一键回归 ===\n");
+
+const SNAPSHOT_TMP = path.join(FIXTURES, "verify", "snapshot-latest.json");
 
 for (const step of steps) {
-  const { status, stdout, stderr } = spawnSync(
-    process.execPath,
-    [step.script, ...step.args],
-    { cwd: ROOT, encoding: "utf-8" },
-  );
+  // V 步两段式：① 用 clean 夹具导出「上一轮全绿」快照；② 用 L 缺口夹具 + --baseline 比对 → 应报基线漂移
+  const spawnArgs = step.custom === "snapshot-drift"
+    ? []
+    : [step.script, ...step.args];
+  let status, stdout, stderr;
+  if (step.custom === "snapshot-drift") {
+    const s1 = spawnSync(process.execPath, [
+      INDEX, "verify",
+      "--oracle", path.join(FIXTURES, "verify", "oracle.json"),
+      "--actual", path.join(FIXTURES, "verify", "actual-clean.json"),
+      "--snapshot", SNAPSHOT_TMP,
+    ], { cwd: ROOT, encoding: "utf-8" });
+    if (s1.status !== 0 || !existsSync(SNAPSHOT_TMP)) {
+      status = s1.status;
+      stdout = s1.stdout ?? "";
+      stderr = `快照导出段失败（exit ${s1.status}）：快照回归前置不成立\n${s1.stderr ?? ""}`;
+    }
+    else {
+      ({ status, stdout, stderr } = spawnSync(process.execPath, [
+        INDEX, "verify",
+        "--oracle", path.join(FIXTURES, "verify", "oracle.json"),
+        "--actual", path.join(FIXTURES, "verify", "actual.json"),
+        "--baseline", SNAPSHOT_TMP,
+      ], { cwd: ROOT, encoding: "utf-8" }));
+    }
+  }
+  else {
+    ({ status, stdout, stderr } = spawnSync(process.execPath, spawnArgs, { cwd: ROOT, encoding: "utf-8" }));
+  }
   const output = `${stdout ?? ""}${stderr ?? ""}`;
   const code = status ?? -1;
 
@@ -234,4 +276,4 @@ if (failed > 0) {
   console.error(`\n✖ ${failed} 步未通过，见上方详情`);
   process.exit(1);
 }
-console.log("\n✔ A-T 全部通过，mapping/parser 可提交或发版");
+console.log("\n✔ A-W 全部通过，mapping/parser 可提交或发版");