sillyspec 3.27.1 → 3.27.5

package/src/change-list.js

@@ -18,6 +18,22 @@ export function normalizePath(raw) {
     .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 语义）、
  * 单星 → 单段（[^/]*）、问号 → 单字符（[^/]），其余转义。
@@ -226,8 +242,12 @@ function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false } = {}
       // incidental：说明列（非路径列的所有 cell）+ 路径 cell 原始值（剥注释前的括号内容）
       const incidental = cells.some((c, i) => i !== pathColIdx && INCIDENTAL_RE.test(c))
         || INCIDENTAL_RE.test(cells[pathColIdx] || '')
-      if (listMode === 'exclude') { entries.delete(filePath); continue }
-      entries.set(filePath, { path: filePath, operation, incidental })
+      // 组合路径单元格拆分（坑 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
     }
 

package/src/change-risk-profile.js

@@ -122,7 +122,8 @@ export const RISK_LEVEL_CAUSES = {
     '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 等）。',
+    'design.md / plan.md 命中跨进程/状态机关键词（daemon / backend / session / lease / lifecycle / heartbeat 等）。' +
+    '关键词前方同句有否定提示（不/未/无/避免…）的命中已被抑制不参与判级——若本变更实际涉及跨进程/状态机改动，请在 design.md frontmatter 用 risk_level 声明真实等级。',
   'contract-required': 'design.md / plan.md 命中 API contract 关键词（api / client / contract / dto）。',
   'explicit': 'design.md frontmatter 的 risk_level 显式声明（覆盖关键词判级）。',
 }
@@ -130,6 +131,69 @@ export const RISK_LEVEL_CAUSES = {
 /** design.md frontmatter 可显式声明的合法 risk_level 值（与 detectChangeRisk 判级结果同集合） */
 const RISK_LEVELS = ['doc-only', 'unit-sufficient', 'contract-required', 'integration-critical', 'deployment-critical']
 
+// ============ 同句否定抑制（坑 risk-negation-blindness） ============
+//
+// detectChangeRisk 原为全文 blob 字面命中：design 写「本次不新增 daemon 协议」仍判
+// integration-critical、强制全套集成证据，对无状态后端变更误伤（用户实证 2026-08-24）。
+// 机械抑制规则（不做事语义理解，三段判定）：
+//   ① 子句切分：按 句号/分号/逗号/换行 切子句，否定只在同子句内生效——「不改动 A。新增 B」
+//      的 B 不继承否定；
+//   ② 直接否定：命中位置前方 NEGATION_WINDOW 字符内出现否定提示 → 抑制；
+//   ③ 枚举继承：「不改动 daemon / session / lifecycle」中后位关键词与前位被抑制关键词之间
+//      只隔枚举连接符（空格 / 、 , 和 与 及 and or）→ 继承抑制——纯距离窗口盖不住长枚举，
+//      而「不涉及 daemon 的情况下重构 session」的间隔是普通文字，不继承（session 正常命中）。
+// 同一关键词的**全部**命中都被抑制才不参与判级（任一处未抑制命中仍算数）。降级不静默：
+// design/verify 两道 gate 会把被抑制词打进 warning（可审计），design.md frontmatter
+// risk_level 仍是双向权威覆盖通道（声明优先级最高，行为不变）。
+//
+// 否定提示词排除假阳：不同/不断/不久/不时/不仅（「不」的非否定合成词）、无状态/无法
+// （「无状态后端」是常见肯定表述）、非常/非空/非法（「非空校验 session」是在改 session）。
+const NEGATION_CUES = /不(?!同|断|久|时|仅|妨)|未|无(?!状态|法)|非(?!常|空|法)|避免|排除|无需|不再|no\s+new|not\b|don'?t|without|avoid/i
+const NEGATION_WINDOW = 16
+const CLAUSE_SPLIT_RE = /[。；;，,\n]/
+const ENUM_GAP_RE = /^[\s/|、,，]*(?:(?:和|与|及|and|or)[\s/|、,，]*)*$/i
+
+/**
+ * 单行内统计各关键词命中（同子句否定窗口 + 枚举继承）。
+ * @returns {Map<string, {kept: number, suppressed: number}>} trigger 原文 → 命中统计
+ */
+function collectLineTriggerStats(line, patterns, stats = new Map()) {
+  for (const pattern of patterns) {
+    const re = new RegExp(pattern.source, pattern.flags.includes('g') ? pattern.flags : pattern.flags + 'g')
+    let m
+    while ((m = re.exec(line)) !== null) {
+      if (m[0].length === 0) { re.lastIndex++; continue }
+      // 行内绝对偏移 → 子句内相对偏移（子句内可能有多命中，逐一判定）
+      const clauseStart = line.slice(0, m.index).split(CLAUSE_SPLIT_RE).pop().length
+      const clauseStartAbs = m.index - clauseStart
+      const clause = line.slice(clauseStartAbs).split(CLAUSE_SPLIT_RE)[0]
+      const relIndex = m.index - clauseStartAbs
+      const prefix = clause.slice(0, relIndex)
+      let negated = NEGATION_CUES.test(prefix.slice(-NEGATION_WINDOW))
+      if (!negated && prefix.length > 0) {
+        // 枚举继承：查同子句内更早的关键词命中，且间隔只有枚举连接符
+        for (const other of patterns) {
+          const ore = new RegExp(other.source, other.flags.includes('g') ? other.flags : other.flags + 'g')
+          let om
+          while ((om = ore.exec(clause)) !== null) {
+            if (om[0].length === 0) { ore.lastIndex++; continue }
+            if (om.index >= relIndex) break
+            const gap = clause.slice(om.index + om[0].length, relIndex)
+            const prevSuppressed = NEGATION_CUES.test(clause.slice(0, om.index).slice(-NEGATION_WINDOW))
+            if (prevSuppressed && ENUM_GAP_RE.test(gap)) { negated = true; break }
+          }
+          if (negated) break
+        }
+      }
+      const stat = stats.get(m[0]) || { kept: 0, suppressed: 0 }
+      if (negated) stat.suppressed++
+      else stat.kept++
+      stats.set(m[0], stat)
+    }
+  }
+  return stats
+}
+
 /**
  * 从 design.md 顶部 frontmatter 提取显式 risk_level 声明。
  * 只认文档最开头 `---\n...\n---` 块内的 `risk_level: <level>` 单行（与 plan.md 的 plan_level 同款解析），
@@ -148,10 +212,11 @@ export function detectChangeRisk({ designContent = '', planContent = '', changed
   const triggers = []
 
   // ── 显式豁免优先：design.md frontmatter 声明 risk_level → 以声明为准，跳过关键词判级 ──
-  // 历史教训：detectChangeRisk 是机械字面匹配，不认否定语境——design 写「本次不改动 daemon/session」
-  // 仍命中关键词被误判 integration/deployment-critical，强制要全套集成证据，对无状态后端变更误伤。
-  // 与其在正则层做脆弱的否定识别，不如给一条显式、诚实、可审计（落在 design frontmatter + verify-result）
-  // 的覆盖通道。声明仍走门控（结论 FAIL 仍拦），但豁免级（unit-sufficient 等）不再强制集成证据。
+  // 历史教训：detectChangeRisk 是机械字面匹配——design 写「本次不改动 daemon/session」曾命中关键词
+  // 被误判 integration/deployment-critical，强制要全套集成证据，对无状态后端变更误伤。现给两条通道：
+  // ① 同句否定抑制（上方 NEGATION_CUES，机械可审计、只认「关键词前方否定窗口」不做语义理解）；
+  // ② frontmatter 显式声明（显式、诚实、可审计，落在 design frontmatter + verify-result）——本分支。
+  // 声明仍走门控（结论 FAIL 仍拦），但豁免级（unit-sufficient 等）不再强制集成证据。
   const explicit = extractExplicitRiskLevel(designContent)
   if (explicit) {
     const requiredVerification =
@@ -160,17 +225,20 @@ export function detectChangeRisk({ designContent = '', planContent = '', changed
       explicit === 'contract-required' ? ['unit_tests', 'contract_tests'] :
       explicit === 'doc-only' ? ['static_check'] :
       ['unit_tests']
-    return { level: explicit, triggers: ['risk_level (explicit)'], requiredVerification, explicit: true }
+    return { level: explicit, triggers: ['risk_level (explicit)'], suppressedTriggers: [], 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])
-    }
+  // 逐行收集命中：同句否定窗口内的命中进 suppressed（全部命中均被抑制才剔除该 trigger）
+  const stats = new Map()
+  for (const line of combined.split('\n')) {
+    collectLineTriggerStats(line, INTEGRATION_CRITICAL_PATTERNS, stats)
+  }
+  const suppressedTriggers = []
+  for (const [t, stat] of stats) {
+    if (stat.kept > 0) triggers.push(t)
+    else suppressedTriggers.push(t)
   }
 
   for (const file of changedFiles) {
@@ -184,7 +252,8 @@ export function detectChangeRisk({ designContent = '', planContent = '', changed
   }
 
   if (triggers.length === 0) {
-    return { level: 'doc-only', triggers: [], requiredVerification: ['static_check'] }
+    // 关键词命中全被否定语境抑制（或本就无命中）→ doc-only；抑制词随 suppressedTriggers 上报可审计
+    return { level: 'doc-only', triggers: [], suppressedTriggers, requiredVerification: ['static_check'] }
   }
 
   const deploymentTrigger = triggers.some(t => /cli\.ts|main\.ts|server\.(js|ts)|bootstrap|entrypoint/i.test(t))
@@ -207,7 +276,7 @@ export function detectChangeRisk({ designContent = '', planContent = '', changed
     level = 'unit-sufficient'
   }
 
-  return { level, triggers, requiredVerification }
+  return { level, triggers, suppressedTriggers, requiredVerification }
 }
 
 /**

package/src/config-schema.js

@@ -115,9 +115,9 @@ export const LOCAL_YAML_SCHEMA = {
     {
       id: 'test_strategy',
       title: '测试策略',
-      note: 'verify 阶段 CLI 对账的收窄策略。',
+      note: 'verify 阶段 CLI 对账的收窄策略（D-005@v2：skip 接线兑现 + evidence-auto 新增，full/module 语义不变）。',
       keys: [
-        { path: 'test_strategy', type: 'enum', values: ['full', 'module'], optional: true, status: 'live', readers: ['extractTestStrategy (src/verify-postcheck.js)'], desc: 'full=全量 commands.test；module=按 git diff 命中 modules 子集收窄（需配 modules）。缺省=全量。', example: 'full' },
+        { path: 'test_strategy', type: 'enum', values: ['full', 'module', 'skip', 'evidence-auto'], optional: true, status: 'live', readers: ['extractTestStrategy (src/verify-postcheck.js)', 'resolveTestStrategy (src/verify-postcheck.js)'], desc: 'full=全量 commands.test；module=按 git diff 命中 modules 子集收窄（需配 modules）；skip=真跳过测试（不回退全量，verify 输出显式标注留审计痕迹，R-07）；evidence-auto=按变更目录 module-impact.md 影响类型推荐检查组合（行为→module 聚焦测试、文档/prompt→docs-check、门禁契约→gate；缺失/不可解析降级 module 并注记）。缺省=全量。', example: 'full' },
       ],
     },
     {
@@ -157,6 +157,14 @@ export const LOCAL_YAML_SCHEMA = {
         { path: 'docs-check.cross_repo_roots', type: 'object', optional: true, status: 'live', readers: ['readDocsCheckConfig (src/docs-check.js)'], desc: 'repo://<仓库名> 跨仓引用 → 本机仓库根目录映射。文档里 repo://name/src/x.js:12 形态的引用：未配映射默认跳过（不同设备仓库位置不同，防跨设备误报）；配了映射走与本地引用相同的行号+关键词校验。local.yaml 是 gitignored，绝对路径不入库，每台设备各自配。', example: 'sillyspec: /c/Users/you/IdeaProjects/sillyspec' },
       ],
     },
+    {
+      id: 'decisions',
+      title: '决策库复核阈值',
+      note: 'docs-check 决策规则（W1.1 behind 复核）的消费配置——决策锚定模块源码在「最近确认」后前进超阈值 → doctor 报「决策待复核」（advisory 不阻断）。读键按「存在则读、不存在用缺省」容错。',
+      keys: [
+        { path: 'decisions.behind_threshold', type: 'integer', optional: true, status: 'live', readers: ['readDecisionRulesConfig (src/docs-check.js)'], desc: '决策 behind 复核阈值（锚定模块源码在「最近确认」commit 后的前进数），缺省 10；超阈报「决策待复核」提示。', example: '10' },
+      ],
+    },
   ],
 };
 
@@ -276,9 +284,16 @@ modules:
   frontend: { path: "frontend/", test: "cd frontend && pnpm test" }
   backend: { path: "backend/", test: "cd backend && npm test" }
 
-# ── 测试策略：full=全量 commands.test | module=按命中模块收窄（需配 modules）──
+# ── 测试策略（verify 实测收窄；full/module 语义不变，skip/evidence-auto 为 2026-08-23 新增）──
+# full=全量 commands.test | module=按命中模块收窄（需配 modules）
+# skip=真跳过测试（不回退全量，verify 输出显式标注留审计痕迹）
+# evidence-auto=按变更 module-impact.md 影响面推荐检查组合（行为→module 聚焦测试、文档→docs-check、门禁→gate；缺失降级 module）
 test_strategy: full
 
+# ── 决策库 behind 复核阈值（docs-check 决策规则：源码在「最近确认」后前进超阈值 → 待复核提示；缺省 10）──
+decisions:
+  behind_threshold: 10
+
 # ── 预存失败豁免清单（变更前就失败的测试行；务必定期复核，防误豁免真实失败）──
 known_failures:
   - tests/some-old-stable-failure

package/src/contract-matrix.js

@@ -9,7 +9,9 @@
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs'
-import { join, resolve, basename, relative } from 'path'
+import { join, resolve, basename, dirname, relative } from 'path'
+import { gitQuiet } from './git-helper.js'
+import { splitOwnVsForeignDiffFiles } from './foreign-declared.js'
 import {
   scanBackendEndpoints,
   scanFrontendApiCalls,
@@ -332,6 +334,74 @@ export function buildContractFieldInjection(changeDir, taskName) {
 
 // ─── Verify 阶段：parity check ──────────────────────────────────────────
 
+/**
+ * 读 worktree meta（parity 双根扫描 / diff 收窄共用）。
+ * 优先 specBase/.runtime/worktrees/<change>/meta.json（主仓 spec 根——cwd=worktree 时 specBase 已被
+ * command.js 漂移守卫锚定主仓；旧实现硬编码 scanRoot/.sillyspec/.runtime，worktree 内运行永远读不到
+ * meta）；兼容回退 scanRoot/.sillyspec/.runtime（旧路径）。
+ * @returns {{ meta: object, gitDir: string }|null} gitDir = diff/扫描用 git 根（真实 worktree 或 scanRoot）
+ */
+function _readWorktreeMeta(specBase, scanRoot, changeName) {
+  if (!changeName) return null
+  const candidates = [
+    specBase ? join(specBase, '.runtime', 'worktrees', changeName, 'meta.json') : null,
+    join(scanRoot, '.sillyspec', '.runtime', 'worktrees', changeName, 'meta.json'),
+  ].filter(Boolean)
+  for (const metaPath of candidates) {
+    try {
+      if (!existsSync(metaPath)) continue
+      const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
+      const gitDir = (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath))
+        ? meta.worktreePath : scanRoot
+      return { meta, gitDir }
+    } catch { /* 损坏 meta 试下一候选 */ }
+  }
+  return null
+}
+
+/**
+ * 取本变更 diff 文件集（parity 前端调用收窄用，坑 probe5-fullrepo-frontend-noise）。
+ * 优先 worktree meta 锚点 diff（与 verify 同源）；无 meta 退主仓 git diff HEAD。
+ * @returns {string[]|null}
+ */
+function _resolveDiffFilesForParity(specBase, scanRoot, changeName) {
+  try {
+    const wt = _readWorktreeMeta(specBase, scanRoot, changeName)
+    if (wt) {
+      const diffBase = wt.meta.baselineCommit || wt.meta.actualBaseHash || wt.meta.baseHash
+      if (diffBase) {
+        const out = gitQuiet(wt.gitDir, ['diff', '--name-only', `${diffBase}..HEAD`], { timeout: 30000 })
+        if (out !== null) {
+          const files = out.split('\n').filter(Boolean)
+          // 并入 worktree 未提交（子代理默认不 commit 的形态，与 resolveVerifyChangedFiles 同口径）。
+          // -uall：porcelain 默认把整目录折叠成 `dir/` 一项，文件级匹配（前端调用过滤）会漏新目录
+          // 里的文件（坑 probe5-worktree-single-root-noise 实证：web/ 折叠 → feature.js 漏匹配）
+          try {
+            const wtStatus = gitQuiet(wt.gitDir, ['status', '--porcelain', '--untracked-files=all'], { timeout: 30000, trim: false })
+            for (const line of String(wtStatus || '').split('\n')) {
+              if (!line || line.length < 4) continue
+              const p = line.slice(3).trim().split(' -> ').pop() || ''
+              const clean = p.replace(/^"|"$/g, '')
+              if (clean) files.push(clean)
+            }
+          } catch {}
+          return [...new Set(files)]
+        }
+      }
+    }
+    // 无 meta（brownfield/已 cleanup）：主仓未提交 diff。他者声明归属过滤（坑
+    // verify-reconcile-foreign-wip）：并行会话在途 WIP 的前端文件混入会产出「他者调用 ×
+    // 本变更端点」的 missingBackend 误报——剔除他者显式声明文件（fail-closed：无主保留）。
+    const out = gitQuiet(scanRoot, ['diff', '--name-only', 'HEAD'], { timeout: 30000 })
+    if (out === null) return null
+    const { own, foreign } = splitOwnVsForeignDiffFiles(scanRoot, changeName, out.split('\n').filter(Boolean))
+    if (foreign.length > 0) {
+      console.warn(`⚠️ parity 对账已排除 ${foreign.length} 个并行会话声明的文件（${foreign.slice(0, 5).map(x => x.file).join(', ')}${foreign.length > 5 ? ' 等' : ''}）`)
+    }
+    return own
+  } catch { return null }
+}
+
 /**
  * verify 阶段执行 API parity check
  * @param {string} specBase - .sillyspec 目录
@@ -372,17 +442,92 @@ export function verifyApiParity(specBase, scanRoot, runtimeRoot, changeName = nu
     return { ok: true, missingBackend: [], unusedBackend: [], summary: 'No scan root for parity check', backendCount: allProviderEndpoints.length, frontendCount: 0 }
   }
 
-  const frontendCalls = scanFrontendApiCalls(scanRoot)
-  const { missingBackend, unusedBackend } = diffApiParity(frontendCalls, allProviderEndpoints)
+  // ── 双根并集现算（坑 probe5-worktree-single-root-noise，2026-08-24 用户实证：worktree 场景
+  // 只现算 scanRoot 单根，另一侧端点不在比对集——verify 从主仓跑（apply 前）漏 worktree 新增端点；
+  // verify 从 worktree 跑则既读不到 meta（旧路径硬编码 scanRoot/.sillyspec）也漏主仓既有 daemon
+  // 端点 → 前端调用全量误报 missing）。后端端点全集 = 主仓既有 ∪ worktree 新增 ∪ 存量 artifact：
+  // 现算根集 = [scanRoot, meta.worktreePath, 主仓根（cwd 自身在 linked worktree 内时经
+  // git-common-dir 解析）]，逐根 scanBackendEndpoints 按 method+path 去重。
+  // 存量基线失配坑（probe5-endpoint-baseline-stale，2026-08-22）由本并集一并覆盖：现算当前
+  // 代码 ∪ 存量基线；unusedBackend 只对现算端点算（存量过期端点不再误报 unused）。
+  const wt = _readWorktreeMeta(specBase, scanRoot, changeName)
+  const liveRoots = []
+  const pushRoot = (root, label) => {
+    if (!root || !existsSync(root)) return
+    const abs = resolve(root)
+    if (liveRoots.some(r => resolve(r.root) === abs)) return
+    liveRoots.push({ root, label })
+  }
+  pushRoot(scanRoot, 'scan-root')
+  if (wt && wt.gitDir !== scanRoot) pushRoot(wt.gitDir, 'worktree')
+  // cwd 自身是 linked worktree 时补主仓根（主仓返回 .git → dirname=scanRoot 被 pushRoot 去重）
+  try {
+    const commonDir = gitQuiet(scanRoot, ['rev-parse', '--git-common-dir'])
+    if (commonDir) pushRoot(dirname(resolve(scanRoot, commonDir)), 'main')
+  } catch { /* 非 git 目录/解析失败：单根继续 */ }
+
+  const liveByRoot = []
+  for (const { root, label } of liveRoots) {
+    try { liveByRoot.push({ root, label, endpoints: scanBackendEndpoints(root) }) } catch { /* 单根失败不拖垮整体 */ }
+  }
+  const liveEndpoints = liveByRoot.flatMap(r => r.endpoints)
+  const liveKeys = new Set(liveEndpoints.map(e => `${e.method} ${e.path}`))
+  const mergedKeys = new Set(allProviderEndpoints.map(e => `${e.method} ${e.path}`))
+  const mergedProviderEndpoints = [...allProviderEndpoints]
+  for (const e of liveEndpoints) {
+    const key = `${e.method} ${e.path}`
+    if (!mergedKeys.has(key)) {
+      mergedKeys.add(key)
+      mergedProviderEndpoints.push(e)
+    }
+  }
+
+  // ── 前端调用收窄到本变更 diff（坑 probe5-fullrepo-frontend-noise，2026-08-23 实证：
+  // 「全仓前端调用 × 本变更局部登记」口径下，未受本变更影响的存量调用对不上局部端点集
+  // → 143 个 missing 全是误报噪音）。比对口径 = 本变更 diff 文件内的调用 ∪ 全仓（仅当
+  // 端点登记源也是全仓时——无 changeName 的 CLI contractScan 场景）。diff 不可得时退回
+  // 全仓（不静默跳过对账）。
+  // 扫描根优先真实 worktree（坑 probe5-worktree-single-root-noise）：apply 前新代码只在
+  // worktree，scanRoot（主仓 cwd）里是旧版本——读旧版会漏新调用/多已删调用。
+  let frontendCalls = []
+  let frontendScope = 'full-repo'
+  const frontendRoot = (wt && wt.gitDir !== scanRoot) ? wt.gitDir : scanRoot
+  const frontendRootLabel = frontendRoot === scanRoot ? 'scan-root' : 'worktree'
+  if (changeName) {
+    try {
+      const changed = _resolveDiffFilesForParity(specBase, scanRoot, changeName)
+      if (changed && changed.length > 0) {
+        const changedSet = new Set(changed.map(f => f.replace(/\\/g, '/')))
+        frontendCalls = scanFrontendApiCalls(frontendRoot).filter(c => {
+          const src = String(c.source || '').replace(/\\/g, '/')
+          return changedSet.has(src) || [...changedSet].some(cf => src.endsWith(cf) || cf.endsWith(src))
+        })
+        frontendScope = `change-diff (${changed.length} files @ ${frontendRootLabel})`
+      } else {
+        frontendCalls = scanFrontendApiCalls(frontendRoot)
+      }
+    } catch { frontendCalls = scanFrontendApiCalls(frontendRoot) }
+  } else {
+    frontendCalls = scanFrontendApiCalls(frontendRoot)
+  }
+
+  const { missingBackend, unusedBackend } = diffApiParity(frontendCalls, mergedProviderEndpoints)
+  // unusedBackend 收窄到现算端点（存量 artifact 的过期端点不参与——它不在当前代码里，
+  // 「前端未调用」可能是端点已被重构掉而非真泄漏）
+  const narrowedUnused = unusedBackend.filter(u => {
+    const key = `${u.method} ${u.path}`
+    return liveKeys.has(key) || liveEndpoints.length === 0
+  })
 
   const ok = missingBackend.length === 0
+  const liveRootSummary = liveByRoot.map(r => `${r.label} ${r.endpoints.length}`).join(' + ')
   let summary = ok
-    ? `✅ API parity check passed: ${allProviderEndpoints.length} backend endpoints, ${frontendCalls.length} frontend calls`
-    : `❌ API parity check failed: ${missingBackend.length} frontend calls have no matching backend endpoint`
+    ? `✅ API parity check passed: ${mergedProviderEndpoints.length} backend endpoints (live [${liveRootSummary}] + artifact ${allProviderEndpoints.length}), ${frontendCalls.length} frontend calls [scope: ${frontendScope}]`
+    : `❌ API parity check failed: ${missingBackend.length} frontend calls have no matching backend endpoint [scope: ${frontendScope}]`
 
-  if (unusedBackend.length > 0) {
-    summary += ` | ${unusedBackend.length} backend endpoints unused by frontend`
+  if (narrowedUnused.length > 0) {
+    summary += ` | ${narrowedUnused.length} backend endpoints unused by frontend`
   }
 
-  return { ok, missingBackend, unusedBackend, summary, backendCount: allProviderEndpoints.length, frontendCount: frontendCalls.length }
+  return { ok, missingBackend, unusedBackend: narrowedUnused, summary, backendCount: mergedProviderEndpoints.length, frontendCount: frontendCalls.length, scanRoots: liveByRoot.map(r => r.root) }
 }

package/src/datetime.js

@@ -0,0 +1,20 @@
+/**
+ * 人读墙钟时间工具（坑 taskcard-created-at-utc，2026-08-23 实证：taskcard 骨架 created_at 用
+ * toISOString() 落 UTC——本地 09:39 生成写 01:39，子代理两次手工改）。
+ *
+ * 项目内「人读的 markdown/YAML frontmatter 时间字段」统一走本函数：本地时区 +
+ * `YYYY-MM-DD HH:mm:ss` 形状（scan.js 文档示例形状），手工拼接零 locale/ICU 依赖（Node
+ * small-icu 构建下 toLocaleString('sv-SE') 不可靠）。机器可读处（JSON/DB 列/目录名）继续用
+ * toISOString()——那是 ISO 惯例不是坑。
+ */
+
+/**
+ * 本地墙钟时间字符串（YYYY-MM-DD HH:mm:ss，各段补零）。
+ * @param {Date} [d] 可注入时钟（测试用），缺省当前时间
+ * @returns {string}
+ */
+export function nowWallClock(d = new Date()) {
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} `
+    + `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}