cardbuddy 0.14.3 → 0.16.0

package/dist/vendored/skills/card-skill-trainer/scripts/diagnose_case.mjs

@@ -24,8 +24,9 @@ import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { PNG } from 'pngjs'
 import {
-  attributeFailure, evaluatePassGate, exclusionCoverage, failureSignature, MASK_REVIEW_THRESHOLD,
+  attributeFailure, evaluatePassGate, exclusionCoverage, failureSignature,
 } from './lib/scoring.mjs'
+import { pixelBands, pairDeviations, deriveHints } from './lib/diagnosis.mjs'
 
 const repoRoot = path.resolve(import.meta.dirname, '../../..')
 
@@ -118,72 +119,8 @@ function buildSideImage(designPng, renderPng, sidePath) {
   return sidePath
 }
 
-function pixelBands(designPng, renderPng, exclusions) {
-  const w = Math.min(designPng.width, renderPng.width)
-  const h = Math.min(designPng.height, renderPng.height)
-  const mask = new Uint8Array(w * h)
-  for (const rc of exclusions || []) {
-    const x0 = Math.floor((rc.x ?? 0) * w), y0 = Math.floor((rc.y ?? 0) * h)
-    const x1 = Math.min(w, Math.ceil(((rc.x ?? 0) + (rc.width ?? 0)) * w))
-    const y1 = Math.min(h, Math.ceil(((rc.y ?? 0) + (rc.height ?? 0)) * h))
-    for (let y = y0; y < y1; y++) for (let x = x0; x < x1; x++) mask[y * w + x] = 1
-  }
-  const BANDS = 20
-  const bandDiff = new Array(BANDS).fill(0)
-  const bandTotal = new Array(BANDS).fill(0)
-  let totalDiff = 0
-  let totalCount = 0
-  for (let y = 0; y < h; y++) {
-    const band = Math.min(BANDS - 1, Math.floor((y / h) * BANDS))
-    for (let x = 0; x < w; x++) {
-      if (mask[y * w + x]) continue
-      const i = (y * designPng.width + x) * 4
-      const j = (y * renderPng.width + x) * 4
-      const diff = Math.abs(designPng.data[i] - renderPng.data[j]) > 15
-        || Math.abs(designPng.data[i + 1] - renderPng.data[j + 1]) > 15
-        || Math.abs(designPng.data[i + 2] - renderPng.data[j + 2]) > 15
-      if (diff) { bandDiff[band]++; totalDiff++ }
-      bandTotal[band]++; totalCount++
-    }
-  }
-  const bandPct = bandDiff.map((c, i) => (bandTotal[i] ? c / bandTotal[i] : 0))
-  const hotBands = bandPct.map((pct, i) => ({ band: i, y: Math.round((i / BANDS) * h), pct }))
-    .filter((b) => b.pct >= 0.05).sort((a, b) => b.pct - a.pct)
-  return { hotBands, diffRatio: totalCount ? totalDiff / totalCount : null }
-}
-
-function pairDeviations(specTexts, renderTexts) {
-  const usedSpec = new Set()
-  const deviations = []
-  for (const rt of renderTexts) {
-    const key = norm(rt.text)
-    if (!key) continue
-    let best = null
-    let bestScore = 0
-    for (let i = 0; i < specTexts.length; i++) {
-      if (usedSpec.has(i)) continue
-      const st = specTexts[i]
-      let score = 0
-      if (st.text === key) score = 1
-      else if (st.text.includes(key) || key.includes(st.text)) score = 0.9
-      if (score > bestScore) { bestScore = score; best = { ...st, idx: i } }
-    }
-    if (!best || bestScore < 0.9) continue
-    usedSpec.add(best.idx)
-    deviations.push({
-      text: key.slice(0, 18),
-      dy: +(rt.y - best.y).toFixed(1),
-      dx: +(rt.x - best.x).toFixed(1),
-      dw: +((rt.w || 0) - best.w).toFixed(1),
-      dh: +((rt.h || 0) - best.h).toFixed(1),
-      render: { x: rt.x, y: rt.y, w: rt.w, h: rt.h },
-      spec: { x: best.x, y: best.y, w: best.w, h: best.h, fs: best.fs, lineHeight: best.lineHeight },
-      cid: rt.cid,
-    })
-  }
-  deviations.sort((a, b) => (Math.abs(b.dy) + Math.abs(b.dx)) - (Math.abs(a.dy) + Math.abs(a.dx)))
-  return deviations
-}
+// pixelBands / pairDeviations / deriveHints 已迁至 lib/diagnosis.mjs（run_round 与
+// diagnose_case 共用单一来源，避免两处漂移）；本脚本仅按需引入。
 
 async function main() {
   const results = []
@@ -302,23 +239,18 @@ async function main() {
         provHits = [{ error: String(e.message || e) }]
       }
 
-      // —— 5. 失败类建议 ——
+      // —— 5. 失败类建议（与 run_round 在环归因共用 deriveHints，单一口径）——
       const px = report.pixel || {}
       const fid = report.fidelity || {}
-      const hints = []
-      if (attribution) hints.push(`归因 ${attribution.failureClass}：${attribution.reason}`)
-      if (px.bestAlignDy && Math.abs(px.bestAlignDy) >= 4) hints.push(`全局纵向偏移 dy=${px.bestAlignDy}：查行高/行距累积（Input 高度、行距标注优先、分割线渲染盒高）`)
-      if (bands.hotBands.length && bands.hotBands[0].pct >= 0.2) hints.push(`单带高热 (${(bands.hotBands[0].pct * 100).toFixed(0)}%@y≈${bands.hotBands[0].y})：查该区域语义块（换行折点/缺组件/结构错配）`)
-      if ((fid.components ?? 1) < 0.9) hints.push(`组件计数缺失 comp=${num(fid.components, 2)}：查语义消费（媒体未渲染/文本被吞/重复消费）`)
-      if ((report.duplication?.overall ?? 1) < 0.95) {
-        hints.push(`重影：查同源按钮/文本双路径渲染（${(report.duplication?.offenders || []).map((o) => `「${o.text}」x${o.rendered}/${o.annotated}`).join(' ')}）`)
-      }
-      if ((coverage.total ?? 0) >= MASK_REVIEW_THRESHOLD) {
-        hints.push(`掩膜覆盖 ${(coverage.total * 100).toFixed(1)}% ≥ ${(MASK_REVIEW_THRESHOLD * 100).toFixed(0)}%：得分不代表整卡，必须看图复核`)
-      }
-      const bigDy = deviations.filter((d) => Math.abs(d.dy) >= 3)
-      if (bigDy.length >= 3) hints.push(`${bigDy.length} 个文本 |dy|≥3：纵向节奏问题（行距/padding 体系），非单点`)
-      if (!hints.length) hints.push('像素差异弥散且量级低：多为 1-2px 抗锯齿/字体度量差异，接近噪声底')
+      const hints = deriveHints({
+        attribution: attribution ? { failureClass: attribution.failureClass, reason: attribution.reason } : null,
+        pixel: px,
+        fidelity: fid,
+        duplication: report.duplication || null,
+        coverage,
+        hotBands: bands.hotBands,
+        deviations,
+      })
 
       // —— 6. 输出 ——
       console.log('═══════════════════════════════════════════════════════════')

package/dist/vendored/skills/card-skill-trainer/scripts/lib/diagnosis.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+/**
+ * diagnosis.mjs — 失败案例结构化证据包的纯函数核心（2026-09-25）。
+ *
+ * 单一来源：run_round.mjs（在环归因，零额外渲染复用已有数据）与 diagnose_case.mjs
+ * （按需深度诊断，含 provenance 溯源）共用本模块，避免两处漂移。
+ *
+ * 导出：
+ *   - decodeBufferToPng(buf)         Buffer → PNG.sync 对象（失败返回 null）
+ *   - pixelBands(design, render, exclusions)   逐带像素差异率 + 热区带
+ *   - pairDeviations(specTexts, renderTexts)    标注几何 vs 渲染盒偏差表（dy/dx）
+ *   - deriveHints(ctx)               失败类建议（与评分口径同源）
+ *   - buildInlineDiagnosis(report, ctx)   run_round 在环归因用的轻量结构化包
+ *
+ * 设计约束：本模块只做纯计算，不触碰 Chrome / 文件系统 / 任何门禁口径。
+ * 图像解码只在 buildInlineDiagnosis 内按需发生，且仅针对「确实失败且像素可比对」的案例。
+ */
+import { PNG } from 'pngjs'
+import { MASK_REVIEW_THRESHOLD, exclusionCoverage } from './scoring.mjs'
+
+const norm = (value) => String(value || '').replace(/\s+/g, '')
+
+export function decodeBufferToPng(buf) {
+  try { return buf ? PNG.sync.read(buf) : null } catch { return null }
+}
+
+export function pixelBands(designPng, renderPng, exclusions) {
+  const w = Math.min(designPng.width, renderPng.width)
+  const h = Math.min(designPng.height, renderPng.height)
+  const mask = new Uint8Array(w * h)
+  for (const rc of exclusions || []) {
+    const x0 = Math.floor((rc.x ?? 0) * w), y0 = Math.floor((rc.y ?? 0) * h)
+    const x1 = Math.min(w, Math.ceil(((rc.x ?? 0) + (rc.width ?? 0)) * w))
+    const y1 = Math.min(h, Math.ceil(((rc.y ?? 0) + (rc.height ?? 0)) * h))
+    for (let y = y0; y < y1; y++) for (let x = x0; x < x1; x++) mask[y * w + x] = 1
+  }
+  const BANDS = 20
+  const bandDiff = new Array(BANDS).fill(0)
+  const bandTotal = new Array(BANDS).fill(0)
+  let totalDiff = 0
+  let totalCount = 0
+  for (let y = 0; y < h; y++) {
+    const band = Math.min(BANDS - 1, Math.floor((y / h) * BANDS))
+    for (let x = 0; x < w; x++) {
+      if (mask[y * w + x]) continue
+      const i = (y * designPng.width + x) * 4
+      const j = (y * renderPng.width + x) * 4
+      const diff = Math.abs(designPng.data[i] - renderPng.data[j]) > 15
+        || Math.abs(designPng.data[i + 1] - renderPng.data[j + 1]) > 15
+        || Math.abs(designPng.data[i + 2] - renderPng.data[j + 2]) > 15
+      if (diff) { bandDiff[band]++; totalDiff++ }
+      bandTotal[band]++; totalCount++
+    }
+  }
+  const bandPct = bandDiff.map((c, i) => (bandTotal[i] ? c / bandTotal[i] : 0))
+  const hotBands = bandPct.map((pct, i) => ({ band: i, y: Math.round((i / BANDS) * h), pct }))
+    .filter((b) => b.pct >= 0.05).sort((a, b) => b.pct - a.pct)
+  return { hotBands, diffRatio: totalCount ? totalDiff / totalCount : null }
+}
+
+export function pairDeviations(specTexts, renderTexts) {
+  const usedSpec = new Set()
+  const deviations = []
+  for (const rt of renderTexts) {
+    const key = norm(rt.text)
+    if (!key) continue
+    let best = null
+    let bestScore = 0
+    let bestDist = Infinity
+    for (let i = 0; i < specTexts.length; i++) {
+      if (usedSpec.has(i)) continue
+      const st = specTexts[i]
+      let score = 0
+      if (st.text === key) score = 1
+      else if (st.text.includes(key) || key.includes(st.text)) score = 0.9
+      // Geometric tiebreaker: when multiple specs have same similarity (e.g. identical texts
+      // like two "转账计划"), prefer the nearest by center distance — crossed matching produces
+      // false huge dy/dx that misleads the diagnosis.
+      const dist = Math.hypot(((st.x||0)+(st.w||0)/2)-((rt.x||0)+(rt.w||0)/2), ((st.y||0)+(st.h||0)/2)-((rt.y||0)+(rt.h||0)/2))
+      if (score > bestScore + 1e-9 || (score >= bestScore - 1e-9 && dist < bestDist)) {
+        bestScore = score; best = { ...st, idx: i }; bestDist = dist
+      }
+    }
+    if (!best || bestScore < 0.9) continue
+    usedSpec.add(best.idx)
+    deviations.push({
+      text: key.slice(0, 18),
+      dy: +(rt.y - best.y).toFixed(1),
+      dx: +(rt.x - best.x).toFixed(1),
+      dw: +((rt.w || 0) - best.w).toFixed(1),
+      dh: +((rt.h || 0) - best.h).toFixed(1),
+      render: { x: rt.x, y: rt.y, w: rt.w, h: rt.h },
+      spec: { x: best.x, y: best.y, w: best.w, h: best.h, fs: best.fs, lineHeight: best.lineHeight },
+      cid: rt.cid,
+    })
+  }
+  deviations.sort((a, b) => (Math.abs(b.dy) + Math.abs(b.dx)) - (Math.abs(a.dy) + Math.abs(a.dx)))
+  return deviations
+}
+
+/**
+ * 失败类建议：与 lib/scoring.mjs 的归因/门禁口径同源，run_round 与 diagnose_case 共用。
+ * ctx: { attribution:{failureClass,reason}, pixel, fidelity, duplication, coverage, hotBands, deviations }
+ */
+export function deriveHints(ctx) {
+  const {
+    attribution = null, pixel = {}, fidelity = {}, duplication = null,
+    coverage = {}, hotBands = [], deviations = [],
+  } = ctx || {}
+  const num = (v, d = 4) => (typeof v === 'number' && Number.isFinite(v)) ? v.toFixed(d) : 'N/A'
+  const hints = []
+  if (attribution) hints.push(`归因 ${attribution.failureClass}：${attribution.reason}`)
+  if (pixel.bestAlignDy && Math.abs(pixel.bestAlignDy) >= 4) hints.push(`全局纵向偏移 dy=${pixel.bestAlignDy}：查行高/行距累积（Input 高度、行距标注优先、分割线渲染盒高）`)
+  if (hotBands.length && hotBands[0].pct >= 0.2) hints.push(`单带高热 (${(hotBands[0].pct * 100).toFixed(0)}%@y≈${hotBands[0].y})：查该区域语义块（换行折点/缺组件/结构错配）`)
+  if ((fidelity.components ?? 1) < 0.9) hints.push(`组件计数缺失 comp=${num(fidelity.components, 2)}：查语义消费（媒体未渲染/文本被吞/重复消费）`)
+  if ((duplication?.overall ?? 1) < 0.95) {
+    hints.push(`重影：查同源按钮/文本双路径渲染（${(duplication?.offenders || []).map((o) => `「${o.text}」x${o.rendered}/${o.annotated}`).join(' ')}）`)
+  }
+  const covTotal = coverage?.total ?? 0
+  if (covTotal >= MASK_REVIEW_THRESHOLD) {
+    hints.push(`掩膜覆盖 ${(covTotal * 100).toFixed(1)}% ≥ ${(MASK_REVIEW_THRESHOLD * 100).toFixed(0)}%：得分不代表整卡，必须看图复核`)
+  }
+  const bigDy = deviations.filter((d) => Math.abs(d.dy) >= 3)
+  if (bigDy.length >= 3) hints.push(`${bigDy.length} 个文本 |dy|≥3：纵向节奏问题（行距/padding 体系），非单点`)
+  if (!hints.length) hints.push('像素差异弥散且量级低：多为 1-2px 抗锯齿/字体度量差异，接近噪声底')
+  return hints
+}
+
+function annDefectCount(upstream) {
+  if (!upstream) return 0
+  const ad = upstream.annotationDefects
+  if (Array.isArray(ad)) return ad.length
+  return typeof ad === 'number' ? ad : 0
+}
+
+/**
+ * run_round 在环归因用的轻量结构化包：复用 processCase 已算出的 report / 设计稿 buffer /
+ * 标注文本 / 渲染盒，零额外 Chrome 渲染。provenance（cid→生成器源码行）因需 SCHEMA_PROV
+ * 重生成，不在本包内——按需由 diagnose_case.mjs 深度补全。
+ *
+ * ctx: { designBuf, renderBuf, specTexts, renderedTexts }
+ *   specTexts:  run_round 过滤后的标注文本数组（含 rawText/x/y/w/h/fs）
+ *   renderedTexts: 渲染盒数组（含 text/x/y/w/h/cid，已过滤 Text/Input/Button）
+ */
+export function buildInlineDiagnosis(report, ctx) {
+  const { designBuf = null, renderBuf = null, specTexts = [], renderedTexts = [] } = ctx || {}
+  const designPng = designBuf ? decodeBufferToPng(designBuf) : null
+  const renderPng = renderBuf ? decodeBufferToPng(renderBuf) : null
+  const exclusions = report?.pixelExclusions || []
+  const bands = (designPng && renderPng)
+    ? pixelBands(designPng, renderPng, exclusions)
+    : { hotBands: [], diffRatio: null }
+
+  const specForDev = specTexts.map((el) => ({
+    text: norm(el.rawText ?? el.text ?? ''),
+    x: el.x ?? 0, y: el.y ?? 0, w: el.w ?? 0, h: el.h ?? 0,
+    fs: el.fs ?? el.textStyle?.fontSize ?? 14, lineHeight: el.lineHeight ?? null,
+  }))
+  const renderForDev = renderedTexts.map((el) => ({
+    text: el.text ?? '', x: el.x ?? 0, y: el.y ?? 0, w: el.w ?? 0, h: el.h ?? 0, cid: el.cid,
+  }))
+  const deviations = pairDeviations(specForDev, renderForDev)
+
+  const coverage = report?.exclusionCoverage || exclusionCoverage(exclusions)
+  const attribution = report?.failureClass
+    ? { failureClass: report.failureClass, reason: report.failureReason || '' }
+    : null
+  const hints = deriveHints({
+    attribution,
+    pixel: report?.pixel || {},
+    fidelity: report?.fidelity || {},
+    duplication: report?.duplication || null,
+    coverage,
+    hotBands: bands.hotBands,
+    deviations,
+  })
+
+  return {
+    gateFailures: report?.gateFailures || [],
+    failureClass: attribution?.failureClass || null,
+    failureReason: attribution?.reason || null,
+    metrics: {
+      fidelity: report?.fidelity?.overall ?? null,
+      pixel: report?.pixel?.ratio ?? null,
+      structure: report?.pixel?.structure ?? null,
+      dimension: report?.pixel?.dimension ?? null,
+      color: report?.pixel?.color ?? null,
+      position: report?.position?.overall ?? null,
+      components: report?.fidelity?.components ?? null,
+      duplication: report?.duplication?.overall ?? null,
+      bestAlignDy: report?.pixel?.bestAlignDy ?? null,
+    },
+    exclusionCoverage: coverage,
+    upstream: report?.upstream ? {
+      passed: report.upstream.passed,
+      annotationCompleteness: report.upstream.annotationCompleteness,
+      textRetention: report.upstream.textRetention,
+      structuralFocus: report.upstream.structuralFocus,
+      annotationDefects: annDefectCount(report.upstream),
+    } : null,
+    hotBands: bands.hotBands.slice(0, 8),
+    deviations: deviations.slice(0, 10),
+    layoutCorrections: report?.layoutCorrections || [],
+    correctorRejected: report?.correctorRejected || null,
+    hints,
+  }
+}

package/dist/vendored/skills/card-skill-trainer/scripts/lib/layout-correction-sim.mjs

@@ -0,0 +1,62 @@
+// Layout-correction rigid-body simulation for the trainer's reject fast-path.
+//
+// When correctCardLayout only adjusts paddingTop (Y axis) inside a vertical Column,
+// the correction is an exact rigid body shift: shifting child#i by Δ also shifts every
+// later sibling by the cumulative Δ. The same logic extends to paddingLeft (X axis):
+// a child's paddingLeft change shifts that child's whole subtree horizontally, but —
+// unlike Y — does NOT cascade to later siblings in a vertical flow (each child keeps
+// its own independent horizontal padding). So X deltas are per-child and non-cumulative,
+// while Y deltas accumulate across siblings.
+//
+// Keeping this here (instead of inline in run_round.mjs) makes the admit/translate rules
+// unit-testable without spinning up Chrome. Zero gate behavior changes: the simulator
+// only decides whether a real re-render can be skipped; the final keep/revert decision
+// always goes through the real position + pixel guard.
+
+/**
+ * Whether the rigid-body reject fast-path may replace a real re-render.
+ * @param {Array} adjustments entries pushed by correctCardLayout (axis 'y'|'x', rigidSafe)
+ * @param {Map} cidToChild cid -> child index (built inside correctCardLayout)
+ * @param {Array} [children] card column direct children (to exclude AbsoluteLayout)
+ */
+export function canSimulateReject(adjustments, cidToChild, children) {
+  if (!adjustments?.length || !cidToChild) return false
+  if (!adjustments.every((a) => a.rigidSafe !== false && (a.axis === 'y' || a.axis === 'x'))) return false
+  // AbsoluteLayout children break the simple rigid model (their own left/positioning
+  // context means paddingLeft/paddingTop do not translate the subtree predictably).
+  if (children && !children.every((c) => c.name !== 'AbsoluteLayout')) return false
+  return true
+}
+
+/**
+ * Apply the rigid-body deltas to rendered boxes, returning shifted copies.
+ * Boxes whose cid is not mapped to a child are returned unchanged.
+ * @returns {{ shifted: Array, appliedAxes: Set<string> }}
+ */
+export function simulateLayoutCorrection(boxes, adjustments, cidToChild) {
+  const deltasY = new Map()
+  const deltasX = new Map()
+  const appliedAxes = new Set()
+  for (const a of adjustments || []) {
+    if (a.axis === 'y') {
+      deltasY.set(a.childIndex, (deltasY.get(a.childIndex) || 0) + (a.to - a.from))
+      appliedAxes.add('y')
+    } else if (a.axis === 'x') {
+      // X is per-child, no cross-sibling cascade.
+      deltasX.set(a.childIndex, (deltasX.get(a.childIndex) || 0) + (a.to - a.from))
+      appliedAxes.add('x')
+    }
+  }
+  const shiftForY = (idx) => {
+    let acc = 0
+    for (const [i, d] of deltasY) if (i <= idx) acc += d
+    return acc
+  }
+  const shiftForX = (idx) => deltasX.get(idx) || 0
+  const shifted = (boxes || []).map((b) => {
+    const idx = cidToChild.get(b.cid)
+    if (idx == null) return b
+    return { ...b, y: b.y + shiftForY(idx), x: b.x + shiftForX(idx) }
+  })
+  return { shifted, appliedAxes }
+}

package/dist/vendored/skills/card-skill-trainer/scripts/lib/paradigm-router.mjs

@@ -0,0 +1,76 @@
+// paradigm-router.mjs — 把高频失败签名映射到已沉淀的生成器通用范式引用。
+//
+// 用途：plan_next_round 的 `same-signature-3-rounds` 信号原本只说「脚本补丁无效，
+// 需升级 Skill 级范式」——笼统、Agent 仍需从零救火。本模块把维度级签名（不认业务词）
+// 路由到已落盘的 recipes 章节 / v3 链路铁律 / 生成器识别 intent，让 Agent 直接套用范式，
+// 把迭代预算从「每失败例救火」转向「每签名沉淀一条通用规则」（对应 trainer 效率维度三）。
+//
+// 失败签名 key 形如 `${failureClass}/${signature}`：
+//   failureClass ∈ {PARSER, DSL, STYLE, DATA, ASSET, EVALUATOR}
+//   signature   是门维度（structure/position/overall/color/pixelDiff/components/...）
+// 纯维度信号粗分模式，契合 skill 纯净铁律（禁硬编码业务实体名称）。
+
+export const PARADIGMS = {
+  // STYLE + 结构/位置/整体维度低 = 整块漏建（图表/雷达/分区）
+  'chart-radar-block': {
+    label: '图表/雷达/分区整块漏建',
+    recipeSections: [
+      'recipes.md §1 Canvas 画布标题头（onMeasured 自绘）',
+      'recipes.md §10 Canvas 甜甜圈/环形比例图（donut chart）',
+      'v3_assemble.mjs 散点带拓扑（中心媒体 + 环绕胶囊簇）',
+    ],
+    generatorIntents: [
+      'extract_handcrafted.py canvas_chart（Canvas+onMeasured 识别）',
+      'resolve_card_template.mjs 「雷达图 仪表盘」模板',
+      'v3_shared.mjs R62 图表绘制层序铁律（坐标/参考系/数据图元分层）',
+    ],
+    action: '套用图表通用范式（Canvas 自绘 + onMeasured），禁止用 Text/Image 堆砌或整块漏建；治本在 IR 路径强制把图表几何信号路由到 canvas_chart 识别',
+  },
+  // STYLE + 像素/色维度低 = 底色整层错涂
+  'bg-fill': {
+    label: '底色/背景整层错涂',
+    recipeSections: ['spec_audit.mjs 底色采样（角部 + gutter 众数聚类，禁用 center 采样）'],
+    generatorIntents: ['spec_audit fill 角部 + gutter 众数聚类'],
+    action: '底色取角部/边缘众数，禁止照抄 center 点（雷达/图表中心色常被误当卡底色）；治本在 spec_audit 采样逻辑',
+  },
+  // DSL + 组件计数缺口 = 媒体/列表漏建
+  'list-or-chart-missing': {
+    label: '组件/图表计数缺口（媒体或列表漏建）',
+    recipeSections: ['ir-format.md §2f 列表数组化', 'recipes.md §10 图表范式'],
+    generatorIntents: ['bindings.mjs collectArrayConsumption', 'canvas_chart intent'],
+    action: '先查 canvas_chart 识别与雷达/环图数据绑定（radarData/donutData），再查列表数组化；禁止静态展开或整块漏建',
+  },
+  // 兜底：仍要求沉淀通用规则，但无既有范式可直引
+  generic: {
+    label: '通用门维度失败',
+    recipeSections: [],
+    generatorIntents: [],
+    action: '升级 Skill 级范式：沉淀一条通用规则而非逐例救火',
+  },
+}
+
+/** 基于 failureClass + 门维度签名粗分范式模式（不依赖业务词）。 */
+export function classifyParadigm(signatureKey) {
+  const [failureClass = '', signature = ''] = String(signatureKey || '').split('/')
+  const sig = signature.toLowerCase()
+  if (failureClass === 'STYLE' && /^(structure|position|overall)$/.test(sig)) return 'chart-radar-block'
+  if (failureClass === 'STYLE' && /^(pixeldiff|color)$/.test(sig)) return 'bg-fill'
+  if (failureClass === 'DSL' && sig === 'components') return 'list-or-chart-missing'
+  return 'generic'
+}
+
+/** 取范式引用详情，未知 key 回退 generic。 */
+export function paradigmRefs(key) {
+  return PARADIGMS[key] || PARADIGMS.generic
+}
+
+/** 给 same-signature-3-rounds 信号生成增强 detail（含范式模式 + 引用 + 行动项）。 */
+export function enrichSameSignatureDetail(item) {
+  const patternKey = classifyParadigm(item.signature)
+  const refs = paradigmRefs(patternKey)
+  const base = `签名 ${item.signature} 在 ${item.occurrences} 轮重复出现（${item.rounds.join(' → ')}）：脚本补丁无效，需升级 Skill 级范式。`
+  const parts = [base, `模式=${refs.label}。${refs.action}。`]
+  if (refs.recipeSections.length) parts.push(`参照：${refs.recipeSections.join('；')}。`)
+  if (refs.generatorIntents.length) parts.push(`生成器侧已沉淀：${refs.generatorIntents.join('；')}。`)
+  return { pattern: patternKey, detail: parts.join('') }
+}

package/dist/vendored/skills/card-skill-trainer/scripts/lib/pixel-worker-runner.mjs

@@ -0,0 +1,31 @@
+// 像素评分 worker 运行器（P0-2）：在独立线程内执行 imageFidelity，避免阻塞主事件循环。
+// 纯 JS + pngjs，无 DOM 依赖，可直接在 worker_threads 内 import。
+// 计算异常就地捕获并回传 error，由主侧 scorePixel 触发同步回退，保证训练轮不崩。
+import { parentPort } from 'node:worker_threads'
+import { imageFidelity } from './scoring.mjs'
+
+parentPort.on('message', ({ id, payload }) => {
+  try {
+    // Buffer 经 worker_threads 结构化克隆后可能退化为 Uint8Array，PNG.sync.read 仍需真 Buffer；
+    // Buffer.from 对已是 Buffer 的入参仅复制、对 Uint8Array 则还原，两路都安全。
+    const designBuffer = Buffer.isBuffer(payload.designBuffer)
+      ? payload.designBuffer
+      : Buffer.from(payload.designBuffer)
+    const renderBuffer = Buffer.isBuffer(payload.renderBuffer)
+      ? payload.renderBuffer
+      : Buffer.from(payload.renderBuffer)
+    const result = imageFidelity(
+      designBuffer,
+      renderBuffer,
+      payload.exclusionRects,
+      payload.pixelOnlyRects,
+      payload.opts,
+    )
+    parentPort.postMessage({ id, result })
+  } catch (error) {
+    parentPort.postMessage({
+      id,
+      error: { message: String(error?.message || error), stack: String(error?.stack || '') },
+    })
+  }
+})

package/dist/vendored/skills/card-skill-trainer/scripts/lib/pixel-worker.mjs

@@ -0,0 +1,138 @@
+// 像素评分 worker 池（P0-2）：把 imageFidelity 的同步重计算（含 240×H 全图 diff / 灰度剖面 /
+// 颜色直方图）下沉到 worker_threads，避免并发渲染时评分串行卡住主事件循环——
+// 这正是此前把 --concurrency 锁死在 4 的根因（run_round.mjs 注释）。
+// 纯 JS + pngjs，无 DOM 依赖，可安全在 worker 内 import。
+//
+// 健壮性：worker 创建 / 初始化 / 单任务计算任一环节失败，scorePixel 自动回退到同步
+// imageFidelity，绝不抛出中断训练轮。env CARD_TRAINER_NO_PIXEL_WORKER=1 可强制关闭 worker。
+import { Worker } from 'node:worker_threads'
+import { fileURLToPath } from 'node:url'
+import { imageFidelity } from './scoring.mjs'
+
+const runnerPath = fileURLToPath(new URL('./pixel-worker-runner.mjs', import.meta.url))
+
+class PixelWorkerPool {
+  constructor(size) {
+    this.size = Math.max(1, size)
+    this.workers = []
+    this.idle = []
+    this.queue = []
+    this.pending = new Map()
+    this.nextId = 1
+    this.available = false
+    try {
+      for (let i = 0; i < this.size; i += 1) {
+        const worker = new Worker(runnerPath)
+        worker.__currentId = null
+        worker.on('message', (msg) => this._onMessage(worker, msg))
+        worker.on('error', () => this._onError(worker))
+        this.workers.push(worker)
+        this.idle.push(worker)
+      }
+      this.available = this.workers.length > 0
+    } catch {
+      this.available = false
+    }
+  }
+
+  _onMessage(worker, msg) {
+    const { id, result, error } = msg
+    worker.__currentId = null
+    const pending = this.pending.get(id)
+    if (!pending) return
+    this.pending.delete(id)
+    this.idle.push(worker)
+    if (error) pending.reject(new Error(error.message))
+    else pending.resolve(result)
+    this._drain()
+  }
+
+  _onError(worker) {
+    const id = worker.__currentId
+    worker.__dead = true
+    worker.__currentId = null
+    if (id != null) {
+      const pending = this.pending.get(id)
+      this.pending.delete(id)
+      if (pending) pending.reject(new Error('pixel-worker-failed'))
+    }
+  }
+
+  _drain() {
+    while (this.queue.length) {
+      // 优先挑一个存活 worker；无可用则把积压任务全部 reject，交由调用方同步回退。
+      const liveIdx = this.idle.findIndex((worker) => !worker.__dead)
+      if (liveIdx < 0) {
+        for (const item of this.queue) {
+          const pending = this.pending.get(item.id)
+          this.pending.delete(item.id)
+          if (pending) pending.reject(new Error('pixel-worker-unavailable'))
+        }
+        this.queue.length = 0
+        return
+      }
+      const worker = this.idle.splice(liveIdx, 1)[0]
+      const item = this.queue.shift()
+      worker.__currentId = item.id
+      worker.postMessage({ id: item.id, payload: item.payload })
+    }
+  }
+
+  run(payload) {
+    if (!this.available) return Promise.reject(new Error('pool-unavailable'))
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++
+      this.pending.set(id, { resolve, reject })
+      this.queue.push({ id, payload })
+      this._drain()
+    })
+  }
+
+  async close() {
+    await Promise.all(this.workers.map((worker) => new Promise((resolve) => {
+      try { worker.on('exit', () => resolve()); worker.terminate() } catch { resolve() }
+    })))
+  }
+}
+
+let _pool = null
+let _status = 'uninit' // 'on' | 'off' | 'fallback'
+
+export function initPixelWorkers(size) {
+  if (process.env.CARD_TRAINER_NO_PIXEL_WORKER) {
+    _pool = null
+    _status = 'off'
+    return _status
+  }
+  try {
+    _pool = new PixelWorkerPool(size)
+    _status = _pool.available ? 'on' : 'fallback'
+  } catch {
+    _pool = null
+    _status = 'fallback'
+  }
+  return _status
+}
+
+export function pixelWorkerStatus() {
+  return _status
+}
+
+export async function scorePixel(designBuffer, renderBuffer, exclusionRects = [], pixelOnlyRects = [], opts = {}) {
+  if (_pool && _status === 'on') {
+    try {
+      return await _pool.run({ designBuffer, renderBuffer, exclusionRects, pixelOnlyRects, opts })
+    } catch {
+      // 任一 worker 失败 → 同步回退，绝不让训练轮崩。
+      return imageFidelity(designBuffer, renderBuffer, exclusionRects, pixelOnlyRects, opts)
+    }
+  }
+  return imageFidelity(designBuffer, renderBuffer, exclusionRects, pixelOnlyRects, opts)
+}
+
+export async function closePixelWorkers() {
+  if (_pool) {
+    await _pool.close()
+    _pool = null
+  }
+}