sillyspec 3.28.4 → 3.28.6

package/src/taskcard.js

@@ -74,6 +74,7 @@ export function buildTaskcardSkeleton({ taskId, title, titleZh, author, now, dep
     title: yamlScalar(title),
     title_zh: yamlScalar(titleZh),
     author: yamlScalar(author),
+    generated_by: 'sillyspec-taskcard', // P2-e provenance 戳（CLI 骨架出品标记）
     created_at: now,
     priority: 'P0',
     depends_on: (Array.isArray(dependsOn) && dependsOn.length > 0)
@@ -93,6 +94,7 @@ id: ${fm.id}
 title: ${fm.title}
 title_zh: ${fm.title_zh}
 author: ${fm.author}
+generated_by: ${fm.generated_by}
 created_at: ${fm.created_at}
 priority: ${fm.priority}
 depends_on: ${fm.depends_on}
@@ -232,6 +234,18 @@ export function cmdTaskcard(changeName, opts = {}) {
   // 本地墙钟（坑 taskcard-created-at-utc：toISOString 落 UTC，本地 09:39 写 01:39，子代理手工改两次）
   const now = nowWallClock()
 
+  // ── depends_on 的 plan.md Wave 反填（坑 taskcard-depends-wave-backfill，2026-09-10 驾驭
+  // 小结第五批③，三批子代理均发现骨架 depends_on 为空）：注册表行内注解
+  // `(depends_on: task-01,02)` 是第一来源，但 agent 写 tasks.md 常漏注解 → 骨架全空 →
+  // plan-adopt-waves 拓扑退化全进 Wave 1。plan.md Wave 段（`## Wave N` + `- task-NN` 纯 ID
+  // 引用行）是 plan 阶段的分组真相——Wave N 任务 depends_on = Wave N-1 全部任务（波间串行
+  // 波内并行的既定语义，传递闭包等价）。仅注解缺失时兜底，注解在场优先（更细粒度）。
+  const waveDepsByTask = parsePlanWaveDeps(existsSync(planPath) ? planPath : null)
+  function depsFor(id, reg) {
+    if (reg && Array.isArray(reg.dependsOn) && reg.dependsOn.length > 0) return reg.dependsOn
+    return waveDepsByTask.get(id) || []
+  }
+
   const tasksDir = join(changeDir, 'tasks')
   mkdirSync(tasksDir, { recursive: true })
 
@@ -248,12 +262,41 @@ export function cmdTaskcard(changeName, opts = {}) {
     }
     writeFileSync(filePath, buildTaskcardSkeleton({
       taskId: id, title: finalTitle, titleZh: finalTitleZh, author, now,
-      // depends_on 从 tasks.md 行内注解反填（坑 taskcard-design-field-conflicts）：注册表
-      // 注解与 plan/design 的依赖声明同源，骨架直接带上省主代理逐卡转录
-      dependsOn: reg ? reg.dependsOn : [],
+      // depends_on 双来源：① tasks.md 行内注解反填（坑 taskcard-design-field-conflicts）
+      // ②注解缺失时按 plan.md Wave 分组兜底（坑 taskcard-depends-wave-backfill，见上）
+      dependsOn: depsFor(id, reg),
       sets,
     }), 'utf8')
     created.push(filePath)
   }
   return { created, skipped, tasksDir }
 }
+
+/**
+ * plan.md Wave 段解析 → 每任务的跨波依赖（Wave N 任务 → Wave N-1 全部任务 ID）。
+ * Wave 段形态（plan 铁律）：`## Wave N` 标题 + `- task-NN` 纯 ID 引用行。Wave 1 / 无 Wave /
+ * 解析异常 → 空 Map（调用方回退注解来源，fail-soft）。
+ * @param {string|null} planPath plan.md 绝对路径（null → 空 Map）
+ * @returns {Map<string, string[]>} taskId → 前一波任务 ID 列表
+ */
+export function parsePlanWaveDeps(planPath) {
+  const out = new Map()
+  if (!planPath) return out
+  let content
+  try { content = readFileSync(planPath, 'utf8').replace(/\r\n/g, '\n') } catch { return out }
+  const waves = [] // 每元素：task id 数组（按 Wave 标题出现顺序）
+  let cur = null
+  for (const line of content.split('\n')) {
+    const w = line.match(/^##\s+Wave\s+(\d+)\s*$/i)
+    if (w) { cur = []; waves.push(cur); continue }
+    if (cur === null) continue
+    const t = line.match(/^[-*]\s+(task-\d{1,3})\s*$/i)
+    if (t) cur.push(`task-${t[1].replace(/^task-/i, '').padStart(2, '0')}`)
+  }
+  for (let w = 1; w < waves.length; w++) {
+    const prev = waves[w - 1]
+    if (!prev || prev.length === 0) continue
+    for (const id of waves[w]) out.set(id, [...prev])
+  }
+  return out
+}

package/src/validate-artifacts.js

@@ -0,0 +1,163 @@
+/**
+ * validate-artifacts.js（P2-d，noai-ir-roadmap §5）：产物 schema 校验总命令的实现体。
+ *
+ * 背景：verify-facts 是唯一有真 validator 的 artifact（validateFactsV2），review.json/
+ * verify-required-evidence/endpoints/module-map 各自散落或无独立校验入口。本模块把既有
+ * 校验器聚合为一把伞（`sillyspec validate --change <c>`）：逐产物 pass/fail/skip 三态 +
+ * exit 1 on fail——「新解析器写之前先过 schema」有了统一落点。
+ *
+ * 复用面（不重复造校验器）：verify-facts validateFactsV2 / task review validateReviewSchema /
+ * stage review validateStageReviewSchema / module-map parseModuleMapSimple。轻形状检查仅覆盖
+ * 无既有 validator 的 required-evidence 与 endpoints（容忍缺省，出场才算）。
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+
+function checkJson(path, fn) {
+  if (!existsSync(path)) return { status: 'skip', reason: '不存在（未生成，不算失败）' }
+  let data
+  try {
+    data = JSON.parse(readFileSync(path, 'utf8'))
+  } catch (e) {
+    return { path, status: 'fail', issues: [`JSON 解析失败: ${e.message}`] }
+  }
+  try {
+    const issues = fn(data) || []
+    return { path, status: issues.length > 0 ? 'fail' : 'pass', issues }
+  } catch (e) {
+    return { path, status: 'fail', issues: [e.message] }
+  }
+}
+
+/**
+ * 校验一个变更的全部结构化产物。
+ * @returns {{ checks: Array<{ artifact: string, path?: string, status: 'pass'|'fail'|'skip', issues?: string[], reason?: string }>, ok: boolean }}
+ */
+export async function validateChangeArtifacts({ cwd, specBase, changeName, runtimeRoot }) {
+  const checks = []
+  const changeDir = join(specBase, 'changes', changeName)
+  const rt = runtimeRoot || join(specBase, '.runtime')
+
+  // ① verify-facts.json（既有真 validator）
+  {
+    const { validateFactsV2 } = await import('./verify-facts-schema.js')
+    const r = checkJson(join(changeDir, 'verify-facts.json'), (d) => {
+      const v = validateFactsV2(d)
+      return v && !v.ok ? (v.errors || ['validateFactsV2 不通过']) : []
+    })
+    checks.push({ artifact: 'verify-facts.json', ...r })
+  }
+
+  // ② verify-required-evidence.json（轻形状：execute Task Review Gate 的 cannot_verify 账）
+  {
+    const r = checkJson(join(changeDir, 'verify-required-evidence.json'), (d) => {
+      const issues = []
+      if (!d || typeof d !== 'object' || !Array.isArray(d.items)) issues.push('顶层缺 items 数组')
+      else {
+        for (const it of d.items) {
+          if (!it || typeof it.task !== 'string') issues.push(`items[].task 非字符串: ${JSON.stringify(it).slice(0, 60)}`)
+          if (!Array.isArray(it.evidence)) issues.push(`${it && it.task}: evidence 非数组`)
+        }
+      }
+      return issues
+    })
+    checks.push({ artifact: 'verify-required-evidence.json', ...r })
+  }
+
+  // ③ task review.json（最新 execute run 的逐 task 产物——既有 validateReviewSchema）
+  {
+    const markerPath = join(rt, `current-execute-run-id-${changeName}`)
+    const runId = existsSync(markerPath) ? readFileSync(markerPath, 'utf8').trim() : null
+    if (!runId) {
+      checks.push({ artifact: 'task reviews', status: 'skip', reason: '无 execute run marker（未经 execute 或已清理）' })
+    } else {
+      const tasksDir = join(rt, 'execute-runs', runId, 'tasks')
+      const files = existsSync(tasksDir) ? readdirSync(tasksDir).filter((d) => existsSync(join(tasksDir, d, 'review.json'))).map((d) => join(tasksDir, d, 'review.json')) : []
+      if (files.length === 0) {
+        checks.push({ artifact: 'task reviews', status: 'skip', reason: `run ${runId} 无 review.json` })
+      } else {
+        const { validateReviewSchema } = await import('./task-review.js')
+        const issues = []
+        for (const f of files) {
+          try {
+            const v = validateReviewSchema(JSON.parse(readFileSync(f, 'utf8')))
+            if (v && !v.ok) issues.push(`${f}: ${(v.errors || ['schema 不通过']).join('；').slice(0, 120)}`)
+          } catch (e) {
+            issues.push(`${f}: ${e.message}`)
+          }
+        }
+        checks.push({ artifact: `task reviews（${files.length} 个，run ${runId}）`, status: issues.length > 0 ? 'fail' : 'pass', issues })
+      }
+    }
+  }
+
+  // ④ stage reviews（brainstorm/plan/execute 的阶段评审产物——既有 validateStageReviewSchema）
+  {
+    const dir = join(rt, 'stage-reviews')
+    const files = existsSync(dir) ? readdirSync(dir).filter((d) => existsSync(join(dir, d, 'review.json'))).map((d) => join(dir, d, 'review.json')) : []
+    if (files.length === 0) {
+      checks.push({ artifact: 'stage reviews', status: 'skip', reason: '无 stage-reviews 产物' })
+    } else {
+      const { validateStageReviewSchema } = await import('./stage-review.js')
+      const issues = []
+      for (const f of files) {
+        try {
+          const v = validateStageReviewSchema(JSON.parse(readFileSync(f, 'utf8')))
+          if (v && !v.ok) issues.push(`${f}: ${(v.errors || ['schema 不通过']).join('；').slice(0, 120)}`)
+        } catch (e) {
+          issues.push(`${f}: ${e.message}`)
+        }
+      }
+      checks.push({ artifact: `stage reviews（${files.length} 份）`, status: issues.length > 0 ? 'fail' : 'pass', issues })
+    }
+  }
+
+  // ⑤ endpoints 契约产物（contract-artifacts/<change>/<task>/endpoints.json——轻形状）
+  {
+    const dir = join(rt, 'contract-artifacts', changeName)
+    const files = existsSync(dir) ? readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).flatMap((d) => existsSync(join(dir, d.name, 'endpoints.json')) ? [join(dir, d.name, 'endpoints.json')] : []) : []
+    if (files.length === 0) {
+      checks.push({ artifact: 'endpoints', status: 'skip', reason: '无 contract-artifacts 产物' })
+    } else {
+      const issues = []
+      for (const f of files) {
+        const r = checkJson(f, (d) => (!d || typeof d !== 'object' || (!Array.isArray(d.endpoints) && !Array.isArray(d)) ? ['缺 endpoints 数组'] : []))
+        if (r.status === 'fail') issues.push(`${f}: ${(r.issues || []).join('；')}`)
+      }
+      checks.push({ artifact: `endpoints（${files.length} 份）`, status: issues.length > 0 ? 'fail' : 'pass', issues })
+    }
+  }
+
+  // ⑥ module-map（全局一份/多份——schema_version 2 + canonical 解析可读）
+  {
+    const { parseModuleMapSimple } = await import('./modules.js')
+    const docsRoot = join(specBase, 'docs')
+    const maps = existsSync(docsRoot) ? readdirSync(docsRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync(join(docsRoot, d.name, 'modules', '_module-map.yaml'))).map((d) => join(docsRoot, d.name, 'modules', '_module-map.yaml')) : []
+    if (maps.length === 0) {
+      checks.push({ artifact: 'module-map', status: 'skip', reason: '无 _module-map.yaml（未 scan）' })
+    } else {
+      const issues = []
+      for (const m of maps) {
+        const text = readFileSync(m, 'utf8')
+        const sv = text.match(/^schema_version:\s*(\d+)/m)
+        if (!sv) issues.push(`${m}: 缺 schema_version 声明`)
+        else if (sv[1] !== '2') issues.push(`${m}: schema_version=${sv[1]}（期望 2）`)
+        if (!parseModuleMapSimple(text) || Object.keys(parseModuleMapSimple(text)).length === 0) issues.push(`${m}: canonical 解析 0 模块`)
+      }
+      checks.push({ artifact: `module-map（${maps.length} 份）`, status: issues.length > 0 ? 'fail' : 'pass', issues })
+    }
+  }
+
+  return { checks, ok: checks.every((c) => c.status !== 'fail') }
+}
+
+export function renderValidateReport(result) {
+  const lines = ['🧪 产物 schema 校验（validate 总命令）']
+  for (const c of result.checks) {
+    const mark = c.status === 'pass' ? '✅' : c.status === 'skip' ? '⏭️ ' : '❌'
+    lines.push(`   ${mark} ${c.artifact}${c.status === 'skip' ? ' — ' + (c.reason || '跳过') : ''}`)
+    for (const i of (c.issues || []).slice(0, 5)) lines.push(`      - ${i}`)
+  }
+  lines.push(result.ok ? '\n✅ 全部在场产物校验通过（skip = 未生成不算失败）' : `\n❌ ${result.checks.filter((c) => c.status === 'fail').length} 类产物校验失败`)
+  return lines.join('\n')
+}

package/src/verify-postcheck.js

@@ -23,6 +23,7 @@
  */
 
 import { execSync, spawnSync } from 'child_process'
+import { createHash } from 'crypto'
 import { IR_STRICT_SINCE } from './constants.js'
 import { gitQuiet } from './git-helper.js'
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs'
@@ -1058,8 +1059,33 @@ export function resolveVerifyChangedFiles(cwd, changeName, ctx = null, opts = {}
             !p.startsWith('.sillyspec/changes/') &&
             !p.startsWith('.sillyspec/.runtime/') &&
             !p.startsWith('.sillyspec/quicklog/'))
-        if (wtFiles.length > 0) {
-          mainFiles = [...new Set([...(mainFiles || []), ...wtFiles])]
+        // 已提交口径补齐（2026-09-10 用户反馈②「先提交则 diff 空」时序两难的 diff 半边）：
+        // worktree 内已 commit 的改动对主仓 base..HEAD 与 status --porcelain 双双不可见——
+        // 用 merge-base(主仓 HEAD, worktree HEAD)（= worktree 创建锚点）到 worktree HEAD 的
+        // commit diff 补入，未提交 ∪ 已提交两形态全覆盖。wtGitDir===cwd（in-place 退化）时
+        // 已提交改动已在 mainFiles，跳过防双并。fail-open：git 失败退回 status-only 现状。
+        let committedFiles = []
+        if (wtGitDir !== cwd) {
+          try {
+            const mainHead = gitQuiet(cwd, ['rev-parse', 'HEAD'], { timeout: 15000 })
+            const wtHead = gitQuiet(wtGitDir, ['rev-parse', 'HEAD'], { timeout: 15000 })
+            const mb = (mainHead && wtHead)
+              ? gitQuiet(wtGitDir, ['merge-base', wtHead, mainHead], { timeout: 15000 })
+              : null
+            if (mb) {
+              const diffOut = gitQuiet(wtGitDir, ['diff', '--name-only', mb, wtHead], { timeout: 30000 })
+              committedFiles = String(diffOut || '').split('\n')
+                .map(p => p.replace(/^"|"$/g, '').replace(/\\/g, '/').trim())
+                .filter(p => p && p !== '.sillyspec' &&
+                  !p.startsWith('.sillyspec/changes/') &&
+                  !p.startsWith('.sillyspec/.runtime/') &&
+                  !p.startsWith('.sillyspec/quicklog/'))
+            }
+          } catch { /* 已提交补齐失败退回 status-only（fail-open，不拖垮未提交并入） */ }
+        }
+        const merged = [...new Set([...(mainFiles || []), ...wtFiles, ...committedFiles])]
+        if (wtFiles.length > 0 || committedFiles.length > 0) {
+          mainFiles = merged
         }
       }
     } catch { /* working-tree 并入失败退回 commit diff 口径（fail-open） */ }
@@ -1929,6 +1955,40 @@ export function printVerifyDeletionCheck(result) {
   console.warn('   提示：确认删除是否预期。预期删除请在 design.md 清单用「删除」操作显式声明；误删请恢复。')
 }
 
+/**
+ * verify-result.md 内容回退检测（2026-09-10 用户反馈③：报告在 verify 中途被平台同步覆盖
+ * 回旧版一次，只能靠人眼发现后重写）。覆盖者在本仓之外（daemon/平台侧按服务端版本回写），
+ * CLI 侧能做的是**检测可见**：每次 CLI 读到该文件时记高水位指纹（content hash + mtime），
+ * 下次读到「内容变了且 mtime 回退」= 旧版复活的确定性指纹（服务端回写会顺带恢复服务端
+ * mtime，时间倒流唯此一路）→ ⚠️ 告警。纯 advisory 不阻断；高水位只前进不后退（回退态
+ * 不覆盖指纹，agent 重写后新指纹正常接管）。fail-open：任何异常视为无回退。
+ * @param {string} specBase spec 根（hwm 文件落 .runtime/）
+ * @param {string} changeName 变更名
+ * @param {string} absPath verify-result.md 绝对路径
+ * @returns {{ regressed: boolean, prevMtime: number|null }}
+ */
+export function trackVerifyResultRegression(specBase, changeName, absPath) {
+  try {
+    if (!absPath || !existsSync(absPath)) return { regressed: false, prevMtime: null }
+    const st = statSync(absPath)
+    const hash = createHash('sha256').update(readFileSync(absPath)).digest('hex')
+    const hwmPath = join(specBase, '.runtime', `verify-result-hwm-${changeName}.json`)
+    let prev = null
+    try { prev = JSON.parse(readFileSync(hwmPath, 'utf8')) } catch { prev = null }
+    const regressed = !!(prev && typeof prev.hash === 'string' &&
+      prev.hash !== hash && typeof prev.mtimeMs === 'number' &&
+      st.mtimeMs < prev.mtimeMs - 1000)
+    // 高水位只前进：当前 mtime 更新（正常编辑/重写）才覆盖指纹；回退态保留旧指纹供重写后再比对
+    if (!prev || st.mtimeMs >= (prev.mtimeMs || 0)) {
+      try {
+        mkdirSync(join(specBase, '.runtime'), { recursive: true })
+        writeFileSync(hwmPath, JSON.stringify({ hash, mtimeMs: st.mtimeMs, ts: Date.now() }) + '\n')
+      } catch { /* hwm 落盘失败 → 下次当首次（fail-open） */ }
+    }
+    return { regressed, prevMtime: prev && prev.mtimeMs ? prev.mtimeMs : null }
+  } catch { return { regressed: false, prevMtime: null } }
+}
+
 /**
  * required-evidence 对账（advisory，不阻断 verify 完成）。
  *
@@ -2224,14 +2284,20 @@ function parsePorcelainFilePaths(raw) {
  * 统一收尾：filterDeliverableFiles 过滤基建产物（.sillyspec/changes|.runtime|quicklog、
  * meta.json——流程产物不算 scope creep）+ 去重排序（输出确定性）。
  *
- * @returns {{ ok: boolean, form: 'worktree'|'post-apply', files: string[], sources: string[], foreignExcluded: number, degradedReason: string|null }}
+ * baseAnchor：与 files 同源的 diff 基点锚（scope-audit 行数采集复用，本模块自身不消费）——
+ * 形态 A 读同一份 worktree meta.json（优先级 baselineCommit>actualBaseHash>baseHash，与
+ * resolveMainChangedFiles 同口径，三锚全缺 null）；形态 B 取 merge-base hash（分支不存在/
+ * merge-base 不可得 null）；降级返回恒 null。
+ *
+ * @returns={{ ok: boolean, form: 'worktree'|'post-apply', files: string[], sources: string[], foreignExcluded: number, degradedReason: string|null, baseAnchor: string|null }}
  */
-function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, changeName }) {
+export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, changeName }) {
   const metaPath = join(specBase, '.runtime', 'worktrees', changeName, 'meta.json')
   const form = existsSync(metaPath) ? 'worktree' : 'post-apply'
   const sources = []
   const union = new Set()
   let foreignExcluded = 0
+  let baseAnchor = null
 
   if (form === 'worktree') {
     // —— 形态 A：worktree 存活，整链复用（锚点优先级 baselineCommit>actualBaseHash>baseHash、
@@ -2239,22 +2305,36 @@ function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, changeName })
     const files = resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase })
     if (files === null) {
       return { ok: false, form, files: [], sources, foreignExcluded,
-        degradedReason: 'worktree 锚点 diff 与主仓 fallback 均失败（git 不可用 / 非仓库）' }
+        degradedReason: 'worktree 锚点 diff 与主仓 fallback 均失败（git 不可用 / 非仓库）', baseAnchor: null }
     }
+    // baseAnchor：读同一份 worktree meta.json 锚点（baselineCommit>actualBaseHash>baseHash，
+    // resolveMainChangedFiles 同口径；解析失败/三锚全缺 → null）
+    try {
+      const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
+      baseAnchor = meta?.baselineCommit || meta?.actualBaseHash || meta?.baseHash || null
+    } catch {}
     sources.push('worktree:diff-base..HEAD', 'worktree:status-porcelain(uncommitted)')
     for (const f of files) union.add(normalizeReconcilePath(f))
   } else {
     // —— 形态 B：post-apply 自取三源 ——
     let diffOk = false
     let statusOk = false
-    // B1 merge-base 锚定 diff（分支/merge-base 不可得时静默省略该源，不算 git 失败）
+    // B1 merge-base 锚定 diff（分支/merge-base 不可得时静默省略该源，不算 git 失败）。
+    // 分支删除后回退审计 tag（quick-df1fed77）：apply+cleanup 删分支时 worktree.js:1065 打
+    // sillyspec-audit/<branch> tag 锚定 tip（gc 安全）——tag ref 可继续算 merge-base，baseAnchor
+    // 与 B1 diff 源在归档/已提交形态下恢复完整（否则恒 null，行数只剩 HEAD 未提交窗口口径）。
     const branch = 'sillyspec/' + changeName
     const branchHash = gitQuiet(cwd, ['rev-parse', '--verify', '--quiet', branch + '^{commit}'], { timeout: 30 * 1000 })
-    if (typeof branchHash === 'string' && branchHash.trim()) {
+    const auditTag = 'sillyspec-audit/' + branch
+    const diffRef = (typeof branchHash === 'string' && branchHash.trim())
+      ? branch
+      : (gitQuiet(cwd, ['rev-parse', '--verify', '--quiet', auditTag + '^{commit}'], { timeout: 30 * 1000 }) ? auditTag : null)
+    if (diffRef) {
       // 形态 B 定义下 meta 已删，baseBranch 无从读 → 缺省 'main'（run/prompt.js:764 同缺省）；
       // 主分支叫 master 等仓库 merge-base 失败 → 与分支不存在同处置（省略该源）
-      const mergeBase = gitQuiet(cwd, ['merge-base', 'main', branch], { timeout: 30 * 1000 })
+      const mergeBase = gitQuiet(cwd, ['merge-base', 'main', diffRef], { timeout: 30 * 1000 })
       if (typeof mergeBase === 'string' && mergeBase.trim()) {
+        baseAnchor = mergeBase.trim()
         const files = runGitDiffNameOnly(cwd, mergeBase.trim())
         if (files !== null) {
           diffOk = true
@@ -2289,12 +2369,12 @@ function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, changeName })
     }
     if (!diffOk && !statusOk) {
       return { ok: false, form, files: [], sources, foreignExcluded,
-        degradedReason: 'merge-base 锚定 diff 未得且主仓 status 失败（git 不可用 / 非仓库 / 无锚点分支）' }
+        degradedReason: 'merge-base 锚定 diff 未得且主仓 status 失败（git 不可用 / 非仓库 / 无锚点分支）', baseAnchor: null }
     }
   }
 
   const files = [...new Set(filterDeliverableFiles([...union]).filter(Boolean))].sort()
-  return { ok: true, form, files, sources, foreignExcluded, degradedReason: null }
+  return { ok: true, form, files, sources, foreignExcluded, degradedReason: null, baseAnchor }
 }
 
 /**

package/src/verify-probes.js

@@ -24,6 +24,7 @@ import {
   FACTS_SCHEMA_VERSION, EVIDENCE_SLOT_HEADING, RECEIPT_SLOT_HEADING, parseEvidenceSlots,
 } from './verify-facts-schema.js'
 import { parseFileChangeListDetailed } from './change-list.js'
+import { parseDecisions } from './decision-distill.js'
 import { parseAllowedPaths } from './stages/plan-postcheck.js'
 import { verifyApiParity, _readWorktreeMeta } from './contract-matrix.js'
 import { splitOwnVsForeignDiffFiles } from './foreign-declared.js'
@@ -152,16 +153,18 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
     const moduleDirs = [...new Set(allowed.map(p => dirname(p.split('\\').join('/'))).filter(d => d && d !== '.'))]
     const testFiles = []
     for (const d of moduleDirs) {
-      // 同探针 1 的 worktree 回退（坑 probe1-worktree-path-blind）：新模块目录 apply 前只在
-      // worktree——主仓目录缺失时到 worktree 找 co-located 测试（路径相对 worktree 根呈现）
-      let searchRoot = join(cwd, d)
-      let relBase = cwd
-      if (!existsSync(searchRoot) && wtRoot && existsSync(join(wtRoot, d))) {
-        searchRoot = join(wtRoot, d)
-        relBase = wtRoot
-      }
-      for (const f of findTestFiles(searchRoot, relBase)) {
-        if (!testFiles.includes(f)) testFiles.push(f)
+      // 双根并集扫描（坑 probe3-worktree-test-false-negative，2026-09-10 驾驭小结第五批②，
+      // 用户实证 5 条假 warning）：apply 前新测试文件只在 worktree（untracked），而模块目录在
+      // 主仓**已存在**——旧「主仓目录缺失才回退 worktree」条件不触发，探针 3 报「未找到测试
+      // 文件」假阴。改为无条件双根并集（主仓 ∪ worktree，各自存在才扫，路径相对各自根呈现，
+      // 按 rel 去重主仓优先——与探针 5 的三根并集同族）。主仓 in-place（wtRoot=null）零变化。
+      const roots = []
+      if (existsSync(join(cwd, d))) roots.push({ root: join(cwd, d), base: cwd })
+      if (wtRoot && wtRoot !== cwd && existsSync(join(wtRoot, d))) roots.push({ root: join(wtRoot, d), base: wtRoot })
+      for (const s of roots) {
+        for (const f of findTestFiles(s.root, s.base)) {
+          if (!testFiles.includes(f)) testFiles.push(f)
+        }
       }
     }
     probe3.tasks.push({
@@ -355,6 +358,22 @@ export function buildVerifyFacts(result, { changeName, now } = {}) {
   }
 }
 
+/**
+ * 平台模式产物路径回显注记（2026-09-10 驾驭小结②，用户实锤「显示混乱」）：
+ * verify-probes --init 在平台模式（.sillyspec-platform.json pointer 存在）下 spec 根解析为
+ * hub 镜像目录——回显的物理路径（骨架生成/已存在/facts 刷新）都在镜像根下，而产物经
+ * daemon spec-sync 落主仓 .sillyspec/changes/<change>/。agent/人工核对以主仓路径为准，
+ * 回显行尾追加本注记消歧义（本地模式返回空串，回显零变化）。
+ * @param {string|null} platformBase 平台镜像根（null/undefined = 非平台模式）
+ * @param {string} changeName 变更名
+ * @param {string} file 产物文件名（verify-result.md / verify-facts.json）
+ * @returns {string} 注记文本（非平台模式为 ''）
+ */
+export function formatPlatformPathNote(platformBase, changeName, file) {
+  if (!platformBase) return ''
+  return `（平台模式：物理写盘在 hub 镜像根 ${platformBase}；主仓同步位置 .sillyspec/changes/${changeName}/${file}，核对以主仓路径为准）`
+}
+
 /**
  * verify-probes --init 落盘 verify-facts.json（CLI 全权写）。v2（2026-09-08-ir-verify-facts）改
  * 分段合并：re-init 刷新机器段（probes/generatedAt），保留既有 slot-backfill/实测固化段
@@ -363,9 +382,10 @@ export function buildVerifyFacts(result, { changeName, now } = {}) {
  * @param {string} changeDir 变更目录（spec 根下 changes/<name>）
  * @param {object} result runVerifyProbes 返回值
  * @param {string} changeName 变更名（统一命令行呈现）
+ * @param {{ platformNote?: string }} [opts] platformNote 回显行尾追加（平台模式路径消歧，纯回显层不进落盘）
  * @returns {{ facts: object, path: string }}
  */
-export function writeVerifyFacts(changeDir, result, changeName) {
+export function writeVerifyFacts(changeDir, result, changeName, opts = {}) {
   const fresh = buildVerifyFacts(result, { changeName })
   const factsPath = join(changeDir, 'verify-facts.json')
   let facts = fresh
@@ -383,7 +403,7 @@ export function writeVerifyFacts(changeDir, result, changeName) {
     }
   } catch { /* 首次落盘/v1/损坏 → 全新快照（v1 无固化段，直接升 v2） */ }
   writeFileSync(factsPath, JSON.stringify(facts, null, 2) + '\n')
-  console.log(`📝 已刷新 verify-facts.json 机器底稿: ${factsPath}（v2 分段合并，固化段保留；CLI 全权写，勿手改）`)
+  console.log(`📝 已刷新 verify-facts.json 机器底稿: ${factsPath}（v2 分段合并，固化段保留；CLI 全权写，勿手改）${opts.platformNote || ''}`)
   return { facts, path: factsPath }
 }
 
@@ -483,6 +503,108 @@ export function backfillMissingEvidenceSlots(mdPath, requiredEvidenceItems = [])
   return { added }
 }
 
+/**
+ * 结论草稿槽行预填（P0-1 前置三，noai-ir-roadmap §3）：机械事实全绿时把骨架「结论枚举：」
+ * 待填槽替换为 PASS 草稿——显式「草稿待确认」内联标注（非默认值语义），agent 复核后可改写；
+ * gate 对槽行的独立复核逻辑不经本函数（判定链不动，预填只省打字成本）。纯文本变换三态：
+ * 槽行未填（仍含「待填」）→ 改写；已填（任何枚举值）→ 原样返回；无槽行（legacy 存量）→
+ * 原样返回。改写后槽行满足 extractVerifyConclusionSlot 行首锚定枚举解析（返回 PASS）。
+ */
+export function applyConclusionDraftToText(text, draft = 'PASS') {
+  const normalized = String(text).replace(/\r\n/g, '\n')
+  const lines = normalized.split('\n')
+  for (let i = 0; i < lines.length; i++) {
+    if (/^结论枚举：/.test(lines[i]) && lines[i].includes('待填')) {
+      lines[i] = `结论枚举：${draft}（🤖 CLI 草稿待确认——机械事实全绿自动预填：noAI 实测通过 + 探针 1/3/5/6 干净 + 风险门非 integration/deployment；复核后不同意即改写本行枚举值，gate 独立复核不受预填影响）`
+      return lines.join('\n')
+    }
+  }
+  return text
+}
+
+/**
+ * 决策追踪矩阵机械半边（P0-1，noai-ir-roadmap §3）：D→FR→task 链自结构化字段构建——
+ * decisions.md 条目（parseDecisions 双格式解析，与 distill 同源单一实现）× tasks/task-NN.md
+ * frontmatter 的 decision_ids / requirement_ids（taskcard 9 硬校验字段，CLI 骨架写入——比
+ * tasks.md 行内注解可靠）。Evidence / 状态两列是人工判断置 <待填>；D 无 task 回指 →
+ * ⚠️ 未闭环显式列出（这正是矩阵要暴露的风险，不静默）。
+ * @returns {{ rows: string[], decisionCount: number, taskCount: number }|null}
+ *   null = 无 decisions.md / 解析 0 条（矩阵段留 TODO 不注入）
+ */
+export function buildDecisionChainMatrix(changeDir) {
+  let decisions
+  try {
+    decisions = parseDecisions(changeDir)
+  } catch {
+    return null
+  }
+  if (!decisions || decisions.missing || (decisions.entries || []).length === 0) return null
+  // task 卡 frontmatter 结构化字段反查（列表 [a, b] 形态；frontmatter 由 plan-postcheck 硬校验）
+  const taskRefs = []
+  const tasksDir = join(changeDir, 'tasks')
+  try {
+    if (existsSync(tasksDir)) {
+      for (const f of readdirSync(tasksDir).filter((f) => /^task-\d+\.md$/.test(f)).sort()) {
+        const raw = readFileSync(join(tasksDir, f), 'utf8')
+        const id = (raw.match(/^id:\s*(\S+)/m) || [])[1] || f.replace(/\.md$/, '')
+        const decLine = (raw.match(/^decision_ids:\s*\[([^\]]*)\]/m) || [])[1] || ''
+        const reqLine = (raw.match(/^requirement_ids:\s*\[([^\]]*)\]/m) || [])[1] || ''
+        taskRefs.push({
+          task: id,
+          decisions: new Set(decLine.split(',').map((s) => s.trim()).filter(Boolean)),
+          reqs: new Set(reqLine.split(',').map((s) => s.trim()).filter(Boolean)),
+        })
+      }
+    }
+  } catch { /* tasks 目录不可读 → 矩阵 task 列全标未闭环（信息仍在） */ }
+  const rows = []
+  for (const d of decisions.entries) {
+    // task 卡 decision_ids 可能写 D-001（无 @vN）——id 与 number 双匹配同源
+    const hitTasks = taskRefs.filter((t) => t.decisions.has(d.id) || t.decisions.has(d.number))
+    const frs = [...new Set(hitTasks.flatMap((t) => [...t.reqs]))].sort()
+    const taskCell = hitTasks.length > 0 ? hitTasks.map((t) => t.task).join('、') : '⚠️ 未闭环（无 task 回指）'
+    const frCell = frs.length > 0 ? frs.join('、') : '⚠️ 未映射'
+    rows.push(`| ${d.id} | ${frCell} | ${taskCell} | <待填：证据回指> | <待填> |`)
+  }
+  return { rows, decisionCount: decisions.entries.length, taskCount: taskRefs.length }
+}
+
+/**
+ * 矩阵机械半边注入 verify-result.md（--init 接线）：只在「决策追踪矩阵」段内仍是骨架
+ * TODO 行（含 D-xxx 形态）且段内无既有表格时替换注入——幂等（agent 已写/前次注入零改动），
+ * 不触碰正文其余部分。落盘失败 fail-soft 返回 null。
+ * @returns {{ decisions: number, tasks: number }|null} null = 无 decisions/无可替换 TODO/已注入
+ */
+export function injectDecisionChainDraft(mdPath, changeDir) {
+  let text
+  try { text = readFileSync(mdPath, 'utf8') } catch { return null }
+  const headingIdx = text.indexOf('## 决策追踪矩阵')
+  if (headingIdx === -1) return null
+  const nextHeading = text.indexOf('\n## ', headingIdx + 1)
+  const sectionEnd = nextHeading === -1 ? text.length : nextHeading
+  const section = text.slice(headingIdx, sectionEnd)
+  if (/^\|/m.test(section)) return null // 已有表格 → 尊重既有内容
+  const todoRe = /<!--TODO:[^\n]*D-xxx[^\n]*-->/
+  if (!todoRe.test(section)) return null // 无骨架 TODO（手写正文）→ 不动
+  const matrix = buildDecisionChainMatrix(changeDir)
+  if (!matrix || matrix.rows.length === 0) return null
+  const block = [
+    '<!-- 机械半边预填（CLI，P0-1）：D→FR→task 链自 decisions.md × tasks/*.md frontmatter 结构化字段构建；',
+    '     Evidence / 状态两列是人工判断——逐格复核，未闭环行必须在报告标注风险 -->',
+    '| 决策 ID | FR | Task | Evidence | 状态 |',
+    '|---|---|---|---|---|',
+    ...matrix.rows,
+  ].join('\n')
+  const next = text.slice(0, headingIdx) + section.replace(todoRe, block) + text.slice(sectionEnd)
+  try {
+    writeFileSync(mdPath, next)
+  } catch (e) {
+    console.warn(`⚠️ 决策追踪矩阵预填落盘失败（fail-soft）: ${e && e.message ? e.message : e}`)
+    return null
+  }
+  return { decisions: matrix.decisionCount, tasks: matrix.taskCount }
+}
+
 /**
  * 生成 verify-result.md 骨架（七章节；探针结果机械预填，语义章节 <!--TODO--> 占位）。
  * 结论走「结论枚举：」固定槽行（刀③，2026-09-08）——占位符不含枚举词（<待填：三选一>），