dsh-ppt-studio 1.1.5 → 1.2.1

package/lib/verify.js

@@ -19,6 +19,11 @@
  *                             不得静默跳过（静默返空与"真没问题"在输出上不可区分，2026-09-18 假绿灯事故的根因）
  */
 
+// 阶段 A（docs/08 §5）：结构关系（推导 + 几何反验证）。注意方向是 verify → relations，不反向
+// （relations.js 不依赖 verify），因此不存在循环依赖。
+import { deriveRelations, checkDiagram, summaryLine, usesStructure } from './pptd/relations.js'
+import { checkLineRules } from './pptd/line-rules.js'
+
 const TOL = 1 // px
 
 const NEUTRAL_GRAY_RE = /^#(?:[0-9a-fA-F]{6})$/ // 黑白灰中性色宽判：RGB 各分量近等
@@ -256,7 +261,34 @@ export function analyzePage(page, size) {
   const minY = sa?.top ?? 0
   const maxX = pw - (sa?.right ?? 0)
   const maxY = ph - (sa?.bottom ?? 0)
-  const declared = declaredClosure(page) // P0-2：声明闭包（嵌套承载相邻层声明 → 隔层自动通过）
+  const declaredBase = declaredClosure(page) // P0-2：声明闭包（嵌套承载相邻层声明 → 隔层自动通过）
+  // ── 阶段 A（docs/08 §5）：结构关系 = 推导 + 几何反验证 ──
+  // ① **有效**关系的豁免注入声明集（推导结果**不落盘**，每次现算）；
+  // ② 声明不成立 ⇒ 点名错误；③ 已失效的声明降级为可见警告（"声明复核"段）；
+  // ④ 图专属机械检查。以上**仅在"本页用了结构声明"时启用** ⇒ 没用新特性的页面行为与从前完全一致。
+  const usedStructure = usesStructure(page)
+  const rel = usedStructure ? deriveRelations(page) : { relations: [], exempt: [], invalid: [], errors: [], stats: { groups: 0, contains: 0, attach: 0, badge: 0, overlapDecl: 0, exempt: 0 } }
+  const declared = new Set([...declaredBase, ...(usedStructure ? rel.exempt : [])])
+  if (usedStructure) {
+    for (const e of rel.errors) findings.push({ severity: 'error', code: e.code, message: e.detail })
+    for (const iv of rel.invalid) {
+      if (iv.type !== 'overlapDecl') continue // 不成立的 contains/attach/badge 已进 rel.errors
+      findings.push({ severity: 'warning', code: 'declared-stale', message: `预期重叠声明已失效：${iv.from} × ${iv.to}（两端当前并不相交，建议移除）` })
+    }
+    const dg = checkDiagram(page)
+    for (const e of dg.errors) {
+      // text-over-text 已由既有 content-collision 覆盖 ⇒ 不重复上抛（自证脚本仍直接断言该检查本身）
+      if (e.code === 'text-over-text') continue
+      findings.push({ severity: 'error', code: e.code, message: e.detail })
+    }
+    for (const w of dg.warnings) findings.push({ severity: 'warning', code: w.code, message: w.detail })
+    // attach 改写过手写坐标 ⇒ 必须可见（"attach 优先"可以，静默覆盖不行）
+    for (const el of els) for (const n of (el.attachNotes ?? [])) findings.push({ severity: 'warning', code: 'attach-override', message: `${el.id}: ${n}` })
+    // 结构关系豁免的对数（供报告"结构关系"行使用）
+    findings.structureStats = { ...rel.stats, usedStructure: true }
+  }
+  // 折线绘制规则（阶段 A1，泛用性优先）：对**所有**页面生效（含手写自由发挥）——只警告，不改判定
+  for (const w of checkLineRules(els)) findings.push({ severity: 'warning', code: w.code, message: w.message })
   const outOfSafe = new Set(page.expectedOutOfSafeArea ?? []) // 出界分级声明制（C3 修订）
   const lenient = page.overlapMode === 'lenient'
   const pairKey = (a, b) => [a, b].sort().join(' × ')
@@ -355,6 +387,25 @@ export function analyzePage(page, size) {
         let code = 'overlap'
         let note = ''
         if (ki === 'line' || kj === 'line') {
+          // R12：折线的**整体外接框**不是它的绘制区域——绕开盒子的路线，AABB 必然罩住那个盒子 ⇒ 误报
+          //（实测：密集状态机里"上方绕行"的退货线 AABB 正好罩住 s3，报出 58.5×54 = 整框面积）。
+          // 改为**逐段真实相交**：只有某一段确实穿过对方矩形**内部**才算重叠（贴边不算、绕行不算、穿过才算）。
+          const lnEl = ki === 'line' ? els[i] : els[j]
+          const otherEl = ki === 'line' ? els[j] : els[i]
+          const unt = otherEl.bounds
+          const rOther = unt && (Array.isArray(unt) ? { x: unt[0], y: unt[1], w: unt[2], h: unt[3] } : unt)
+          const segHitsRect = (pts, r) => {
+            if (!r || !Array.isArray(pts)) return true
+            for (let k = 0; k + 1 < pts.length; k++) {
+              const [ax1, ay1] = pts[k]
+              const [ax2, ay2] = pts[k + 1]
+              const x0 = Math.min(ax1, ax2); const x1 = Math.max(ax1, ax2)
+              const y0 = Math.min(ay1, ay2); const y1 = Math.max(ay1, ay2)
+              if (x1 > r.x + 0.5 && x0 < r.x + r.w - 0.5 && y1 > r.y + 0.5 && y0 < r.y + r.h - 0.5) return true
+            }
+            return false
+          }
+          if (!segHitsRect(lnEl.points, rOther)) continue
           severity = 'warning'
           note = '—— 连线/箭头跨越，视为引导或标注线'
         } else if (ri === 'content' && rj === 'content') {
@@ -482,6 +533,23 @@ export function verifyDeck(layout) {
       if (f.severity === 'confirmed') continue
       out.push(`  - [${f.severity === 'error' ? '✗' : '~'}] ${f.code}｜${f.message}`)
     }
+    // ── 阶段 A 报告形态（docs/08 §5）：结构关系只计数；**声明复核段固定存在**（豁免必须可见）──
+    if (findings.structureStats !== undefined) {
+      const rel = deriveRelations(page)
+      out.push(`  · ${summaryLine(rel)}`)
+      const decls = Array.isArray(page.expectedOverlaps) ? page.expectedOverlaps : []
+      const noReason = decls.filter((d) => !d || typeof d.reason !== 'string' || d.reason.trim() === '').length
+      const stale = rel.invalid.filter((iv) => iv.type === 'overlapDecl').length
+      // "是否覆盖"必须按**推断**角色判（roleOf 返回的是生效角色，显式优先 ⇒ 直接比会永远相等）
+      const inferred = (el) => (['text', 'table', 'chart'].includes(el.type ?? el.kind) ? 'content' : ((el.type === 'line' || el.kind === 'line') ? 'line' : 'background'))
+      const overrides = (page.elements ?? []).filter((el) => el.role !== undefined && el.role !== inferred(el))
+      const overNoReason = overrides.filter((el) => typeof el.roleReason !== 'string' || el.roleReason.trim() === '')
+      const parts = []
+      parts.push(decls.length ? `预期重叠声明 ${decls.length} 处${stale ? `（${stale} 处已失效）` : ''}${noReason ? `（${noReason} 处缺 reason）` : ''}` : '预期重叠声明 0 处')
+      parts.push(overrides.length ? `role 覆盖 ${overrides.length} 处${overNoReason.length ? `（${overNoReason.length} 处缺 roleReason）` : ''}` : 'role 覆盖 0 处')
+      parts.push(`自证：关系全部通过几何反验证${rel.invalid.filter((iv) => iv.type !== 'overlapDecl').length ? `（${rel.invalid.filter((iv) => iv.type !== 'overlapDecl').length} 处不成立已按冲突报）` : ''}`)
+      out.push(`  · 设计声明复核：${parts.join('｜')}`)
+    }
     for (const s of suggestions) {
       out.push(`  - [·] ${s.code}｜${s.message}`)
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ppt-studio",
-  "version": "1.1.5",
+  "version": "1.2.1",
   "description": "在 DeepSeek Harness 里做 PPT：说需求 → 逐页制作 → 导出可编辑的 .pptx。含布局检查、Office 真渲染复核，以及可扩展的本地模板库",
   "//publish": "2026-09-18 定：发 npm，**无 scope** 包名 `dsh-ppt-studio`。**状态（2026-09-26）：已发布** —— `dsh-ppt-studio@1.1.0` 在 npm 上（`dist-tags.latest`、public，发布者 `zbsph`），registry 的 tarball 与 GitHub Release 资产**逐字节相同**（sha256 `9303cc5c…`）。首个版本是 `npm publish <发版 tgz>` 直发的；**从下一版起改走 Trusted Publishing（OIDC）全自动通道**：`.github/workflows/publish.yml` 由 release 事件触发 → 下载 Release 资产 → OIDC `npm publish` → 发后自证 integrity —— 零长期 token、零手工（npm 已公告：Bypass-2FA 直发 2027-01 移除）。发布纪律不变：**用发版时那个 tgz**（`.sync-state.json` 的 `localTgz`），**别在 main 前进后跑裸 `npm publish`**（会按当前工作区重新打包 ⇒ 破坏'两条通道同一份字节'）。手动补发入口：Actions → Publish to npm → Run workflow。见 README §10 与 docs/05「发布-同步纪律」。",
   "repository": { "type": "git", "url": "git+https://github.com/zbsph/dsh-ppt-studio.git" },
@@ -28,7 +28,6 @@
   },
   "files": [
     "lib",
-    "vendor",
     "templates",
     "docs",
     "skills",
@@ -60,10 +59,21 @@
     }
   },
   "scripts": {
+    "verify:package": "node scripts/check-package.mjs",
+    "verify:products": "node scripts/verify-products.mjs",
+    "verify:handdrawn": "node scripts/verify-handdrawn.mjs",
+    "verify:optionprobe": "node scripts/handdrawn-option-probe.mjs",
+    "verify:redprobe": "node scripts/red-probe.mjs",
+    "verify:linetext": "node scripts/check-line-text.mjs",
     "build": "bash scripts/build.sh",
     "build:node": "node scripts/build.mjs",
     "sync": "node scripts/release-sync.mjs",
-    "test": "node scripts/build.mjs && node scripts/check-tracked-lf.mjs && node scripts/smoke.mjs && node scripts/check-preset.mjs",
+    "test": "node scripts/build.mjs && node scripts/check-tracked-lf.mjs && node scripts/check-lib-sync.mjs && node scripts/check-unknown-keys.mjs && node scripts/check-removed-traces.mjs && node scripts/check-generators.mjs && node scripts/smoke.mjs && node scripts/check-preset.mjs && node scripts/verify-handdrawn.mjs && node scripts/red-probe.mjs && node scripts/check-line-text.mjs && node scripts/handdrawn-option-probe.mjs",
+    "test:fast": "node scripts/test-fast.mjs",
+    "test:release": "node scripts/test-release.mjs",
+    "test:map": "node scripts/test-map.mjs",
+    "check:syntax": "node scripts/check-syntax.mjs",
+    "test:map:audit": "node scripts/test-map.mjs --audit",
     "check:eol": "node scripts/check-tracked-lf.mjs",
     "fresh": "node scripts/verify-fresh-install.mjs",
     "test:real": "node scripts/regression-real.mjs",
@@ -77,6 +87,13 @@
     "probe:effect": "node scripts/probe-effect-semantics.mjs",
     "probe:reparse": "node scripts/probe-reparse-safety.mjs",
     "probe:asset": "node scripts/probe-asset-freshness.mjs",
+    "probe:prompt": "node scripts/probe-prompt-cost.mjs",
+    "probe:prompt:check": "node scripts/probe-prompt-cost.mjs --check",
+    "bench:scale": "node scripts/bench-diagram-scale.mjs",
+    "verify:relations": "node scripts/verify-diagram-relations.mjs",
+    "verify:handwritten": "node scripts/verify-handwritten.mjs",
+    "verify:shape": "node scripts/verify-shape.mjs",
+    "render:group": "node scripts/render-group.mjs",
     "eval:skills": "node scripts/eval-skills-score.mjs"
   }
 }

package/scripts/audit-manual-facts.mjs

@@ -64,6 +64,8 @@ const vLines = src.verify.split(/\r?\n/)
 const codes = new Map()
 vLines.forEach((line, i) => {
   if (/\b(?:let|const|var)\s+code\s*=/.test(line)) return
+  // 阶段 A（2026-09-28）：本行**显式**写了非 error 的 severity ⇒ 不是错误码（同上，避免被上 3 行的 'error' 误收）
+  if (/severity\s*[:=]\s*'(?:warning|confirmed|suggestion|info)'/.test(line)) return
   for (const m of line.matchAll(/code\s*[:=]\s*'([a-z-]+)'/g)) {
     const w = vLines.slice(Math.max(0, i - 3), i + 1).join('\n')
     codes.set(m[1], /'error'/.test(w) ? 'error' : 'warn|suggest')
@@ -84,8 +86,10 @@ for (const c of ['density', 'hotspot', 'near-align']) {
 const conformanceMode = src.verify.match(/severity: mode === 'strict' \? 'error' : 'warning',\s*\n?\s*code: 'theme-conformance'/)
 check('theme-conformance：strict=error / suggest=warning / off=跳过（手册如此描述）', !!conformanceMode, 'verify.js themeConformance(): severity 随 mode 切换；无 colors 自动跳过')
 
-const lineValidator = src.schema.match(/仅支持 2 点 \[\[x1,y1\],\[x2,y2\]\]/)
-check('line 只支持两点（手册已写明，拆成多条 line）', !!lineValidator, `schema.js validateLine: ${(lineValidator?.[0] ?? '未找到').slice(0, 60)}`)
+// 阶段 A（2026-09-28）事实更新：line 不再"只支持两点"——>2 点折线已支持（导出为 custGeom 开放路径），
+// 非法点列（<2 点/非数字）仍显式报错。手册必须写新事实。
+const lineValidator = src.schema.match(/至少 2 点、每点两个有限数字/)
+check('line 支持 ≥2 点折线（手册已写明；非法点列仍报错）', !!lineValidator, `schema.js validateLine: ${(lineValidator?.[0] ?? '未找到').slice(0, 60)}`)
 
 const tableKeys = src.schema.match(/table: \['cols', 'rows', 'header'\]/)
 check('table 只有 cols/rows/header（手册"没有逐列对齐字段"成立）', !!tableKeys, `schema.js ELEMENT_KEYS: ${tableKeys?.[0] ?? '未找到'}`)
@@ -177,7 +181,15 @@ const dirG = join(tmp, 'g-3pts-line')
 await writeDeck(dirG, ['  - elementId: poly', '    elementType: line', '    points: [[10, 10], [50, 30], [90, 10]]'])
 let badLine = null
 try { await resolveDeck(dirG) } catch (e) { badLine = e }
-check('运行时：三点折线被拒（手册"每条只有两点"成立）', !!badLine && /2 点/.test(badLine.messages?.join(';') ?? ''), (badLine?.messages ?? []).join('; ').slice(0, 120) || '竟然通过了')
+// 阶段 A（2026-09-28）事实更新：三点折线**被接受**（导出为 custGeom 开放路径）；手册已改写。
+// 同时钉住反面：**一点**折线仍必须报错（"≥2 点"这条下限不能丢）。
+const dirG2 = join(tmp, 'g-1pt-line')
+await writeDeck(dirG2, ['  - elementId: dot', '    elementType: line', '    points: [[10, 10]]'])
+let onePt = null
+try { await resolveDeck(dirG2) } catch (e) { onePt = e }
+check('运行时：三点折线被接受、一点折线被拒（手册"≥2 点，>2 点为折线"成立）',
+  badLine === null && !!onePt && /至少 2 点/.test(onePt.messages?.join(';') ?? ''),
+  `三点=${badLine ? `被拒(${(badLine.messages ?? []).join('; ').slice(0, 60)})` : '通过'}｜一点=${onePt ? '被拒' : '竟然通过'}`)
 
 const dirH = join(tmp, 'h-notes')
 await mkdir(join(dirH, 'pages'), { recursive: true })

package/scripts/bench-diagram-scale.mjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * 150 元素规模基线（阶段 A 硬门槛之一，docs/08 §8）：`node scripts/bench-diagram-scale.mjs`
+ *
+ * 为什么单独一个脚本而不是塞进 smoke：**计时断言在 CI 上必然抖动**（共享 runner、冷启动），
+ * 把抖动带进门禁会让"红"失去意义。所以这里做"可复跑的量化基线"，把数字写进 docs/02，
+ * 由人在批次边界核对；门槛不达标时退出码 1。
+ *
+ * 门槛（初值，docs/08 §8）：verify ≤ 3s｜预览 HTML ≤ 1.5MB｜单页总处理 ≤ 10s
+ *
+ * 夹具刻意**用满阶段 A 的新能力**：1 容器 + 40 盒（各自 contains 自己的标签）+ 68 文本 + 20 线
+ * （8 条 attach、6 条 3 点折线、6 条双箭头）+ 1 徽章 + 5 组（含一层嵌套）+ 2 条有意重叠声明
+ * + 1 处 role 覆盖（带 roleReason）——即"最坏情况"的形状：关系多、交叉检查多、报告段最长。
+ */
+import { performance } from 'node:perf_hooks'
+import { mkdirSync, writeFileSync, readFileSync, rmSync, statSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { resolveDeck } from '../lib/pptd/schema.js'
+import { renderDeck } from '../lib/pptd/render-html.js'
+import { analyzePage, verifyDeck } from '../lib/verify.js'
+import { deriveRelations, checkDiagram } from '../lib/pptd/relations.js'
+import { exportPptx } from '../lib/pptd/export-pptx.js'
+
+const WORK = join(tmpdir(), `pptd-bench-scale-${Date.now()}`)
+rmSync(WORK, { recursive: true, force: true })
+mkdirSync(join(WORK, 'pages'), { recursive: true })
+
+// ── 造 150 个元素 ────────────────────────────────────────────────────────────
+const COLORS = ['#2563EB', '#0EA5E9', '#F59E0B', '#10B981', '#EF4444', '#7C3AED']
+const els = []
+const groups = []
+const boxIds = []
+let n = 0
+const push = (el) => { els.push(el); n++; return el.elementId }
+
+// 1 个容器（覆盖下面所有"内容"：盒子/标签/线/注记都在它内部 ⇒ 都能被 contains（含传递闭包）结构豁免）
+push({ elementId: 'zone', elementType: 'shape', kind: 'roundRect', bounds: [20, 20, 920, 500], fill: '#F8FAFC', role: 'background' })
+// 40 个盒子 + 40 个标签（标签贴在盒子内部下缘，盒子声明 contains 自己的标签）
+const lineIds = []
+const noteIds = []
+for (let j = 0; j < 4; j++) {
+  const row = []
+  for (let i = 0; i < 10; i++) {
+    const x = 50 + i * 88
+    const y = 45 + j * 105
+    const id = `box_${j}_${i}`
+    push({ elementId: id, elementType: 'shape', kind: 'roundRect', bounds: [x, y, 76, 56], fill: COLORS[(i + j) % COLORS.length], line: { color: '#1F2937', width: 1 } })
+    push({ elementId: `lbl_${j}_${i}`, elementType: 'text', bounds: [x + 4, y + 30, 68, 22], content: { text: `节点${j}${i}`, style: 'body' }, role: 'content' })
+    // 盒子包含自己的标签（结构关系 ⇒ 盒子×标签 的重叠被豁免，而不是逐对写 expectedOverlaps）
+    // 注意：push 了两个元素之后，**盒子**的数组下标是 length-2（length-3 会指到上一个标签——写夹具时踩过）
+    els[els.length - 2].contains = [`lbl_${j}_${i}`]
+    row.push(id)
+    boxIds.push(id)
+  }
+  groups.push({ id: `g_row${j}`, label: `第 ${j} 行`, members: row })
+}
+groups.push({ id: 'g_all', label: '整块', members: ['g_row0', 'g_row1', 'g_row2', 'g_row3'] })
+
+// 20 条线：8 条 attach（行内相邻盒子右→左）、6 条 3 点折线（落在盒子行之间的水平间隙里）、6 条双箭头
+for (let k = 0; k < 8; k++) {
+  const j = k % 4
+  const i = k % 9
+  const x1 = 50 + i * 88 + 76
+  const x2 = 50 + (i + 1) * 88
+  const y = 45 + j * 105 + 28
+  const id = `ln_a${k}`
+  push({ elementId: id, elementType: 'line', points: [[x1, y], [x2, y]], arrow: 'end', attach: { from: { ref: `box_${j}_${i}`, side: 'right' }, to: { ref: `box_${j}_${i + 1}`, side: 'left' } }, line: { color: '#1F2937', width: 1 } })
+  lineIds.push(id)
+}
+// 折线落在盒子左侧外沿（x=40..45，盒子从 x=50 起 ⇒ 不与盒子相交），高度取行间间隙（不与盒子重叠）
+for (let k = 0; k < 6; k++) {
+  const y = [128, 140, 233, 245, 338, 350][k]
+  const id = `ln_p${k}`
+  push({ elementId: id, elementType: 'line', points: [[40, y], [45, y], [45, y - 6]], arrow: 'both', line: { color: '#7C3AED', width: 1, dash: 'dash' } })
+  lineIds.push(id)
+}
+for (let k = 0; k < 6; k++) {
+  const x = 60 + k * 140
+  const id = `ln_b${k}`
+  // y=423：落在最后一行盒子（底 416）与注记带（430 起）之间的空隙、容器内 ⇒ 与两者都不相交
+  push({ elementId: id, elementType: 'line', points: [[x, 423], [x + 60, 423]], arrow: 'both', line: { color: '#EF4444', width: 1 } })
+  lineIds.push(id)
+}
+// 1 个徽章（压在容器顶边，声明归属）
+push({ elementId: 'chip', elementType: 'shape', kind: 'roundRect', bounds: [60, 6, 120, 28], fill: '#1F2937', badgeOf: 'zone', roleReason: '标题胶囊压在容器顶边' })
+// 注记补齐到 150：12 列 × 4 行网格（宽 70 < 间距 76 ⇒ 互不重叠；全在容器内 ⇒ 可被 contains 传递闭包豁免）
+for (let r = 0; r < 4; r++) {
+  for (let i = 0; i < 12; i++) {
+    const id = `note_${r}_${i}`
+    push({ elementId: id, elementType: 'text', bounds: [30 + i * 76, 430 + r * 22, 70, 22], content: { text: `注${r}${i}`, style: 'body' } })
+    noteIds.push(id)
+  }
+}
+// 容器包含**所有**内部内容（盒子、线、注记）——这才是"容器"的语义；标签由各自的盒子声明
+els.find((e) => e.elementId === 'zone').contains = [...boxIds, ...lineIds, ...noteIds]
+
+const pageYaml = ['pageType: content', 'groups:', ...groups.flatMap((g) => [`  - id: ${g.id}`, `    label: ${g.label}`, `    members: [${g.members.join(', ')}]`]),
+  'expectedOverlaps:', '  - pair: [chip, zone]', '    reason: "徽章压在容器顶边（设计意图）"',
+  'elements:', ...els.map((e) => {
+    const lines = [`  - elementId: ${e.elementId}`, `    elementType: ${e.elementType}`]
+    if (e.bounds) lines.push(`    bounds: [${e.bounds.join(', ')}]`)
+    if (e.kind) lines.push(`    kind: ${e.kind}`)
+    if (e.fill) lines.push(`    fill: "${e.fill}"`)
+    if (e.line) lines.push(`    line: {color: "${e.line.color}", width: ${e.line.width}${e.line.dash ? `, dash: ${e.line.dash}` : ''}}`)
+    if (e.points) lines.push(`    points: [${e.points.map((p) => `[${p.join(', ')}]`).join(', ')}]`)
+    if (e.arrow) lines.push(`    arrow: ${typeof e.arrow === 'string' ? `'${e.arrow}'` : e.arrow}`)
+    if (e.attach) lines.push(`    attach: {from: {ref: ${e.attach.from.ref}, side: ${e.attach.from.side}}, to: {ref: ${e.attach.to.ref}, side: ${e.attach.to.side}}}`)
+    if (e.role) lines.push(`    role: ${e.role}`)
+    if (e.roleReason) lines.push(`    roleReason: "${e.roleReason}"`)
+    if (e.badgeOf) lines.push(`    badgeOf: ${e.badgeOf}`)
+    if (e.contains) lines.push(`    contains: [${e.contains.join(', ')}]`)
+    if (e.content) lines.push(`    content: {text: "${e.content.text}", style: ${e.content.style}}`)
+    return lines.join('\n')
+  }), ''].join('\n')
+writeFileSync(join(WORK, 'deck.yaml'), ['version: 1', 'title: bench-150', 'size: [960, 540]', 'theme:',
+  `  colors: {primary: "#2563EB", text: "#1F2937"${COLORS.map((c, i) => `, c${i}: "${c}"`).join('')}}`, '  textStyles:',
+  '    body: {fontSize: 12, color: "$text"}', 'pages:', '  - pages/01.yaml', ''].join('\n'))
+writeFileSync(join(WORK, 'pages', '01.yaml'), pageYaml)
+
+// ── 计时 ────────────────────────────────────────────────────────────────────
+const t = async (fn) => { const t0 = performance.now(); const v = await fn(); return { ms: performance.now() - t0, v } }
+const out = {}
+const size = { width: 960, height: 540 }
+
+const A = await t(() => resolveDeck(WORK)); out.resolveDeck = A.ms
+const ctx = A.v
+// 注意：renderDeck 的 `out` 是**相对 deck 目录**的相对路径（与 exportPptx 的绝对路径语义不同）
+const B = await t(() => renderDeck(ctx, { out: 'preview' })); out.renderDeck = B.ms
+const previewDir = join(WORK, 'preview')
+const layoutPath = join(previewDir, 'layout.json')
+const layout = JSON.parse(readFileSync(layoutPath, 'utf8'))
+const page = layout.pages[0]
+const C = await t(() => analyzePage(page, size)); out.analyzePage = C.ms
+const D = await t(() => deriveRelations(page)); out.deriveRelations = D.ms
+const E = await t(() => checkDiagram(page)); out.checkDiagram = E.ms
+const F = await t(() => verifyDeck(layout)); out.verifyDeck = F.ms
+const G = await t(() => exportPptx(ctx, { out: join(WORK, 'out.pptx') })); out.exportPptx = G.ms
+const htmlBytes = readdirSync(previewDir).filter((f) => f.endsWith('.html'))
+  .reduce((a, f) => a + statSync(join(previewDir, f)).size, 0)
+out.previewHtmlBytes = htmlBytes
+out.totalMs = out.resolveDeck + out.renderDeck + out.analyzePage + out.verifyDeck + out.exportPptx
+
+const TH = { verify: 3000, html: 1.5 * 1024 * 1024, total: 10000 }
+const checks = [
+  ['元素数 = 150（夹具自证）', layout.pages[0].elements.length === 150, `elements=${layout.pages[0].elements.length}`],
+  ['关系推导无错误（夹具自证：结构声明全部成立）', D.v.errors.length === 0, D.v.errors.length ? `${D.v.errors.length} 条，前 3 条：${D.v.invalid.slice(0, 3).map((x) => `${x.type}:${x.from}→${x.to}:${x.why}`).join('｜')}` : '无'],
+  ['结构关系被真的用到（组/包含/附着/徽章）', D.v.stats.groups === 5 && D.v.stats.contains >= 40 && D.v.stats.attach === 16 && D.v.stats.badge === 1, JSON.stringify(D.v.stats)],
+  [`verify 用时 ≤ ${TH.verify}ms`, out.verifyDeck <= TH.verify, `${out.verifyDeck.toFixed(1)}ms`],
+  [`预览 HTML ≤ ${(TH.html / 1024 / 1024).toFixed(1)}MB`, htmlBytes <= TH.html, `${(htmlBytes / 1024).toFixed(0)}KB`],
+  [`单页总处理 ≤ ${TH.total}ms`, out.totalMs <= TH.total, `${out.totalMs.toFixed(1)}ms`],
+]
+let fail = 0
+console.log('==== 150 元素规模基线（阶段 A 硬门槛）====')
+for (const [name, ok, detail] of checks) { if (!ok) fail++; console.log(`${ok ? '✓' : '✗'} ${name} — ${detail}`) }
+console.log('\n耗时明细（ms）: ' + JSON.stringify(Object.fromEntries(Object.entries(out).filter(([k]) => k.endsWith('Ms') || k === 'htmlBytes').map(([k, v]) => [k, typeof v === 'number' ? Math.round(v * 10) / 10 : v]))))
+console.log('报告规模（行数）:', F.v.text.split('\n').length, '｜错误/警告:', F.v.errors.length, '/', F.v.warns.length)
+// 错误码直方图（基线必须能解释每一个错误：干净夹具应当趋近 0，否则说明夹具自身有真冲突）
+const hist = (list) => [...list.reduce((m, f) => m.set(f.code, (m.get(f.code) ?? 0) + 1), new Map())]
+  .sort((a, b) => b[1] - a[1]).slice(0, 6).map(([c, n]) => `${c}×${n}`).join('｜')
+console.log('错误码前 6:', hist(F.v.errors) || '无')
+console.log('警告码前 6:', hist(F.v.warns) || '无')
+rmSync(WORK, { recursive: true, force: true })
+if (fail) { console.log(`\n✗ ${fail} 项未达门槛——按 docs/08 §8 需先优化再进入下一阶段`); process.exit(1) }
+console.log('\n✓ 全部达标')

package/scripts/check-generators.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/**
+ * 生成器检查网：`examples/hand-drawn/gen/*.cjs` 全部过 `node --check`。
+ *
+ * 为什么需要：生成器**不在** `npm test` 网内 ⇒ 一个语法/TDZ 级错误（实测：参数化时写成
+ * `… || PPTX` 自引用 ⇒ 缺省路径必崩）能躲过所有测试，直到某次真跑才炸。
+ * 这里只做静态检查（快、无副作用）；缺省路径的**运行时**检查由 `verify:handdrawn` 等覆盖。
+ */
+import { execFileSync } from 'node:child_process'
+import { readdirSync } from 'node:fs'
+import { join } from 'node:path'
+
+const ROOT = new URL('..', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')
+const DIR = join(ROOT, 'examples', 'hand-drawn', 'gen')
+const files = readdirSync(DIR).filter((f) => f.endsWith('.cjs')).sort()
+let bad = 0
+for (const f of files) {
+  try { execFileSync('node', ['--check', join(DIR, f)], { stdio: 'pipe' }) }
+  catch (e) { bad++; console.log('  ✗ 语法错误：' + f + '\n' + String(e.stderr ?? '').split('\n').slice(0, 4).join('\n')) }
+}
+console.log('生成器检查网：' + files.length + ' 个脚本｜语法错 ' + bad + ' 个' + (bad === 0 ? ' ✓' : ''))
+process.exit(bad === 0 ? 0 : 1)

package/scripts/check-lib-sync.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/**
+ * lib ⟷ src 一致性守卫。
+ * 为什么必须有：`package.json` 的 files 白名单**只发 lib**（main = ./lib/index.js），且没有 prepack 钩子
+ * ⇒ 一旦 lib 与 src 不同步（漏 build / 半途改 src），**装出来的包就是错的**。
+ * 判据：文件集合相同 + 逐字节相同。
+ */
+import { readdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { createHash } from 'node:crypto'
+
+const ROOT = new URL('..', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')
+const walk = (base) => {
+  const out = []
+  const rec = (dir, rel) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const r = rel ? rel + '/' + e.name : e.name
+      if (e.isDirectory()) rec(join(dir, e.name), r)
+      else out.push(r)
+    }
+  }
+  rec(join(ROOT, base), '')
+  return out.sort()
+}
+const sha = (p) => createHash('sha256').update(readFileSync(p)).digest('hex')
+const a = walk('src'), b = walk('lib')
+const onlySrc = a.filter((f) => !b.includes(f))
+const onlyLib = b.filter((f) => !a.includes(f))
+const differ = a.filter((f) => b.includes(f) && sha(join(ROOT, 'src', f)) !== sha(join(ROOT, 'lib', f)))
+console.log('lib ⟷ src：src ' + a.length + ' 个 / lib ' + b.length + ' 个｜仅 src ' + onlySrc.length + '｜仅 lib ' + onlyLib.length + '｜字节不同 ' + differ.length)
+for (const f of [...onlySrc.map((x) => '仅 src: ' + x), ...onlyLib.map((x) => '仅 lib: ' + x), ...differ.map((x) => '字节不同: ' + x)].slice(0, 12)) console.log('   · ' + f)
+if (onlySrc.length || onlyLib.length || differ.length) { console.log('✗ lib 与 src 不一致 ⇒ 先跑 node scripts/build.mjs 并提交（files 只发 lib，装出来会是错的）'); process.exit(1) }
+console.log('✓ lib 与 src 完全一致（files 只发 lib ⇒ 这一步守住"装出来等于仓库"）')

package/scripts/check-line-text.mjs

@@ -0,0 +1,30 @@
+/**
+ * 线 × 文字检查的单元证据（先红后绿）
+ *   ① 穿过文字 ⇒ 必须报 line-cross-text
+ *   ② 不穿过  ⇒ 必须沉默
+ *   ③ 声明刻意穿过(roleReason) ⇒ 必须沉默（豁免有效）
+ * 用法：node scripts/check-line-text.mjs
+ */
+import { checkLineText } from '../src/pptd/line-text-rule.js'
+
+const line = { elementType: 'line', elementId: 'life', points: [[100, 0], [100, 100]] }
+const over = { elementType: 'text', elementId: 'lab', bounds: [80, 40, 60, 24] }
+const clear = { elementType: 'text', elementId: 'lab2', bounds: [200, 40, 60, 24] }
+
+const a = checkLineText([line, over])
+const b = checkLineText([line, clear])
+const c = checkLineText([{ ...line, roleReason: '刻意穿过示意' }, over])
+
+const rows = [
+  ['① 穿过文字 ⇒ 报错', a.length === 1 && a[0].code === 'line-cross-text', a.length ? a[0].message : '(未报)'],
+  ['② 不穿过 ⇒ 沉默', b.length === 0, '命中 ' + b.length],
+  ['③ 声明刻意穿过 ⇒ 沉默', c.length === 0, '命中 ' + c.length],
+]
+let bad = 0
+console.log('线×文字检查单元证据：')
+for (const [name, ok, detail] of rows) {
+  if (!ok) bad++
+  console.log('  ' + (ok ? '✓' : '✗') + ' ' + name.padEnd(22) + ' ' + detail)
+}
+console.log('==== ' + (bad === 0 ? '全部通过' : bad + ' 项未通过') + ' ====')
+process.exit(bad === 0 ? 0 : 1)

package/scripts/check-package.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * 打包与安装一致性（P3）。本机专用，不进 npm test（要 npm pack + 真实安装）。
+ * ① npm pack 出 tarball ⇒ 断言必含发行所需目录/文件；
+ * ② 装到干净临时目录 ⇒ require 入口可用；
+ * ③ 扫描装出的树 ⇒ 不得含已移除方案痕迹；手画回归语料不入包。
+ * 注：Windows 上 npm/tar 是垫片 ⇒ 一律 execSync（shell），不用 execFileSync('npm')（会 ENOENT）。
+ */
+import { execSync } from 'node:child_process'
+import { readdirSync, readFileSync, writeFileSync, statSync, mkdtempSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+const ROOT = new URL('..', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')
+const tmp = mkdtempSync(join(tmpdir(), 'pptd-pkg-'))
+const MUST = ['package/package.json', 'package/README.md', 'package/cordis.patch.yml']
+const MUSTDIR = ['package/lib', 'package/skills', 'package/agent-presets', 'package/docs', 'package/templates']
+const TERM = /图族|diagram-families|diagram-ir|FAMILIES|d1_|diagram:|diagram\.style|layoutDiagram|validateDiagram|图编译/
+
+console.log('… ① npm pack')
+const out = execSync('npm pack --pack-destination "' + tmp + '"', { cwd: ROOT, encoding: 'utf8' }).trim()
+const tgz = join(tmp, out.split('\n').pop().trim())
+console.log('   ' + tgz.split(/[\\/]/).pop() + '（' + Math.round(statSync(tgz).size / 1024) + ' KB）')
+const list = execSync('tar -tzf "' + tgz + '"', { encoding: 'utf8' }).replace(/\r/g, '').split('\n').filter(Boolean)
+let bad = 0
+for (const m of MUST) if (!list.includes(m)) { console.log('   ✗ 缺 ' + m); bad++ }
+for (const d of MUSTDIR) if (!list.some((l) => l.startsWith(d + '/'))) { console.log('   ✗ 缺目录 ' + d); bad++ }
+if (list.some((l) => l.startsWith('package/examples/hand-drawn'))) { console.log('   ✗ 手画回归语料竟被打包'); bad++ }
+if (list.some((l) => l.startsWith('package/src/'))) { console.log('   ✗ src 被打包（应只发 lib）'); bad++ }
+console.log('   包内文件 ' + list.length + ' 个｜必需项 ' + (bad ? '✗ ' + bad + ' 项不符' : '✓ 全部存在'))
+if (bad) process.exit(1)
+
+console.log('… ② 装到干净临时目录并 require 入口')
+const inst = join(tmp, 'inst')
+execSync('mkdir "' + inst + '"', { shell: 'cmd.exe' })
+writeFileSync(join(inst, 'package.json'), '{"name":"pkgtest","private":true}\n')
+execSync('npm install --no-save --silent "' + tgz + '"', { cwd: inst, stdio: 'inherit' })
+const entry = join(inst, 'node_modules', 'dsh-ppt-studio', 'lib', 'index.js')
+if (!existsSync(entry)) { console.log('   ✗ 入口不存在：' + entry); process.exit(1) }
+const keys = execSync('node -e "const m=require(process.argv[1]);console.log(Object.keys(m).join(String.fromCharCode(32)))" "' + entry + '"', { encoding: 'utf8' }).trim()
+const kn = keys ? keys.split(/\s+/).length : 0
+console.log('   ✓ require 可用，导出 ' + kn + ' 项：' + (keys ? keys.split(/\s+/).slice(0, 10).join(' ') : '') + (kn > 10 ? ' …' : ''))
+
+console.log('… ③ 装出的树里不得含已移除方案的痕迹')
+const hits = []
+const walk = (d) => {
+  for (const e of readdirSync(d, { withFileTypes: true })) {
+    const p = join(d, e.name)
+    if (/\.(png|jpg|pptx|tgz|zip)$/.test(e.name)) continue
+    if (e.name === 'check-package.mjs' || e.name === 'check-removed-traces.mjs') continue // 本文件自带该词表(检查器自指), 不算痕迹
+    if (e.isDirectory()) walk(p)
+    else if (/\.(js|mjs|cjs|md|ya?ml|json|txt)$/.test(e.name)) {
+      readFileSync(p, 'utf8').split('\n').forEach((l, i) => { if (TERM.test(l)) hits.push(p.replace(inst + '/', '') + ':' + (i + 1)) })
+    }
+  }
+}
+walk(join(inst, 'node_modules', 'dsh-ppt-studio'))
+console.log('   命中 ' + hits.length + ' 处' + (hits.length ? '（' + hits.slice(0, 5).join(', ') + '）' : ' ✓'))
+if (hits.length) process.exit(1)
+console.log('==== 打包与安装一致性：通过 ====')

package/scripts/check-removed-traces.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+/**
+ * 可见文本痕迹守卫：仓库里不得残留"已移除的开发期方案"的任何字样（含根目录、templates、agent-presets 等）。
+ *
+ * 为什么固化成脚本：这条判据此前用的是临时脚本，且一度只扫 6 个目录、还出现过"检查器扫到自己"的假阳性。
+ * 允许清单（**唯一**允许出现这些字样之处，且都在代码里作为**禁词表**本身）：
+ *   · scripts/check-removed-traces.mjs（本文件）
+ *   · scripts/check-package.mjs（打包检查的词表）
+ * 用法：node scripts/check-removed-traces.mjs
+ */
+import { readdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const ROOT = new URL('..', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')
+const TERM = /图族|diagram-families|diagram-ir|FAMILIES|d1_|diagram:|diagram\.style|layoutDiagram|validateDiagram|图编译/
+const ALLOW = new Set(['scripts/check-removed-traces.mjs', 'scripts/check-package.mjs'])
+const SKIPDIR = /(^|\/)(\.git|node_modules|preview|\.tmp[^/]*)$/
+const EXT = /\.(js|mjs|cjs|md|ya?ml|json|txt|yml)$/
+
+const hits = []
+const walk = (rel) => {
+  for (const e of readdirSync(join(ROOT, rel), { withFileTypes: true })) {
+    const r = rel ? rel + '/' + e.name : e.name
+    if (SKIPDIR.test(r)) continue
+    if (e.isDirectory()) { walk(r); continue }
+    if (!EXT.test(e.name)) continue
+    if (ALLOW.has(r)) continue
+    const p = join(ROOT, r)
+    let t = ''
+    try { t = readFileSync(p, 'utf8') } catch { continue }
+    t.split('\n').forEach((l, i) => { if (TERM.test(l)) hits.push(r + ':' + (i + 1) + ' ' + l.trim().slice(0, 80)) })
+  }
+}
+walk('')
+console.log('可见文本痕迹扫描：命中 ' + hits.length + ' 处' + (hits.length ? '' : ' ✓'))
+for (const h of hits.slice(0, 12)) console.log('   · ' + h)
+process.exit(hits.length ? 1 : 0)

package/scripts/check-syntax.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+/**
+ * 语法体检（廉价跨切面守卫）：`node scripts/check-syntax.mjs`
+ *
+ * 为什么单列一条：本会话在 `SCHEMA_REF`（模板字符串）里写**行内反引号**踩了四次——
+ * 每次都是"文件直接解析失败 ⇒ 全链路崩"，但只看 exit code 容易漏读报错内容。
+ * 这条守卫把"所有源文件至少能解析"变成 1–2 秒内可得的确定结论。
+ *
+ * 覆盖：`src/**\/*.js`、`lib/**\/*.js`、`scripts/*.mjs`（跳过 node_modules 与临时目录）。
+ */
+import { readdirSync, statSync } from 'node:fs'
+import { join, extname, relative } from 'node:path'
+import { execFileSync } from 'node:child_process'
+
+const root = join(import.meta.dirname, '..')
+
+function walk(dir, out = []) {
+  for (const name of readdirSync(dir).sort()) {
+    if (name === 'node_modules' || name.startsWith('.')) continue
+    const p = join(dir, name)
+    const st = statSync(p)
+    if (st.isDirectory()) walk(p, out)
+    else if (['.js', '.mjs'].includes(extname(name))) out.push(p)
+  }
+  return out
+}
+
+const files = [...walk(join(root, 'src')), ...walk(join(root, 'lib')), ...walk(join(root, 'scripts'))]
+const bad = []
+for (const f of files) {
+  try {
+    execFileSync(process.execPath, ['--check', f], { stdio: 'pipe' })
+  } catch (e) {
+    const msg = String(e.stderr ?? e.message ?? '').split('\n').filter((l) => l.trim()).slice(0, 3).join(' / ')
+    bad.push(`${relative(root, f)}: ${msg.slice(0, 200)}`)
+  }
+}
+if (bad.length) {
+  console.log(`✗ 语法体检：${bad.length} 个文件解析失败`)
+  for (const b of bad) console.log(`  · ${b}`)
+  console.log('  提示：模板字符串里出现行内反引号是历史高频坑（SCHEMA_REF 等长文本块）。')
+  process.exit(1)
+}
+console.log(`✓ 语法体检：${files.length} 个源文件全部通过 node --check`)