sillyspec 3.26.13 → 3.26.15

package/src/sync.js

@@ -9,6 +9,7 @@
  */
 
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync, chmodSync } from 'fs';
+import { writeAtomicSync } from './fs-atomic.js';
 import { join } from 'path';
 import { resolvePlatformSpecDir } from './progress.js';
 import { safeGit } from './git-helper.js';
@@ -131,12 +132,14 @@ function replaceTopLevelSection(text, name, body) {
   return `${stripped}\n\n${name}:\n${body}\n`;
 }
 
-/** 文本级写 local.yaml（保留传入 text 的注释/结构）；确保 .sillyspec 目录存在。 */
+/** 文本级写 local.yaml（保留传入 text 的注释/结构）；确保 .sillyspec 目录存在。
+ *  原子写（fs-atomic 契约：local.yaml 被 hook/probe 等其他进程并发读，裸 writeFileSync 的
+ *  写入窗口可读到半截文件 → mcp 段解析失败回退 env → 误判 no-config 降级）。 */
 function writeLocalYamlRaw(cwd, text) {
   const dir = join(cwd, '.sillyspec');
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   const yamlPath = join(cwd, LOCAL_YAML);
-  writeFileSync(yamlPath, text, 'utf8');
+  writeAtomicSync(yamlPath, text, 'utf8');
   // 体检 SEC-04：local.yaml 含明文 token，收紧为仅属主可读写。POSIX chmod 0600 生效；
   // Windows 上 Node chmod 只映射只读位（近似 no-op），属可接受 best-effort
   try { chmodSync(yamlPath, 0o600); } catch { /* chmod 失败不阻断连接流程 */ }
@@ -364,7 +367,7 @@ export class SyncManager {
           // 删段后纯空白（无任何段也无注释）→ 删除整个文件；注释算内容，有注释则保留
           try { unlinkSync(p); } catch { /* best effort */ }
         } else {
-          writeFileSync(p, newText, 'utf8');
+          writeAtomicSync(p, newText, 'utf8');
         }
       }
     }
@@ -609,7 +612,10 @@ export class SyncManager {
       return { synced: 0, errors: ['未指定变更名称'] };
     }
 
-    const changeDir = join(this.cwd, CHANGES_DIR, changeName);
+    // 树根与进度/spec 树同源（safePlatformSpecDir，BUG-01 同族）：此前硬编码 cwd/.sillyspec/changes，
+    // 平台模式（specRoot 指向外部）下路径不存在 → syncDocuments 恒报「变更不存在」且调用方不查
+    // 返回值 → 文档在平台模式下静默永不同步。
+    const changeDir = join(safePlatformSpecDir(this.cwd) || join(this.cwd, '.sillyspec'), 'changes', changeName);
     if (!existsSync(changeDir)) {
       console.warn(`[sync] 变更不存在: ${changeName}`);
       return { synced: 0, errors: [`变更不存在: ${changeName}`] };
@@ -997,7 +1003,10 @@ export class SyncManager {
         const { ProgressManager } = await import('./progress.js');
         const pm = new ProgressManager({ specDir: safePlatformSpecDir(this.cwd) });
         const db = pm._ensureDB(this.cwd).getDb();
-        db.prepare('UPDATE changes SET last_synced_platform_ts = MAX(?, COALESCE(last_synced_platform_ts, ?)) WHERE name = ?')
+        // 参数侧同样 COALESCE（坑 keep-local-base-ts-null-param）：SQLite 标量 MAX() 任一参数
+        // 为 NULL 即返回 NULL——冲突文件 platform_last_pushed_at 为 null 时 MAX(NULL, 旧值)
+        // 会把已回填的 base_ts 清空，恰好违背本注释的单调防回退意图。
+        db.prepare('UPDATE changes SET last_synced_platform_ts = MAX(COALESCE(?, last_synced_platform_ts), COALESCE(last_synced_platform_ts, ?)) WHERE name = ?')
           .run(platformPushedAt, platformPushedAt, changeName);
       } catch (err) {
         return { ok: false, resolved: false, reason: `keep-local 更新 base_ts 失败: ${err.message}` };
@@ -1024,9 +1033,12 @@ export class SyncManager {
     }
 
     if (mode === 'take-platform' && cf) {
-      // 用冲突文件的 platform_progress 调 import 覆盖本地（保隔离：import 不覆盖 isolation_*）
+      // 用冲突文件的 platform_progress 调 import 覆盖本地（保隔离：import 不覆盖 isolation_*）。
+      // fail-closed（坑 take-platform-empty-import）：缺 platform_progress 时必须直接返回——
+      // { ...null } 展开为 {}，import 会照常跑完整事务（DELETE stages 后按空 JSON 重建 =
+      // 清空本地进度），返回值却报 ok:false「未执行」，用户以为无事发生实则数据已丢。
       if (!cf.platform_progress) {
-        progressOutcome = { ok: false, resolved: false, reason: '冲突文件缺 platform_progress，无法 take-platform（建议先 platform pull）' };
+        return { ok: false, resolved: false, reason: '冲突文件缺 platform_progress，无法 take-platform（建议先 platform pull）' };
       }
       try {
         const { ProgressManager } = await import('./progress.js');

package/src/task-review.js

@@ -525,12 +525,15 @@ export function validateTaskReviews(opts) {
 
 // QUAL-01 收口：原为本地 execFileSync('git')（无 safe.directory、与 git-helper 口径分裂），
 // 现走统一入口；抛错/trim 语义不变，timeout 15000 保留（rev-parse/diff 大仓余量）
-function runGit(gitDir, args) {
-  return git(gitDir, args, { timeout: 15000 })
+function runGit(gitDir, args, opts = {}) {
+  return git(gitDir, args, { timeout: 15000, ...opts })
 }
 
 // porcelain 状态行 → 变更文件路径（对齐 shared.js:343 parsePorcelainPath：`XY path`、引号包裹、
 // rename `R old -> new` 取箭头后）。未 commit 的 working-tree 改动对账用。
+// ⚠️ 入参必须是【未 trim】的原始输出（git(..., {trim:false})）——porcelain 行首空格是状态码
+// 一部分，git() 默认 trim 会把 ' M feature.js' 削成 'M feature.js'，slice(3) 再咬掉路径首字符
+// （实测 'eature.js'）→ 未提交文件对账全错位（verifyReviewGitEvidence 相交比对误判「完全不相交」）。
 function parsePorcelainFiles(statusOut) {
   const files = []
   for (const line of String(statusOut).split('\n')) {
@@ -639,7 +642,7 @@ export function verifyReviewGitEvidence(review, gitDir, cache = null) {
   try {
     let wtStatus = c.wtStatus.get(gitDir)
     if (wtStatus === undefined) {
-      wtStatus = runGit(gitDir, ['status', '--porcelain'])
+      wtStatus = runGit(gitDir, ['status', '--porcelain'], { trim: false })
       c.wtStatus.set(gitDir, wtStatus)
     }
     if (wtStatus && wtStatus.trim().length > 0) {
@@ -983,7 +986,30 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
   }
 
   // base..head diff 文件集（worktree-aware；null=git 不可用，[]=无 commit diff）
-  const diffFiles = resolveVerifyChangedFiles(cwd, changeName)
+  let diffFiles = resolveVerifyChangedFiles(cwd, changeName)
+  // ⚠️ 并入 worktree 未提交改动（坑 draft-attribution-uncommitted-worktree，2026-08-21 实证）：
+  // 子代理默认不 commit（execute 复盘 a 同源事实），真实改动全在 worktree working-tree——只看
+  // base..HEAD commit diff 时归属恒空，9/9 草稿全成「无归属」靠主代理手写升级。与
+  // verifyReviewGitEvidence 的 working-tree 并入口径同源：status --porcelain 文件（排除
+  // .sillyspec/ 运行时产物）并入归属集，按 allowed_paths 正常路径归属；review.head 仍为 HEAD
+  // commit——evidence 校验对「commit diff 空 + working-tree 有改动」明示不判伪造，语义一致。
+  try {
+    const wm = new WorktreeManager({ cwd })
+    const meta = wm.getMeta(changeName)
+    if (meta) {
+      const wtGitDir = (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath))
+        ? meta.worktreePath
+        : cwd
+      const wtStatus = runGit(wtGitDir, ['status', '--porcelain'], { trim: false })
+      const wtFiles = parsePorcelainFiles(wtStatus)
+        .map(p => String(p).replace(/\\/g, '/'))
+        .filter(p => p !== '.sillyspec' && !p.startsWith('.sillyspec/'))
+      if (wtFiles.length > 0) {
+        diffFiles = [...new Set([...(Array.isArray(diffFiles) ? diffFiles : []), ...wtFiles])]
+        console.log(`[sillyspec] 草稿归属并入 ${wtFiles.length} 个 worktree 未提交文件（子代理未 commit 的改动按 allowed_paths 归属）`)
+      }
+    }
+  } catch { /* working-tree 并入失败退回 commit diff 口径（fail-open，不阻断草稿） */ }
   // 单仓模式（无 ctx）：主仓无 diff 即无任何 task 可生成 → 提前返回（原逻辑零回归）。
   // 有 ctx：主仓无 diff 不阻断——跨仓 task 的 diff 在跨仓仓根独立取（per-task），主仓 task 自然跳过（空 changedFiles）。
   if (!ctx && (!diffFiles || diffFiles.length === 0)) {
@@ -1023,6 +1049,7 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
   const taskFiles = readdirSync(tasksDir).filter(f => /^task-\d+\.md$/.test(f)).sort()
   let generated = 0
   let skipped = 0
+  let noAttributionCount = 0
   const attributed = new Set()
 
   for (const tf of taskFiles) {
@@ -1081,11 +1108,6 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
         : []
     }
 
-    // 空 changedFiles 的 task 不生成（verifyReviewGitEvidence 判空 diff 伪造，留给 agent 手补）
-    if (taskChangedFiles.length === 0) {
-      skipped++
-      continue
-    }
     // 主仓 task 缺 base/head（meta 缺失 / HEAD 解析失败，见上方 :968-981 注释承诺的"后续跳过"）：
     // 跳过留给 agent 手补。此前 null.slice(0,8) 直接 TypeError 崩掉整个草稿生成（体检 BUG-06）
     if (!crossEntry && (!taskBase || !taskHead)) {
@@ -1097,6 +1119,42 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
       taskChangedFiles.forEach(f => attributed.add(f))
     }
 
+    // 空 changedFiles 的 task 也生成「无归属」草稿（坑 task-review-draft-skip-leak，2026-08-21
+    // 实证：task-08/task-10 两次都因 allowed_paths 未命中 diff 被静默跳过，--done gate 拦截后
+    // agent 只能从零手写 review.json）。cannot_verify 草稿本就待复核（verify 阶段兑现
+    // requiredEvidence），空 changedFiles 不触发 emptyDiff 伪造误判（该判定看真实 git diff 而非
+    // review.changedFiles），shouldAutoCheckTask 零 diff 守卫也保证不会被自动勾选——草稿从
+    // 「漏了让 agent 从零写」变成「给了骨架让 agent 升级 verdict」。
+    if (taskChangedFiles.length === 0) {
+      const draft = {
+        schemaVersion: REVIEW_SCHEMA_VERSION,
+        task: taskId,
+        base: taskBase,
+        head: taskHead,
+        changedFiles: [],
+        specVerdict: 'cannot_verify',
+        qualityVerdict: 'cannot_verify',
+        requiredEvidence: ['auto-generated draft (no-attributed-diff): ' + taskId +
+          ' 的 allowed_paths 未命中本次 diff 任何文件（task 未实现 / 改动与他人同文件 / 路径不匹配）——' +
+          '需人工确认实际改动后升级 verdict，确属未实现则回 fail'],
+        reviewerNotes: 'auto-generated draft from git diff ' + taskBase.slice(0, 8) + '..' + taskHead.slice(0, 8) +
+          ';verdict=未评审（无归属 diff 兜底草稿，坑 task-review-draft-skip-leak）',
+      }
+      if (draftRepo) draft.repo = draftRepo
+      // fail-open（对齐函数头契约 + execute-run-dir-fail-loud 测试锁定的「写失败返回统计不抛」）：
+      // 无归属草稿写入失败（如 tasks/ 被普通文件占位 ENOTDIR）降级 skipped，不崩整个草稿生成
+      try {
+        mkdirSync(reviewDir, { recursive: true })
+        writeFileSync(reviewPath, JSON.stringify(draft, null, 2) + '\n')
+        generated++
+        noAttributionCount++
+      } catch (e) {
+        console.error(`[sillyspec] task ${taskId} 无归属草稿落盘失败（降级留给 agent 手补）: ${e.message}`)
+        skipped++
+      }
+      continue
+    }
+
     const draft = {
       schemaVersion: REVIEW_SCHEMA_VERSION,
       task: taskId,
@@ -1115,7 +1173,195 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
   }
 
   const unattributed = (Array.isArray(diffFiles) ? diffFiles : []).filter(f => !attributed.has(f))
-  return { generated, skipped, unattributed, executeRunId }
+  return { generated, skipped, noAttribution: noAttributionCount, unattributed, executeRunId }
+}
+
+/**
+ * adoptTaskReviewMechanics —— 已存在 review.json 的 mechanics 字段一键重算代填（保 verdict）。
+ *
+ * 背景（2026-08-21 agent-手工产出审计项①）：review.json 里 schemaVersion/task/base/head/
+ * changedFiles(/repo) 全部可由 CLI 从 git + task 卡机械推导（generateTaskReviewDrafts 已证明），
+ * agent/子代理手算 hash、手抄 diff 清单是纯错误面——而 gate（verifyReviewGitEvidence）校验的
+ * 恰是这些字段。与草稿生成互补：草稿只补「缺失」，adopt 修「已存在但 mechanics 错/缺」——
+ * 保留人工语义字段（specVerdict/qualityVerdict/requiredEvidence/reviewerNotes），只重写 mechanics。
+ *
+ * verdict 保护策略（不猜 agent 本意）：
+ * - 合法 verdict（VALID_VERDICTS）原样保留；
+ * - 非法/缺失 verdict 降级 cannot_verify，reviewerNotes 追加标记，requiredEvidence 缺失补占位
+ *  （schema 要求 cannot_verify 必带非空 requiredEvidence）；
+ * - JSON 解析失败的 review 不救（无法可信保留任何字段），报出来留给 agent 修 JSON 后重跑。
+ *
+ * fail-open：与草稿生成同契约——缺数据返回统计与 reasons，不抛。
+ *
+ * @param {{ changeName: string, cwd: string, platformOpts?: object, ctx?: object|null }} opts
+ * @returns {Promise<{ adopted: number, unchanged: number, skipped: number, missing: number,
+ *                     downgraded: string[], reasons: string[], executeRunId?: string }>}
+ */
+export async function adoptTaskReviewMechanics({ changeName, cwd, platformOpts = {}, ctx = null }) {
+  const specBase = platformOpts.specRoot || join(cwd, '.sillyspec')
+  const runtimeRoot = resolveRuntimeRoot(platformOpts, specBase)
+  const tasksDir = join(specBase, 'changes', changeName, 'tasks')
+  const reasons = []
+
+  if (!changeName) {
+    return { adopted: 0, unchanged: 0, skipped: 0, missing: 0, downgraded: [], reasons: ['无 changeName'] }
+  }
+  if (!existsSync(tasksDir)) {
+    return { adopted: 0, unchanged: 0, skipped: 0, missing: 0, downgraded: [], reasons: ['无 tasks/ 目录'] }
+  }
+
+  // executeRunId：与草稿/gate 同源 marker。缺 marker 不新建 run——adopt 修的是当前 run 里
+  // 已存在的 review，marker 丢失说明无「当前 run」语义，无对象可修（gate 对 marker 缺失放行，
+  // 下游 Task Review Gate 兜底，这里同口径不造 run）。
+  const runIdFile = join(runtimeRoot, 'current-execute-run-id-' + changeName)
+  let executeRunId = ''
+  try {
+    if (existsSync(runIdFile)) {
+      const c = readFileSync(runIdFile, 'utf8').trim()
+      if (isValidExecuteRunId(c)) executeRunId = c
+    }
+  } catch {}
+  if (!executeRunId) {
+    return { adopted: 0, unchanged: 0, skipped: 0, missing: 0, downgraded: [], reasons: ['无 execute run marker——无当前 run，adopt 无对象'] }
+  }
+
+  // base/head + diff：与 generateTaskReviewDrafts 同源口径（meta 锡点 + worktree rev-parse +
+  // resolveVerifyChangedFiles），保证 adopt 产物与 gate 校验输入一致。
+  const diffFiles = resolveVerifyChangedFiles(cwd, changeName)
+  let base = null
+  let head = null
+  let reviewGitDir = cwd
+  try {
+    const wm = new WorktreeManager({ cwd })
+    const meta = wm.getMeta(changeName)
+    base = (meta && (meta.baselineCommit || meta.baseHash)) || null
+    if (meta && meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) {
+      reviewGitDir = meta.worktreePath
+    }
+  } catch {}
+  if (base) {
+    try {
+      head = runGit(reviewGitDir, ['rev-parse', 'HEAD'])
+    } catch {
+      head = null
+    }
+  }
+
+  const taskFiles = readdirSync(tasksDir).filter(f => /^task-\d+\.md$/.test(f)).sort()
+  let adopted = 0
+  let unchanged = 0
+  let skipped = 0
+  let missing = 0
+  const downgraded = []
+
+  for (const tf of taskFiles) {
+    const taskId = tf.replace(/\.md$/, '')
+    const reviewPath = join(runtimeRoot, 'execute-runs', executeRunId, 'tasks', taskId, 'review.json')
+    if (!existsSync(reviewPath)) {
+      missing++
+      continue
+    }
+
+    const existing = readReview(reviewPath)
+    if (existing.parseError) {
+      skipped++
+      reasons.push(`${taskId}: JSON 解析失败，adopt 不猜字段——先修 JSON 再重跑`)
+      continue
+    }
+    const prev = existing.review || {}
+
+    const content = readFileSync(join(tasksDir, tf), 'utf8')
+    const allowedPaths = parseAllowedPaths(content)
+    const taskRepo = normalizeRepoKey(parseRepo(content))
+    const crossEntry = (ctx && taskRepo !== DEFAULT_REPO_KEY) ? ctx.resolve(taskRepo) : null
+    let taskBase = base
+    let taskHead = head
+    let taskChangedFiles
+    let draftRepo
+
+    if (crossEntry) {
+      const baseCommit = parseBaseCommit(content)
+      const headCommit = parseHeadCommit(content)
+      if (!baseCommit || !headCommit) {
+        skipped++
+        reasons.push(`${taskId}: 跨仓 task 卡缺 base/head 锡点，无法 adopt`)
+        continue
+      }
+      taskBase = baseCommit
+      taskHead = headCommit
+      draftRepo = taskRepo
+      let crossDiffFiles = []
+      try {
+        const out = runGit(crossEntry.gitDir, ['diff', '--name-only', `${baseCommit}..${headCommit}`])
+        crossDiffFiles = out ? out.split('\n').filter(Boolean).map(p => p.replace(/\\/g, '/')) : []
+      } catch {
+        skipped++
+        reasons.push(`${taskId}: 跨仓 git diff 失败（${crossEntry.gitDir}）`)
+        continue
+      }
+      taskChangedFiles = allowedPaths.length > 0
+        ? crossDiffFiles.filter(f => allowedPaths.some(p => pathMatches(f, p)))
+        : crossDiffFiles
+    } else {
+      const mainDiff = Array.isArray(diffFiles) ? diffFiles : []
+      taskChangedFiles = allowedPaths.length > 0
+        ? mainDiff.filter(f => allowedPaths.some(p => pathMatches(f, p)))
+        : []
+    }
+
+    if (!crossEntry && (!taskBase || !taskHead)) {
+      skipped++
+      reasons.push(`${taskId}: 主仓缺 worktree meta base/head，无法 adopt`)
+      continue
+    }
+
+    const merged = { ...prev }
+    merged.schemaVersion = REVIEW_SCHEMA_VERSION
+    merged.task = taskId
+    merged.base = taskBase
+    merged.head = taskHead
+    merged.changedFiles = taskChangedFiles
+    if (draftRepo) merged.repo = draftRepo
+
+    let verdictTouched = false
+    for (const v of ['specVerdict', 'qualityVerdict']) {
+      if (!VALID_VERDICTS.includes(merged[v])) {
+        merged[v] = 'cannot_verify'
+        verdictTouched = true
+      }
+    }
+    if (verdictTouched) downgraded.push(taskId)
+    let evidenceFilled = false
+    if ((merged.specVerdict === 'cannot_verify' || merged.qualityVerdict === 'cannot_verify')
+      && (!Array.isArray(merged.requiredEvidence) || merged.requiredEvidence.length === 0)) {
+      merged.requiredEvidence = [`adopt 代填：原 review 缺 requiredEvidence（verdict=${merged.specVerdict}/${merged.qualityVerdict}），待人工复核补证据`]
+      evidenceFilled = true
+    }
+    if (verdictTouched) {
+      merged.reviewerNotes = String(merged.reviewerNotes || '') + (merged.reviewerNotes ? '; ' : '')
+        + 'adopt: 原 verdict 非法/缺失已降级 cannot_verify（不猜本意）'
+    }
+
+    const mechanicsChanged = prev.schemaVersion !== merged.schemaVersion
+      || prev.base !== merged.base
+      || prev.head !== merged.head
+      || JSON.stringify(prev.changedFiles ?? null) !== JSON.stringify(merged.changedFiles)
+      || prev.repo !== merged.repo
+
+    try {
+      if (mechanicsChanged || verdictTouched || evidenceFilled) {
+        writeFileSync(reviewPath, JSON.stringify(merged, null, 2) + '\n')
+        adopted++
+      } else {
+        unchanged++
+      }
+    } catch (e) {
+      skipped++
+      reasons.push(`${taskId}: 写回失败 ${e.message}`)
+    }
+  }
+
+  return { adopted, unchanged, skipped, missing, downgraded, reasons, executeRunId }
 }
 
 /**

package/src/verify-probes.js

@@ -0,0 +1,264 @@
+/**
+ * verify-probes.js — `sillyspec verify-probes` 的机械探针实现 + verify-result.md 骨架生成
+ * （2026-08-21 agent-手工产出审计第三批 H1/H3/H5/H7/F9）。
+ *
+ * verify-probes.md 模板定义六个探针，agent 此前逐条手跑 grep/递归查找/git 对账再手工拼表格。
+ * 本模块把纯机械的四个探针命令化（语义判断的留 agent，输出里显式标注）：
+ *   探针1 未实现标记扫描：design §6 清单的具体文件逐行 grep TODO/FIXME/尚未实现 等
+ *   探针3 测试覆盖：逐 task 按 allowed_paths 定位模块目录，递归找测试文件（co-located tests/ 陷阱）
+ *   探针5 API 契约对账：复用 contract-matrix.verifyApiParity（endpoints.json × 前端调用）+ 表格渲染
+ *   探针6 删除对账：git diff --name-status HEAD 的 D/R × design 声明操作三态判定
+ * 探针2（关键词提取半语义）/探针3.4 集成盲区/3.5 断言抽查/探针4（决策追踪语义）留 agent。
+ *
+ * verify-result.md 骨架：七章节固定结构 + 探针结果机械预填 + 其余章节 <!--TODO--> 占位。
+ * 结论章节留「待填」——extractVerifyConclusion 找不到 PASS/FAIL 关键词即判不过，骨架不能
+ * 直接过门（与 symbol-impact 骨架同款防偷懒语义）。
+ */
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'fs'
+import { join, dirname, basename } from 'path'
+import { gitQuiet } from './git-helper.js'
+import { parseFileChangeListDetailed } from './change-list.js'
+import { parseAllowedPaths } from './stages/plan-postcheck.js'
+import { verifyApiParity } from './contract-matrix.js'
+import { resolveSpecDir, resolveRuntimeRoot } from './run/shared.js'
+
+const TODO_MARKER_RE = /尚未实现|TODO|FIXME|HACK|XXX/
+const TEST_FILE_RE = /test|spec/i
+const PROBE1_MAX_MATCHES = 200
+
+function listTaskIds(tasksPath) {
+  if (!existsSync(tasksPath)) return []
+  const ids = []
+  for (const line of readFileSync(tasksPath, 'utf8').split('\n')) {
+    const m = line.match(/^[-*]\s*\[[ xX]\]\s*(task-\d+)\b/)
+    if (m) ids.push(m[1])
+  }
+  return ids
+}
+
+/** 递归找测试文件（排除 node_modules/.git/dist 等；返回 posix 相对 cwd 路径，封顶展示） */
+function findTestFiles(rootDir, cwd, cap = 10) {
+  const found = []
+  const skip = new Set(['node_modules', '.git', '.gradle', '__pycache__', '.venv', 'dist', 'build', 'target', 'out'])
+  const walk = (d) => {
+    let entries
+    try {
+      entries = readdirSync(d, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const e of entries) {
+      const full = join(d, e.name)
+      if (e.isDirectory()) {
+        if (!skip.has(e.name)) walk(full)
+      } else if (e.isFile() && TEST_FILE_RE.test(basename(e.name))) {
+        found.push(full.split('\\').join('/').replace(cwd.split('\\').join('/').replace(/\/$/, '') + '/', ''))
+        if (found.length >= cap) return
+      }
+    }
+  }
+  if (existsSync(rootDir)) walk(rootDir)
+  return found
+}
+
+/**
+ * 跑四个机械探针。
+ * @param {{ cwd: string, changeName: string, specDir?: string|null }} opts
+ * @returns {{ probe1: object, probe3: object, probe5: object, probe6: object }}
+ */
+export function runVerifyProbes({ cwd, changeName, specDir = null }) {
+  const specBase = resolveSpecDir(cwd, { specDir })
+  const changeDir = join(specBase, 'changes', changeName)
+  const designPath = join(changeDir, 'design.md')
+  const detailed = existsSync(designPath) ? parseFileChangeListDetailed(designPath) : []
+  const designOps = new Map(detailed.map(e => [e.path, e.operation]))
+
+  // ── 探针 1：未实现标记扫描（design 清单具体文件；glob 项列出让 agent 展开）──
+  const probe1 = { matches: [], globEntries: [], skippedFiles: [] }
+  for (const e of detailed) {
+    if (e.path.startsWith('.sillyspec/')) continue
+    if (/[*?[\]]/.test(e.path)) {
+      probe1.globEntries.push(e.path)
+      continue
+    }
+    const abs = join(cwd, e.path)
+    if (!existsSync(abs)) {
+      probe1.skippedFiles.push(e.path)
+      continue
+    }
+    try {
+      const lines = readFileSync(abs, 'utf8').split('\n')
+      lines.forEach((line, i) => {
+        if (probe1.matches.length >= PROBE1_MAX_MATCHES) return
+        if (TODO_MARKER_RE.test(line)) probe1.matches.push({ file: e.path, line: i + 1, content: line.trim().slice(0, 160) })
+      })
+    } catch {
+      probe1.skippedFiles.push(e.path)
+    }
+  }
+
+  // ── 探针 3：验收标准测试覆盖（task 卡 allowed_paths → 模块目录递归找测试文件）──
+  const tasksPath = join(changeDir, 'tasks.md')
+  const probe3 = { tasks: [], note: '集成盲区（路由/跨模块装配）与断言有效性抽查是语义判断，留给 agent 逐 task 标注 ⚠️' }
+  for (const taskId of listTaskIds(tasksPath)) {
+    const cardPath = join(changeDir, 'tasks', `${taskId}.md`)
+    let allowed = []
+    if (existsSync(cardPath)) allowed = parseAllowedPaths(readFileSync(cardPath, 'utf8'))
+    const moduleDirs = [...new Set(allowed.map(p => dirname(p.split('\\').join('/'))).filter(d => d && d !== '.'))]
+    const testFiles = []
+    for (const d of moduleDirs) {
+      for (const f of findTestFiles(join(cwd, d), cwd)) {
+        if (!testFiles.includes(f)) testFiles.push(f)
+      }
+    }
+    probe3.tasks.push({
+      task: taskId,
+      moduleDirs,
+      testFiles: testFiles.slice(0, 10),
+      testFileCount: testFiles.length,
+      hasTest: testFiles.length > 0,
+      located: moduleDirs.length > 0,
+    })
+  }
+
+  // ── 探针 5：API 契约对账（复用 verifyApiParity：endpoints.json × 前端调用）──
+  const runtimeRoot = resolveRuntimeRoot({ specRoot: specDir }, specBase)
+  const probe5 = verifyApiParity(specBase, cwd, runtimeRoot, changeName)
+
+  // ── 探针 6：代码删除对账（git diff --name-status HEAD 的 D/R × design 声明三态）──
+  const probe6 = { deletions: [], note: '以 git 事实为准（真实 > 声明）；是否 FAIL blocker 由 agent 诚实判定' }
+  const nsOut = gitQuiet(cwd, ['diff', '--name-status', 'HEAD']) || ''
+  for (const row of nsOut.split('\n').filter(Boolean)) {
+    const [status, ...paths] = row.split('\t')
+    const st = (status || '').trim().toUpperCase()
+    if (!/^[DRC]/.test(st)) continue
+    // R/C 的旧路径等价删除（paths[0]）；D 的唯一路径
+    const target = (st.startsWith('D') ? paths[0] : paths[0]) || ''
+    const posix = target.split('\\').join('/')
+    if (!posix || posix.startsWith('.sillyspec/') || posix === 'meta.json' || basename(posix) === 'meta.json') continue
+    const op = designOps.get(posix)
+    let verdict
+    if (op && /删除|delete|del/i.test(op)) verdict = '✅ 合规（design 声明删除）'
+    else if (op) verdict = `❌ 高风险（design 声明「${op}」却整文件删除）`
+    else verdict = '⚠️ 未声明删除（design 清单未列出）'
+    probe6.deletions.push({ path: posix, status: st, designOp: op || null, verdict })
+  }
+
+  return { probe1, probe3, probe5, probe6 }
+}
+
+/**
+ * 渲染探针结果为 markdown（可直接粘进 verify-result.md「探针结果」章节）。
+ */
+export function renderVerifyProbesReport(result) {
+  const L = []
+  const { probe1, probe3, probe5, probe6 } = result
+
+  L.push('#### 探针 1：未实现标记扫描（design 清单文件）')
+  if (probe1.matches.length === 0) {
+    L.push('- ✅ 无 TODO/FIXME/尚未实现 标记命中')
+  } else {
+    for (const m of probe1.matches) L.push(`- ⚠️ \`${m.file}:${m.line}\` ${m.content}`)
+  }
+  if (probe1.globEntries.length > 0) L.push(`- ℹ️ glob 项未展开（agent 手动展开扫描）：${probe1.globEntries.join('、')}`)
+  if (probe1.skippedFiles.length > 0) L.push(`- ℹ️ 清单文件不存在（跳过）：${probe1.skippedFiles.join('、')}`)
+  L.push('')
+
+  L.push('#### 探针 2：设计关键词覆盖')
+  L.push('<!--TODO: 半语义探针——从 design 提取能力关键词逐个 grep 确认实现（agent 执行）-->')
+  L.push('')
+
+  L.push('#### 探针 3：验收标准测试覆盖')
+  if (probe3.tasks.length === 0) {
+    L.push('- ℹ️ tasks.md 无 checkbox 任务')
+  } else {
+    for (const t of probe3.tasks) {
+      if (!t.located) {
+        L.push(`- ⚠️ ${t.task}: 无 task 卡/allowed_paths，无法定位模块目录（agent 手查）`)
+      } else if (t.hasTest) {
+        L.push(`- ✅ ${t.task}: 模块目录（${t.moduleDirs.join('、')}）找到 ${t.testFileCount} 个测试文件（${t.testFiles.slice(0, 5).join('、')}${t.testFileCount > 5 ? ' …' : ''}）`)
+      } else {
+        L.push(`- ⚠️ ${t.task}: 模块目录（${t.moduleDirs.join('、')}）递归未找到测试文件（含 co-located tests/）`)
+      }
+    }
+  }
+  L.push(`- ℹ️ ${probe3.note}`)
+  L.push('')
+
+  L.push('#### 探针 4：决策追踪覆盖')
+  L.push('<!--TODO: 语义探针——D-xxx@vN → FR-xxx → plan/task 引用 → 证据回指闭环（agent 执行）-->')
+  L.push('')
+
+  L.push('#### 探针 5：API Contract Parity')
+  L.push(`- ${probe5.summary || `backend ${probe5.backendCount ?? 0} 端点 / frontend ${probe5.frontendCount ?? 0} 调用`}`)
+  if ((probe5.missingBackend || []).length > 0) {
+    L.push('')
+    L.push('| 状态 | 前端调用 | 后端端点 | 文件 |')
+    L.push('|---|---|---|---|')
+    for (const m of probe5.missingBackend) {
+      L.push(`| ❌ missing | ${m.method} ${m.path} | — | ${m.consumerFile || '?'}${m.consumerLine ? ':' + m.consumerLine : ''} |`)
+    }
+    L.push('')
+    L.push('- ❌ contract gap 是真实集成缺陷——诚实判 FAIL 并回 execute 补端点（CLI 仅 advisory 不硬阻断）')
+  }
+  if ((probe5.unusedBackend || []).length > 0) {
+    L.push(`- ⚠️ ${probe5.unusedBackend.length} 个后端端点前端未调用（warning 不阻断）：${probe5.unusedBackend.slice(0, 5).map(u => `${u.method} ${u.path}`).join('、')}${probe5.unusedBackend.length > 5 ? ' …' : ''}`)
+  }
+  L.push('')
+
+  L.push('#### 探针 6：代码删除对账')
+  if (probe6.deletions.length === 0) {
+    L.push('- ✅ git diff 无整文件删除（D/R/C）记录')
+  } else {
+    for (const d of probe6.deletions) {
+      L.push(`- ${d.verdict} \`${d.path}\`（git 状态 ${d.status}）`)
+    }
+  }
+  L.push(`- ℹ️ ${probe6.note}`)
+  return L.join('\n')
+}
+
+/**
+ * 生成 verify-result.md 骨架（七章节；探针结果机械预填，语义章节 <!--TODO--> 占位）。
+ * 结论章节留「待填」——extractVerifyConclusion 无 PASS/FAIL 关键词即判不过，骨架不能直接过门。
+ * @returns {string|null} 骨架全文；无 design.md/tasks.md（非完整流程变更）→ null
+ */
+export function generateVerifyResultSkeleton(result) {
+  const L = [
+    '# 验证报告（骨架由 `sillyspec verify-probes --change <变更名> --init` 生成）',
+    '',
+    '> 探针结果已机械预填；其余章节把 `<!--TODO-->` 替换为真实内容。**结论必须写明 PASS / FAIL**——',
+    '> 留「待填」会被 gate 判不过（fail-closed）。',
+    '',
+    '## 结论：<待填：PASS 或 FAIL（+一句话理由）>',
+    '',
+    '## 任务完成度',
+    '<!--TODO: 逐 task 对照 tasks.md 勾选与验收标准，完成/未完成/存疑三态-->',
+    '',
+    '## 设计一致性',
+    '<!--TODO: 实现与 design.md 的偏差（无偏差也显式写「一致」）-->',
+    '',
+    '## 探针结果（CLI 机械预填）',
+    renderVerifyProbesReport(result),
+    '',
+    '## 测试结果',
+    '<!--TODO: 测试命令 + 结果（通过数/失败数；known_failures 豁免逐条注明）-->',
+    '',
+    '## 决策追踪矩阵（如存在 decisions.md；无则删本节）',
+    '<!--TODO: | 决策 ID | FR | Task | Evidence | 状态 |（D-xxx@vN → FR-xxx → task → 证据回指闭环）-->',
+    '',
+    '## 技术债务',
+    '<!--TODO: TODO/FIXME/HACK 统计（探针 1 的命中已预填在上方探针结果）-->',
+    '',
+    '## 变更风险等级',
+    '<!--TODO: doc-only / unit-sufficient / contract-required / integration-critical / deployment-critical；若 design.md frontmatter 有 risk_level 显式声明，写明「显式声明 = <等级>」+ 理由（豁免可审计）-->',
+    '',
+    '## Runtime Evidence',
+    '<!--TODO: 关键命令输出/时间戳/commit hash 证据链；integration/deployment-critical 必填，按实际触碰的运行时组件写（启动命令/端点/请求响应/日志片段/生命周期终态断言/失败模式排除），未涉及的行写「不涉及」-->',
+    '',
+    '## 代码审查',
+    '<!--TODO: 问题列表 + 总体评价-->',
+    '',
+  ]
+  return L.join('\n')
+}