cardbuddy 0.14.3 → 0.16.0

package/dist/vendored/skills/dsl-card-generator/scripts/lib/paths.py

@@ -15,15 +15,11 @@ paths.py — skill 内部路径与宿主项目路径单一来源（Python 侧）
   DSL_CARD_PREVIEW_DIR   自包含预览目录（默认 <skill>/vendor/preview）
   DSL_CARD_BASELINES_DIR 渲染基线目录（默认 <project>/.card-baselines）
 """
-import json
 import os
 from pathlib import Path
 
 _HERE = Path(__file__).resolve().parent
 
-# 占位 sentinel：与任何用户传入的 fallback 都不会相同的内部对象。
-_MISSING = object()
-
 # 当前 skill 根目录：scripts/lib -> scripts -> dsl-card-generator
 skill_root = _HERE.parent.parent
 
@@ -93,36 +89,3 @@ host_skills_dir = _host_skills_dir()
 def card_dir(card_id: str) -> Path:
     """解析卡片目录的绝对路径：`<cards_dir>/<id>`。"""
     return cards_dir / card_id
-
-
-def card_schema_path(card_id: str) -> Path:
-    """解析卡片 schema.json 的绝对路径。"""
-    return cards_dir / card_id / "schema.json"
-
-
-def card_data_path(card_id: str) -> Path:
-    """解析卡片 data.json 的绝对路径。"""
-    return cards_dir / card_id / "data.json"
-
-
-def read_json(p: Path, fallback=_MISSING):
-    """
-    安全读取 JSON（不存在或解析失败时返回 fallback）。
-
-    Args:
-        p: 路径
-        fallback: 不存在/解析失败时的返回值。默认抛错。
-    Returns:
-        解析后的 Python 值
-    """
-    p = Path(p)
-    if not p.is_file():
-        if fallback is _MISSING:
-            raise FileNotFoundError(f"File not found: {p}")
-        return fallback
-    try:
-        return json.loads(p.read_text(encoding="utf-8"))
-    except Exception as e:
-        if fallback is _MISSING:
-            raise RuntimeError(f"Cannot parse JSON {p}: {e}") from e
-        return fallback

package/dist/vendored/skills/dsl-card-generator/scripts/lib/python.mjs

@@ -0,0 +1,99 @@
+/**
+ * python.mjs — 跨平台 Python 解释器解析的**单一来源**（Node 侧）。
+ *
+ * 为什么必须真跑一次 `--version`（而不是只看「能不能 spawn」）：Windows 上 `python3` 常是
+ * Microsoft Store 的**应用执行别名** —— 进程能启动，却立刻以 9009 退出，这不是 ENOENT。
+ * 只按 spawn 异常判断就会钉死这个假解释器，autofix / validate 全部静默不执行，调用方
+ * 收到的是一个**永远修不好**的 validate error（实测模型为它空转 20 轮，每轮重跑 iterate）。
+ *
+ * 为什么集中到本文件：同一件事此前在 5 个脚本里各写一遍，能力互不相同 ——
+ *   · `expand_ir.mjs`          真探测 + `py`（原本最完整，本文件的基准）
+ *   · `route_input.mjs`        真探测 + `py`，但不认 `WORKBUDDY_PYTHON`
+ *   · `add_component.mjs`      不真探测、不认 `py`
+ *   · `gate.mjs` / `v3_regression.mjs`  只读 `process.env.PYTHON || 'python3'`（**完全不探测**）
+ *   · `register_card_template.mjs`      只读 `DSL_PYTHON`、不认 `py`
+ * 后果：同一台机器上 `gate.mjs` 判定「没有 Python」而 `expand_ir.mjs` 跑得通。
+ *
+ * 环境变量链（前者优先，命中即停止回退到自动探测）：
+ *   `DSL_CARD_PYTHON`（权威）> `WORKBUDDY_PYTHON` > `DSL_PYTHON` > `PYTHON`
+ * 后两项为历史兼容（分别在 register_card_template / gate / v3_regression 里出现过），
+ * **新代码一律用 `DSL_CARD_PYTHON`**。
+ */
+import { spawnSync } from 'node:child_process'
+
+/** 显式指定的解释器，按优先级排列；命中即不再做自动探测。 */
+export const PYTHON_ENV_KEYS = ['DSL_CARD_PYTHON', 'WORKBUDDY_PYTHON', 'DSL_PYTHON', 'PYTHON']
+
+/** 权威环境变量名（文档 / 报错提示里要用户设置的那个）。 */
+export const PYTHON_ENV_PRIMARY = 'DSL_CARD_PYTHON'
+
+/** 自动探测顺序：`py` 是 Windows 官方启动器，`python3` 可能是 Store 假别名故不设优先级。 */
+export const PYTHON_AUTO_BINS = ['python3', 'python', 'py']
+
+/**
+ * 真跑一次 `--version` 判断解释器可用（识别 Windows Store 假别名）。
+ * @param {string} bin
+ * @returns {boolean}
+ */
+export function probePython(bin) {
+  const b = String(bin || '').trim()
+  if (!b) return false
+  try {
+    const r = spawnSync(b, ['--version'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 5000,
+    })
+    if (r.status !== 0) return false
+    return /Python \d/i.test(`${r.stdout || ''}${r.stderr || ''}`)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 候选解释器列表（去重、保持优先级）。
+ *
+ * 语义与 `expand_ir.mjs` 原实现一致：显式指定且探测通过 → 只返回它；显式指定但探测不过
+ * → 仍保留一次机会（可能是带参数的包装器）；全探测失败 → 回落到常见名字，让报错里能带出
+ * 真实 stderr，而不是一句笼统的「python 不可用」。
+ *
+ * @returns {string[]}
+ */
+export function pythonCandidates() {
+  const out = []
+  const seen = new Set()
+  const push = (bin) => {
+    const b = String(bin || '').trim()
+    if (!b || seen.has(b)) return
+    seen.add(b)
+    out.push(b)
+  }
+
+  for (const key of PYTHON_ENV_KEYS) {
+    const val = process.env[key]
+    if (!val) continue
+    if (probePython(val)) {
+      push(val)
+      return out // 显式指定且可用：不再回退到其它解释器
+    }
+    push(val) // 探测不过也留一次机会（包装器 / 路径含参数）
+  }
+
+  for (const bin of PYTHON_AUTO_BINS) if (probePython(bin)) push(bin)
+  for (const bin of ['python3', 'python']) push(bin)
+  return out
+}
+
+/**
+ * 最优先的可用解释器（总是返回可用的命令名，探测全失败时返回 `python3` 以便报错原样带出）。
+ * @returns {string}
+ */
+export function resolvePython() {
+  return pythonCandidates()[0] || 'python3'
+}
+
+/** 当前环境是否**有**可用 Python（供「没装就别跑」的早退分支用）。 */
+export function hasPython() {
+  return probePython(resolvePython())
+}

package/dist/vendored/skills/dsl-card-generator/scripts/lib/rules/adaptive-width.mjs

@@ -0,0 +1,105 @@
+/**
+ * rules/adaptive-width.mjs —— 宽度自适应契约的机械判据（ir-format.md §2f）。
+ *
+ * 背景（2026-09-25 汇率卡事故）：容器类节点把「设计稿测量宽」写死成 px
+ * （如第一层主容器 rect.width="343"），卡片在非设计宽度的宿主容器里
+ * 无法自适应——Root 撑满了，内容层却锁死在 343px。
+ *
+ * 渲染契约（component-meta.json / components.css 实证）：
+ *   - 全部容器组件的 meta 默认 rect.width 就是 "100%"（覆盖默认 = 显式声明固定）；
+ *   - adapter.doSize 对 '%' 值原样透传（不做 px 换算）；
+ *   - 纵向流（Root/Column/AbsoluteLayout）里子项交叉轴默认 stretch。
+ * 因此「占满语义」永远不该写成 px：写 100%（显式）或不写（默认）都自适应，
+ * 且在以卡面宽为基准的渲染/截图环境下与原 px 值逐像素等价（父内容盒宽 == 原 px）。
+ *
+ * 判定口径（全部是格式/几何/结构特征，与任何业务无关）：
+ *   1. 节点类型 ∈ 容器白名单（meta 默认 100% 的那批）；
+ *   2. rect.width 是纯数字（px 字面量；'100%'/'auto'/表达式不在此列）；
+ *   3. 父内容盒宽可计算（Root 直系 = view.width；父定宽 = 父宽 − 父水平 padding；
+ *      父 100%/无宽则透传，透传链不可达时跳过）；
+ *   4. 宽度占满父内容盒（98% ~ 103%，容差 2px 量级的标注/取整误差）；
+ *      **超出型不报**（ratio > 1.03：绝对层故意越出卡面的形态，属另一话题）；
+ *   5. 父为纵向流（Root/Column/AbsoluteLayout 或显式 flexDirection=column）——
+ *      Row/MultiColumn 主轴语境里并列子项定宽是 space-between 等范式的合法组成
+ *      （ir-format.md R-FIXEDW / R-COMPARE），不在此规则射程。
+ */
+import { hit } from './walk.mjs'
+
+const FULLWIDTH_CONTAINERS = new Set([
+  'Row', 'Column', 'MultiColumn', 'ListLayout', 'GridLayout', 'ViewContainer',
+])
+
+/** 纵向流父级：显式 flexDirection=column 优先，否则按渲染器默认方向推断。 */
+function isColumnAxis(node) {
+  const fl = (node?.style?.properties || []).find((g) => g.itemKey === 'flex')
+  const dir = (fl?.itemChildren?.properties || []).find((c) => c.itemKey === 'flexDirection')?.itemValue
+  if (dir === 'column') return true
+  if (dir === 'row') return false
+  const cls = node?.className
+  return cls === 'Root' || cls === 'Column' || cls === 'AbsoluteLayout'
+}
+
+/** rect.width 纯数字（px 字面量）→ 数值；无/百分比/auto/表达式 → null。 */
+function fixedPxWidth(node) {
+  const rect = (node?.style?.properties || []).find((g) => g.itemKey === 'rect')
+  const child = (rect?.itemChildren?.properties || []).find((c) => c.itemKey === 'width')
+  if (!child) return null
+  const raw = String(child.itemValue ?? '').trim()
+  if (!/^-?\d+(\.\d+)?$/.test(raw)) return null
+  const n = Number(raw)
+  return Number.isFinite(n) && n > 0 ? n : null
+}
+
+/** 水平 padding 合计（单值 padding 或 paddingLeft+paddingRight）。 */
+function horizontalPadding(node) {
+  const g = (node?.style?.properties || []).find((x) => x.itemKey === 'padding')
+  let all = 0
+  let left = 0
+  let right = 0
+  for (const c of g?.itemChildren?.properties || []) {
+    if (c.itemKey === 'padding') all = Number(c.itemValue) || 0
+    if (c.itemKey === 'paddingLeft') left = Number(c.itemValue) || 0
+    if (c.itemKey === 'paddingRight') right = Number(c.itemValue) || 0
+  }
+  return (left || all) + (right || all)
+}
+
+export function collectFullwidthFixedPx(view) {
+  const out = []
+  if (!view || typeof view !== 'object') return out
+  const viewW = Number(String(view.width ?? '').replace(/[^0-9.\-]/g, '')) || 0
+
+  /**
+   * @param node 当前节点
+   * @param parentContent 父节点的内容盒宽（父解析宽 − 父水平 padding；Root = view.width − Root padding）
+   *   —— 子节点 rect.width:"100%" 的解析基准就是这个值（doSize 对 % 原样透传）。
+   *   父为 '100%'/无宽时解析宽 = 透传 parentContent；父定宽 px 时 = 定宽值。
+   */
+  const walk = (node, parentContent, isRoot) => {
+    if (!node || typeof node !== 'object') return
+    const selfResolved = isRoot ? viewW : (() => {
+      const w = fixedPxWidth(node)
+      return w !== null ? w : parentContent
+    })()
+    const selfContent = Math.max(0, selfResolved - horizontalPadding(node))
+    const kids = [
+      ...(node.components || []),
+      ...((node.slots || []).flatMap((s) => (s && s.components) || [])),
+    ]
+    for (const child of kids) {
+      if (!child || typeof child !== 'object') continue
+      const w = fixedPxWidth(child)
+      if (selfContent > 0 && w !== null && FULLWIDTH_CONTAINERS.has(child.className)
+        && isColumnAxis(node)) {
+        const ratio = w / selfContent
+        if (ratio >= 0.98 && ratio <= 1.03) {
+          out.push(hit('r66-fullwidth-px', 'error', child.componentId || '',
+            `${child.className} "${child.componentId || child.name || ''}" 在纵向流父级里把占满语义写死成 rect.width="${w}"（父内容盒宽 ≈ ${Math.round(selfContent)}）——宿主容器宽度一旦偏离设计基准，内容层锁死不自适应（ir-format.md §2f）。修法：改 width:"100%"（或不写 width，meta 默认即 100%），与设计宽逐像素等价且随容器自适应；真固定宽元素（图标/头像/徽章/图表画布）保留 px。注意 100% 节点禁叠水平 margin（rules.md §十六 R63），水平内缩写父容器 padding。`))
+        }
+      }
+      walk(child, selfContent, false)
+    }
+  }
+  walk(view, 0, true)
+  return out
+}

package/dist/vendored/skills/dsl-card-generator/scripts/lib/rules/bindings.mjs

@@ -0,0 +1,260 @@
+/**
+ * rules/bindings.mjs —— 列表数组化与数据绑定完备的共享判定（lint_card / readiness 单一来源）。
+ *
+ * 为什么必须有它（2026-09-25 用户反馈）：
+ *   「数据绑定齐全（尤其是列表化的数据，应该在视觉分析层面就明确用数组来绑定列表）」
+ * 三个实测疏漏形态，此前没有任何门禁能发现：
+ *   ① 列表数据建了、视图零消费 —— transferPlan.payeeList / dreamPlan.planTimeList /
+ *      creditCardPayment.myCardList / branchdata.businessScopeList /
+ *      financialProductDetail.tradeRules（全仓 75 卡对账实测）：data.json 里数组静置，
+ *      schema 整段静态展开或根本没建，像素分照样高，数据维度完全缺失；
+ *   ② 同构 tile 静态展开 —— ≥3 个结构相同的兄弟子树、值全是字面量（评分星 / tab 标签 /
+ *      固定按钮组是**合法**静态形态，tile 特征「值逐行互异」才能区分真数据行）；
+ *   ③ ListLayout/GridLayout 没写 item 模板（slotScope 插槽为空）或 value 没绑数组
+ *      —— 渲染 0 项，列表整段空白。
+ *
+ * ── 消费判定（宽收口防误报；判据经全仓 75 卡实测校准）────────────────
+ * 数组变量被以下任一途径引用即视为「被消费」：
+ *   a) 复现器（ListLayout/GridLayout）value 的 $表达式 引用（含 `$$` 整项与三元/切片复合式）
+ *   b) 复现器 slotScope 插槽内的 $<字段> 引用 —— 字段名 ∈ 数组元素键集合
+ *   c) 事件代码（setData / this.state|data 赋值 / 任意代码文本）中出现变量名
+ *      —— monthlyBill 的 $renderListData 由 customAction 运行时转造、$listData 是其源，
+ *         不扫代码会把这对合法形态误判成「一悬空一未消费」（readiness.mjs 已有同款结论）
+ *   d) 任意属性 / 样式 / 指令表达式中引用（v-show 条件、bindHints 等）
+ * 未消费且**名字带列表语义**（list|items|rows|records|details|rules|entries）→ 硬伤；
+ * 其余未消费（radarData / donutData 这类 Canvas 图表数据、theme 配置数组）→ 只统计不拦
+ * —— 名单语义来自「数据建的什么」，拦不拦看「视觉提名了什么」（readiness 的 lists 门）。
+ */
+import { walkNodes, hit } from './walk.mjs'
+
+/** 复现器类名（slotScope 只出现在这两类；与 component-meta 的插槽声明一致）。 */
+export const REPEATER_CLASSES = new Set(['ListLayout', 'GridLayout'])
+
+/** 列表语义名：命中即「未消费 = 硬伤」（拦像素循环）。名单来自全仓疏漏实测。 */
+export const LIST_SEMANTIC_RE = /list|items|rows|records|details|rules|entries/i
+
+/** 从 $表达式 抽根变量名（与 readiness.collectBindingRefs 同口径）。 */
+export function extractRoots(value) {
+  const roots = new Set()
+  for (const m of String(value || '').matchAll(/\$([A-Za-z_][A-Za-z0-9_]*)/g)) roots.add(m[1])
+  return roots
+}
+
+/**
+ * 顶层数组变量表：data.json（渲染真值）→ mocks → inputParams.defaultValue 三来源合并。
+ * @returns {Map<string, {len:number, fields:Set<string>, source:string}>}
+ */
+export function collectArrayVars(schema, data) {
+  const arrays = new Map()
+  const add = (name, v, source) => {
+    if (!name || !Array.isArray(v)) return
+    const fields = v[0] && typeof v[0] === 'object' ? new Set(Object.keys(v[0])) : new Set()
+    arrays.set(name, { len: v.length, fields, source })
+  }
+  for (const [k, v] of Object.entries(data || {})) add(k, v, 'data.json')
+  for (const [k, v] of Object.entries(schema?.dictionary?.mocks || {})) if (!arrays.has(k)) add(k, v, 'mocks')
+  for (const p of schema?.dictionary?.inputParams || []) if (p?.key && !arrays.has(p.key)) add(p.key, p.defaultValue, 'inputParams')
+  return arrays
+}
+
+/** 收集 schema 全部事件动作代码文本（自 readiness.mjs collectActionCode 单向收敛到此处）。 */
+export function collectActionCode(schema) {
+  const out = []
+  const push = (v) => {
+    if (typeof v === 'string') {
+      if (v) out.push(v)
+      return
+    }
+    if (v && typeof v === 'object') {
+      for (const k of ['code', 'compiled', 'expression']) if (typeof v[k] === 'string' && v[k]) out.push(v[k])
+    }
+  }
+  const walk = (n) => {
+    if (!n || typeof n !== 'object') return
+    for (const ea of n.eventactions || []) {
+      const a = ea?.action
+      if (!a) continue
+      for (const k of ['code', 'compiled', 'expression', 'actionValue']) push(a[k])
+      for (const p of a.properties || []) push(p?.itemValue)
+    }
+    for (const c of n.components || []) walk(c)
+    for (const s of n.slots || []) for (const c of s.components || []) walk(c)
+  }
+  walk(schema?.view || schema)
+  return out
+}
+
+/** 节点全部属性值（properties + style 组子键），供表达式扫描。 */
+function* propValues(node) {
+  for (const p of node.properties || []) if (p && typeof p.itemValue === 'string') yield p.itemValue
+  for (const g of node.style?.properties || []) {
+    for (const c of g.itemChildren?.properties || []) if (c && typeof c.itemValue === 'string') yield c.itemValue
+  }
+}
+
+/**
+ * 数组消费对账。
+ * @returns {{ consumed:Set<string>, arrays:Map, unconsumed:Array<{name,len,semantic,source}>,
+ *             repeaterCount:number, scopedListCount:number }}
+ *   scopedListCount = 「value 绑定了数组」的复现器个数（readiness lists 门的对账基数）。
+ */
+export function collectArrayConsumption(schema, data) {
+  const arrays = collectArrayVars(schema, data)
+  const consumed = new Set()
+  let repeaterCount = 0
+  let scopedListCount = 0
+  const view = schema?.view || schema
+
+  walkNodes(view, (n) => {
+    const isRepeater = REPEATER_CLASSES.has(n.className)
+    if (isRepeater) {
+      repeaterCount++
+      const vp = (n.properties || []).find((p) => p?.itemKey === 'value')
+      const roots = extractRoots(vp?.itemValue)
+      let hitsArray = false
+      for (const r of roots) if (arrays.has(r)) { consumed.add(r); hitsArray = true }
+      if (hitsArray) scopedListCount++
+    }
+    for (const val of propValues(n)) {
+      for (const r of extractRoots(val)) if (arrays.has(r)) consumed.add(r)
+    }
+  })
+  // 事件代码：变量名出现在代码里即消费（含 setData 转造源 / state 赋值）
+  for (const code of collectActionCode(schema)) {
+    for (const name of arrays.keys()) if (code.includes(name)) consumed.add(name)
+  }
+  // slotScope 插槽内的 $<字段> 引用：字段名命中某数组的元素键 ⇒ 该数组被模板消费
+  const markSlotFields = (n) => {
+    for (const val of propValues(n)) {
+      for (const r of extractRoots(val)) {
+        for (const [name, a] of arrays) if (a.fields.has(r)) consumed.add(name)
+      }
+    }
+  }
+  walkNodes(view, (n) => {
+    const isRepeater = REPEATER_CLASSES.has(n.className)
+    if (!isRepeater) return
+    for (const s of n.slots || []) {
+      if (!s?.slotScope) continue
+      for (const c of s.components || []) walkNodes(c, markSlotFields)
+    }
+  })
+
+  const unconsumed = [...arrays.keys()]
+    .filter((name) => !consumed.has(name))
+    .map((name) => ({ name, len: arrays.get(name).len, semantic: LIST_SEMANTIC_RE.test(name), source: arrays.get(name).source }))
+  return { consumed, arrays, unconsumed, repeaterCount, scopedListCount }
+}
+
+/**
+ * 复现器硬伤：value 没绑数组（渲染 0 项）或 slotScope 插槽无模板组件（渲染 N 个空壳）。
+ * 两条都必然是错的 —— 定 error。
+ */
+export function collectRepeaterDefects(view) {
+  const out = []
+  walkNodes(view, (n) => {
+    if (!REPEATER_CLASSES.has(n.className)) return
+    const cid = n.componentId || ''
+    const vp = (n.properties || []).find((p) => p?.itemKey === 'value')
+    if (!vp || !String(vp.itemValue ?? '').trim()) {
+      out.push(hit(
+        'binding-repeater-no-scope',
+        'error',
+        cid,
+        `${n.className} "${cid}" 的 value 没绑数组表达式 → 渲染 0 项，列表整段空白。` +
+          'value 用 itemValueFrom:"1" 绑 $数组变量（范式 ir-format.md §2e / recipe_snippets/list-expand-collapse.json）',
+      ))
+      return
+    }
+    const scoped = (n.slots || []).some((s) => s?.slotScope && (s.components || []).length)
+    if (!scoped) {
+      out.push(hit(
+        'binding-repeater-no-scope',
+        'error',
+        cid,
+        `${n.className} "${cid}" 没有带 item 模板的 slotScope 插槽（slots[].slotScope=true 且 components 非空）→ ` +
+          '数组有多少条就渲染多少个空壳。把一行的完整结构写进 slotScope 插槽，字段用 $<字段名> / $$ / $_index',
+      ))
+    }
+  })
+  return out
+}
+
+/** 同构签名：className 链（深度 ≤4），与子树内容无关的纯结构指纹。 */
+function structuralSignature(root) {
+  const ks = []
+  const g = (nd, d) => {
+    if (!nd || typeof nd !== 'object' || d > 4) return
+    ks.push(nd.className || '?')
+    for (const c of nd.components || []) g(c, d + 1)
+    for (const s of nd.slots || []) for (const c of s.components || []) g(c, d + 1)
+  }
+  g(root, 0)
+  return ks.join('>')
+}
+
+/** 子树是否含 $ 绑定属性。 */
+function hasBinding(root) {
+  let found = false
+  walkNodes(root, (n) => {
+    if (found) return
+    for (const val of propValues(n)) if (val.includes('$')) { found = true; return }
+    for (const ea of n.eventactions || []) if (String(ea?.action?.properties?.map((p) => p?.itemValue).join('') || '').includes('$')) found = true
+  })
+  return found
+}
+
+/** 子树的文本值序列（Text.value 字面量；绑定值不算 —— 全静态是前提）。 */
+function textValues(root) {
+  const out = []
+  walkNodes(root, (n) => {
+    if (n.className !== 'Text') return
+    for (const p of n.properties || []) {
+      if (p?.itemKey === 'value' && typeof p.itemValue === 'string' && !p.itemValue.includes('$')) out.push(p.itemValue.trim())
+    }
+  })
+  return out
+}
+
+/**
+ * 同构 tile 静态展开（warn）：复现器外 ≥3 个结构相同的兄弟子树、全静态、
+ * 且文本值逐行互异（「值互异」正是数据行特征 —— 评分星/同款图标行值全同，被此判据排除；
+ * 与 spec_audit.mjs pushCandidate 的装饰重复排除判据同源）。
+ */
+export function collectStaticTileExpansion(view) {
+  const out = []
+  const visit = (node) => {
+    if (!node || typeof node !== 'object') return
+    const kids = []
+    for (const s of node.slots || []) for (const c of s.components || []) kids.push(c)
+    for (const c of node.components || []) kids.push(c)
+    const inRepeater = REPEATER_CLASSES.has(node.className)
+    if (!inRepeater && kids.length >= 3) {
+      const bySig = new Map()
+      for (const k of kids) {
+        const sig = structuralSignature(k)
+        if (!bySig.has(sig)) bySig.set(sig, [])
+        bySig.get(sig).push(k)
+      }
+      for (const [sig, group] of bySig) {
+        if (group.length < 3) continue
+        if (group.some(hasBinding)) continue
+        const rows = group.map(textValues).filter((r) => r.length >= 2)
+        if (rows.length < group.length) continue // tile 特征：每行 ≥2 条文本（单文本 = tab/按钮组，合法静态）
+        const distinct = new Set(rows.map((r) => JSON.stringify(r)))
+        if (distinct.size < 2) continue // 值全同 = 装饰性重复（同款图标行），不拦
+        out.push(hit(
+          'binding-list-static-expansion',
+          'warn',
+          node.componentId || '',
+          `${node.className || '?'} "${node.componentId || ''}" 下有 ${group.length} 个同构静态 tile（签名 ${sig.slice(0, 60)}…，值逐行互异）→ ` +
+            '疑似列表数据被静态展开：设计稿若是重复数据行，应改 ListLayout/GridLayout + 数组变量 + slotScope 模板' +
+            '（范式 ir-format.md §2e）。若确认是装饰性重复可忽略本预警',
+        ))
+      }
+    }
+    for (const c of kids) visit(c)
+  }
+  visit(view)
+  return out
+}

package/dist/vendored/skills/dsl-card-generator/scripts/lib/rules/expr.mjs

@@ -0,0 +1,52 @@
+/**
+ * rules/expr.mjs —— 表达式的可静态判定缺陷（lint_card / preflight 单一来源）。
+ */
+import { hit, walkNodes } from './walk.mjs'
+
+/**
+ * R61/R12 的「疑似运行期数据」启发式形态表（导出供测试直测；lint 消费方为 r61 提醒级 WARN）。
+ * 命中 ≠ 违规（版本号 / 固定营销话术会误报），语义复核交 AI。日期为完整日期才命中
+ * （"2026.09" 这类年月段不匹配），点分日期（2025.10.10）为 §11.11 高发形态。
+ */
+export const NUMERIC_HINT_PATTERNS = [
+  { re: /\d{1,3}(,\d{3})+(\.\d+)?/, label: '千分号数字' },
+  { re: /[¥￥]\s*\d+(\.\d+)?/, label: '货币符+数字' },
+  { re: /\d+(\.\d+)?\s*(元|笔|次|个|条)/, label: '数字+单位词' },
+  { re: /\d{4}[-/.年]\d{1,2}[-/.月]\d{1,2}/, label: '日期' },
+]
+
+/** 文案/inputParams 默认值里的「疑似运行期数字」标签（r61 消费；无命中返回 null）。 */
+export function numericHint(str) {
+  if (!str) return null
+  for (const { re, label } of NUMERIC_HINT_PATTERNS) if (re.test(str)) return label
+  return null
+}
+
+/**
+ * R23：百分比表达式（含 `*100`）必须配 `Math.round`，否则 JS 浮点精度会产出 33.333333%。
+ *
+ * 扫描范围：component properties + 全部 style 子项（两处都可能是表达式值）。
+ * @param {object} view schema.view
+ * @returns {Array<{code:string,severity:string,componentId:string,message:string,detail:string}>}
+ */
+export function collectExprNoMathRound(view) {
+  const out = []
+  walkNodes(view, (n) => {
+    const props = [...(n.properties || [])]
+    for (const g of n.style?.properties || []) {
+      for (const c of g.itemChildren?.properties || []) props.push(c)
+    }
+    for (const p of props) {
+      if (String(p.itemValueFrom) !== '1' || typeof p.itemValue !== 'string') continue
+      if (!/\*\s*100/.test(p.itemValue)) continue
+      if (/Math\.round/.test(p.itemValue)) continue
+      out.push(hit(
+        'r23-no-math-round',
+        'error',
+        n.componentId || '',
+        `"${n.componentId || ''}" 表达式含 *100 但无 Math.round → JS 浮点精度溢出（R23）: ${p.itemValue.slice(0, 50)}`,
+      ))
+    }
+  })
+  return out
+}

package/dist/vendored/skills/dsl-card-generator/scripts/lib/rules/image.mjs

@@ -0,0 +1,96 @@
+/**
+ * rules/image.mjs —— Image 组件的「静默失效」类硬契约（lint_card / preflight 单一来源）。
+ *
+ * 为什么必须共享：这两条是模型最高频踩的坑（`itemValueFrom` 三态 + `rect.height`），
+ * 原先在 lint（迭代门禁）与 preflight（生成前检查）各写一遍，文案已经漂移
+ * （"渲染器不走图片逻辑，空白" vs "但值是路径 → 渲染器不走图片逻辑，空白"；
+ * "压缩图片高度" vs "会压缩图片高度"）—— 同一张卡两处报告措辞不同，模型会当成两件事。
+ *
+ * 文案以 lint 版为准（lint 是迭代门禁主力，被模型逐轮消费）。
+ */
+import { hit, walkNodes, findProp, findStyleChild } from './walk.mjs'
+
+/**
+ * R25：Image 的图片地址属性（键固定为 `value`）三态精确映射。
+ *
+ *   from="0"（常量）—— 渲染器不走图片逻辑 ⇒ 静态路径必须用 "2"
+ *   from="1"（变量）—— 值必须是 `$` 开头的表达式
+ *   from="2"（图片值）—— 值必须是静态路径，写成 `$表达式` 会被**原样透传**进 url(...)
+ *
+ * @param {object} view schema.view
+ * @param {{reportMissingProp?: boolean}} [opts]
+ *   reportMissingProp=true 时额外报「没有 itemKey="value" 属性」（preflight 侧独有：
+ *   键名写错如 `image` 会让下游检查全部短路，必须显式拦）。lint 侧由 R28b 契约覆盖，
+ *   默认 false 以保持 lint 输出不变。
+ * @returns {Array<{code:string,severity:string,componentId:string,message:string,detail:string}>}
+ */
+export function collectImageValueFrom(view, { reportMissingProp = false } = {}) {
+  const out = []
+  walkNodes(view, (n) => {
+    if (n.className !== 'Image') return
+    const cid = n.componentId || ''
+    const p = reportMissingProp ? findProp(n, 'value') : null
+    if (reportMissingProp && !p) {
+      out.push(hit(
+        'r25-image-no-value-prop',
+        'error',
+        cid,
+        `Image "${cid}" 没有 itemKey="value" 的属性 → 运行时拿不到图片地址，渲染成破图（R25）。该组件元数据里图片地址的键固定为 value`,
+      ))
+      return
+    }
+    for (const prop of n.properties || []) {
+      if (prop.itemKey !== 'value') continue
+      const from = String(prop.itemValueFrom || '')
+      const val = String(prop.itemValue || '')
+      if (from === '0' && !val.startsWith('$')) {
+        out.push(hit(
+          'r25-image-from-0',
+          'error',
+          cid,
+          `Image "${cid}" itemValueFrom="0"(常量) → 渲染器不走图片逻辑，空白（R25）。静态路径用 "2"`,
+        ))
+      }
+      if (from === '1' && !val.startsWith('$')) {
+        out.push(hit(
+          'r25-image-from-1',
+          'error',
+          cid,
+          `Image "${cid}" itemValueFrom="1"(变量) 但值不以 $ 开头 → 表达式求值失败，空白（R25）`,
+        ))
+      }
+      if (from === '2' && val.startsWith('$')) {
+        out.push(hit(
+          'r25-image-from-2',
+          'error',
+          cid,
+          `Image "${cid}" itemValueFrom="2"(图片/文件值) 但值是表达式 "${val}" → ` +
+            `运行时对 "2" 是原样透传（property.js onPreview），该字符串直接进 background-image:url(${val})，` +
+            `画布必然空白（R25）。变量绑定必须改 "1"`,
+        ))
+      }
+    }
+  })
+  return out
+}
+
+/**
+ * R32：Image 必须有显式 `rect.height`（否则 CSS aspect-ratio:16/9 压缩图片高度）。
+ * @returns {Array} 同 collectImageValueFrom
+ */
+export function collectImageNoHeight(view) {
+  const out = []
+  walkNodes(view, (n) => {
+    if (n.className !== 'Image') return
+    const h = findStyleChild(n, 'rect', 'height')
+    if (!h || !String(h.itemValue).trim()) {
+      out.push(hit(
+        'r32-image-no-height',
+        'error',
+        n.componentId || '',
+        `Image "${n.componentId || ''}" 缺 rect.height → CSS aspect-ratio:16/9 压缩图片高度（R32）。设显式高度`,
+      ))
+    }
+  })
+  return out
+}