sillyspec 3.27.2 → 3.27.6

package/.claude/worktrees/sillyspec-data-model-research/src/change-list.js

@@ -0,0 +1,290 @@
+import { readFileSync, existsSync } from 'fs'
+
+/**
+ * 路径项归一化：去反引号、去行内括号注释（`src/foo.js (新增)` / `src/foo.js（说明）`）、
+ * 统一为正斜杠、去首尾空白与尾部斜杠。
+ * design 清单 cell 与 task allowed_paths 共用此归一化（两处写法都可能带注释/反引号）。
+ * @param {string} raw
+ * @returns {string}
+ */
+export function normalizePath(raw) {
+  if (!raw) return ''
+  return raw
+    .replace(/`/g, '')
+    .replace(/\s*（[^）]*）\s*$/, '')
+    .replace(/\s*\([^)]*\)\s*$/, '')
+    .replace(/\\/g, '/')
+    .replace(/\/+$/, '')
+    .trim()
+}
+
+/**
+ * 组合路径单元格拆分（坑 design-combined-cell-mismatch，2026-08-22 实证："router.py + service.py"
+ * 一行两文件整体当单路径，字面匹配对账不过）。拆分符：+ 、 ／ | ; ；——每 token 独立校验
+ * （looksLikePath 不过的丢弃，防自由文本混入）；无分隔符返回单元素数组（零变化）。
+ * 不含空白要求（"a.py+b.py" 与 "a.py + b.py" 都拆）。
+ * @param {string} cell 路径单元格（normalizePath 后）
+ * @returns {string[]}
+ */
+function splitCombinedPaths(cell) {
+  const raw = String(cell || '').trim()
+  if (!raw) return []
+  const tokens = raw.split(/\s*[+|；;、]\s*|／/).map(t => t.trim()).filter(Boolean)
+  const valid = tokens.filter(t => !isPlaceholder(t) && looksLikePath(t) && !t.startsWith('.sillyspec/'))
+  return valid.length > 0 ? valid : (looksLikePath(raw) ? [raw] : [])
+}
+
+/**
+ * glob → 正则：双星（globstar）跨零或多段目录（含零段，bash 语义）、
+ * 单星 → 单段（[^/]*）、问号 → 单字符（[^/]），其余转义。
+ * pattern 不含通配符时返回 false（调用方先用完全相等判断）。
+ * 不支持字符类（design/allowed_paths 实际不写，遇方括号按字面转义）。
+ * @param {string} str
+ * @param {string} pattern
+ * @returns {boolean}
+ */
+export function globMatch(str, pattern) {
+  if (!/[*?]/.test(pattern)) return false
+  let re = '^'
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i]
+    if (ch === '*') {
+      if (pattern[i + 1] === '*') {
+        // ** 跨零或多段：吞掉紧随的 /，输出 (?:.*/)? 让 src/**/a.js 也能匹配 src/a.js
+        if (pattern[i + 2] === '/') { re += '(?:.*/)?'; i += 2 }
+        else { re += '.*'; i++ }
+      } else {
+        re += '[^/]*'
+      }
+    } else if (ch === '?') {
+      re += '[^/]'
+    } else {
+      re += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    }
+  }
+  re += '$'
+  try { return new RegExp(re).test(str) } catch { return false }
+}
+
+/**
+ * 双向容差匹配：design 清单文件 vs task allowed_paths（或脏文件 vs 清单）。
+ * 命中条件（任一）：完全相等 / 目录前缀包含（双向）/ glob 通配（双向）。
+ * @param {string} a
+ * @param {string} b
+ * @returns {boolean}
+ */
+export function pathMatches(a, b) {
+  a = normalizePath(a)
+  b = normalizePath(b)
+  if (!a || !b) return false
+  if (a === b) return true
+  if (a.startsWith(b + '/') || b.startsWith(a + '/')) return true
+  if (globMatch(a, b) || globMatch(b, a)) return true
+  return false
+}
+
+/**
+ * 「文件变更清单」章节标题同义词（与 src/stage-contract.js 的识别集对齐，
+ * 避免两个校验器对「有没有清单」给出矛盾结论）。
+ * 容忍可选编号前缀（`## 6. 文件变更清单` / `## 6) 文件变更清单`）——
+ * brainstorm Step11 模板鼓励 design 章节带编号，编号前缀不应让 plan-postcheck 解析失败。
+ */
+const FILE_LIST_SECTION_RE = /^#{2,3}\s*(?:\d+[.)]\s*)?(文件变更清单|变更文件清单|文件清单|File Changes|Files to Change)/im
+
+/**
+ * exclude 子标题词集：「不修改/暂缓/保留」类 —— 其下路径从清单移除，不强制 task 覆盖。
+ * 用排除集而非白名单：容忍「改动/变更/涉及」等近义 include 写法。
+ */
+const EXCLUDE_SUBSECTION_RE = /不修改|不变|保留|无变更|未变更|不改动|暂不|暂缓|暂定|待定|后续|未改|无需|不涉及/
+
+/**
+ * operation 词→归一化标签。design 清单「操作」列 cell 与分类列表子标题共用。
+ * 用途：verify 删除探针对账——声明「新增/修改」却整文件删除 = 高风险信号。
+ */
+const OP_KEYWORDS = [
+  { re: /^(新增|新建|创建|添加|add|new|create)$/i, op: '新增' },
+  { re: /^(修改|更新|调整|改动|变更|重写|modify|update|change)$/i, op: '修改' },
+  { re: /^(删除|移除|去掉|remove|delete|drop)$/i, op: '删除' },
+  { re: /^(重命名|改名|rename|move)$/i, op: '重命名' },
+]
+function classifyOperation(raw) {
+  if (!raw) return null
+  const hit = OP_KEYWORDS.find(k => k.re.test(raw.trim()))
+  return hit ? hit.op : null
+}
+
+/**
+ * 分类列表子标题 → operation（`### 删除文件` → '删除'）。不命中返回 null。
+ * ⚠️ 调用方必须先判 EXCLUDE_SUBSECTION_RE：「### 不修改文件」含「修改」二字，
+ *    会被此处误匹配为「修改」——exclude 永远优先，命中 exclude 不跑 OP 映射。
+ */
+const OP_SUBSECTION_RE = [
+  { re: /新增|新建|创建/, op: '新增' },
+  { re: /修改|更新|改动|重写/, op: '修改' },
+  { re: /删除|移除|去掉/, op: '删除' },
+  { re: /重命名|改名/, op: '重命名' },
+]
+function classifySubsectionOp(title) {
+  const hit = OP_SUBSECTION_RE.find(k => k.re.test(title))
+  return hit ? hit.op : null
+}
+
+/** 表头列定位：cell 整体匹配操作类列名（与 isPathHeaderCell 对偶，用于定位 operation 列） */
+function isOperationHeaderCell(c) {
+  return /^(操作|类型|变更类型|改动类型|变更|operation|type|action|op)$/i.test(c)
+}
+
+function isPlaceholder(p) {
+  return !p || p === '—' || p === '-' || /^(n\/?a|无|none|-+)$/i.test(p)
+}
+
+/** 表头列定位：cell 整体匹配路径类词 */
+function isPathHeaderCell(c) {
+  return /^(文件路径|文件名|文件|路径|filepath|filename|file\s*path|path)$/i.test(c)
+}
+
+/**
+ * 路径合理性兜底：合法路径必含目录分隔 `/` 或扩展名点；
+ * 两者皆无时仅保留纯 ASCII 单词 token（Dockerfile / Makefile / LICENSE 这类无扩展名文件名），
+ * 丢弃含空格/中文的脏描述（如 design 表格第二列误写的「frontend 组件测试」「后端逻辑」）。
+ * 防止把自由文本当路径计入 fileCount，虚高 review-tier 分级（误推 independent）。
+ */
+function looksLikePath(p) {
+  if (!p) return false
+  if (p.includes('/') || p.includes('.')) return true
+  return /^[\w@-]+$/.test(p)
+}
+
+/**
+ * 「顺带修复」标记：design §6 清单里标注的、不属本次变更 task 边界但合规修的预存债文件
+ * （CLAUDE.md 规则20 鼓励）。assess 的 allowed_paths 校验对 incidental 文件豁免（坑
+ * worktree-execute-apply-friction 坑1/4）。标记载体：表格「说明」列写「顺带修复：xxx」，
+ * 或路径 cell / 列表项的括号注释「（顺带修复）」。
+ */
+const INCIDENTAL_RE = /顺带修复|附带修复|顺带|drive-?by|incidental/i
+
+/**
+ * 从 design.md 解析文件变更清单（含 incidental 标记）。兼容两种真实写法：
+ *   ① 表格：`| 操作 | 文件路径 | 说明 |`（brainstorm 模板默认）
+ *   ② 分类列表：`### 新增文件` / `### 修改文件` / `### 不修改文件` 下的 `- path`
+ * 表头列顺序自适应（定位「文件/路径/file/path」列，列顺序写反时不会把操作名当路径）；
+ * 忽略 `.sillyspec/`（keepSillyspecDocs=true 时保留 `.sillyspec/docs/`）与占位符（`—`/`-`/`N/A`/`无`）；「不修改/暂缓」子段下的路径会被排除；
+ * CRLF 容错。incidental 嗅探：表格非路径列（说明列）+ 路径 cell 原始值（剥注释前的括号内容）+ 列表项原文。
+ *
+ * 内核函数：parseFileChangeList（Set 包装，向后兼容）与 parseFileChangeListDetailed 共用，
+ * 单一真相源，避免两处各自重写清单解析漂移。
+ * @param {string} designMdPath - design.md 文件路径
+ * @returns {Array<{ path: string, operation: string|null, incidental: boolean }>}（顺序按首次出现，exclude 子段移除）
+ */
+function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false } = {}) {
+  if (!designMdPath || !existsSync(designMdPath)) return []
+
+  const content = readFileSync(designMdPath, 'utf8').replace(/\r\n/g, '\n')
+
+  const sectionMatch = content.match(FILE_LIST_SECTION_RE)
+  if (!sectionMatch) return []
+
+  // 从标题后开始，截取到下一个 ## 标题或文件末尾
+  const afterSection = content.slice(sectionMatch.index + sectionMatch[0].length)
+  const nextSectionMatch = afterSection.match(/^##\s/m)
+  const relevantContent = nextSectionMatch
+    ? afterSection.slice(0, nextSectionMatch.index)
+    : afterSection
+
+  const lines = relevantContent.split('\n')
+  let headerSkipped = false
+  let pathColIdx = 1            // 默认第 2 列；解析表头后可重定位
+  let opColIdx = -1             // 操作列下标（表头扫描后定位；-1 = 无操作列 → operation=null）
+  let listMode = 'include'      // include | exclude（分类列表子段）
+  let currentOp = null          // 分类列表子标题推导的 operation（表格模式不用）
+  const entries = new Map()     // path -> { path, operation, incidental }（exclude 子段 delete）
+
+  for (const line of lines) {
+    // 分类列表子标题：### 新增文件 / ### 修改文件 / ### 不修改文件
+    const subHeader = line.match(/^###\s+(.+?)\s*$/)
+    if (subHeader) {
+      // ⚠️ EXCLUDE 优先：「### 不修改文件」含「修改」二字，会被 classifySubsectionOp 误匹配。
+      //    先判 exclude 词集，命中则 exclude 且 currentOp=null，绝不跑 OP 映射。
+      if (EXCLUDE_SUBSECTION_RE.test(subHeader[1])) {
+        listMode = 'exclude'
+        currentOp = null
+      } else {
+        listMode = 'include'
+        currentOp = classifySubsectionOp(subHeader[1])
+      }
+      continue
+    }
+
+    // 表格行
+    if (line.startsWith('|')) {
+      if (/^\|[-:\s|]+\|$/.test(line)) continue // 分隔行
+      const cells = line.split('|').slice(1, -1).map(c => c.trim())
+      if (cells.length < 2) continue
+
+      if (!headerSkipped) {
+        headerSkipped = true
+        // 表头列定位：找「文件/路径/file/path」列，找不到保持默认第 2 列
+        const idx = cells.findIndex(isPathHeaderCell)
+        if (idx >= 0) pathColIdx = idx
+        // 操作列定位：非路径列里找操作类列名（「操作/类型/operation」），找不到 opColIdx 保持 -1
+        const opIdx = cells.findIndex((c, i) => i !== pathColIdx && isOperationHeaderCell(c))
+        if (opIdx >= 0) opColIdx = opIdx
+        continue
+      }
+
+      const filePath = normalizePath(cells[pathColIdx] || '')
+      // 列定位兜底：取到纯操作词（表头未命中且列顺序异常）→ 跳过，避免把「修改」当路径
+      if (/^(新增|修改|删除|重命名|new|modify|update|delete|create|rename)$/i.test(filePath)) continue
+      if (isPlaceholder(filePath) || (filePath.startsWith('.sillyspec/') && !(keepSillyspecDocs && filePath.startsWith('.sillyspec/docs/')))) continue
+      if (!looksLikePath(filePath)) continue // 脏描述兜底：丢弃非路径自由文本（防虚高 fileCount）
+      // operation：操作列 cell 分类（无操作列 → null）
+      const operation = opColIdx >= 0 ? classifyOperation(cells[opColIdx] || '') : null
+      // incidental：说明列（非路径列的所有 cell）+ 路径 cell 原始值（剥注释前的括号内容）
+      const incidental = cells.some((c, i) => i !== pathColIdx && INCIDENTAL_RE.test(c))
+        || INCIDENTAL_RE.test(cells[pathColIdx] || '')
+      // 组合路径单元格拆分（坑 design-combined-cell-mismatch，2026-08-22 实证：单元格写
+      // "router.py + service.py" 一行两文件——整体当单路径字面匹配对账不过，逼文档写法服务
+      // 校验器）。拆分符：+ / ／ / | / 、 / ; / ；——每个 token 独立过校验入表；单路径零变化。
+      const pathTokens = splitCombinedPaths(filePath)
+      if (listMode === 'exclude') { for (const t of pathTokens) entries.delete(t); continue }
+      for (const t of pathTokens) entries.set(t, { path: t, operation, incidental })
+      continue
+    }
+
+    // 分类列表项：`- path` / `- \`path\``
+    const listItem = line.match(/^\s*-\s+(.+)/)
+    if (listItem) {
+      const filePath = normalizePath(listItem[1])
+      if (isPlaceholder(filePath) || (filePath.startsWith('.sillyspec/') && !(keepSillyspecDocs && filePath.startsWith('.sillyspec/docs/')))) continue
+      if (!looksLikePath(filePath)) continue // 脏描述兜底
+      const incidental = INCIDENTAL_RE.test(listItem[1])
+      if (listMode === 'exclude') { entries.delete(filePath); continue }
+      entries.set(filePath, { path: filePath, operation: currentOp, incidental })
+    }
+  }
+
+  return [...entries.values()]
+}
+
+/**
+ * 从 design.md 解析文件变更清单（路径集合，向后兼容）。
+ * @param {string} designMdPath - design.md 文件路径
+ * @param {string} designMdPath - design.md 文件路径
+ * @param {{ keepSillyspecDocs?: boolean }} [opts] - keepSillyspecDocs=true 时保留 `.sillyspec/docs/`（dogfood 模块文档=交付物，apply gate 需识别；默认 false 跳过全部 .sillyspec/ 保持 fileCount 判档不变）
+ * @returns {Set<string>} 文件路径集合（相对路径，如 "src/worktree.js"）
+ */
+export function parseFileChangeList(designMdPath, opts) {
+  return new Set(_parseFileListDetailed(designMdPath, opts).map(e => e.path))
+}
+
+/**
+ * 从 design.md 解析文件变更清单（含 operation + incidental 标记）。
+ * operation 供 verify 删除探针对账（声明「新增/修改」却整文件删除 = 高风险）；
+ * incidental 供 assess allowed_paths 豁免。
+ * @param {string} designMdPath - design.md 文件路径
+ * @param {{ keepSillyspecDocs?: boolean }} [opts] - 同 parseFileChangeList
+ * @returns {Array<{ path: string, operation: string|null, incidental: boolean }>}
+ */
+export function parseFileChangeListDetailed(designMdPath, opts) {
+  return _parseFileListDetailed(designMdPath, opts)
+}

package/.claude/worktrees/sillyspec-data-model-research/src/change-risk-profile.js

@@ -0,0 +1,270 @@
+/**
+ * change-risk-profile.js — 变更风险分级检测
+ *
+ * 根据变更涉及的文件类型、关键词、git diff、brainstorm 产物，
+ * 判定 5 级风险（doc-only / unit-sufficient / contract-required /
+ * integration-critical / deployment-critical），产出门控验证需求。
+ */
+
+// ============ 向后兼容：旧的 INTEGRATION_CRITICAL_PATTERNS ============
+
+const INTEGRATION_CRITICAL_PATTERNS = [
+  /\bdaemon\b/i,
+  /\bbackend\b/i,
+  /\bclient.*api\b/i,
+  /\bgrpc\b/i,
+  /\bwebsocket\b/i,
+  /\bhttp.*client\b/i,
+  /\bsession\b/i,
+  /\blease\b/i,
+  /\bagent.?run\b/i,
+  /\blifecycle\b/i,
+  /\bstate.?transition\b/i,
+  /\bclaim\b/i,
+  /\bheartbeat\b/i,
+  /\bcross.?process\b/i,
+  /\bipc\b/i,
+  /\bmessage.?queue\b/i,
+  /\bpub.?sub\b/i,
+  /\bcli\.ts\b/i,
+  /\bmain\.ts\b/i,
+  /\bentrypoint\b/i,
+  /\bserver\.(js|ts)\b/i,
+  /\bbootstrap\b/i,
+  /\bdockerfile\b/i,
+  /\bdocker.?compose\b/i,
+]
+
+const INTEGRATION_FILE_PATTERNS = [
+  /daemon/i,
+  /session.?manager/i,
+  /agent.?run/i,
+  /lifecycle/i,
+  /state.?machine/i,
+  /lease/i,
+  /cli\.(js|ts)$/,
+  /main\.(js|ts)$/,
+  /server\.(js|ts)$/,
+  /bootstrap/i,
+  /startup/i,
+]
+
+/**
+ * task 级「端到端/deployment-critical」文本判定（execute 批量完成 autoCheckPlanFromReviews 用）。
+ *
+ * 聚焦需要真实集成/启动验证的 task，区别于 change 级 INTEGRATION_CRITICAL_PATTERNS（含 backend/session
+ * 等泛词——task 级用会误伤普通后端 task）。命中端到端集成语义（端到端/真实集成/daemon↔backend/
+ * integration test/e2e）或部署启动入口（cli.ts/main.ts/entrypoint/server/bootstrap/startup/docker）。
+ * 坑 execute-batch-complete-endtoend-checkbox：这类 task 的 review cannot_verify 不算 checked，
+ * 阻断 execute 批量完成（必须 pass），防端到端未真验就被批量放行（verify integration-evidence 兜底外的
+ * execute 侧前置门）。
+ * @param {string} text task 描述文本（plan.md task 行 + tasks/task-XX.md 内容）
+ * @returns {boolean}
+ */
+const END_TO_END_TASK_KEYWORDS = [
+  /端到端/, /真实集成/, /daemon.*backend/i, /integration\s*test/i, /e2e\s*test/i,
+  /runtime\s*evidence/i, /运行时证据/,
+  /\bcli\.ts\b/i, /\bmain\.ts\b/i, /\bentrypoint\b/i, /\bserver\.(js|ts)\b/i,
+  /\bbootstrap\b/i, /\bstartup\b/i, /启动/, /\bdockerfile\b/i, /\bdocker.?compose\b/i,
+]
+export function isEndToEndTaskText(text = '') {
+  return END_TO_END_TASK_KEYWORDS.some(re => re.test(text))
+}
+
+// ============ 门控可执行化（A：报错说人话） ============
+//
+// 历史教训：integration-critical / deployment-critical 门控只报「缺少真实集成证据 / 需要真实
+// 启动验证证据」，agent 看不出具体缺哪一项、要写/做什么才算过，只能靠改结论文案撞墙。
+// 此处把每一项 requiredVerification 的需求（写什么 / 做什么）和判级原因显式导出，
+// 供 stage-contract 拼成可执行的报错信息。
+
+/** 每项 requiredVerification 的需求描述 + 字面期望 */
+export const VERIFICATION_NEEDS = {
+  unit_tests: {
+    desc: '单元测试（verify 必做；在 verify-result.md 写明测试套件与结果）',
+    literals: [],
+  },
+  contract_tests: {
+    desc: '契约测试（前后端/跨进程 API parity 对账，写明结论）',
+    literals: [],
+  },
+  real_daemon_backend_integration: {
+    desc: '真实 daemon↔backend 集成验证（非仅 mock 单测）。写「真实集成/端到端」的证据；',
+    // 同义扩充（坑 verify-literal-evidence-mismatch，2026-08-22 实证：证据第一轮就齐但表述
+    // 不含字面词被误拦三轮）——覆盖常见自然表述 + PID 登记句式（verify prompt 要求照写）
+    literals: ['端到端', 'integration test', 'e2e test', 'daemon.*backend', '真实集成',
+      'runtime evidence', '运行时证据', '联调', '打通', '实际请求', '真实请求', '跨进程',
+      'PID 已登记', 'verify-services'],
+  },
+  runtime_log_evidence: {
+    desc: 'Runtime Evidence section + 指向真实日志/证据片段。',
+    literals: ['Runtime Evidence', '运行时证据', 'daemon log', '日志片段', '日志关键',
+      '日志:', '日志摘录', '日志', 'log 摘录', 'log 片段', '进程日志', 'PID 已登记', 'verify-services'],
+  },
+  real_startup_once: {
+    desc: '真实启动一次本变更触及的部署/启动入口（服务入口、CLI 主入口、守护进程等——须是本变更实际改动的那一类入口，不能拿无关进程的启动来凑数）。',
+    // 同义扩充（同坑）：自然表述 + CLI 回执句式；checkIntegrationEvidence 另拼 CLI 回执文本
+    //（verify-services.receipt.json，服务回收器落盘）——结构化信号不依赖 agent 措辞
+    literals: ['启动.*一次', '实际.*启动', 'real startup', 'docker up', 'npm start', 'node server',
+      '真实启动', '拉起', '已启动', '进程启动', '服务启动', '启动验证',
+      'PID 已登记', 'verify-services'],
+  },
+  terminal_state_assertion: {
+    desc: '终态断言（建议项，不阻断）：AgentRun running→completed/failed、session/lease end 状态同步。',
+    literals: ['terminal state', '终态', 'completed failed', 'session end', 'lease end',
+      '生命周期终态', '状态同步'],
+  },
+}
+
+/** 风险分级的判定来源（命中关键词来源 = design.md / plan.md 内容，非改动文件本身） */
+export const RISK_LEVEL_CAUSES = {
+  'deployment-critical':
+    'design.md / plan.md 命中启动入口关键词（cli.ts / main.ts / server.(js|ts) / bootstrap / entrypoint）。' +
+    '注意：这是按 design/plan 里的措辞判定的，不一定代表你真改了启动入口；若属误判可在 design.md frontmatter 用 risk_level 显式声明真实等级（如 unit-sufficient）覆盖——不要靠删措辞绕门控，危险链路该有真实启动证据。',
+  'integration-critical':
+    'design.md / plan.md 命中跨进程/状态机关键词（daemon / backend / session / lease / lifecycle / heartbeat 等）。',
+  'contract-required': 'design.md / plan.md 命中 API contract 关键词（api / client / contract / dto）。',
+  'explicit': 'design.md frontmatter 的 risk_level 显式声明（覆盖关键词判级）。',
+}
+
+/** design.md frontmatter 可显式声明的合法 risk_level 值（与 detectChangeRisk 判级结果同集合） */
+const RISK_LEVELS = ['doc-only', 'unit-sufficient', 'contract-required', 'integration-critical', 'deployment-critical']
+
+/**
+ * 从 design.md 顶部 frontmatter 提取显式 risk_level 声明。
+ * 只认文档最开头 `---\n...\n---` 块内的 `risk_level: <level>` 单行（与 plan.md 的 plan_level 同款解析），
+ * 不扫正文——避免正文里讨论 risk_level 措辞时被误当声明。返回合法 level 或 null。
+ */
+export function extractExplicitRiskLevel(designContent = '') {
+  const fm = designContent.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+  if (!fm) return null
+  const line = fm[1].split('\n').map(l => l.trim()).find(l => l.startsWith('risk_level:'))
+  if (!line) return null
+  const value = line.slice('risk_level:'.length).trim().replace(/^["']|["']$/g, '').toLowerCase()
+  return RISK_LEVELS.includes(value) ? value : null
+}
+
+export function detectChangeRisk({ designContent = '', planContent = '', changedFiles = [] } = {}) {
+  const triggers = []
+
+  // ── 显式豁免优先：design.md frontmatter 声明 risk_level → 以声明为准，跳过关键词判级 ──
+  // 历史教训：detectChangeRisk 是机械字面匹配，不认否定语境——design 写「本次不改动 daemon/session」
+  // 仍命中关键词被误判 integration/deployment-critical，强制要全套集成证据，对无状态后端变更误伤。
+  // 与其在正则层做脆弱的否定识别，不如给一条显式、诚实、可审计（落在 design frontmatter + verify-result）
+  // 的覆盖通道。声明仍走门控（结论 FAIL 仍拦），但豁免级（unit-sufficient 等）不再强制集成证据。
+  const explicit = extractExplicitRiskLevel(designContent)
+  if (explicit) {
+    const requiredVerification =
+      explicit === 'deployment-critical' ? ['unit_tests', 'contract_tests', 'real_daemon_backend_integration', 'runtime_log_evidence', 'real_startup_once'] :
+      explicit === 'integration-critical' ? ['unit_tests', 'contract_tests', 'real_daemon_backend_integration', 'runtime_log_evidence', 'terminal_state_assertion'] :
+      explicit === 'contract-required' ? ['unit_tests', 'contract_tests'] :
+      explicit === 'doc-only' ? ['static_check'] :
+      ['unit_tests']
+    return { level: explicit, triggers: ['risk_level (explicit)'], requiredVerification, explicit: true }
+  }
+
+  const combined = [designContent, planContent].join('\n')
+
+  for (const pattern of INTEGRATION_CRITICAL_PATTERNS) {
+    if (pattern.test(combined)) {
+      pattern.lastIndex = 0
+      const match = combined.match(pattern)
+      if (match && !triggers.includes(match[0])) triggers.push(match[0])
+    }
+  }
+
+  for (const file of changedFiles) {
+    for (const pattern of INTEGRATION_FILE_PATTERNS) {
+      if (pattern.test(file)) {
+        pattern.lastIndex = 0
+        const match = file.match(pattern)
+        if (match && !triggers.includes(match[0])) triggers.push(match[0])
+      }
+    }
+  }
+
+  if (triggers.length === 0) {
+    return { level: 'doc-only', triggers: [], requiredVerification: ['static_check'] }
+  }
+
+  const deploymentTrigger = triggers.some(t => /cli\.ts|main\.ts|server\.(js|ts)|bootstrap|entrypoint/i.test(t))
+  const lifecycleTrigger = triggers.some(t => /session|lease|agent.?run|lifecycle|state.?transition|claim|heartbeat/i.test(t))
+  const crossProcessTrigger = triggers.some(t => /daemon|backend|client.*api|grpc|websocket|cross.?process|ipc|message.?queue/i.test(t))
+
+  let level
+  const requiredVerification = ['unit_tests']
+
+  if (deploymentTrigger) {
+    level = 'deployment-critical'
+    requiredVerification.push('contract_tests', 'real_daemon_backend_integration', 'runtime_log_evidence', 'real_startup_once')
+  } else if (lifecycleTrigger || crossProcessTrigger) {
+    level = 'integration-critical'
+    requiredVerification.push('contract_tests', 'real_daemon_backend_integration', 'runtime_log_evidence', 'terminal_state_assertion')
+  } else if (triggers.some(t => /api|client|contract|dto/i.test(t))) {
+    level = 'contract-required'
+    requiredVerification.push('contract_tests')
+  } else {
+    level = 'unit-sufficient'
+  }
+
+  return { level, triggers, requiredVerification }
+}
+
+/**
+ * 检查 verify-result.md 是否包含集成验证证据
+ *
+ * opts.extraEvidenceText（坑 verify-literal-evidence-mismatch，2026-08-22）：调用方可注入
+ * CLI 结构化回执文本（如 verify-services.receipt.json 的服务回收回执）——它随 verifyContent
+ * 一起参与 literals 匹配，agent 真实起过服务且 CLI 回收过（有回执）时不再依赖其自然语言
+ * 措辞恰好含字面词，表述差异不再误拦。
+ */
+export function checkIntegrationEvidence(verifyContent, requiredVerification, opts = {}) {
+  const errors = []
+  const warnings = []
+  const lower = (String(verifyContent || '') + '\n' + String(opts.extraEvidenceText || '')).toLowerCase()
+
+  // 字面证据正则从 VERIFICATION_NEEDS[k].literals 派生——与报错描述、prompt 事前契约严格同源,
+  // 杜绝历史上"描述说 A、正则查 B"的分叉(checkIntegrationEvidence 正则曾比 VERIFICATION_NEEDS
+  // 描述多匹配 集成测试/backend.*daemon/real.*integration 等)。literals 为空的 need
+  // (unit_tests/contract_tests)无字面校验,视为满足。
+  const hasEvidence = (k) => {
+    const n = VERIFICATION_NEEDS[k]
+    if (!n || !n.literals || n.literals.length === 0) return true
+    return new RegExp(n.literals.join('|'), 'i').test(lower)
+  }
+
+  const needsIntegration = requiredVerification.includes('real_daemon_backend_integration')
+  const needsLogEvidence = requiredVerification.includes('runtime_log_evidence')
+  const needsTerminalState = requiredVerification.includes('terminal_state_assertion')
+  const needsRealStartup = requiredVerification.includes('real_startup_once')
+
+  if (needsIntegration) {
+    const hasMockOnly = /mock.*test.*passed|unit.*test.*passed/i.test(lower)
+    const hasIntegrationEvidence = hasEvidence('real_daemon_backend_integration')
+    if (!hasIntegrationEvidence && hasMockOnly) {
+      errors.push('integration-critical 变更只提供了 mock 单测证据，缺少真实 daemon↔backend 集成验证')
+    } else if (!hasIntegrationEvidence) {
+      errors.push('integration-critical 变更缺少集成验证证据 — 需要真实 daemon↔backend 测试结果或运行时日志')
+    }
+  }
+
+  if (needsLogEvidence) {
+    if (!hasEvidence('runtime_log_evidence')) {
+      errors.push('integration-critical 变更的 verify-result.md 缺少 Runtime Evidence section')
+    }
+  }
+
+  if (needsTerminalState) {
+    if (!hasEvidence('terminal_state_assertion')) {
+      warnings.push('建议检查终态断言：AgentRun running→completed/failed、session end 状态同步')
+    }
+  }
+
+  if (needsRealStartup) {
+    if (!hasEvidence('real_startup_once')) {
+      errors.push('deployment-critical 变更需要真实启动验证证据')
+    }
+  }
+
+  return { ok: errors.length === 0, errors, warnings }
+}

package/.claude/worktrees/sillyspec-data-model-research/src/check-primitives.js

@@ -0,0 +1,65 @@
+/**
+ * check-primitives.js — 共享的产物字面校验原语(纯函数)
+ *
+ * 从 workflow.js 的 checkOutput / _checkWorkflow 抽出,作为"何谓 contains_sections / min_lines /
+ * no_placeholder / no_empty_files"的**全仓单一语义源**。workflow 引擎与 stage-contract 引擎
+ * (stage-contract-engine.js)共用同一组谓词,杜绝"workflow 认 `## X` 子串、stage-contract 认别的"
+ * 这类判定分叉(本任务的"事前==事后"同源在原语层就成立)。
+ *
+ * 设计原则:纯文本判定,不碰 fs。调用方负责读文件 + CRLF 归一化后传入 content——
+ * 这样 Windows CRLF 差异在调用方收敛(plan-postcheck 已用 LF-normalizing reader),引擎拿到
+ * 什么判什么,不在原语层二次引入 readFileSync 差异(缺陷 windows-python-crlf-taskcard 的根因)。
+ */
+
+// no_placeholder 的默认占位词。与原 workflow.js checkOutput/_checkWorkflow 逐字一致——
+// 改动会破坏存量扫描文档的占位判定,属契约级常量。
+const DEFAULT_PLACEHOLDER_PATTERNS = [
+  '待补充', 'TODO', 'TBD', '未分析', '根据项目情况', '根据实际情况', '按需填写',
+]
+
+/** 内容非空(trim 后有字符)。用于 no_empty_files。 */
+export function contentNonEmpty(content) {
+  return typeof content === 'string' && content.trim().length > 0
+}
+
+/** 行数(split('\n'))。用于 min_lines 的 detail 文案与判定。 */
+export function lineCount(content) {
+  return typeof content === 'string' ? content.split('\n').length : 0
+}
+
+/** 行数 ≥ min。用于 min_lines 判定。 */
+export function meetsMinLines(content, min) {
+  return lineCount(content) >= min
+}
+
+/**
+ * 返回缺失的章节(sections 中未以 `## <section>` 子串出现的)。
+ * 用于 contains_sections——判定与原 workflow.js 逐字一致(`## ${s}` 前缀子串匹配)。
+ */
+export function missingSections(content, sections) {
+  if (typeof content !== 'string') return sections.slice()
+  return sections.filter(s => !content.includes(`## ${s}`))
+}
+
+/** 是否含全部章节(missingSections 为空的语法糖)。 */
+export function hasAllSections(content, sections) {
+  return missingSections(content, sections).length === 0
+}
+
+/**
+ * 返回命中的占位词(patterns 中匹配"独立成行"的)。
+ * 用于 no_placeholder——正则 `^\s*[-*]?\s*<p>\s*$`(m flag)与原 workflow.js 逐字一致。
+ * patterns 为空/未传时用 DEFAULT_PLACEHOLDER_PATTERNS(等价原 `check.patterns || [defaults]`)。
+ */
+export function placeholderLineMatches(content, patterns) {
+  if (typeof content !== 'string') return []
+  const pats = (patterns && patterns.length > 0) ? patterns : DEFAULT_PLACEHOLDER_PATTERNS
+  return pats.filter(p => new RegExp(`^\\s*[-*]?\\s*${p}\\s*$`, 'm').test(content))
+}
+
+/** 无占位词命中(placeholderLineMatches 为空的语法糖)。 */
+export function hasNoPlaceholderLine(content, patterns) {
+  return placeholderLineMatches(content, patterns).length === 0
+}
+
+export { DEFAULT_PLACEHOLDER_PATTERNS }