sillyspec 3.32.2 → 3.32.3

package/src/verify-probes.js

@@ -2180,6 +2180,9 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
             task: fmId || f.replace(/\.md$/, ''),
             acceptance: parsed.acceptance,
             fmError: parsed.status === 'invalid-yaml' ? parsed.error : null,
+            // FR-06（2026-10-09-verify-reuse-friction）：行 repo 归属写侧透传（跨仓卡 tests
+            // 仓根相对，读侧按行根解析）
+            repo: parseRepo(raw) || null,
             raw,
           })
         }
@@ -2280,6 +2283,9 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
                 discovery: 'machine',
                 confirmed_by: null,
                 source_change: changeName,
+                // FR-06（2026-10-09-verify-reuse-friction）：跨仓卡的 tests 是仓根相对——
+                // 行携 repo 归属供读侧按行根解析（缺省不落键=主仓，D-005@v1）。
+                ...(t.repo && t.repo !== 'main' ? { repo: t.repo } : {}),
               })
             })
           }
@@ -3854,3 +3860,138 @@ export function refreshProbeSections(existingText, freshReportText) {
   }
   return { text: out.join('\n'), replaced, kept, appended, carriedRows }
 }
+
+// ── --force 保人工面（2026-10-09-verify-papercuts ②）──
+// postmortem（2026-10-09-verify-reuse-friction 收口实证）：--force 全骨架重置虽有自动备份，
+// 但结论槽/移交项表/探针矩阵已填判定/决策矩阵已填格仍全部被 wipe——重填整套人工面是当日
+// 最大单点浪费（备份在 .runtime 里，找回-回填的来回远比携载贵）。本组合器把 --force 语义
+// 从「全量重置 + 备份找回」升级为「机器段全量重刷 + 人工面按段携载」：
+//   - 纯人工段（结论/移交项/证据账/集成回执/任务完成度/设计一致性/独立复核/风险等级）：
+//     旧段已填（无 <待填/<TODO 占位）→ 原样保留；未填 → 用新骨架（占位换新占位，无损失）；
+//   - 矩阵段（决策追踪矩阵/接口验证覆盖矩阵）：表格行按首列键携载（mergeProbeSection 同
+//     款语义——已填 Evidence/判定行不丢，新增行从新骨架进场）；
+//   - 探针容器段（## 探针结果）：逐探针号 merge（已填表格行携载，机器结论行刷新）；
+//   - 其余机器段：新骨架；旧文独有的自定义段：追加保留（不销毁用户内容）。
+// 安全方向与 refreshProbeSections 一致：宁可少刷新不误删；stale 由 gate 的
+// checkProbeConsistency 独立把关。备份照旧保留（兜底通道不撤）。
+
+/** 顶层段切分（^## 标题行起，至下一 ^## 或 EOF；# 级更细的 #### 归属其容器段） */
+function splitTopSections(text) {
+  const lines = String(text ?? '').split('\n')
+  const sections = []
+  let cur = null
+  for (let i = 0; i < lines.length; i++) {
+    if (/^## /.test(lines[i])) {
+      if (cur) cur.endLine = i
+      cur = { headingLine: lines[i], startLine: i, endLine: lines.length }
+      sections.push(cur)
+    }
+  }
+  return { lines, sections }
+}
+
+/** 段身份键：剥 [层：…] 尾注与（…）括注——同族段跨渲染措辞漂移仍可对上 */
+function topSectionKey(headingLine) {
+  return headingLine
+    .replace(/^##\s*/, '')
+    .replace(/\s*\[.*\]\s*$/, '')
+    .replace(/（.*$/, '')
+    .trim()
+}
+
+const HUMAN_SECTION_KEYS = ['结论', '移交项', '证据账', '集成验证回执', '任务完成度', '设计一致性', '独立复核', '变更风险等级', '技术债务', 'Runtime Evidence', '代码审查']
+const MATRIX_SECTION_KEYS = ['决策追踪矩阵', '接口验证覆盖矩阵']
+const PROBE_CONTAINER_KEY = '探针结果'
+
+/** 探针容器段合并：新骨架容器为基，逐探针号对旧容器做已填行携载；旧独有探针号追加 */
+function mergeProbeContainer(oldContainerLines, freshContainerLines) {
+  const oldParsed = splitProbeSectionRanges(oldContainerLines.join('\n'))
+  const freshParsed = splitProbeSectionRanges(freshContainerLines.join('\n'))
+  const out = [...freshParsed.lines]
+  let carriedRows = 0
+  const oldByNum = new Map(oldParsed.sections.map(s => [s.num, s]))
+  for (let idx = freshParsed.sections.length - 1; idx >= 0; idx--) {
+    const fs = freshParsed.sections[idx]
+    const os = oldByNum.get(fs.num)
+    if (!os) continue
+    const merged = mergeProbeSection(
+      oldParsed.lines.slice(os.startLine, os.endLine),
+      freshParsed.lines.slice(fs.startLine, fs.endLine),
+    )
+    // 倒序替换（审查 P2 修正，2026-10-09-verify-papercuts）：mergeProbeSection 对含 stale
+    // 键的段会在段尾追加（行数 > freshSeg），正序 splice 会使后续探针段 startLine 错位——
+    // 从后往前替换则前面行号不受影响，任一段行数膨胀都安全。
+    carriedRows += merged.carried
+    // 用 merged 文本替换 fresh 容器中该探针段（逐段行数已知，从后往前替换保行号稳定）
+    const freshSeg = freshParsed.lines.slice(fs.startLine, fs.endLine)
+    out.splice(fs.startLine, freshSeg.length, ...merged.text.split('\n'))
+  }
+  const freshNums = new Set(freshParsed.sections.map(s => s.num))
+  for (const os of oldParsed.sections) {
+    if (!freshNums.has(os.num)) {
+      out.push('', ...oldParsed.lines.slice(os.startLine, os.endLine))
+    }
+  }
+  return { text: out.join('\n'), carriedRows }
+}
+
+/**
+ * --force 应用骨架：机器段全量重刷 + 人工面携载（纯函数，导出供回归直测）。
+ * @param {string} existingText 现文（含已填人工面）
+ * @param {string} skeletonText generateVerifyResultSkeleton 新骨架
+ * @returns {{ text: string, carriedSections: string[], carriedRows: number }}
+ */
+export function applySkeletonPreservingHuman(existingText, skeletonText) {
+  const old = splitTopSections(existingText)
+  const fresh = splitTopSections(skeletonText)
+  const oldByKey = new Map()
+  for (const s of old.sections) {
+    const k = topSectionKey(s.headingLine)
+    if (!oldByKey.has(k)) oldByKey.set(k, s) // 同键段取首个（重复标题形态保首段）
+  }
+  const carriedSections = []
+  let carriedRows = 0
+  const out = []
+  let cursor = 0
+  for (const fs of fresh.sections) {
+    // 骨架段前的行原样带过
+    for (; cursor < fs.startLine; cursor++) out.push(fresh.lines[cursor])
+    const k = topSectionKey(fs.headingLine)
+    const os = oldByKey.get(k)
+    const freshSeg = fresh.lines.slice(fs.startLine, fs.endLine)
+    if (!os) {
+      out.push(...freshSeg)
+    } else if (HUMAN_SECTION_KEYS.includes(k)) {
+      const oldSeg = old.lines.slice(os.startLine, os.endLine)
+      if (/<待填|<!--TODO/.test(oldSeg.join('\n'))) {
+        out.push(...freshSeg) // 未填 → 换新骨架占位
+      } else {
+        out.push(...oldSeg) // 已填 → 原样保留
+        carriedSections.push(k)
+      }
+    } else if (MATRIX_SECTION_KEYS.includes(k)) {
+      const merged = mergeProbeSection(old.lines.slice(os.startLine, os.endLine), freshSeg)
+      carriedRows += merged.carried
+      out.push(...merged.text.split('\n'))
+      if (merged.carried > 0) carriedSections.push(k)
+    } else if (k === PROBE_CONTAINER_KEY) {
+      const merged = mergeProbeContainer(old.lines.slice(os.startLine, os.endLine), freshSeg)
+      carriedRows += merged.carriedRows
+      out.push(...merged.text.split('\n'))
+      if (merged.carriedRows > 0) carriedSections.push(k)
+    } else {
+      out.push(...freshSeg) // 机器段（探针概览/接口声明等）→ 新骨架
+    }
+    cursor = fs.endLine
+    oldByKey.delete(k)
+  }
+  for (; cursor < fresh.lines.length; cursor++) out.push(fresh.lines[cursor])
+  // 旧文独有段（用户自定义节）追加保留
+  if (oldByKey.size > 0) {
+    out.push('')
+    for (const [, s] of oldByKey) {
+      out.push(...old.lines.slice(s.startLine, s.endLine))
+    }
+  }
+  return { text: out.join('\n'), carriedSections, carriedRows }
+}

package/src/wt-commit.js

@@ -17,7 +17,7 @@
  *
  * 成功返回 HEAD hash（review.json 的 head 锚点直接可用）；无变更 → ok=true + skipped。
  */
-import { join, resolve } from 'node:path'
+import { join, resolve, relative, sep, basename, dirname } from 'node:path'
 import { existsSync, readFileSync } from 'node:fs'
 import { withFileLock } from './quicklog.js'
 import { safeGit } from './git-helper.js'
@@ -55,6 +55,48 @@ async function gitWithLockRetry(cwd, args, label, { retries = 6, waitMs = 1000 }
  * @returns {Promise<{ok:boolean,skipped:boolean,head:string,shortHead:string,worktreePath:string,changeName:string,files:string[]}>}
  *   ok=false 时抛错（调用方打错误 + exit 1），skipped=无变更可提交（HEAD 不动，不算失败）。
  */
+/**
+ * 从 cwd 推断变更名（wt-commit 免 --change 通道；FR-08 / D-006@v1）。
+ * 跨仓 worktree 名 <change>--<repoKey>——仅当后缀命中 repos 注册表（worktrees 上两级
+ * local.yaml）且剥出候选是已知变更目录才剥（不猜切分）；全段命中主仓已知变更不剥（防
+ * 变更真名恰以 --repoKey 结尾）；均不中 → 原样透传（现状行为，调用方自然报错引导
+ * 显式 --change）。导出供三态回归直测（index.js dispatch 内联形态不可测——独立审查指出的
+ * 验证面缺口）。
+ */
+export async function inferChangeFromWorktreeCwd(dir) {
+  // 深路径归一（FR-08）：cwd 可能在 worktree 内多层深处——specBase 推导须从 worktree 根起算。
+  // 找 'worktrees' 目录段在原路径中的位置，根 = 该段后第一段截尾；specBaseGuess = 根上溯
+  // 三级（worktrees → .runtime → .sillyspec 的父，即主仓 specBase）。
+  const s = String(dir)
+  const norm = s.split('\\').join('/')
+  const wtIdx = norm.lastIndexOf('/worktrees/')
+  let seg = null
+  let specBaseGuess = null
+  if (wtIdx !== -1) {
+    const rest = norm.slice(wtIdx + '/worktrees/'.length)
+    const rootRel = rest.split('/')[0]
+    seg = rootRel || null
+    const rootNorm = norm.slice(0, wtIdx + '/worktrees/'.length + rootRel.length)
+    specBaseGuess = rootNorm.split('/').slice(0, -3).join('/')
+  }
+  if (seg && seg.includes('--')) {
+    try {
+      if (specBaseGuess) {
+        const knownWhole = existsSync(join(specBaseGuess, 'changes', seg))
+        const dash = seg.lastIndexOf('--')
+        const cand = seg.slice(0, dash)
+        const suffix = seg.slice(dash + 2)
+        if (!knownWhole && cand && /^[A-Za-z0-9_.-]+$/.test(suffix)) {
+          const { parseRepoRegistry } = await import('./stages/plan-postcheck.js')
+          const reg = parseRepoRegistry(readFileSync(join(specBaseGuess, 'local.yaml'), 'utf8'))
+          if (reg.has(suffix) && existsSync(join(specBaseGuess, 'changes', cand))) seg = cand
+        }
+      }
+    } catch { /* 注册表不可读 → 原样透传（fail-safe） */ }
+  }
+  return seg
+}
+
 export async function runWtCommit({ changeName, message, pathspecs = [], pathspecFile = null, cwd = process.cwd() }) {
   if (!changeName) throw new Error('缺少 --change <变更名>（worktree 名；在 worktree 内运行时可省略，CLI 从 cwd 推断）')
   if (!message || !message.trim()) throw new Error('缺少 -m/--message <提交信息>（建议 "<task-NN 摘要>"）')
@@ -77,10 +119,47 @@ export async function runWtCommit({ changeName, message, pathspecs = [], pathspe
   // 隔离模式（worktree 目录存在）→ 提交目标 = worktree 本体；in-place-fallback（meta 声明无
   // worktree 直改主仓）→ 主仓根（与 MultiRepoContext 主仓 entry 的 worktreePath 兜底口径一致）。
   // 顺序先看目录再看 meta：worktree 目录存在即隔离态，meta 缺失/损坏不改变目标（fail-safe）。
+  // FR-08（2026-10-09-verify-reuse-friction / D-006@v1）：cwd 已在本变更的 worktree 内 →
+  // 提交目标=该 worktree 本体。跨仓 worktree 名 <change>--<repoKey> 不在 getWorktreePath
+  // 的主仓命名域（原路径必落「worktree 不存在」错）；主仓 worktree 场景与原值同目录零漂移。
+  // 归属校验（不猜）：worktree 根段 === changeName，或 === changeName--<注册repoKey>（repos
+  // 注册表读自 worktreeBase 上两级的 local.yaml；注册表不可读 → 只认精确名，fail-safe）。
   let target = null
-  if (existsSync(worktreePath)) {
+  {
+    // 基座发现（目录事实）：优先 wm.worktreeBase（主仓）；cwd 不在其下时向上找名为 worktrees
+    // 的目录作基座（跨仓 worktree 是跨仓仓的 git worktree，WorktreeManager 从其 cwd 算不出
+    // 主仓基座——跨仓 worktree 的父目录本身就是 worktrees 基座）。
+    let base = resolve(wm.worktreeBase)
+    {
+      let d = resolve(cwd)
+      for (;;) {
+        if (dirname(d) === base) break
+        const parent = dirname(d)
+        if (basename(parent) === 'worktrees') { base = parent; break }
+        if (parent === d) break
+        d = parent
+      }
+    }
+    const cwdAbs = resolve(cwd)
+    if (cwdAbs.startsWith(base + sep)) {
+      const wtRoot = relative(base, cwdAbs).split(sep)[0]
+      let own = wtRoot === changeName
+      if (!own && wtRoot.startsWith(changeName + '--')) {
+        const suffix = wtRoot.slice(changeName.length + 2)
+        if (suffix && /^[A-Za-z0-9_.-]+$/.test(suffix)) {
+          try {
+            const { parseRepoRegistry } = await import('./stages/plan-postcheck.js')
+            const reg = parseRepoRegistry(readFileSync(join(base, '..', '..', 'local.yaml'), 'utf8'))
+            own = reg.has(suffix)
+          } catch { own = false }
+        }
+      }
+      if (own && existsSync(join(base, wtRoot))) target = join(base, wtRoot)
+    }
+  }
+  if (!target && existsSync(worktreePath)) {
     target = worktreePath
-  } else {
+  } else if (!target) {
     const meta = wm.getMeta(changeName)
     if (meta && meta.mode === 'in-place-fallback') {
       target = resolve(wm.worktreeBase, '..', '..', '..') // <main>/.sillyspec/.runtime/worktrees → <main>