sillyspec 3.32.9 → 3.33.0

package/src/quicklog.js

@@ -124,13 +124,18 @@ export function sanitizeDesc(description) {
  * 「需求：/动机：」类标签前缀，空白折叠单行，超长截断加 …；空输入返回 ''（调用方兜底
  * change 名）。agent 在 --input 首行写一句中文概括即成标题（flow start 横幅有指引），
  * --title 显式覆盖一切推导。
+ * 段头行防御（2026-10-15-title-label-skip）：过门格式示例曾被读成段头形态——agent 把
+ * 「动机与背景：」独立成行照抄，白名单无复合词致整行成标题（进度库 6 变更实证）。两道
+ * 防御：白名单补复合词（动机与背景/背景与动机）；任意短段头行（≤12 字非冒号内容+行尾
+ * 冒号，如「变更背景：」「详细说明：」）整行跳过取次非空行——冒号后无内容不成标题。
  */
 export function deriveChangeTitle(input, max = 50) {
   for (const l of String(input || '').replace(/\r\n/g, '\n').split('\n')) {
     const t = l.trim()
     if (!t) continue
     if (/^成功标准\s*[:：]/.test(t)) break
-    const stripped = t.replace(/^(?:需求|动机|背景|任务|标题)\s*[:：]\s*/, '').trim()
+    if (/^[^:：]{1,12}[:：]$/.test(t)) continue
+    const stripped = t.replace(/^(?:需求|动机|背景|任务|标题|动机与背景|背景与动机)\s*[:：]\s*/, '').trim()
     if (!stripped) continue
     const one = stripped.replace(/\s+/g, ' ')
     return one.length > max ? one.slice(0, max) + '…' : one

package/src/run/archive-distill.js

@@ -39,6 +39,9 @@ export async function executeArchiveDistill({ cwd, specBase, changeName }) {
       console.warn(`\n⚠️  rejected 决策缺否决理由/复潮条件（needsWait）——这些条目未写盘，其余条目照常提炼。`)
       console.warn(`   裁决指引（确认归档 --confirm 前处理）：`)
       console.warn(`   ① 补录：把缺失字段补进 ${join(changeDir, 'decisions.md')} 后重跑提炼（幂等）——`)
+      console.warn(`      可复制补丁样例（在对应 D-xxx@vN 条目末尾追加两行，字段名与值之间用冒号+空格）：`)
+      console.warn(`      - 否决理由: <一句话核心劣势>`)
+      console.warn(`      - 复潮条件: <何种信号下可重议本方案>`)
       console.warn(`      node --input-type=module -e "import { distillIntoKnowledge } from '<sillyspec 源码路径>/src/decision-distill.js'; console.log(JSON.stringify(distillIntoKnowledge(${JSON.stringify(changeDir)}, ${JSON.stringify(knowledgeRoot)}, ${JSON.stringify(headHash)}), null, 2))"`)
       console.warn(`   ② 跳过：经用户裁决不入库该条，并在「确认归档」--output 注记跳过原因。`)
     }

package/src/run/command.js

@@ -232,7 +232,7 @@ export async function ensureStageSteps(progress, stageName, cwd, specDir = null)
 function emitReadonlyEmptyGuide() {
   console.log('ℹ️ 未找到进度数据（只读查询不建变更）')
   console.log('   → 可开始轻量变更（--input 引号内换行合法，下例可照抄）：')
-  console.log('     sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>')
+  console.log('     sillyspec flow start --change <YYYY-MM-DD-名> --input "<一句中文概括（首行即变更标题）；随后动机与背景')
   console.log('')
   console.log('     成功标准：')
   console.log('     - <可验证标准>"')
@@ -858,7 +858,7 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
             quickFallbackUsed = true
           } else {
             console.log('   本仓无近期 quick 会话记录（current marker 与 quick-sessions 均空）——新工作请走轻量变更（--input 引号内换行合法，可照抄）：')
-            console.log('   sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>')
+            console.log('   sillyspec flow start --change <YYYY-MM-DD-名> --input "<一句中文概括（首行即变更标题）；随后动机与背景')
             console.log('')
             console.log('   成功标准：')
             console.log('   - <可验证标准>"')
@@ -2076,7 +2076,7 @@ async function runAutoMode(pm, progress, cwd, flags, changeName, platformOpts =
     if (classification.mode === 'quick') {
       console.log(`📊 auto 模式分类：${classification.reason} 判为小变更`)
       console.log(`   小变更请走轻量变更（quick 通道已退役，v3.30.0 起拒绝新会话；--input 引号内换行合法，可照抄）：`)
-      console.log('   sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>')
+      console.log('   sillyspec flow start --change <YYYY-MM-DD-名> --input "<一句中文概括（首行即变更标题）；随后动机与背景')
       console.log('')
       console.log('   成功标准：')
       console.log('   - <可验证标准>"')

package/src/run/complete-handlers.js

@@ -816,9 +816,14 @@ export async function bakeArchiveTimeline({ cwd, specBase, changeName, destDir,
     const { readWatcherEvents, watcherEventsPath } = await import('../watcher.js')
     const res = readWatcherEvents({ runtimeRoot, change: changeName })
     if (!res.exists) return { ok: true, skipped: true, reason: `无事件流（${watcherEventsPath(runtimeRoot, changeName)}）` }
-    const { parseTaskLines, renderBakedTimeline, resolveCommitAnchors, readBirthTs } = await import('../timeline.js')
+    // 侧车透传（2026-10-14-timeline-ticktime-anchor-scope）：destDir 内 task-ticks.jsonl 已随归档包
+    // ——烤制面读包内侧车（与 tasks.md 同源同路径形态），精确勾选时刻跨机可读；锚收敛 changeName
+    // 进解析（消息不含变更名的提交不锚任务行）。
+    const { parseTaskLines, renderBakedTimeline, resolveCommitAnchors, parseTickLog, readBirthTs } = await import('../timeline.js')
     let tasks = null
     try { tasks = parseTaskLines(readRawImpl(join(destDir, 'tasks.md'), 'utf8')) } catch { /* 任务面缺失照烤（渲染层有降级段） */ }
+    let tickLog = []
+    try { tickLog = parseTickLog(readRawImpl(join(destDir, 'task-ticks.jsonl'), 'utf8')) } catch { /* 侧车缺失照烤（时刻退推断面） */ }
     let tier = null
     try { const m = /^tier:\s*(\S+)/m.exec(readRawImpl(join(destDir, 'flow-state.yaml'), 'utf8')); if (m) tier = m[1] } catch { /* 头脑风暴预段等无 flow-state 按未知 */ }
     const look = gitLook || ((hash) => {
@@ -829,12 +834,12 @@ export async function bakeArchiveTimeline({ cwd, specBase, changeName, destDir,
       const sep2 = rest.indexOf('\x1f')
       return { hash: out.slice(0, sep), dateISO: rest.slice(0, sep2), message: rest.slice(sep2 + 1) }
     })
-    const anchors = resolveCommitAnchors(res.events, look)
+    const anchors = resolveCommitAnchors(res.events, look, changeName)
     let eventsRaw = null
     try { eventsRaw = readRawImpl(watcherEventsPath(runtimeRoot, changeName), 'utf8') } catch { /* 副本缺源只烤渲染面 */ }
     const oversize = eventsRaw != null && Buffer.byteLength(eventsRaw, 'utf8') > eventsCopyMaxBytes
     // 评审 P3-1 清偿：副本未落盘（读源失败或超帽）时头注记必须显式「未随包」，不虚报在场
-    const timelineMd = renderBakedTimeline({ change: changeName, events: res.events, tasks, anchors, birthTs: readBirthTs(destDir), tier, bakedAtIso: nowIso || new Date().toISOString(), eventsCopySkipped: eventsRaw == null || oversize })
+    const timelineMd = renderBakedTimeline({ change: changeName, events: res.events, tasks, anchors, birthTs: readBirthTs(destDir), tier, bakedAtIso: nowIso || new Date().toISOString(), eventsCopySkipped: eventsRaw == null || oversize, tickLog })
     writeImpl(join(destDir, 'timeline.md'), timelineMd)
     const files = ['timeline.md']
     if (eventsRaw != null && !oversize) {

package/src/run/complete.js

@@ -493,25 +493,26 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
               .filter((h) => !_hits.some((x) => x.file === h.file && x.id === h.id && (x.change || '') === (h.change || '')))
             _hits.push(..._viaImpact)
           } catch { /* 图构建/键解析 fail-soft——词面命中面不受影响 */ }
-          // 已回应不重弹：decisions.md 正文已含「命中 id＋域文件名」共现（小白鼠回应形态
-          // 「unmapped.md D-001@v1」）→ 视为已甄别过，静默；同轮查询串仍含其词面属预期。
+          // 已回应不重弹：decisions.md 某行同时含「命中 id＋域文件名（或命中条目变更名）」（小白鼠
+          // 回应形态「unmapped.md D-001@v1」）→ 视为已甄别过，静默。行级共现（2026-10-14-decision-id-p2-hardening
+          // 收紧：文件级共现时本变更自身同号 id + 正文常见词 backend/unmapped 撞车会静默吞掉他变更命中）。
           const _answered = _dm
             ? (h) => {
                 const _dom = String(h.file || '').replace(/^decisions\//, '').replace(/\.md$/, '')
-                return _dm.includes(h.id) && _dm.includes(_dom)
+                return _dm.split(/\r?\n/).some((line) => line.includes(h.id) && (line.includes(_dom) || (h.change && line.includes(h.change))))
               }
             : () => false
           const _echoHits = _hits.filter((h) => !_answered(h))
           const _entries = km.matched ? (km.entries || []) : []
           if (_echoHits.length > 0 || _entries.length > 0) {
-            const { deathPathNote } = await import('../knowledge-match.js')
+            const { deathPathNote, decisionChangeQualifier } = await import('../knowledge-match.js')
             console.warn(`\n⚠️ [knowledge-gate] 方案/决策知识命中（设计时点防复潮提示，warn 不阻断）：`)
             for (const h of _echoHits.slice(0, 5)) {
               const _note = h.status === 'rejected'
                 ? ` 否决理由：${h.reason || '（未记录）'}`
                 : h.deathPath ? ` ⚰️死路注记：${deathPathNote(h.reason)}` : ''
               const _via = h.viaImpact ? ` 🧭impact 可达（键：${h.impactKey}）` : ''
-              console.warn(`   - ${h.id} ${h.title}（${h.file}）status=${h.status || '?'}${_note}${_via}`)
+              console.warn(`   - ${h.id} ${h.title}（${h.file}｜${decisionChangeQualifier(h.change)}）status=${h.status || '?'}${_note}${_via}`)
             }
             for (const e of _entries.slice(0, 3)) {
               const _base = e.anchor ? `${e.file}#${e.anchor}` : e.file
@@ -673,40 +674,9 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   // 勾选回归 agent 手动（完成=实现+测试绿+wt-commit 即勾，同 thin 工作单元语义），假勾防线由
   // detectExecuteBatchFinish 内 checkExecuteCodeEvidence 代码证据核验 + verify 测试对账承担。
   if (stageName === 'execute' && changeName) {
-    // 自动勾选（full-autopilot-parity，R21 thin 实证迁移）：execute --done 时解析 run 内提交的
-    // task-NN token，自动勾选 tasks.md 未勾条目——agent 手动勾选是 R19/R20 的行为惯性（tick-loop-nudge
-    // 提示词无效），机器代勾与 thin 的 flow done 同逻辑。fail-soft。
-    try {
-      const _tasksMdPath = join(specBase, 'changes', changeName, 'tasks.md')
-      if (existsSync(_tasksMdPath)) {
-        const _runIdFile = join(resolveRuntimeRoot(platformOpts, specBase), `current-execute-run-id-${changeName}`)
-        let _tickCommits = ''
-        try {
-          if (existsSync(_runIdFile)) {
-            _tickCommits = gitQuiet(cwd, ['log', '--format=%B%x1e', 'HEAD~20..HEAD']) || ''
-          }
-        } catch {}
-        if (!_tickCommits) _tickCommits = gitQuiet(cwd, ['log', '--format=%B%x1e', '-20']) || ''
-        if (_tickCommits) {
-          const _texts = String(_tickCommits).split('\x1e').map(x => x.trim()).filter(Boolean).join('\n')
-          const _evidenced = new Set()
-          for (const m of _texts.matchAll(/task-(\d{1,2})/gi)) _evidenced.add(String(Number(m[1])).padStart(2, '0'))
-          if (_evidenced.size > 0) {
-            let _md = readFileSync(_tasksMdPath, 'utf8')
-            let _ticked = 0
-            for (const nn of _evidenced) {
-              const re = new RegExp(`^- \\[ \\](.*task-${nn}[:\\s])`, 'm')
-              if (re.test(_md)) { _md = _md.replace(re, `- [x]$1`); _ticked++ }
-            }
-            if (_ticked > 0) {
-              const { writeAtomicSync } = await import('../fs-atomic.js')
-              writeAtomicSync(_tasksMdPath, _md)
-              console.log(`✅ [自动勾选] ${_ticked} 个任务有提交证据但未勾——已机器代勾（full-autopilot-parity）`)
-            }
-          }
-        }
-      }
-    } catch { /* auto-tick fail-soft */ }
+    // 自动勾选（full-autopilot-parity，R21 thin 实证迁移）：代勾判据/实现见
+    // autoTickTasksFromCommitSubjects（subject token × allowed_paths 实现事实锚）。
+    await autoTickTasksFromCommitSubjects({ changeName, cwd, specBase, platformOpts })
     const _bf = await detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, platformOpts, steps })
     if (_bf.batched && _bf.aligned > 0) {
       console.log(`\n🚀 execute 批量完成：plan 全勾 + 代码核验通过，一次性补完 ${_bf.aligned} 个剩余 step → 进入阶段完成分支`)
@@ -1532,8 +1502,10 @@ export function shouldAutoCheckTask(r, endToEnd, ctx = null, changeName = '') {
   if (isExplicitReviewWrite(r.review)) return true
 
   // W2 task-04 草稿零 diff 守卫（FR-03）
-  // ctx 给定且 review 为自动草稿时，要求 changedFiles 非空且实测 diff 非空
-  if (ctx && r.review?.reviewerNotes && r.review.reviewerNotes.includes('auto-generated draft')) {
+  // review 为自动草稿时，要求 changedFiles 非空且实测 diff 非空。ctx 缺席（直写/主仓形态
+  // buildDraftContext 返 null）同样保守不勾——原「ctx=null 直接放行」使 cannot_verify 草稿
+  // 无任何实现核验即被代勾（坑 wt-commit-auto-tick-unimplemented-tasks 连带，2026-10-15）。
+  if (r.review?.reviewerNotes && r.review.reviewerNotes.includes('auto-generated draft')) {
     const taskId = r.review.task || 'task-NN'
     const unlockCmd = `sillyspec review write${changeName ? ` --change ${changeName}` : ' --change <变更名>'} --task ${taskId} --spec pass --quality pass --force --changed-files <文件>`
     const changedFiles = r.review.changedFiles || []
@@ -1541,8 +1513,8 @@ export function shouldAutoCheckTask(r, endToEnd, ctx = null, changeName = '') {
       console.warn(`⚠️ 草稿 review changedFiles 为空，跳过自动勾选（task=${taskId}）——解锁：${unlockCmd}（纯验证任务用 --changed-files "" + --evidence "<验证说明>"）`)
       return false
     }
-    if (!ctx.gitDir || !ctx.base || !ctx.head) {
-      console.warn(`⚠️ ctx 信息不完整（gitDir=${ctx.gitDir}, base=${ctx.base}, head=${ctx.head}），跳过草稿 diff 校验，保守不勾（task=${taskId}）——解锁：${unlockCmd}`)
+    if (!ctx || !ctx.gitDir || !ctx.base || !ctx.head) {
+      console.warn(`⚠️ ctx 缺席或不完整（gitDir=${ctx && ctx.gitDir}, base=${ctx && ctx.base}, head=${ctx && ctx.head}），跳过草稿 diff 校验，保守不勾（task=${taskId}）——解锁：${unlockCmd}`)
       return false
     }
     // 预取路径：一次全量 diff 文件集内存归属（autoCheckPlanFromReviews/批量路径已 prefetch）
@@ -1572,6 +1544,86 @@ export function shouldAutoCheckTask(r, endToEnd, ctx = null, changeName = '') {
 
   return true
 }
+/**
+ * execute --done 的 full-autopilot 代勾（独立函数供测试直驱；completeStep execute 分支调用）。
+ *
+ * 实现事实锚（坑 wt-commit-auto-tick-unimplemented-tasks，2026-10-15 消费仓两次实证：原按
+ * %B 提交全文提 token——task-01 提交正文提及 task-02/03/04 即全被误勾，批量完成判定与续跑
+ * 跳过双失真）：证据源收敛为提交 subject 行（%s）的 task-NN token，且任务卡 allowed_paths
+ * 在场时要求「提及该 task 的提交触及面 × allowed_paths」交叠（parseAllowedPaths +
+ * pathMatches，与草稿归属同口径）；无卡面/无 allowed_paths 退化为仅 subject token。无锚不勾。
+ * fail-soft（异常零行为）。
+ * @param {{ changeName: string, cwd: string, specBase: string, platformOpts?: object }} opts
+ */
+export async function autoTickTasksFromCommitSubjects({ changeName, cwd, specBase, platformOpts = {} }) {
+  try {
+    const _tasksMdPath = join(specBase, 'changes', changeName, 'tasks.md')
+    if (!existsSync(_tasksMdPath)) return { ticked: 0, skippedNoAnchor: 0 }
+    const _runIdFile = join(resolveRuntimeRoot(platformOpts, specBase), `current-execute-run-id-${changeName}`)
+    let _tickLog = ''
+    try {
+      if (existsSync(_runIdFile)) {
+        _tickLog = gitQuiet(cwd, ['log', '--name-only', '--format=%x1e%s', 'HEAD~20..HEAD'], { trim: false }) || ''
+      }
+    } catch {}
+    if (!_tickLog) _tickLog = gitQuiet(cwd, ['log', '--name-only', '--format=%x1e%s', '-20'], { trim: false }) || ''
+    if (_tickLog) {
+      // 逐提交解析：首行 = subject（token 证据面——正文散文提及不是实现证据），其余行 = 该提交触及文件
+      const _evidenced = new Map()
+      for (const _chunk of String(_tickLog).split('\x1e')) {
+        const _lines = String(_chunk || '').split('\n').map(x => x.trim()).filter(Boolean)
+        if (_lines.length === 0) continue
+        for (const m of _lines[0].matchAll(/task-(\d{1,2})/gi)) {
+          const nn = String(Number(m[1])).padStart(2, '0')
+          if (!_evidenced.has(nn)) _evidenced.set(nn, new Set())
+          for (const f of _lines.slice(1)) _evidenced.get(nn).add(f)
+        }
+      }
+      if (_evidenced.size > 0) {
+        // 任务卡 allowed_paths 索引（卡面读取失败 → 无卡面口径：仅 subject token）
+        const _allowedByTask = new Map()
+        let _pathMatches = null
+        try {
+          const { parseAllowedPaths } = await import('../stages/plan-postcheck.js')
+          ;({ pathMatches: _pathMatches } = await import('../change-list.js'))
+          const _tasksDir = join(specBase, 'changes', changeName, 'tasks')
+          for (const nn of _evidenced.keys()) {
+            const _cardPath = join(_tasksDir, `task-${nn}.md`)
+            if (existsSync(_cardPath)) {
+              const _paths = parseAllowedPaths(readFileSync(_cardPath, 'utf8'))
+                .map(p => String(p).replace(/^NEW:\s*/, '').trim()).filter(Boolean)
+              if (_paths.length > 0) _allowedByTask.set(nn, _paths)
+            }
+          }
+        } catch { /* 卡面读取失败 → 无锚退化为仅 subject token（与无卡面同口径） */ }
+        let _md = readFileSync(_tasksMdPath, 'utf8')
+        let _ticked = 0
+        let _skippedNoAnchor = 0
+        for (const [nn, _files] of _evidenced) {
+          const _allowed = _allowedByTask.get(nn)
+          if (_allowed && _pathMatches && ![..._files].some(f => _allowed.some(p => _pathMatches(f, p)))) {
+            _skippedNoAnchor++
+            continue // subject 提及但触及面与声明面零交叠——无实现事实锚不勾
+          }
+          const re = new RegExp(`^- \\[ \\](.*task-${nn}[:\\s])`, 'm')
+          if (re.test(_md)) { _md = _md.replace(re, `- [x]$1`); _ticked++ }
+        }
+        if (_ticked > 0) {
+          const { writeAtomicSync } = await import('../fs-atomic.js')
+          writeAtomicSync(_tasksMdPath, _md)
+          console.log(`✅ [自动勾选] ${_ticked} 个任务有实现证据（提交 subject token${_allowedByTask.size > 0 ? ' × allowed_paths 交叠' : ''}）但未勾——已机器代勾（full-autopilot-parity）`)
+        }
+        if (_skippedNoAnchor > 0) {
+          console.log(`ℹ️ [自动勾选] ${_skippedNoAnchor} 个 task 号有 subject token 但触及面与 allowed_paths 零交叠——不代勾（无实现事实锚），完成时请人工核对勾选`)
+        }
+        return { ticked: _ticked, skippedNoAnchor: _skippedNoAnchor }
+      }
+    }
+    return { ticked: 0, skippedNoAnchor: 0 }
+  } catch { /* auto-tick fail-soft */ }
+  return { ticked: 0, skippedNoAnchor: 0 }
+}
+
 export async function autoCheckPlanFromReviews({ stageName, changeName, cwd, platformOpts }) {
   if (stageName !== 'execute' || !changeName) {
     return { autoChecked: false, checkedCount: 0, skippedCount: 0 }
@@ -1713,7 +1765,7 @@ export function detectVerifyBatchFinish({ changeName, specBase, steps }) {
   }
 }
 
-async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, platformOpts, steps }) {  if (stageName !== 'execute' || !changeName) return { batched: false, aligned: 0 }
+export async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, platformOpts, steps }) {  if (stageName !== 'execute' || !changeName) return { batched: false, aligned: 0 }
   try {
     const changeDir = join(specBase, 'changes', changeName)
     const { total: planTotal, checked: planChecked } = pm.readPlanCheckboxStatus(changeDir)
@@ -1747,6 +1799,23 @@ async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBa
     // → 每个 task 进 blockedTasks → 批量完成静默失效
     const runtimeRoot = resolveRuntimeRoot(platformOpts, specBase)
     const runIdFile = join(runtimeRoot, `current-execute-run-id-${changeName}`)
+    // ── 缺席草稿自动补齐（坑 task-review-retired-archive-mismatch，2026-10-15 归档门口实证）──
+    // Task Review 层退役（2026-09-26）后 execute 批量完成不再产 per-task review.json，但本函数
+    // 下方复核循环与 archive step2 完成度判定（真相源=review.json verdict）仍以它在场为前提——
+    // 正常走完五阶段的变更到归档门口必然全量「review.json 缺失」。退役时 generateTaskReviewDrafts
+    // 只摘了调用点（函数本体与 backfill-reviews 手动通道都在）：此处对缺失面重新接线——机械
+    // 幂等（已存在不覆盖人工/子代理 verdict），失败 fail-open 不阻断批量（最坏退回修复前形态，
+    // 下方复核循环照旧拦）。挂在 runId marker 读取之前：run 缺失时生成器建 run + 写 marker，
+    // 下方循环一次读盘即见。
+    try {
+      const { generateTaskReviewDrafts } = await import('../task-review.js')
+      const draftOut = await generateTaskReviewDrafts({ changeName, cwd, platformOpts })
+      if (draftOut && draftOut.generated > 0) {
+        console.log(`📝 [批量完成前置] 自动补 ${draftOut.generated} 份 per-task review 草稿（机械幂等；archive 完成度真相源在场——草稿 verdict=cannot_verify 仍由 verify 兑证/人工复核升级，summarizeTaskCompletion 单列可见）`)
+      }
+    } catch (e) {
+      console.warn(`⚠️ per-task 草稿自动补齐异常（fail-open，批量完成继续走既有复核循环）: ${(e && e.message) || e}`)
+    }
     const blockedTasks = []
     const { readReview, isValidExecuteRunId } = await import('../task-review.js')
     // runId marker 对全部 task 恒定：循环外一次读盘（原实现逐 task 重复 readFileSync 同一文件）

package/src/run/gates.js

@@ -224,7 +224,7 @@ export function warnMissingUiPrototype(stageName, changeName, currentStepName, s
   const design = readFileSync(designPath, 'utf8')
   const feExts = [...new Set((design.match(/\.(vue|svelte|astro|tsx|jsx|css|scss|sass|less|styl|html)\b/gi) || []).map(s => s.replace('.', '').toLowerCase()))]
   if (feExts.length === 0) return
-  console.warn(`   ⚠️ design.md 命中前端文件类型（${feExts.join('/')}）但变更目录无 prototype-*.html——轻微样式改动可忽略；布局/交互流程级变化应补原型（sillyspec run brainstorm --reopen 回到「分段展示设计」，或直接让 agent 补生成；已有可复跑 HTML 原型则登记复用：复制进变更目录并命名 prototype-<名称>.html，execute 按此命名注入）`)
+  console.warn(`   ⚠️ design.md 命中前端文件类型（${feExts.join('/')}）但变更目录无 prototype-*.html——轻微样式改动可忽略；布局/交互流程级变化应补原型（sillyspec run brainstorm --reopen 回到「分段展示设计」，或直接让 agent 补生成；已有可复跑 HTML 原型则登记复用：复制进变更目录并命名 prototype-<名称>.html，execute 按此命名注入；本仓形态未在 local.yaml ui_prototype 登记的，收口前补登记——form: real-code 或 single-html+豁免 ruling）`)
 }
 
 /**
@@ -958,6 +958,99 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       writeVerifyGatePointer({ runtimeRoot: reconcileRuntimeRoot, changeName, blocked: true, note: 'target_files ②类（missing_declared）阻断' })
       docGateFailures.push({ type: 'gate_rollback', detail: 'verify-contract', label: 'target_files 对账阻断（②类「声明未做」——计划落空，明细见上）' })
     }
+    // ── 探针一致性 / draft 篡改门禁 / ceremony 双跑三门（坑 verify-close-gate-staggered-exposure，
+    //    2026-10-15 消费仓四轮 --done 实证：三门原在实测门之后逐个 fail-fast——每轮先付 195s
+    //    实测再见一个新文档问题，四轮纯往返约 20 分钟。三门数据面（facts 已于 runValidators 前
+    //    backfill、verify-result.md 正文/sidecar、ceremony tier 文件、git diff）与实测结果零数据
+    //    依赖——照 required-evidence/reconcile 先例前移并入 docGateFailures 收集（R16 聚合一次
+    //    全列），失败统一在检查点 A 回滚（进度不丢，修复后重跑 --done）。──
+    // 探针一致性（task-03 / ir-stage-p3b D-002@v1 方案A）：「#### 探针 N」机械预填段长在 agent
+    // 可编辑的正文里，其防篡改基准是正文锚点而非 verify-facts.json（删底稿绕不过防护）。
+    // checkProbeConsistency 重跑只读探针与正文锚点对账，分级（D-003）：probe1/probe6 不符 =
+    // ERROR → 收集阻断（正文预填段疑似被篡改）；probe3/probe5 环境敏感维度 + R-06 HEAD 前进
+    // 降级 = WARNING → 放行告警（drift）；skipped/degraded → 放行提示。
+    // 接线形态照 P3a reconcile 先例：envelope + print（ERROR 时 console.error 逐条 mismatch +
+    // supportedFixes）+ verify-runs 落盘 + docGateFailures。
+    const { checkProbeConsistency } = await import('../verify-postcheck.js')  // isStrictChange 复用本块 reconcile 段既有 import
+    const probeCheck = checkProbeConsistency({
+      // 四参与 reconcile 同源取值：cwd/specBase/changeName 原样透传；runtimeRoot 复用上方
+      // reconcileRuntimeRoot（resolveRuntimeRoot(platformOpts, specBase)）——checkProbeConsistency
+      // 的锚点产物实际都在 changeDir，此参为统一传参签名对齐预留，口径一处定义不二算
+      cwd, specBase, changeName,
+      runtimeRoot: reconcileRuntimeRoot,
+      // IR 严格档（2026-09-07-ir-hardening D-002@v1）：created_at ≥ IR_STRICT_SINCE 的变更
+      // 探针子节全缺 = ERROR（存量 skip 语义零变化）；fail-open（读不到 → false 落豁免）
+      strictMode: isStrictChange({ pm, cwd, changeName }),
+    })
+    const probeEnvelope = buildProbeConsistencyEnvelope(probeCheck)
+    const probeBlocked = printProbeConsistencyCheck(probeCheck, probeEnvelope)
+    // 探针7 covered 证据锚点 advisory（坑 probe7-covered-anchor-missing，2026-09-15 复盘：7 行
+    // covered 证据缺 file:line 被审查打回——预填说明已载明口径，机器在 --done 时点再拦一道，
+    // 省一轮人工往返）。advisory 不阻断；独立模块零环（verify-probes 是多会话冲突面，不碰）。
+    try {
+      const { checkProbe7AnchorCoverage } = await import('../probe7-anchor-check.js')
+      const p7ReportPath = join(specBase, 'changes', changeName, 'verify-result.md')
+      if (existsSync(p7ReportPath)) {
+        const p7Anchor = checkProbe7AnchorCoverage(readFileSync(p7ReportPath, 'utf8'))
+        if (p7Anchor.applicable && p7Anchor.missingAnchors.length > 0) {
+          console.warn(`\n⚠️ 探针7 锚点校验：${p7Anchor.missingAnchors.length}/${p7Anchor.coveredRows} 行判定为 covered 但证据列缺 file:line / \`.test.\` 文件名 / 反引号路径锚点（advisory 不阻断，审查会要求回补）：`)
+          for (const m of p7Anchor.missingAnchors.slice(0, 10)) {
+            console.warn(`   - ${m.task}：${m.acceptance || '(空 acceptance)'}——证据当前为「${m.evidence || '(空)'}」，应给 \`测试文件路径:行号\` 首命中锚点、\`.test.\` 测试文件名或反引号包裹的路径/测试名（行号可省）`)
+          }
+          if (p7Anchor.missingAnchors.length > 10) console.warn(`   …还有 ${p7Anchor.missingAnchors.length - 10} 行`)
+        }
+      }
+    } catch { /* 锚点校验异常 fail-soft 不影响 gate */ }
+    // 结果落盘（对齐 writeReconcileRunResult 先例）：独立文件 probe-consistency-result.json——
+    // 与 reconcile-result.json 同 gate 运行同目录组织（verify-runs/<ts>/），但不并入后者：
+    // reconcile-result.json 的 schema 已被 P3a 消费方锁定，塞探针字段（读改写/扩参）只会引入
+    // 两检查间耦合；各写各的回执、按文件名订阅更干净。fail-soft 不影响 gate 判定
+    writeProbeConsistencyRunResult({ runtimeRoot: reconcileRuntimeRoot, changeName, envelope: probeEnvelope, result: probeCheck })
+    if (probeBlocked) {
+      writeVerifyGatePointer({ runtimeRoot: reconcileRuntimeRoot, changeName, blocked: true, note: '探针一致性抽查 error 阻断' })
+      docGateFailures.push({ type: 'gate_rollback', detail: 'verify-contract', label: '探针一致性抽查 error 阻断（明细见上）' })
+    }
+    // ── verify 填槽制篡改门禁（r5l 方案3 / 评审护栏#2 承重件，v2 件二）──
+    // verify-probes --init --draft 生成的机器预填段（任务完成度/风险等级/测试结果/决策追踪）带
+    // sha256 指纹标记 + .runtime sidecar 台账；--done 对账：标记被删 / 内容哈希失配 → 收集阻断
+    // （heredoc 整份重写的典型形态——Write 可用与否均免疫，机制修法不做生成侧劝说）。修改机器
+    // 段唯一通道 verify-probes --amend-draft（重锚 + amendment 审计）。无 sidecar（未用 draft /
+    // 存量变更）→ not-applicable 零红；门禁自身异常 fail-soft（对齐探针抽查 degraded 语义）。
+    try {
+      const { checkDraftIntegrity } = await import('../verify-draft.js')
+      const draftCheck = checkDraftIntegrity({
+        mdPath: join(specBase, 'changes', changeName, 'verify-result.md'),
+        changeName, runtimeRoot: reconcileRuntimeRoot,
+      })
+      if (draftCheck.applicable && !draftCheck.ok) {
+        console.error(`\n❌ verify-result.md 机器预填段篡改门禁：${draftCheck.violations.length} 处失配——draft 预填段被整份重写或标记被删/被手工重锚。`)
+        for (const v of draftCheck.violations) console.error(`   - ${v}`)
+        console.error('   修复：还原机器段原文（AGENT 槽——结论枚举/移交项/审查叙述——不受本门限制）；确要修改机器段，跑 sillyspec verify-probes --change ' + changeName + ' --amend-draft 留痕重锚后重新 --done。')
+        writeVerifyGatePointer({ runtimeRoot: reconcileRuntimeRoot, changeName, blocked: true, note: 'draft 篡改门禁阻断' })
+        docGateFailures.push({ type: 'gate_rollback', detail: 'verify-contract', label: 'verify-result.md 机器预填段篡改门禁（明细见上）' })
+      }
+    } catch { /* 门禁异常 fail-soft（不是篡改，对齐探针 degraded 放行） */ }
+    // ── ceremony 双跑收口·第一出口（2026-09-18-ceremony-risk-pricing task-04 / FR-03 / D-003；
+    //    execute 评审 FAIL 项补接线）：声明档（.runtime/ceremony-tier-<change>.json 开跑定价）vs
+    //    实际 diff 重跑 blast+span 的事实档，mismatch（severity=error，懒 agent 低报）汇入收集
+    //    硬 flag 面（照 reconcile/probe 先例检查点 A 统一回滚，修复后重跑 --done 进度不丢）。
+    //    检查/记账/种子收敛在 runCeremonyDualRunCheck 单点（archive 出口 complete-handlers.js
+    //    runArchiveCeremonyDualRunExit 同款消费）；skipped（档位文件缺失=存量变更零红门禁）/
+    //    degraded（git 不可用降级）零噪音放行；整体 fail-soft——检查自身异常降级放行（异常
+    //    不是低报，对齐 archive 出口同款处置）。specBase/runtimeRoot 与四邻检查同源。──
+    try {
+      const { runCeremonyDualRunCheck, printCeremonyDualRunCheck } = await import('../verify-postcheck.js')
+      const ceremonyCheck = await runCeremonyDualRunCheck({
+        cwd, specBase, changeName,
+        runtimeRoot: reconcileRuntimeRoot,
+      })
+      printCeremonyDualRunCheck(ceremonyCheck)
+      if (ceremonyCheck.status === 'mismatch' && ceremonyCheck.severity === 'error') {
+        docGateFailures.push({ type: 'gate_rollback', detail: 'verify-contract', label: 'ceremony 双跑 mismatch（声明档低报，明细见上）' })
+      }
+    } catch (e) {
+      console.warn(`⚠️  Ceremony 双跑对账异常降级放行（不阻断 verify，fail-soft）: ${(e && e.message) || e}`)
+    }
   }
   // ── 收集模式检查点 A（verify）：纯文档门全清后才进入实测门（test/lint/parity/probe 保持
   //    fail-fast 不变）。brainstorm/plan/execute 不走本检查点（其实测面为空，检查点 B 收口）。──
@@ -1304,18 +1397,11 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       //    快照含基线债文件时恒败，agent 被逼范围外清偿或逃生口）。失败输出提及文件 × 本变更
       //    文件集零交集 → 存量债 advisory 降档放行（债非本变更引入，硬拦只是制造范围外功）；
       //    有交集 / 输出无可识别路径（unattributable，纯配置错误类）→ 维持硬拦（保守）。──
-      let lintOwnership = null
-      try {
-        const { triageLintOwnership, resolveVerifyChangedFiles } = await import('../verify-postcheck.js')
-        const lintScopeFiles = (resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase }) || [])
-          .map(f => String(f).replace(/\\/g, '/')).filter(f => !f.startsWith('.sillyspec/'))
-        lintOwnership = triageLintOwnership({ failureFiles: lintCheck.failureFiles || [], changeFiles: lintScopeFiles })
-      } catch { /* 鉴定链异常维持硬拦（保守） */ }
-      if (lintOwnership && lintOwnership.verdict === 'pre-existing') {
-        console.warn('\n⚠️ Verify lint 实测失败，但归属鉴定为 HEAD 存量债（失败提及文件与本变更文件集零交集）——降档 advisory 不阻断 verify 完成：')
-        console.warn(`   存量债文件：${(lintCheck.failureFiles || []).join('、') || '（见上方输出）'}`)
-        console.warn('   处置建议：单独 quick 机械清偿（顺手清债解锁全仓 lint 门），或本变更确认无关时设 SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕）。债随基线存在，与本变更交付无关。')
-      } else {
+      // 2026-10-15-lint-triage-path-unify：判定与文案收敛到 ./lint-ownership.js（与 noAI 质量
+      // 扫描路径同源——原两路径分叉见消费仓坑档案 verify-lint-triage-path-divergence.md）。
+      const { lintOwnershipDowngrade } = await import('./lint-ownership.js')
+      const lintAdvisoryDowngraded = await lintOwnershipDowngrade({ lintCheck, cwd, changeName, specBase })
+      if (!lintAdvisoryDowngraded) {
       console.error('\n❌ verify 阶段被阻断：CLI 亲自实测 lint 失败（agent 的 lint 自报告与实测不符时以实测为准）。')
       if (usedSnapInfo) {
         try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
@@ -1339,7 +1425,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       }
       console.error('   修复后重跑 --done（进度不丢）；确认要跳过实测请设 SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕）。')
       return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-lint' })
-      } // else（pre-existing 降档分支）结束——维持硬拦分支的 rollback 语义不变
+      } // 硬拦分支结束（降档放行时直接落到后续 parity/删除探针——rollback 语义不变）
     }
     // 契约 parity 对账：扫前端 API 调用 vs execute 提取的 provider endpoint artifact。
     // 接线自 contract-matrix pipeline（verifyApiParity 的 CLI 入口）。
@@ -1351,95 +1437,6 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     const { runVerifyDeletionCheck, printVerifyDeletionCheck } = await import('../verify-postcheck.js')
     const deletionCheck = runVerifyDeletionCheck({ cwd, specBase, changeName })
     printVerifyDeletionCheck(deletionCheck)
-    // ── verify-result.md 探针预填段一致性抽查（task-03 / ir-stage-p3b D-002@v1 方案A）──
-    // 「#### 探针 N」机械预填段（verify-probes --init 生成）长在 agent 可编辑的正文里，其防篡改
-    // 基准是正文锚点而非 verify-facts.json（删底稿绕不过防护）。checkProbeConsistency 重跑只读
-    // 探针与正文锚点对账，分级（D-003）：probe1/probe6 不符 = ERROR → 阻断回滚（正文预填段疑似
-    // 被篡改）；probe3/probe5 环境敏感维度 + R-06 HEAD 前进降级 = WARNING → 放行告警（drift）；
-    // skipped（存量旧格式报告/无 changeName）/degraded（重跑异常 fail-soft）→ 放行提示。
-    // 接线形态照上方 P3a reconcile 先例：envelope + print（ERROR 时 console.error 逐条 mismatch +
-    // supportedFixes）+ verify-runs 落盘 + rollbackCompletionAndReturn。
-    const { checkProbeConsistency, isStrictChange } = await import('../verify-postcheck.js')
-    const probeCheck = checkProbeConsistency({
-      // 四参与 reconcile 同源取值：cwd/specBase/changeName 原样透传；runtimeRoot 复用上方
-      // reconcileRuntimeRoot（resolveRuntimeRoot(platformOpts, specBase)）——checkProbeConsistency
-      // 的锚点产物实际都在 changeDir，此参为统一传参签名对齐预留，口径一处定义不二算
-      cwd, specBase, changeName,
-      runtimeRoot: reconcileRuntimeRoot,
-      // IR 严格档（2026-09-07-ir-hardening D-002@v1）：created_at ≥ IR_STRICT_SINCE 的变更
-      // 探针子节全缺 = ERROR（存量 skip 语义零变化）；fail-open（读不到 → false 落豁免）
-      strictMode: isStrictChange({ pm, cwd, changeName }),
-    })
-    const probeEnvelope = buildProbeConsistencyEnvelope(probeCheck)
-    const probeBlocked = printProbeConsistencyCheck(probeCheck, probeEnvelope)
-    // 探针7 covered 证据锚点 advisory（坑 probe7-covered-anchor-missing，2026-09-15 复盘：7 行
-    // covered 证据缺 file:line 被审查打回——预填说明已载明口径，机器在 --done 时点再拦一道，
-    // 省一轮人工往返）。advisory 不阻断；独立模块零环（verify-probes 是多会话冲突面，不碰）。
-    try {
-      const { checkProbe7AnchorCoverage } = await import('../probe7-anchor-check.js')
-      const p7ReportPath = join(specBase, 'changes', changeName, 'verify-result.md')
-      if (existsSync(p7ReportPath)) {
-        const p7Anchor = checkProbe7AnchorCoverage(readFileSync(p7ReportPath, 'utf8'))
-        if (p7Anchor.applicable && p7Anchor.missingAnchors.length > 0) {
-          console.warn(`\n⚠️ 探针7 锚点校验：${p7Anchor.missingAnchors.length}/${p7Anchor.coveredRows} 行判定为 covered 但证据列缺 file:line / \`.test.\` 文件名 / 反引号路径锚点（advisory 不阻断，审查会要求回补）：`)
-          for (const m of p7Anchor.missingAnchors.slice(0, 10)) {
-            console.warn(`   - ${m.task}：${m.acceptance || '(空 acceptance)'}——证据当前为「${m.evidence || '(空)'}」，应给 \`测试文件路径:行号\` 首命中锚点、\`.test.\` 测试文件名或反引号包裹的路径/测试名（行号可省）`)
-          }
-          if (p7Anchor.missingAnchors.length > 10) console.warn(`   …还有 ${p7Anchor.missingAnchors.length - 10} 行`)
-        }
-      }
-    } catch { /* 锚点校验异常 fail-soft 不影响 gate */ }
-    // 结果落盘（对齐 writeReconcileRunResult 先例）：独立文件 probe-consistency-result.json——
-    // 与 reconcile-result.json 同 gate 运行同目录组织（verify-runs/<ts>/），但不并入后者：
-    // reconcile-result.json 的 schema 已被 P3a 消费方锁定，塞探针字段（读改写/扩参）只会引入
-    // 两检查间耦合；各写各的回执、按文件名订阅更干净。fail-soft 不影响 gate 判定
-    writeProbeConsistencyRunResult({ runtimeRoot: reconcileRuntimeRoot, changeName, envelope: probeEnvelope, result: probeCheck })
-    if (probeBlocked) {
-      writeVerifyGatePointer({ runtimeRoot: reconcileRuntimeRoot, changeName, blocked: true, note: '探针一致性抽查 error 阻断' })
-      return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
-    }
-    // ── verify 填槽制篡改门禁（r5l 方案3 / 评审护栏#2 承重件，v2 件二）──
-    // verify-probes --init --draft 生成的机器预填段（任务完成度/风险等级/测试结果/决策追踪）带
-    // sha256 指纹标记 + .runtime sidecar 台账；--done 对账：标记被删 / 内容哈希失配 → 阻断回滚
-    // （heredoc 整份重写的典型形态——Write 可用与否均免疫，机制修法不做生成侧劝说）。修改机器
-    // 段唯一通道 verify-probes --amend-draft（重锚 + amendment 审计）。无 sidecar（未用 draft /
-    // 存量变更）→ not-applicable 零红；门禁自身异常 fail-soft（对齐探针抽查 degraded 语义）。
-    try {
-      const { checkDraftIntegrity } = await import('../verify-draft.js')
-      const draftCheck = checkDraftIntegrity({
-        mdPath: join(specBase, 'changes', changeName, 'verify-result.md'),
-        changeName, runtimeRoot: reconcileRuntimeRoot,
-      })
-      if (draftCheck.applicable && !draftCheck.ok) {
-        console.error(`\n❌ verify-result.md 机器预填段篡改门禁：${draftCheck.violations.length} 处失配——draft 预填段被整份重写或标记被删/被手工重锚。`)
-        for (const v of draftCheck.violations) console.error(`   - ${v}`)
-        console.error('   修复：还原机器段原文（AGENT 槽——结论枚举/移交项/审查叙述——不受本门限制）；确要修改机器段，跑 sillyspec verify-probes --change ' + changeName + ' --amend-draft 留痕重锚后重新 --done。')
-        writeVerifyGatePointer({ runtimeRoot: reconcileRuntimeRoot, changeName, blocked: true, note: 'draft 篡改门禁阻断' })
-        return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
-      }
-    } catch { /* 门禁异常 fail-soft（不是篡改，对齐探针 degraded 放行） */ }
-    // ── ceremony 双跑收口·第一出口（2026-09-18-ceremony-risk-pricing task-04 / FR-03 / D-003；
-    //    execute 评审 FAIL 项补接线）：声明档（.runtime/ceremony-tier-<change>.json 开跑定价）vs
-    //    实际 diff 重跑 blast+span 的事实档，mismatch（severity=error，懒 agent 低报）汇入 verify
-    //    errors 硬 flag 面——阻断回滚（照 reconcile/probe 先例 rollbackCompletionAndReturn，修复后
-    //    重跑 --done 进度不丢）。检查/记账/种子收敛在 runCeremonyDualRunCheck 单点（archive 出口
-    //    complete-handlers.js runArchiveCeremonyDualRunExit 同款消费）；skipped（档位文件缺失=存量
-    //    变更零红门禁）/degraded（git 不可用降级）零噪音放行；整体 fail-soft——检查自身异常降级
-    //    放行（异常不是低报，对齐 archive 出口同款处置）。specBase/runtimeRoot 与四邻检查同源
-    //    （reconcileRuntimeRoot=resolveRuntimeRoot(platformOpts, specBase)，口径一处定义不二算）。──
-    try {
-      const { runCeremonyDualRunCheck, printCeremonyDualRunCheck } = await import('../verify-postcheck.js')
-      const ceremonyCheck = await runCeremonyDualRunCheck({
-        cwd, specBase, changeName,
-        runtimeRoot: reconcileRuntimeRoot,
-      })
-      printCeremonyDualRunCheck(ceremonyCheck)
-      if (ceremonyCheck.status === 'mismatch' && ceremonyCheck.severity === 'error') {
-        return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
-      }
-    } catch (e) {
-      console.warn(`⚠️  Ceremony 双跑对账异常降级放行（不阻断 verify，fail-soft）: ${(e && e.message) || e}`)
-    }
     // ── 行号漂移自动重锚（2026-09-09 §7-6：quick --done 已接，verify/archive 收尾补接）──
     // 本变更 diff 中的 .md 文档经 autoReanchorDocRefs 定点重锚（fixable 唯一/优选命中才改 +
     // 同口径回执），消灭「src 改动平移行号 → 下次 docs gate 拦」的人工往返。挂 verify 收尾即

package/src/run/lint-ownership.js

@@ -0,0 +1,37 @@
+/**
+ * lint 归属鉴定降档（共享 helper）——2026-10-15-lint-triage-path-unify。
+ *
+ * 背景（消费仓坑档案 docs/sillyspec/verify-lint-triage-path-divergence.md，2026-10-15
+ * -dsh-engine-acp verify 实证）：降档判定原先只实现在 gates.js 的 verify --done 拦截面；
+ * verify step6「noAI 质量扫描」（verify-quality-scan.js）只做 shouldBlockVerifyLint 二值
+ * 判定直接 throw——同一失败两路径行为分叉（step6 throw / --done 降档）。本模块把判定与
+ * 提示文案收敛为单一来源，两路径同接线。
+ *
+ * 语义（R4-S-F 实证口径，与 gates.js 原内联实现等价）：
+ * - pre-existing（失败提及文件 × 本变更文件集零交集）→ 打印降档 warning，返回 true（放行）；
+ * - owned（有交集）/ unattributable（输出无可识别路径）/ 鉴定链异常 → 返回 false
+ *   （维持硬拦，保守——无法排除本变更责任时宁可拦不可漏）。
+ *
+ * @param {{lintCheck?: {failureFiles?: string[]}, cwd: string, changeName: string, specBase: string, importer?: () => Promise<any>}} input
+ *   importer 可注入（测试用）；缺省动态加载 ../verify-postcheck.js（triageLintOwnership +
+ *   resolveVerifyChangedFiles——运行时 import 避免模块加载环）。
+ * @returns {Promise<boolean>} true=降档放行（advisory），false=维持硬拦。
+ */
+export async function lintOwnershipDowngrade({ lintCheck, cwd, changeName, specBase, importer }) {
+  const load = importer || (async () => import('../verify-postcheck.js'))
+  let lintOwnership = null
+  try {
+    const { triageLintOwnership, resolveVerifyChangedFiles } = await load()
+    const lintScopeFiles = (resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase }) || [])
+      .map((f) => String(f).replace(/\\/g, '/')).filter((f) => !f.startsWith('.sillyspec/'))
+    lintOwnership = triageLintOwnership({ failureFiles: (lintCheck && lintCheck.failureFiles) || [], changeFiles: lintScopeFiles })
+  } catch { /* 鉴定链异常维持硬拦（保守） */ }
+  if (lintOwnership && lintOwnership.verdict === 'pre-existing') {
+    const failureFiles = (lintCheck && lintCheck.failureFiles) || []
+    console.warn('\n⚠️ Verify lint 实测失败，但归属鉴定为 HEAD 存量债（失败提及文件与本变更文件集零交集）——降档 advisory 不阻断 verify 推进：')
+    console.warn(`   存量债文件：${failureFiles.join('、') || '（见上方输出）'}`)
+    console.warn('   处置建议：单独清偿（顺手清债解锁全仓 lint 门），或本变更确认无关时设 SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕）。债随基线存在，与本变更交付无关。')
+    return true
+  }
+  return false
+}