@qilitt-mickey/vue3-temp-skill 1.1.49 → 1.1.51

package/package.json

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

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

@@ -1,9 +1,11 @@
 {
-  "$comment": "端到端示例 · 整页场景还原（对照效果图逐模块提取的完整交付样例，模拟设计技能真实产出）。覆盖：global 主题 + 壳层全模块 + 列表页全字段 + 表格细粒度点位（操作列形态/状态Tag/金额对齐/缩略图）+ pending 新点位。值口径演示：主题色用语义值（钴蓝-N/错误色）、尺寸用数值字面量（28px/40px 等，设计侧 v1.0 协议第 3 条合法通道）、灰阶用临时主题 hex + notes 申报。业务功能差异（新增运单按钮功能、demo 演示按钮去留）不在本变更集范围，走项目侧业务闭环开发（双层交付）。运行：node parser/index.js match <本文件>（cwd 为 skill 根）。",
+  "$comment": "端到端示例 · 整页场景还原（对照效果图逐模块提取的完整交付样例，模拟设计技能真实产出）。G8 模式闸正例：mode=restore + scheme + oracle(含 mockup) + coverage(含 registry) 齐备。覆盖：global 主题 + 壳层全模块 + 列表页全字段 + 表格细粒度点位（操作列形态/状态Tag/金额对齐/缩略图）+ pending 新点位。值口径演示：主题色用语义值（钴蓝-N/错误色）、尺寸用数值字面量（28px/40px 等，设计侧 v1.0 协议第 3 条合法通道）、灰阶用临时主题 hex + notes 申报。业务功能差异（新增运单按钮功能、demo 演示按钮去留）不在本变更集范围，走项目侧业务闭环开发（双层交付）。运行：node parser/index.js match <本文件>（cwd 为 skill 根）。",
   "schema": "design.changeset/1.0",
   "changeset_version": "1.0.0",
   "mapping_version": "1.0.0",
   "scene": "admin",
+  "scheme": "default",
+  "mode": "restore",
   "layout_type": "vertical",
   "global": {
     "brand_primary": "钴蓝-5",
@@ -26,12 +28,35 @@
       }
     },
     { "id": "admin.layout.header", "style": { "bg": "#FFFFFF" } },
-    { "id": "admin.layout.header.lang_switch", "form": "inline_switch", "suppress": ["icon_only"] },
+    {
+      "id": "admin.layout.header.lang_switch",
+      "form": "inline_switch",
+      "suppress": ["icon_only"],
+      "style": { "icon_size": "16px", "gap": "8px", "text_font_size": "14px" }
+    },
     {
       "id": "admin.layout.header.user_profile",
       "style": { "avatar_width": "28px", "avatar_height": "28px", "avatar_radius": "全圆角", "name_font_size": "14px", "name_font_weight": "中等" }
     },
     { "id": "admin.layout.tabs", "form": "chrome", "style": { "bg": "#FFFFFF" } },
+    {
+      "id": "admin.content.table.header_cell",
+      "style": { "height": "48px", "padding": "16px", "bg": "#FAFAFA", "font_weight": "中等", "text_align": "左对齐", "nowrap": "不换行" },
+      "layer": { "height": "host", "padding": "host", "bg": "host", "font_weight": "host", "text_align": "inner", "nowrap": "inner" },
+      "suppress_inner": true
+    },
+    {
+      "id": "admin.content.table.cell",
+      "style": { "padding_y": "8px", "vertical_align": "middle" },
+      "layer": { "padding_y": "inner", "vertical_align": "inner" },
+      "suppress_inner": true
+    },
+    {
+      "id": "admin.content.table.cell_status",
+      "form": "filled",
+      "style": { "bg": "#E8F3FF", "text_color": "钴蓝-5", "radius": "小圆角" }
+    },
+    { "id": "component.tag.status", "form": "filled", "style": { "height": "24px", "radius": "小圆角", "bg_color": "#F6FFED" } },
     {
       "id": "admin.content.page_header",
       "style": { "title_size": "20px", "title_weight": "加粗", "desc_color": "钴蓝-3", "actions_gap": "8px" }
@@ -52,10 +77,41 @@
     { "id": "admin.content.table.area", "style": { "header_bg": "#FAFAFA", "row_hover_bg": "#FAFAFA", "radius": "小圆角" } },
     { "id": "admin.content.table.cell_amount", "style": { "align": "right", "font_variant_numeric": "等宽数字" } },
     { "id": "admin.content.table.cell_thumb", "style": { "thumb_width": "40px", "thumb_height": "40px", "thumb_radius": "小圆角" } },
-    { "id": "component.tag.status", "form": "filled", "style": { "height": "24px", "radius": "小圆角" } },
     { "id": "component.button.danger", "style": { "bg_color": "错误色", "border_color": "错误色", "text_color": "#FFFFFF" } },
     { "id": "admin.content.pagination", "style": { "active_bg": "钴蓝-5", "active_color": "#FFFFFF" } }
   ],
+  "oracle": {
+    "mockup": "verify/运单管理-钴蓝.html",
+    "sids": [
+      "admin.layout.sidebar",
+      "admin.layout.sidebar.logo_area",
+      "admin.layout.sidebar.menu",
+      "admin.layout.header",
+      "admin.layout.header.lang_switch",
+      "admin.layout.header.user_profile",
+      "admin.layout.tabs",
+      "admin.content.page_header",
+      "admin.content.filter_area",
+      "admin.content.table.operation_bar",
+      "admin.content.table.operation_column",
+      "admin.content.table.area",
+      "admin.content.table.header_cell",
+      "admin.content.table.cell",
+      "admin.content.table.cell_status",
+      "admin.content.table.cell_amount",
+      "admin.content.table.cell_thumb",
+      "component.tag.status",
+      "component.button.danger",
+      "admin.content.pagination"
+    ]
+  },
+  "coverage": {
+    "registry": "references/page-specs/styles/default/scenes/admin/restore-registry.json",
+    "registrable": 186,
+    "applicable": 186,
+    "covered": 186,
+    "gaps": []
+  },
   "pending": [
     {
       "proposed_id": "admin.content.page_header.greeting",

package/parser/fixtures/changeset-neg4-g8.json

@@ -0,0 +1,15 @@
+{
+  "$comment": "G8 模式闸负例：mode=restore 但缺 oracle 与 coverage（伪还原变更集，2026-09-20 事故的机检复现件）。预期：match 打印「G8 模式闸」并 exit 1。与 changeset-pos.json 的区别仅此——mode=restore 却没带基线三件套。",
+  "schema": "design.changeset/1.0",
+  "changeset_version": "1.0.0",
+  "mapping_version": "1.0.0",
+  "scene": "admin",
+  "mode": "restore",
+  "layout_type": "vertical",
+  "global": { "brand_primary": "钴蓝-5" },
+  "changes": [
+    { "id": "admin.layout.sidebar.menu", "style": { "menu_bg": "钴蓝-9", "menu_active_bg": "钴蓝-5" } },
+    { "id": "component.button.primary", "style": { "bg_color": "钴蓝-5" } }
+  ],
+  "notes": "伪还原变更集：只换主题色就宣称场景还原——没有 oracle 验收基线（还原度不可证明）、没有 coverage 登记表记账（组内子项静默丢失不可数）。G8 之前这类变更集只收软提示、一路绿灯，落地后用户看到「只变了主题、布局细节零变化」。"
+}

package/parser/fixtures/changeset-neg5-g8-stub.json

@@ -0,0 +1,26 @@
+{
+  "$comment": "G8 强化负例（二轮）：mode=restore，scheme/oracle/coverage 三个对象都在，但 oracle.mockup 与 coverage.registry 为空串 —— 「有壳无芯」的伪基线：验收抽不出效果图、覆盖率无法以登记表重算。预期：match 打印「G8 模式闸」并 exit 1。与 changeset-fullpage-restore.json 的区别仅在此三处。",
+  "schema": "design.changeset/1.0",
+  "changeset_version": "1.0.0",
+  "mapping_version": "1.0.0",
+  "scene": "admin",
+  "scheme": "default",
+  "mode": "restore",
+  "layout_type": "vertical",
+  "global": { "brand_primary": "钴蓝-5" },
+  "changes": [
+    { "id": "admin.layout.sidebar.menu", "style": { "menu_bg": "钴蓝-9", "menu_active_bg": "钴蓝-5" } }
+  ],
+  "oracle": {
+    "mockup": "",
+    "sids": ["admin.layout.sidebar.menu"]
+  },
+  "coverage": {
+    "registry": "",
+    "registrable": 186,
+    "applicable": 4,
+    "covered": 4,
+    "gaps": []
+  },
+  "notes": "空壳伪基线：oracle/coverage 对象齐全但 mockup 与 registry 为空。过去只校验『对象是否存在』，这类写法能一路绿灯——效果图无从抽取、A/C 无从重算，『完备性可数』形同虚设。G8 强化后予拦截。"
+}

package/parser/fixtures/verify//350/277/220/345/215/225/347/256/241/347/220/206-/351/222/264/350/223/235.html

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<!-- G8 模式闸正例配套 · 效果图实物（changeset-fullpage-restore.json 的 oracle.mockup 夹具，非真实交付件）。
+     文件名带主题词「钴蓝」（oracle 主题一致性校验依据）；每个 data-sid 对应 oracle.sids。
+     文末注释内含 1 个同形 data-sid（parser 剥注释后不计数，验证 §7.1 注释兜底防线）。 -->
+<html>
+<head><meta charset="utf-8"><title>运单管理-钴蓝</title></head>
+<body>
+  <div class="sidebar-container" data-sid="admin.layout.sidebar">
+    <div class="sidebar-logo" data-sid="admin.layout.sidebar.logo_area">LOGO</div>
+    <ul class="el-menu" data-sid="admin.layout.sidebar.menu"><li>菜单项</li></ul>
+  </div>
+  <header class="navbar" data-sid="admin.layout.header">
+    <div class="language-trigger" data-sid="admin.layout.header.lang_switch"><span class="language-icon">中</span><span class="language-text">简体中文</span></div>
+    <div class="navbar-right el-dropdown-link" data-sid="admin.layout.header.user_profile"><img alt=""><p>张伟</p></div>
+  </header>
+  <div class="tags-view" data-sid="admin.layout.tabs"><span class="scroll-item">首页</span></div>
+  <main class="app-main">
+    <div class="vts-page-header" data-sid="admin.content.page_header"><h2>运单管理</h2></div>
+    <div class="filter-area" data-sid="admin.content.filter_area"><input></div>
+    <div class="table-area">
+      <div class="table-bar" data-sid="admin.content.table.operation_bar"><button>新增运单</button></div>
+      <table data-sid="admin.content.table.area">
+        <thead>
+          <tr>
+            <th class="el-table__cell" data-sid="admin.content.table.header_cell">列名</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr>
+            <td class="el-table__cell" data-sid="admin.content.table.cell">单元格文本</td>
+            <td class="operate" data-sid="admin.content.table.operation_column"><a>查看</a><span class="divider"></span><a>更多</a></td>
+            <td class="amount" data-sid="admin.content.table.cell_amount">¥1,280.00</td>
+            <td><img class="thumb" data-sid="admin.content.table.cell_thumb"></td>
+            <td><span class="tag" data-sid="admin.content.table.cell_status">已签收</span><span class="tag global" data-sid="component.tag.status">状态</span></td>
+          </tr>
+        </tbody>
+      </table>
+      <button class="danger" data-sid="component.button.danger">批量删除</button>
+      <div class="pagination" data-sid="admin.content.pagination">1 2 3</div>
+    </div>
+  </main>
+  <!-- 注释内同形串（剥注释后不计数）：data-sid="admin.content.page_header" -->
+</body>
+</html>

package/parser/index.js

@@ -104,7 +104,7 @@ function printHelp() {
 
 用法：
   node parser/index.js build [--dry]                      校验映射表并生成 dist/ 产物
-  node parser/index.js match <changeset.json...>          对设计变更集执行三级匹配（可多文件）
+  node parser/index.js match <changeset.json...>          对设计变更集执行三级匹配（可多文件；顶层 mode=restore 时 G8 模式闸强制 oracle.mockup + coverage.registry 齐备）
   node parser/index.js match <cs.json> --registry <reg.json>
                                                           匹配 + 登记表覆盖率当场重算（子项级细闸，有缺口 exit 1）
   node parser/index.js match --batch <dir>                项目级批量匹配：目录下全部变更集 + 跨文件汇总
@@ -241,6 +241,55 @@ function matchOne(file, dataset, batchSummary, opts = {}) {
     console.warn(`  ⚠ schema "${changeset.schema}" 为历史值，建议设计侧升级为 "design.changeset/1.0"`);
   }
 
+  // G8 模式闸（2026-09-20 事故机制化）：变更集顶层 mode 声明交付模式。
+  //   mode=restore（场景还原）→ oracle + coverage 强制齐备，缺失 = exit 1。
+  //   事故背景：还原项目后重跑技能，产出「只换主题色」的轻量变更集却以还原之名交付——
+  //   186 条登记表、oracle 基线、coverage 记账全部缺席，parser 只打提示不阻断，一路绿灯
+  //   落地后用户看到「只变了主题、布局细节零变化」。教训文档化 ≠ 机器闸门：
+  //   「场景还原应给」的软提示升级为「mode=restore 必须给」的硬闸。
+  //   二轮强化：oracle/coverage 须有「芯」——oracle.mockup 与 coverage.registry 非空，
+  //   堵住空壳伪基线（有对象无内容）继续蒙混。
+  //   mode 缺省 / mode=design → 维持软提示口径（轻量主题调整等规范设计场景不受影响）。
+  const MODES = ["design", "restore"];
+  const mode = changeset.mode === undefined || changeset.mode === null ? "design" : changeset.mode;
+  if (!MODES.includes(mode)) {
+    console.error(`✖ mode 应为 "design" / "restore"，实际 "${mode}"`);
+    batchSummary?.invalid.push(path.basename(file));
+    if (!batchSummary)
+      process.exit(1);
+    return;
+  }
+  if (mode === "restore") {
+    // G8 强化（2026-09-20 二轮）：不只看「有没有 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(`  只换主题色也能一路绿灯落地，但布局细节点位从未被声明，还原度不可证明（2026-09-20 实证事故）。`);
+      console.error(`  处置：补齐后重跑；若本次确属轻量主题调整而非场景还原，改 mode="design" 并如实声明。`);
+      batchSummary?.invalid.push(path.basename(file));
+      if (!batchSummary)
+        process.exit(1);
+      return;
+    }
+    console.log(`  ✔ G8 模式闸：mode=restore，oracle + coverage 齐备（基线三件套完整）`);
+  }
+
   // 版本校验（mapping_version 缺失或不匹配 → 拒绝。版本恒定 1.0.0，此校验为破坏性升级保险丝：仅双侧同步升版时才会拦截）
   const versions = new Set(
     Object.values(dataset.files).map(d => d.meta?.version).filter(Boolean),
@@ -344,12 +393,18 @@ function matchOne(file, dataset, batchSummary, opts = {}) {
   }
 
   // oracle 验收基线（：设计侧给的效果图 + 待比对点位；项目侧落地后跑 verify 逐点 diff）
-  checkOracle(changeset, plan, valueDict);
-  checkCoverage(changeset);
+  // 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 不参与
-  const regGaps = checkRegistryCoverage(changeset, plan, opts);
+  // strict（mode=restore）同时驱动 G9 登记表身份闸与 G10 dims 兑现闸
+  const regGaps = checkRegistryCoverage(changeset, plan, { ...opts, strict: mode === "restore" });
   if (batchSummary)
-    batchSummary.registryGaps += regGaps;
+    batchSummary.registryGaps += regGaps + oracleGaps;
+  else if (regGaps + oracleGaps > 0)
+    process.exitCode = 1;
 
   // 输出转换计划
   console.log(`\n=== 三级匹配结果（scene=${changeset.scene}，${plan.length} 条）===`);
@@ -681,11 +736,15 @@ function priorityRequirement(strategy) {
  *     反之声明了却不在 sids 里的点位 → 落地后无法机器验收。
  * 两者都属「交付不完整」，与颜色红线同级，必须回流设计侧补齐。
  */
-function checkOracle(changeset, plan, valueDict) {
+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;
+    return 0;
   }
 
   const sids = Array.isArray(oracle.sids) ? oracle.sids : [];
@@ -737,16 +796,16 @@ function checkOracle(changeset, plan, valueDict) {
   );
   // 实物闭合兜底（G3）：带登记表时由 checkRegistryCoverage 做权威实物对账；
   // 未带登记表时此处直接打开 mockup 数 data-sid，防止「sids 自报全绿、实物基线为空」。
+  // mockup 路径解析复用 resolveFirstExisting（变更集同目录 → cwd → 技能根）。
   if (!changeset.coverage?.registry && mockup) {
-    const cands = [path.resolve(mockup), path.resolve(ROOT, mockup), path.resolve(process.cwd(), mockup)];
+    const mockupPath = resolveFirstExisting(mockup, opts.filePath);
     let physical = null;
-    for (const c of cands) {
+    if (mockupPath) {
       try {
-        const stripped = readFileSync(c, "utf-8").replace(/<!--[\s\S]*?-->/g, "");
+        const stripped = readFileSync(mockupPath, "utf-8").replace(/<!--[\s\S]*?-->/g, "");
         physical = new Set([...stripped.matchAll(/data-sid\s*=\s*["']([^"']+)["']/g)].map(m => m[1]));
-        break;
       }
-      catch { /* 试下一个候选路径 */ }
+      catch { /* mockup 不可读，physical 保持 null */ }
     }
     if (physical) {
       const sidNoPhysical = sids.filter(s => !physical.has(s) && !hiddenOnly.has(s));
@@ -765,11 +824,22 @@ function checkOracle(changeset, plan, valueDict) {
 
   if (issues.length === 0) {
     console.log(`  ✔ oracle 校验通过：主题一致、覆盖度双向闭合`);
-    return;
+    return 0;
+  }
+  // G11 oracle 基线硬闸（2026-09-21 机制化）：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;
 }
 
 /**
@@ -778,10 +848,13 @@ function checkOracle(changeset, plan, valueDict) {
  * 这里只做结构一致性校验：covered 必须等于 applicable、gaps 必须为空。
  * 缺 coverage 时无法判断「是否有组内子项被静默丢失」——属交付完整性的信号缺口。
  */
-function checkCoverage(changeset) {
+function checkCoverage(changeset, opts = {}) {
   const cov = changeset.coverage;
   if (!cov || typeof cov !== "object") {
-    console.log(`\n提示：变更集未提供 coverage 覆盖率记账（场景还原应给）—— 无法判断是否有规范子项被静默丢失，完备性不可数，建议回流设计侧补齐。`);
+    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);
@@ -810,7 +883,7 @@ function checkCoverage(changeset) {
     console.log(`  ✘ ${it}`);
 }
 
-/** 依次尝试候选路径，返回首个存在者（相对路径基准：变更集所在目录 → 当前工作目录 → 技能仓库根） */
+/** 依次尝试候选路径，返回首个存在者（相对路径基准：变更集所在目录 → 当前工作目录 → 技能仓库根 → 兄弟设计技能 project-ui-design 根） */
 function resolveFirstExisting(raw, filePath) {
   if (!raw || typeof raw !== "string")
     return null;
@@ -820,6 +893,10 @@ function resolveFirstExisting(raw, filePath) {
   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))
@@ -862,6 +939,12 @@ function checkRegistryCoverage(changeset, plan, opts = {}) {
       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;
   }
@@ -874,6 +957,23 @@ function checkRegistryCoverage(changeset, plan, opts = {}) {
     console.error(`\n✖ 登记表读取/解析失败：${registryPath} —— ${e.message}`);
     return 1;
   }
+
+  // G9 登记表身份闸（2026-09-21 机制化）：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}`);
@@ -895,33 +995,76 @@ function checkRegistryCoverage(changeset, plan, opts = {}) {
   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;
-  if (typeof mockupRef === "string" && mockupRef.trim()) {
-    const cands = [path.resolve(mockupRef), path.resolve(ROOT, mockupRef), path.resolve(process.cwd(), mockupRef)];
-    for (const c of cands) {
-      try {
-        const html = readFileSync(c, "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 = c;
-        break;
-      }
-      catch { /* 该候选路径不可读，试下一个 */ }
+  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)));
-  const gaps = applicable.filter(it => !registrySids(it).every(s => declared.has(s)));
+
+  // G10 dims 兑现闸（2026-09-21 机制化）：「兑现」从「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}`);
+  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
   let physicalGap = false;
@@ -953,17 +1096,24 @@ function checkRegistryCoverage(changeset, plan, opts = {}) {
     physicalGap = true;
   }
 
-  if (gaps.length === 0 && !physicalGap) {
-    console.log(`  ✔ 覆盖率通过：C = A，无子项被静默丢失；效果图实物标注闭合`);
+  if (gaps.length === 0 && dimsGaps.length === 0 && !physicalGap) {
+    console.log(`  ✔ 覆盖率通过：C = A，无子项被静默丢失；dims 维度全兑现（G10）；效果图实物标注闭合`);
     return 0;
   }
 
-  if (gaps.length === 0 && physicalGap) {
+  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 字段）；「点位在、细节丢」正是样式细节不还原的机制成因。`);
+  }
+
   const byGroup = new Map();
   for (const it of gaps) {
     const g = it.group || "（未分组）";
@@ -980,7 +1130,8 @@ function checkRegistryCoverage(changeset, plan, opts = {}) {
     if (!opts.verbose && list.length > shown.length)
       console.log(`      …（同组其余 ${list.length - shown.length} 条，加 --verbose 展开）`);
   }
-  return gaps.length;
+  // G10 dims 缺口计入返回值：strict 模式下 =「交付不完整」与欠声明同级
+  return gaps.length + (opts.strict ? dimsGaps.length : 0);
 }
 
 /**

package/parser/regression.js

@@ -15,7 +15,9 @@
  *   E  match 负例2（mapping_version 不符） → exit 1
  *   F  match 负例3（禁词阻断）             → exit 1
  *   G  match 旧协议兼容                    → exit 0 且输出含 ⚠ 告警
- *   H  match 整页场景还原样例              → exit 0 且输出含 #245BFF（壳层+内容区全模块 L1）
+ *   H  match 整页场景还原样例（mode=restore）→ exit 0 且输出含 #245BFF 与「G8 模式闸」（壳层+内容区全模块 L1）
+ *   P  match G8 负例（mode=restore 缺 oracle/coverage）→ exit 1 且输出含「G8 模式闸」（伪还原变更集拦截）
+ *   Q  match G8 强化负例（mode=restore 但 mockup/registry 为空壳）→ exit 1 且输出含「G8 模式闸」（有壳无芯伪基线拦截）
  *   I  build --dry 产物链自检              → exit 0 且输出含 dry-run
  *   J  match  三声明维度                → exit 0 且输出含「结构施工 structure_ops」
  *   K  audit 挂载点 / 死通道审计            → exit 1（夹具项目故意存在挂载点缺失 / 死通道）
@@ -98,10 +100,10 @@ const steps = [
   },
   {
     key: "H",
-    name: "match 整页场景还原样例（壳层+内容区全模块 L1 + 数值字面量透传）",
+    name: "match 整页场景还原样例（mode=restore 基线三件套 + 壳层+内容区全模块 L1 + 数值字面量透传）",
     script: INDEX,
     args: ["match", path.join(FIXTURES, "changeset-fullpage-restore.json")],
-    expect: { code: 0, includes: "#245BFF" },
+    expect: { code: 0, includes: ["#245BFF", "G8 模式闸"] },
   },
   {
     key: "I",
@@ -152,12 +154,26 @@ const steps = [
     args: ["registry", path.join(FIXTURES, "registry-bad.json")],
     expect: { code: 1, includes: "硬缺口" },
   },
+  {
+    key: "P",
+    name: "match G8 模式闸负例（mode=restore 缺 oracle/coverage = 伪还原变更集 → exit 1）",
+    script: INDEX,
+    args: ["match", path.join(FIXTURES, "changeset-neg4-g8.json")],
+    expect: { code: 1, includes: "G8 模式闸" },
+  },
+  {
+    key: "Q",
+    name: "match G8 强化负例（mode=restore 但 oracle.mockup / coverage.registry 为空壳 = 有壳无芯 → exit 1）",
+    script: INDEX,
+    args: ["match", path.join(FIXTURES, "changeset-neg5-g8-stub.json")],
+    expect: { code: 1, includes: "G8 模式闸" },
+  },
 ];
 
 const results = [];
 let failed = 0;
 
-console.log("=== A-O 端到端一键回归 ===\n");
+console.log("=== A-Q 端到端一键回归 ===\n");
 
 for (const step of steps) {
   const { status, stdout, stderr } = spawnSync(
@@ -194,4 +210,4 @@ if (failed > 0) {
   console.error(`\n✖ ${failed} 步未通过，见上方详情`);
   process.exit(1);
 }
-console.log("\n✔ A-O 全部通过，mapping/parser 可提交或发版");
+console.log("\n✔ A-Q 全部通过，mapping/parser 可提交或发版");

package/references/design-apply.md

@@ -62,6 +62,8 @@ parser match（确定性翻译）→ 施工坐标 → AI 按坐标改代码 →
   "changeset_version": "1.0.0",           // 恒填 "1.0.0"
   "mapping_version": "1.0.0",             // 恒填 "1.0.0"：版本由双侧 SKILL.md 体系版本统一管理，词典不单独演进。parser 校验口径 = 变更集值 ∈ 词典版本集合（恒通过）；仅协议破坏性升级时双侧同步升版
   "scene": "admin",              // 场景前缀，须与 mapping 场景域一致
+  "scheme": "default",           // 方案标识（mode=restore 时必填）：取设计侧 page-specs/styles/registry.json 的方案 id；与 scene 共同定位「方案 × 场景」的清单/登记表
+  "mode": "restore",             // 交付模式（G8 模式闸）：restore=场景还原（scheme + oracle.mockup + coverage.registry 强制必填）；design=显式声明的轻量微调；缺省 design
   "layout_type": "vertical",    // 标准布局枚举：vertical / horizontal / mix（字段名固定 layout_type，非 layout）
   "global": { "brand_primary": "钴蓝-5" },  // 可选：全局令牌通道（整套主题切换优先走此节点；值 = 语义名或临时主题 hex）
   "changes": [
@@ -190,10 +192,11 @@ node parser/index.js match --batch <changesets-dir>
 
 | 闸 | 触发条件 | 判据来源 | 违规输出 |
 |---|---|---|---|
+| **G8 模式闸** | 变更集顶层 `mode: "restore"`（场景还原）但基线不全：缺 `scheme` / `oracle` / `coverage`，**或 `oracle.mockup` / `coverage.registry` 为空**（有壳无芯的伪基线）——伪还原变更集（只换主题色却以还原之名交付）拒绝执行；`mode` 非法值同样阻断 | 变更集顶层 `scheme` / `mode` / `oracle.mockup` / `coverage.registry` | `G8 模式闸：mode=restore 但缺少 … → 拒绝执行` |
 | **G1 suppress 收口** | 条目声明某 `form`，词典 `suppress_rules[form]`（或 forms 描述「suppress 必含 x」内联标记）要求收口的出厂互斥通道未全部出现在该条目 `suppress[]` | 词典条目 `suppress_rules` | `suppress 缺口：…必须收口出厂互斥通道 [x]，缺 [x]` |
 | **G5 几何语境** | 词典 preconditions 含「几何语境随值迁移」标记 ∧ `style` 含 padding/margin 族几何字段落宿主 ∧ 未声明 `suppress_inner` | 词典条目 preconditions 标记句 | `suppress_inner 缺口：…两层之和 ≠ 设计值` |
 
-两闸与禁词校验同级阻断（`exit 1`）——「新旧形态叠加」「两层 padding 相加」都是值全对、观感全错的历史事故源（双竖条、28px 列挤压），不允许靠观感兜底。
+三闸与禁词校验同级阻断（`exit 1`）——「新旧形态叠加」「两层 padding 相加」「伪还原只换主题」都是历史事故源（双竖条、28px 列挤压、「还原后布局细节零变化」），不允许靠观感兜底。G8 判据一句话：**「把系统 / 页面改成 X」默认是还原（restore），必须带齐 `scheme` + `oracle.mockup` + `coverage.registry`；只有「显式声明只改主题色、其它不动」才用 `design`**（2026-09-20 事故机制化：还原项目后重跑，无登记表无基线的轻量变更集一路绿灯，落地后「只变了主题、布局细节零变化」；二轮强化再堵住 `oracle`/`coverage` 只给空壳、无 `mockup`/`registry` 芯的写法）。**降级不许静默发生**：变更集 `notes` 与交付说明都须显式写出本次 `mode` 与范围。
 
 **验收基线输出**：转换计划末尾另打印 `=== 验收基线 oracle ===`（效果图路径 + 待比对点位）与 `=== 覆盖率 coverage ===`（登记项 R / 适用 A / 已兑现 C）。有 `oracle` → 落地后必须跑第 6 步 `verify`；缺 `oracle` / `coverage` → 输出提示，把「补基线 / 补登记覆盖率」回流设计侧（场景还原应给）。
 **覆盖率校验**：`coverage.covered` 必须等于 `coverage.applicable`、`gaps` 为空，否则打印缺口清单——`C < A` 即**欠声明**（有规范子项未落进 `changes[]`/`visible`/`pending`），属设计侧交付不完整，必须回流，不得在项目侧"猜着补"。
@@ -496,7 +499,7 @@ html .navbar .navbar-breadcrumb-wrap {
 ## 端到端回归（改 parser/mapping 后必跑）
 
 ```bash
-node parser/regression.js        # 一键跑完 A-O 十五步（自动断言退出码与关键输出，任一失败 exit 1 并回显详情）
+node parser/regression.js        # 一键跑完 A-Q 十七步（自动断言退出码与关键输出，任一失败 exit 1 并回显详情）
 npm run regression               # 等价写法
 ```
 
@@ -518,9 +521,11 @@ node parser/index.js verify --oracle parser/fixtures/verify/oracle.json --actual
 node parser/index.js match --registry parser/fixtures/registry-sample.json parser/fixtures/changeset-registry-gap.json  # M. 登记表覆盖率细闸：夹具欠声明 2 条恒存在子项 → exit 1
 node parser/index.js registry parser/fixtures/registry-sample.json    # N. 登记表通道核验：点位全部命中 → exit 0；输出含「登记表通道核验」
 node parser/index.js registry parser/fixtures/registry-bad.json       # O. 登记表硬缺口：引用不存在且未标 pending 的点位 → exit 1
+node parser/index.js match parser/fixtures/changeset-neg4-g8.json     # P. G8 模式闸负例：mode=restore 缺 oracle/coverage（伪还原变更集）→ exit 1
+node parser/index.js match parser/fixtures/changeset-neg5-g8-stub.json # Q. G8 强化负例：mode=restore 但 mockup/registry 空壳（有壳无芯伪基线）→ exit 1
 ```
 
-通过标准：regression.js 输出 `A✔ B✔ … O✔` 且 exit 0；分步跑时各步符合注释预期。夹具含义见各文件 `$comment`。
+通过标准：regression.js 输出 `A✔ B✔ … Q✔` 且 exit 0；分步跑时各步符合注释预期。夹具含义见各文件 `$comment`。
 
 ## 配套工具（作者/维护侧）