cardbuddy 0.13.3 → 0.14.1

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

@@ -0,0 +1,484 @@
+#!/usr/bin/env node
+/**
+ * plan_next_round.mjs — 失败自动归因 + 下一轮计划（工程待补清单 P1-8）
+ *
+ * 此前的闭环断点：run_round 产出 review-queue / semantic-review，score_round 产出签名与门禁，
+ * round_diff 产出回归清单，但「下一轮到底修什么、修哪个文件、是否已经收敛」全靠人读三份产物。
+ * 单卡实测（training/plans/card-gen-speed-analysis.md）：99.7% 的时间花在分析与返工上，
+ * 不是工具耗时——所以这里把归因、聚类、焦点集、门禁判定、收敛早停一次算完。
+ *
+ * 用法：
+ *   node skills/card-skill-trainer/scripts/plan_next_round.mjs --run training/runs/r263 \
+ *     [--anchor training/anchors/r176.json] [--blind training/runs/r264] \
+ *     [--history auto|<dir,dir>] [--history-depth 8] [--focus-below 0.85] [--focus-limit 12] [--json]
+ *
+ * 产出（全部落在本轮 reports/，不写 src/）：
+ *   next-round-plan.json      机器可读计划：聚类 / 焦点集 / 晋级门 / 泛化门 / 收敛信号
+ *   lesson-drafts.jsonl       lessons.jsonl 新格式草稿（status=candidate，人工审批后落盘）
+ *   convergence-report.json   仅在收敛/早停信号触发时写出（SKILL「收敛检测与早停」要求）
+ *
+ * 归因只认指标与标注缺陷证据（缺口、掩膜、缺切图计数、几何偏移），不认业务词/画板名。
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import {
+  attributeFailure, evaluateGeneralizationGate, evaluatePassGate, failureSignature,
+  MASK_REVIEW_THRESHOLD,
+} from './lib/scoring.mjs'
+import { compareRounds, listRounds, loadRunReports, loadRunSummary, roundMetrics } from './lib/runs.mjs'
+
+const repoRoot = path.resolve(import.meta.dirname, '../../..')
+
+/** 失败类 → 建议修复落点（通用文件，禁止案例专属补丁）。 */
+const TARGETS_BY_CLASS = {
+  PARSER: [
+    'skills/sketch-spec-to-card/scripts/parse_meaxure.py',
+    'skills/sketch-spec-to-card/scripts/vision.py',
+    'skills/sketch-spec-to-card/references/boundary.json',
+  ],
+  DSL: [
+    'skills/dsl-card-generator/scripts/spec_to_schema_v3.mjs',
+    'skills/dsl-card-generator/references/generation_pitfalls.md',
+  ],
+  STYLE: [
+    'skills/dsl-card-generator/scripts/spec_to_schema_v3.mjs',
+    'skills/dsl-card-generator/references/previewer_contract.md',
+    'skills/dsl-card-generator/references/component_rules.md',
+  ],
+  DATA: [
+    'skills/dsl-card-generator/scripts/spec_to_schema_v3.mjs',
+    'skills/dsl-card-generator/references/amount_formatting.md',
+  ],
+  INTERACTION: [
+    'skills/dsl-card-generator/scripts/spec_to_schema_v3.mjs',
+    'skills/dsl-card-generator/references/component_specs.md',
+  ],
+  ASSET: [
+    'skills/dsl-card-generator/scripts/crop_slices.mjs',
+    'skills/sketch-spec-to-card/scripts/parse_meaxure.py',
+    'skills/dsl-card-generator/references/slices_convention.md',
+  ],
+  EVALUATOR: [
+    'skills/card-skill-trainer/scripts/run_round.mjs',
+    'skills/card-skill-trainer/scripts/lib/scoring.mjs',
+    'skills/dsl-card-generator/scripts/render_card.mjs',
+  ],
+}
+
+/** 失败类 → lessons.jsonl 的 category（沿用 lessons 里已有的词表）。 */
+const LESSON_CATEGORY_BY_CLASS = {
+  PARSER: 'PARSER', DSL: 'DSL', STYLE: 'LAYOUT', DATA: 'TEXT',
+  INTERACTION: 'DSL', ASSET: 'MEDIA', EVALUATOR: 'TRAINER',
+}
+
+function parseArgs(argv) {
+  const out = {
+    run: '', anchor: '', blind: '', history: 'auto', historyDepth: 8,
+    focusBelow: 0.85, focusLimit: 12, json: false,
+  }
+  const camel = (raw) => raw.replace(/-([a-z])/g, (_, ch) => ch.toUpperCase())
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index]
+    if (!token.startsWith('--')) continue
+    const key = camel(token.replace(/^--/, ''))
+    const next = argv[index + 1]
+    if (next === undefined || next.startsWith('--')) out[key] = true
+    else { out[key] = next; index += 1 }
+  }
+  return out
+}
+
+const average = (values) => {
+  const numbers = values.filter((value) => typeof value === 'number' && Number.isFinite(value))
+  return numbers.length ? numbers.reduce((sum, value) => sum + value, 0) / numbers.length : null
+}
+const round3 = (value) => typeof value === 'number' && Number.isFinite(value) ? Number(value.toFixed(4)) : null
+
+/** 统一口径：老报告没有 failureSignature / failureClass / gateFailures，按当前尺子现算。 */
+function normalizeReport(report) {
+  const gate = Array.isArray(report.gateFailures) && report.gateFailures.length
+    ? report.gateFailures
+    : (report.passed ? [] : evaluatePassGate(report).failures)
+  const attribution = report.passed ? null : (report.failureClass
+    ? { failureClass: report.failureClass, reason: report.failureReason || '' }
+    : attributeFailure({ ...report, passed: false }))
+  return {
+    ...report,
+    gateFailures: gate,
+    signature: report.failureSignature || failureSignature(report) || (report.passed ? null : 'metric-gate'),
+    failureClass: attribution?.failureClass || (report.passed ? null : 'UNCLASSIFIED'),
+    failureReason: attribution?.reason || '',
+  }
+}
+
+function nextRoundId(round) {
+  const matched = /^r(\d+)(.*)$/.exec(String(round || ''))
+  if (!matched) return `${round || 'r'}-next`
+  return `r${String(Number(matched[1]) + 1).padStart(matched[1].length, '0')}${matched[2]}`
+}
+
+function buildClusters(reports) {
+  const buckets = new Map()
+  for (const report of reports.filter((item) => !item.passed)) {
+    const key = `${report.failureClass}/${report.signature}`
+    if (!buckets.has(key)) buckets.set(key, [])
+    buckets.get(key).push(report)
+  }
+  return [...buckets.entries()]
+    .map(([key, items]) => {
+      const [failureClass, signature] = key.split('/')
+      const coFailures = {}
+      for (const item of items) {
+        for (const failure of item.gateFailures) coFailures[failure.key] = (coFailures[failure.key] || 0) + 1
+      }
+      const missingSliceCases = items.filter((item) =>
+        (item.upstream?.annotationDefects || []).some((defect) => defect?.type === 'missing-slice')).length
+      const highMaskCases = items.filter((item) =>
+        (item.exclusionCoverage?.total ?? 0) >= MASK_REVIEW_THRESHOLD).length
+      const worst = [...items].sort((a, b) =>
+        (a.fidelity?.overall ?? 0) - (b.fidelity?.overall ?? 0))[0]
+      return {
+        failureClass,
+        signature,
+        count: items.length,
+        caseIds: items.map((item) => item.caseId),
+        avgFidelity: round3(average(items.map((item) => item.fidelity?.overall))),
+        avgPixel: round3(average(items.map((item) => item.pixel?.ratio))),
+        avgPosition: round3(average(items.map((item) => item.fidelity?.position))),
+        coFailures: Object.entries(coFailures).sort((a, b) => b[1] - a[1]).map(([dim, count]) => ({ dim, count })),
+        evidence: {
+          missingSliceCases,
+          highMaskCases,
+          avgAbsAlignDy: round3(average(items.map((item) => Math.abs(item.pixel?.bestAlignDy ?? Number.NaN)))),
+          correctorRejected: items.filter((item) => item.correctorRejected).length,
+          sampleReason: worst?.failureReason || '',
+        },
+        suggestedTargets: TARGETS_BY_CLASS[failureClass] || TARGETS_BY_CLASS.DSL,
+        worstCaseId: worst?.caseId || null,
+      }
+    })
+    .sort((a, b) => b.count - a.count || (a.avgFidelity ?? 0) - (b.avgFidelity ?? 0))
+}
+
+function buildFocus(reports, threshold, limit) {
+  const ranked = reports
+    .map((item) => ({
+      caseId: item.caseId,
+      fidelity: typeof item.fidelity?.overall === 'number' ? item.fidelity.overall : 0,
+      passed: !!item.passed,
+    }))
+    .filter((item) => !item.passed || item.fidelity < threshold)
+    .sort((a, b) => a.fidelity - b.fidelity || String(a.caseId).localeCompare(String(b.caseId)))
+  const picked = Number(limit) > 0 ? ranked.slice(0, Number(limit)) : ranked
+  return { threshold, limit: Number(limit) || null, caseIds: picked.map((item) => item.caseId), ranked: picked }
+}
+
+/** 跨轮签名趋势：同一签名在最近 N 轮反复出现 = 脚本补丁无效，需升级到 Skill 级范式。 */
+function buildHistory(historyDirs, currentRound, currentReports) {
+  const rounds = []
+  for (const dir of historyDirs) {
+    let reports
+    try { reports = [...loadRunReports(dir).values()].map(normalizeReport) } catch { continue }
+    if (!reports.length) continue
+    const signatures = {}
+    for (const report of reports.filter((item) => !item.passed)) {
+      signatures[report.signature] = (signatures[report.signature] || 0) + 1
+    }
+    rounds.push({
+      round: path.basename(dir),
+      dir,
+      metrics: roundMetrics(reports),
+      caseIds: reports.map((report) => report.caseId),
+      signatures,
+    })
+  }
+  const currentSignatures = {}
+  for (const report of currentReports.filter((item) => !item.passed)) {
+    currentSignatures[report.signature] = (currentSignatures[report.signature] || 0) + 1
+  }
+  rounds.push({
+    round: currentRound, dir: null, metrics: roundMetrics(currentReports),
+    caseIds: currentReports.map((report) => report.caseId), signatures: currentSignatures,
+  })
+
+  // 重复签名：在本轮出现，且在之前的轮次里也出现过 ≥2 次（合计 ≥3 轮）
+  const repeated = []
+  for (const signature of Object.keys(currentSignatures)) {
+    const seen = rounds.filter((round) => (round.signatures[signature] || 0) > 0)
+    if (seen.length >= 3) {
+      repeated.push({
+        signature,
+        rounds: seen.map((round) => `${round.round}:${round.signatures[signature]}`),
+        occurrences: seen.length,
+      })
+    }
+  }
+  repeated.sort((a, b) => b.occurrences - a.occurrences)
+
+  // 边际收益：取最近 ≤4 轮的共同案例集，算交集上的 avgFidelity 逐轮 delta
+  const tail = rounds.slice(-4)
+  let marginal = null
+  if (tail.length >= 3) {
+    const intersection = tail.reduce((acc, round) =>
+      acc.filter((caseId) => round.caseIds.includes(caseId)), [...tail[0].caseIds])
+    if (intersection.length) {
+      const series = tail.map((round) => ({ round: round.round, avgFidelity: round.metrics.fidelity }))
+      marginal = { sharedCases: intersection.length, series, note: '均值基于共同案例集，跨批次轮次不可直接比' }
+    }
+  }
+  return { rounds: rounds.map((round) => ({ round: round.round, metrics: round.metrics })), repeatedSignatures: repeated, marginal }
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2))
+  if (!args.run) throw new Error('--run 必填（例：--run training/runs/r263）')
+  const runDir = path.resolve(repoRoot, String(args.run))
+  const reports = [...loadRunReports(runDir).values()].map(normalizeReport)
+  if (!reports.length) throw new Error(`${runDir} 里没有案例报告`)
+  const roundName = path.basename(runDir)
+  const summary = loadRunSummary(runDir)
+  const metrics = summary
+    ? {
+      total: summary.total, passed: summary.passed, passRate: summary.passRate,
+      fidelity: summary.avgFidelity, pixel: summary.avgPixelDiff, position: summary.avgPositionFidelity,
+      structure: summary.avgStructureFidelity, components: summary.avgFidelityComponents,
+      minFidelity: summary.minFidelity,
+    }
+    : roundMetrics(reports)
+  const reportDir = path.join(runDir, 'reports')
+  fs.mkdirSync(reportDir, { recursive: true })
+
+  const clusters = buildClusters(reports)
+  const focus = buildFocus(reports, Number(args.focusBelow) || 0.85, Number(args.focusLimit) || 0)
+  const failing = reports.filter((item) => !item.passed)
+
+  // —— 晋级门：与冻结锚点（轮目录或入库压缩锚点）对账 ——
+  let promotionGate = { available: false, reason: '未提供 --anchor（干净克隆可用 training/anchors/r176.json）' }
+  if (args.anchor) {
+    const anchorReports = loadRunReports(String(args.anchor))
+    const comparison = compareRounds(anchorReports, new Map(reports.map((item) => [item.caseId, item])))
+    promotionGate = {
+      available: true,
+      anchor: String(args.anchor),
+      sharedCases: comparison.sharedCount,
+      regressions: comparison.regressed,
+      fixed: comparison.fixed,
+      degradedMeans: (() => {
+        const degraded = []
+        for (const [key, higherIsBetter] of [['fidelity', true], ['position', true], ['structure', true], ['components', true], ['pixel', false]]) {
+          const before = comparison.from[key]
+          const after = comparison.to[key]
+          if (typeof before !== 'number' || typeof after !== 'number') continue
+          const delta = after - before
+          if (higherIsBetter ? delta < -1e-9 : delta > 1e-9) degraded.push({ metric: key, delta: Number(delta.toFixed(5)) })
+        }
+        return degraded
+      })(),
+      added: comparison.added.length,
+      removed: comparison.removed.length,
+    }
+    promotionGate.passed = promotionGate.regressions.length === 0 && promotionGate.degradedMeans.length === 0
+    if (comparison.sharedCount === 0) {
+      promotionGate.note = '与锚点无共享案例：本轮是新批次，只作盲测/基线，不构成锚点回归'
+      promotionGate.passed = null
+    }
+  }
+
+  // —— 泛化盲测门：--blind 传未见样本轮 ——
+  let generalizationGate = { available: false, reason: '未提供 --blind（每 3 轮或晋级前必须盲测 ≥24 例）' }
+  if (args.blind) {
+    const blindDir = path.resolve(repoRoot, String(args.blind))
+    const blindSummary = loadRunSummary(blindDir) || (() => {
+      const blindMetrics = roundMetrics(loadRunReports(blindDir))
+      return { total: blindMetrics.total, passRate: blindMetrics.passRate, avgFidelity: blindMetrics.fidelity }
+    })()
+    const anchorSummary = args.anchor
+      ? (loadRunSummary(String(args.anchor)) || (() => {
+        const anchorMetrics = roundMetrics(loadRunReports(String(args.anchor)))
+        return { avgFidelity: anchorMetrics.fidelity }
+      })())
+      : { avgFidelity: metrics.fidelity }
+    generalizationGate = {
+      available: true,
+      blind: String(args.blind),
+      ...evaluateGeneralizationGate(blindSummary, anchorSummary),
+    }
+  }
+
+  // —— 历史趋势与收敛信号 ——
+  let historyDirs = []
+  if (String(args.history) === 'auto') {
+    const runsRoot = path.join(repoRoot, 'training', 'runs')
+    historyDirs = listRounds(runsRoot)
+      .filter((name) => name !== roundName)
+      .slice(-(Math.max(1, Number(args.historyDepth) || 8)))
+      .map((name) => path.join(runsRoot, name))
+  } else if (args.history && args.history !== 'none') {
+    historyDirs = String(args.history).split(',').filter(Boolean).map((item) => path.resolve(repoRoot, item.trim()))
+  }
+  const history = buildHistory(historyDirs, roundName, reports)
+
+  const signals = []
+  for (const item of history.repeatedSignatures) {
+    signals.push({
+      signal: 'same-signature-3-rounds',
+      detail: `签名 ${item.signature} 在 ${item.occurrences} 轮重复出现（${item.rounds.join(' → ')}）：脚本补丁无效，需升级 Skill 级范式`,
+    })
+  }
+  const series = history.marginal?.series || []
+  if (series.length >= 4) {
+    const deltas = series.slice(1).map((item, index) => item.avgFidelity - series[index].avgFidelity)
+    if (deltas.every((delta) => delta < 0.01)) {
+      signals.push({
+        signal: 'marginal-gain-below-1pt',
+        detail: `连续 ${deltas.length} 轮共同案例集 avgFidelity 提升均 <1pt（${deltas.map((d) => (d * 100).toFixed(2) + 'pp').join(' / ')}）：停止脚本微调`,
+      })
+    }
+  }
+  if (generalizationGate.available) {
+    if (!generalizationGate.anchorGap.met && generalizationGate.anchorGap.actual != null) {
+      signals.push({
+        signal: 'anchor-blind-gap-over-10pts',
+        detail: `锚点−盲测差 ${(generalizationGate.anchorGap.actual * 100).toFixed(1)}pts > 10pts：过拟合风险，强制回退候选规则`,
+      })
+    }
+    if (promotionGate.available && typeof metrics.fidelity === 'number') {
+      const blindFidelity = generalizationGate.avgFidelity?.actual
+      if (typeof blindFidelity === 'number' && metrics.fidelity > blindFidelity && promotionGate.regressions?.length === 0) {
+        signals.push({
+          signal: 'anchor-up-blind-down',
+          detail: `锚点侧 avgFidelity ${(metrics.fidelity * 100).toFixed(1)}% 高于盲测 ${(blindFidelity * 100).toFixed(1)}%：判定过拟合，拒绝晋级`,
+        })
+      }
+    }
+  }
+  const highMaskPassing = reports.filter((item) =>
+    item.passed && (item.exclusionCoverage?.total ?? 0) >= MASK_REVIEW_THRESHOLD)
+  if (highMaskPassing.length) {
+    signals.push({
+      signal: 'pass-by-mask',
+      detail: `${highMaskPassing.length} 例靠掩膜通过（覆盖 ≥${(MASK_REVIEW_THRESHOLD * 100).toFixed(0)}%）：${highMaskPassing.slice(0, 5).map((item) => item.caseId).join(',')}，须看图复核，不得计入晋级证据`,
+    })
+  }
+
+  // —— lesson 草稿（新格式，status=candidate；人工审批后再落盘 lessons.jsonl）——
+  const lessonDrafts = clusters
+    .filter((cluster) => cluster.count >= 2 || cluster.signature !== 'metric-gate')
+    .slice(0, 10)
+    .map((cluster, index) => ({
+      lessonId: `${roundName}-draft-${String(index + 1).padStart(2, '0')}`,
+      signature: cluster.signature,
+      failureClass: cluster.failureClass,
+      evidenceCases: cluster.caseIds.slice(0, 5),
+      rule: 'TODO：人工补写通用规则（只允许几何/样式/结构判据，禁业务词与画板名）',
+      targetFiles: cluster.suggestedTargets,
+      status: 'candidate',
+      round: roundName,
+      metrics: { avgFidelity: cluster.avgFidelity, avgPixel: cluster.avgPixel, coFailures: cluster.coFailures },
+    }))
+  const draftsPath = path.join(reportDir, 'lesson-drafts.jsonl')
+  fs.writeFileSync(draftsPath, lessonDrafts.map((item) => JSON.stringify(item)).join('\n') + (lessonDrafts.length ? '\n' : ''))
+
+  const nextRound = nextRoundId(roundName)
+  const rel = (target) => path.relative(repoRoot, target).split(path.sep).join('/')
+  const nextActions = []
+  if (failing.length) {
+    nextActions.push(`逐例诊断 Top${Math.min(3, clusters.length)} 聚类代表：${clusters.slice(0, 3)
+      .map((cluster) => `node skills/card-skill-trainer/scripts/diagnose_case.mjs --run ${rel(runDir)} --case ${cluster.worstCaseId}`)
+      .join(' ; ')}`)
+  }
+  if (focus.caseIds.length) {
+    nextActions.push(`焦点集增量轮：node skills/card-skill-trainer/scripts/run_round.mjs --dataset <dataset>.jsonl --round ${nextRound} --focus ${rel(runDir)} --focus-limit ${focus.caseIds.length} --inherit ${rel(runDir)}`)
+  }
+  if (args.anchor) {
+    nextActions.push(`锚点回归：node skills/card-skill-trainer/scripts/round_diff.mjs --from ${rel(path.resolve(repoRoot, String(args.anchor)))} --to training/runs/${nextRound}`)
+  }
+  nextActions.push('规则落盘后：node training/tools/aggregate_lessons.mjs 复核 lesson 草稿，并 npm run ci 过硬门禁')
+
+  const plan = {
+    round: roundName,
+    generatedAt: new Date().toISOString(),
+    inputs: {
+      run: rel(runDir),
+      anchor: args.anchor ? String(args.anchor) : null,
+      blind: args.blind ? String(args.blind) : null,
+      history: history.rounds.map((item) => item.round),
+    },
+    metrics,
+    failingCount: failing.length,
+    clusters,
+    focus: { threshold: focus.threshold, limit: focus.limit, caseIds: focus.caseIds },
+    promotionGate,
+    generalizationGate,
+    convergence: { triggered: signals.length > 0, signals },
+    highMaskPassing: highMaskPassing.map((item) => ({ caseId: item.caseId, coverage: round3(item.exclusionCoverage?.total) })),
+    lessonDrafts: rel(draftsPath),
+    nextActions,
+  }
+  const planPath = path.join(reportDir, 'next-round-plan.json')
+  fs.writeFileSync(planPath, JSON.stringify(plan, null, 2) + '\n')
+  if (signals.length) {
+    fs.writeFileSync(path.join(reportDir, 'convergence-report.json'),
+      JSON.stringify({ round: roundName, generatedAt: plan.generatedAt, signals, clusters, nextActions }, null, 2) + '\n')
+  }
+
+  if (args.json) { console.log(JSON.stringify(plan, null, 2)); return }
+
+  const pctValue = (value) => value == null ? 'N/A' : `${(value * 100).toFixed(1)}%`
+  console.log(`══ 下一轮计划 ${roundName} ══`)
+  console.log(`案例 ${metrics.total} / 通过 ${metrics.passed} (${pctValue(metrics.passRate)}) / 失败 ${failing.length}`)
+  console.log(`avgFid ${pctValue(metrics.fidelity)}  avgPix ${pctValue(metrics.pixel)}  avgPos ${pctValue(metrics.position)}  minFid ${pctValue(metrics.minFidelity)}`)
+  console.log('')
+  console.log('── 失败聚类（按例数降序）──')
+  if (!clusters.length) console.log('  （本轮无失败）')
+  for (const cluster of clusters.slice(0, 8)) {
+    console.log(`  [${cluster.failureClass}] ${cluster.signature} × ${cluster.count}  avgFid=${pctValue(cluster.avgFidelity)}`)
+    console.log(`     未达标维度: ${cluster.coFailures.map((item) => `${item.dim}×${item.count}`).join(' ')}`)
+    console.log(`     证据: 缺切图案例 ${cluster.evidence.missingSliceCases} / 高掩膜 ${cluster.evidence.highMaskCases} / |dy|均值 ${cluster.evidence.avgAbsAlignDy ?? 'N/A'} / 校正被拒 ${cluster.evidence.correctorRejected}`)
+    console.log(`     落点: ${cluster.suggestedTargets.join(' , ')}`)
+    console.log(`     案例: ${cluster.caseIds.slice(0, 6).join(',')}${cluster.caseIds.length > 6 ? '…' : ''}`)
+  }
+  console.log('')
+  console.log(`── 焦点集（fidelity<${focus.threshold} 或未通过，共 ${focus.caseIds.length} 例）──`)
+  if (focus.caseIds.length) console.log(`  --only ${focus.caseIds.join(',')}`)
+  console.log('')
+  console.log('── 门禁判定 ──')
+  if (promotionGate.available) {
+    const verdict = promotionGate.passed == null ? 'N/A（新批次）' : promotionGate.passed ? 'PASS' : 'FAIL'
+    console.log(`  晋级门(锚点 ${path.basename(promotionGate.anchor)}, 共享 ${promotionGate.sharedCases} 例): ${verdict}`)
+    if (promotionGate.regressions?.length) console.log(`     回归 pass→fail: ${promotionGate.regressions.map((item) => item.caseId).join(',')}`)
+    // 无共享案例时均值不可比（新批次 vs 锚点），只在有交集时才报退化
+    if (promotionGate.degradedMeans?.length && promotionGate.sharedCases > 0) {
+      console.log(`     均值退化: ${promotionGate.degradedMeans.map((item) => `${item.metric} ${(item.delta * 100).toFixed(2)}pp`).join(' ')}`)
+    }
+  } else console.log(`  晋级门: ${promotionGate.reason}`)
+  if (generalizationGate.available) {
+    console.log(`  泛化盲测门(${path.basename(String(args.blind))}): ${generalizationGate.passed ? 'PASS' : 'FAIL'}`)
+    for (const [key, check] of Object.entries(generalizationGate)) {
+      if (!check || typeof check !== 'object') continue
+      console.log(`     ${check.met ? 'PASS' : 'FAIL'} ${key}: target=${check.target} actual=${check.actual}`)
+    }
+  } else console.log(`  泛化盲测门: ${generalizationGate.reason}`)
+  console.log('')
+  console.log('── 收敛 / 早停信号 ──')
+  if (!signals.length) console.log('  （无）')
+  for (const signal of signals) console.log(`  ! ${signal.signal}: ${signal.detail}`)
+  if (history.repeatedSignatures.length) {
+    console.log('')
+    console.log('── 跨轮重复签名 ──')
+    for (const item of history.repeatedSignatures.slice(0, 6)) console.log(`  ${item.signature}  ${item.rounds.join(' → ')}`)
+  }
+  console.log('')
+  console.log('── 下一轮动作 ──')
+  for (const action of nextActions) console.log(`  • ${action}`)
+  console.log('')
+  console.log(`计划: ${rel(planPath)}`)
+  console.log(`lesson 草稿: ${rel(draftsPath)}（${lessonDrafts.length} 条，status=candidate，需人工审批后落盘 lessons.jsonl）`)
+}
+
+try {
+  main()
+} catch (error) {
+  console.error(String(error?.message || error))
+  process.exit(1)
+}