@qilitt-mickey/vue3-temp-skill 1.1.70 → 1.1.71

package/package.json

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

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

@@ -1,5 +1,5 @@
 {
-  "generated_at": "2026-09-23T09:41:58.162Z",
+  "generated_at": "2026-09-24T07:14:25.807Z",
   "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": {

package/references/design-apply.md

@@ -135,6 +135,17 @@ parser match（确定性翻译）→ 施工坐标 → AI 按坐标改代码 →
 
 **红线摘要（全文适用，细节在各步子文件）**：出厂中性 · 变更集驱动（上文）；先结构后样式（第 2 步先于第 3 步）；缺口只分「能力缺口（当场落地）」与「意图缺口（回流设计侧）」两类；**效果图/大文件只读一次**——期望值落盘 `oracle.json` 后，后续环节一律消费落盘产物，禁止反复重读。环境无 Node 时按「环境备注」（见 maintenance.md）人工执行。
 
+## 施工标记规范（G3：@sid / @closed，design-audit E15 机检）
+
+结构性声明（`form` / `suppress` / `suppress_inner` / `structure_ops` / `text_visible:none` / `visible:false`）**必须在设计层留机读标记**——声明了不等于落地了，没有标记就没有对账凭证（实证：`collapse_trigger.form=header_inline` 声明后壳层零规则，落地端静默无效）：
+
+| 标记 | 写法 | 作用 |
+|---|---|---|
+| `@sid` | 规则上方 `/* @sid: <语义ID> */` | 「变更集 ↔ 设计层」逐条落点对账（@sid 强制） |
+| `@closed` | 收口规则上方 `/* @closed: <通道名> */` | suppress 收口兑现证据（通道名 = 词典 forms/css_vars/custom_style_map 的键） |
+
+补充证据通道：通道为 `css_vars` 键时，设计层对该 var 写关闭值（`transparent` / `none` / `0`）即视为兑现，可免 `@closed` 标记；`visible:false` 的 `display:none` 规则按 E6 口径取证。**双向对账（E15）**：设计层 `@closed` 了变更集未声明的通道 → WARN（台账失真，收口记录进不了 D13 继承链）；声明了词典不认识的 form 值 / 通道名 → ERROR（悬空声明 = 无规则可挂）；结构性声明在设计层零证据 → ERROR。
+
 ## 会话结束条件（终态硬闸，违反 = 交付未完成）
 
 **落地会话不许「做一批、停下来等用户说继续」。** 「继续」只是异常中断后的恢复手段，不是交付形态——把恢复手段当成默认流程 = 把 1:1 还原降级为多次半成品。本轮做完一批点位后，**必须自动进入下一批**，直到同时满足以下三条才允许结束会话：

package/scripts/check.mjs

@@ -53,6 +53,49 @@ const checks = [
       return run(NODE, "scripts/design-audit.mjs", args);
     },
   },
+  {
+    name: "审计闸 G3 回归",
+    desc: "结构声明兑现闸：悬空 form / 未收口通道的假项目必须被 design-audit 拒绝，带 @sid/@closed 标记的正例必须通过",
+    cmd: () => {
+      const neg = path.join(ROOT, "tests/fixtures/audit-g3-negative");
+      const pos = path.join(ROOT, "tests/fixtures/audit-g3-positive");
+      const lines = [];
+      if (fs.existsSync(neg)) {
+        let rejected = false;
+        let out = "";
+        try {
+          out = run(NODE, "scripts/design-audit.mjs", ["--project", neg, "--no-ledger"]);
+        } catch (e) {
+          rejected = true;
+          out = `${e.stdout || ""}${e.stderr || ""}`;
+        }
+        if (!rejected) {
+          throw Object.assign(new Error("审计负例未被拒绝"), {
+            stdout: "  ✗ audit-g3-negative 竟然通过 —— E15 结构声明兑现闸判据被削弱，必须修复\n",
+          });
+        }
+        if (!/\[E15\]/.test(out)) {
+          throw Object.assign(new Error("审计负例未命中 E15"), {
+            stdout: `  ✗ audit-g3-negative 被拒绝，但未命中 [E15] —— 断言已失效\n${out.slice(-800)}\n`,
+          });
+        }
+        lines.push("negative 被拒绝并命中 [E15]");
+      }
+      if (fs.existsSync(pos)) {
+        let out = "";
+        try {
+          out = run(NODE, "scripts/design-audit.mjs", ["--project", pos, "--no-ledger"]);
+        } catch (e) {
+          throw Object.assign(new Error("审计正例被拒绝"), {
+            stdout: `  ✗ audit-g3-positive 被拒绝（E15 存在误报，必须修复）：\n${(e.stdout || "") + (e.stderr || "")}\n`,
+          });
+        }
+        lines.push("positive 通过");
+      }
+      if (!lines.length) return "SKIPPED 未发现审计夹具（仅源码检出时可用）";
+      return `  ${lines.join("；")}`;
+    },
+  },
 ];
 
 function run(runner, script, args = []) {

package/scripts/design-audit.mjs

@@ -32,6 +32,7 @@
  *   E13 固定尺寸内容度量 固定 width 小于内容需求且无收口兜底 → 文字换行/压缩/重叠
  *   E14 列宽预算链自洽  列宽（含公式）扣掉实际 td 内边距后装不下内容 → 操作列按钮被压
  *   E16 引用完整性   变更集引用的实物不存在（改名未同步）/ restore 缺顶层 theme
+ *   E15 结构声明兑现  form 值 / suppress 通道名必须在词典枚举内，且设计层有 @sid / @closed 落点证据（G3 双向对账）
  */
 
 import fs from "fs";
@@ -826,6 +827,195 @@ const lastClassOutsideNot = (sel) => {
   }
 })();
 
+// ── E15 结构声明兑现闸（G3：@sid 强制 + form/suppress 双向对账）──
+// 结构性声明（form / suppress / suppress_inner / structure_ops / text_visible:none /
+// visible:false）不能停留在台账上——项目侧必须有可指认的落点证据。实证缺口
+// （2026-09-24 孔雀绿轮）：collapse_trigger.form=header_inline 声明了，但词典 forms
+// 只有 bottom_bar / center_edge —— 壳层零规则，落地端静默无效，而 E6/E8/E9 的
+// 特判窗口都盖不住它。
+// 证据通道（按优先级）：
+//   ① /* @sid: <语义ID> */      —— 逐条落点标记（@sid 强制的机读载体）
+//   ② /* @closed: <通道名> */   —— suppress 收口证据（与 @sid 同构）
+//   ③ 通道为 css_vars 键时，设计层对该 var 写入关闭值（transparent / none / hidden / 0）
+//   ④ visible:false 的 display:none 收口规则（E6 同源）
+// 判定：
+//   · form 值不在词典 forms 枚举内 / suppress 通道名不是 forms∪css_vars∪custom_style_map
+//     的键 → ERROR（声明悬空 = 项目侧无规则可挂）
+//   · suppress_rules[form] 与 suppress[] 要求的通道无任何兑现证据 → ERROR
+//   · 有落点证据但缺 @sid → WARN（补标记使逐条对账可机读）
+//   · 出厂默认形态且无其他结构载荷 → WARN（保持现状无需规则，但仍需标记）
+//   · 反向：设计层 @closed 了变更集未声明的通道 → WARN（台账失真，收口记录进不了 D13 继承链）
+const CLOSING_VALUE_RE = /^(transparent|none|hidden|0(?:px)?)(\s|$)/i;
+const markedSids = new Set([...designCss.matchAll(/@sid\s*:\s*([\w.$-]+)/g)].map((m) => m[1]));
+const closedMarkers = new Set([...designCss.matchAll(/@closed\s*:\s*([\w.-]+)/g)].map((m) => m[1]));
+
+/** 与 parser extractSuppressRules 同源：结构化 suppress_rules 优先，forms 描述「suppress 必含」兜底 */
+function extractSuppressRulesAudit(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") : [];
+    }
+  }
+  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;
+}
+
+const channelNamesOf = (entry) =>
+  new Set([
+    ...Object.keys(entry?.forms || {}),
+    ...Object.keys(entry?.css_vars || {}),
+    ...Object.keys(entry?.custom_style_map || {}),
+  ]);
+
+/** 通道收口证据：@closed 标记 或（css_vars 键）关闭值覆写 */
+function channelEvidence(entry, ch) {
+  if (closedMarkers.has(ch)) return `@closed:${ch}`;
+  const varName = entry?.css_vars?.[ch];
+  if (varName) {
+    const re = new RegExp(`${varName}\\s*:\\s*([^;\\n}]+)`, "i");
+    const m = re.exec(designCss);
+    if (m && CLOSING_VALUE_RE.test(m[1].trim())) return `${varName} 关闭值覆写`;
+  }
+  return null;
+}
+
+/** visible:false 落点证据（E6 同源口径） */
+function visibleClosureRule(change) {
+  const entry = dictSidMap.get(change.id);
+  const target = classTokens(entry?.selector || "").slice(-1)[0];
+  if (!target) return null;
+  return (
+    designRules.find((r) => r.selector.includes(`.${target}`) && /none/i.test(r.decls.display || "")) || null
+  );
+}
+
+(function checkE15() {
+  if (!changeset) {
+    info("E15", "未发现变更集，跳过结构声明兑现对账");
+    return;
+  }
+  const isStructural = (c) =>
+    typeof c?.form === "string" ||
+    (Array.isArray(c?.suppress) && c.suppress.length > 0) ||
+    (typeof c?.suppress_inner === "string" && c.suppress_inner.trim()) ||
+    (Array.isArray(c?.structure_ops) && c.structure_ops.length > 0) ||
+    c?.style?.text_visible === "none" ||
+    c?.visible === false;
+
+  const changes = changeset.changes || [];
+  for (const change of changes) {
+    if (!isStructural(change)) continue;
+    const entry = dictSidMap.get(change.id);
+    if (!entry) {
+      warn("E15", `${change.id} 声明结构语义（form/suppress 等），但词典无该条目 —— 项目侧无挂载点，无法兑现（match 会拦截）。`);
+      continue;
+    }
+
+    // ① form 值真实性：悬空 form 值 = 壳层零规则（header_inline 实证）
+    if (typeof change.form === "string" && change.form) {
+      const forms = entry.forms && typeof entry.forms === "object" ? Object.keys(entry.forms) : [];
+      const rules = entry.suppress_rules || {};
+      if (forms.length && !forms.includes(change.form) && !(change.form in rules)) {
+        err(
+          "E15",
+          `${change.id} 的 form="${change.form}" 不在词典 forms 枚举 [${forms.join("、")}] 内 —— 项目侧无规则可挂（壳层零规则），声明悬空。形态值只能取词典已支持的枚举；确需新形态先走 pending 补词典。`,
+        );
+      }
+    }
+
+    // ② suppress 通道名真实性（「声明 → 词典」对账）
+    const declared = Array.isArray(change.suppress) ? change.suppress : [];
+    const known = channelNamesOf(entry);
+    const unknown = declared.filter((ch) => !known.has(ch));
+    if (unknown.length) {
+      err(
+        "E15",
+        `${change.id}.suppress 引用了词典不认识的通道 [${unknown.join("、")}]（可用通道：${[...known].join("、")}）—— 通道名以该条目 forms/css_vars/custom_style_map 的键为准。`,
+      );
+    }
+
+    // ③ suppress_rules[form] 与已声明通道的兑现证据（「声明 → 设计层」对账）
+    const required = extractSuppressRulesAudit(entry)[change.form] || [];
+    const demanded = [...new Set([...required, ...declared])];
+    let allClosed = true;
+    for (const ch of demanded) {
+      const ev = channelEvidence(entry, ch);
+      if (!ev) {
+        allClosed = false;
+        const varHint = entry.css_vars?.[ch]
+          ? `，或（通道为 css_vars 键）在设计层覆写 ${entry.css_vars[ch]} 为关闭值（transparent / none / 0）`
+          : "";
+        err(
+          "E15",
+          `${change.id} 要求收口通道「${ch}」，但设计层无任何兑现证据 —— 需要 /* @closed: ${ch} */ 标记${varHint}。声明了不收口 = 出厂旧装饰残留（双竖条并存类实证）。`,
+        );
+      }
+    }
+
+    // ④ @sid 强制（零证据 = 壳层零规则；有证据缺标记 = 降级 WARN 促标记）
+    const hasSid = markedSids.has(change.id);
+    if (!hasSid) {
+      const visRule = change.visible === false ? visibleClosureRule(change) : null;
+      if (change.visible === false && !visRule) {
+        // E6 已就同一根因报 ERROR，此处不重复
+      } else if (demanded.length && allClosed) {
+        warn("E15", `${change.id} 的收口已有落点证据，但缺 /* @sid: ${change.id} */ 标记 —— 补标记使「变更集 ↔ 设计层」逐条对账可机读（G3）。`);
+      } else if (change.visible === false && visRule) {
+        warn("E15", `${change.id} 的 display:none 收口已落（E6 ✓），但缺 /* @sid: ${change.id} */ 标记 —— 补标记使逐条对账可机读。`);
+      } else {
+        const forms = entry.forms && typeof entry.forms === "object" ? entry.forms : {};
+        const isDefaultForm = typeof change.form === "string" && /出厂默认|默认形态|default/i.test(String(forms[change.form] || ""));
+        const hasOps = Array.isArray(change.structure_ops) && change.structure_ops.length > 0;
+        const hasInner = typeof change.suppress_inner === "string" && change.suppress_inner.trim().length > 0;
+        const hasTextNone = change.style?.text_visible === "none";
+        const otherPayload = hasOps || hasInner || hasTextNone || demanded.length > 0;
+        if (isDefaultForm && !otherPayload) {
+          warn("E15", `${change.id} 的 form="${change.form}" 是出厂默认形态（无需新增规则），但缺 /* @sid: ${change.id} */ 标记 —— 建议补标记。`);
+        } else if (hasOps && !otherPayload) {
+          warn("E15", `${change.id} 的 structure_ops 由 parser G2 施工证据闸取证；设计层建议补 /* @sid: ${change.id} */ 标记。`);
+        } else {
+          err(
+            "E15",
+            `${change.id} 的结构性声明在设计层零落点证据（无 @sid 标记、无 @closed 兑现标记、无收口规则）—— 壳层零规则，声明悬空（实证：collapse_trigger.form=header_inline 声明后壳层无任何规则）。每条结构性声明必须在设计层留机读标记：/* @sid: <语义ID> */。`,
+          );
+        }
+      }
+    }
+  }
+
+  // ⑤ 反向对账：设计层收口了变更集未声明的通道 → 台账失真
+  for (const ch of closedMarkers) {
+    const owners = changes
+      .map((c) => ({ c, e: dictSidMap.get(c?.id) }))
+      .filter(({ e }) => e && channelNamesOf(e).has(ch));
+    if (!owners.length) continue; // 不属于本变更集涉及的点位（历史层），不判
+    const accounted = owners.some(
+      ({ c, e }) =>
+        (Array.isArray(c.suppress) ? c.suppress.includes(ch) : false) ||
+        (extractSuppressRulesAudit(e)[c.form] || []).includes(ch),
+    );
+    if (!accounted) {
+      warn(
+        "E15",
+        `设计层 /* @closed: ${ch} */ 收口了通道，但变更集未声明该收口（涉及点位：${owners.map((o) => o.c.id).join("、")}）—— 台账失真：收口记录进不了 D13 继承链，下轮漏抄即出厂形态复现。`,
+      );
+    }
+  }
+  if (!errors.some((e) => e.id === "E15") && !warnings.some((w) => w.id === "E15")) {
+    info("E15", "结构声明兑现：form/suppress 全部落在词典已知通道且设计层有落点证据 ✓");
+  }
+})();
+
 // ── @sid 标记覆盖率（可选增强） ─────────────────────────────
 (function checkSidCoverage() {
   const marked = new Set([...designCss.matchAll(/@sid\s*:\s*([\w.$-]+)/g)].map((m) => m[1]));