sillyspec 3.32.7 → 3.32.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sillyspec",
-  "version": "3.32.7",
+  "version": "3.32.8",
   "description": "SillySpec CLI — 流程状态机，让 AI 严格按步骤来",
   "icon": "logo.jpg",
   "homepage": "https://sillyspec.ppdmq.top/",

package/src/change-list.js

@@ -168,6 +168,17 @@ function looksLikePath(p) {
  */
 const INCIDENTAL_RE = /顺带修复|附带修复|顺带|drive-?by|incidental/i
 
+/**
+ * 「<repo-key> 仓变更」段头识别（单一源——2026-10-13-h2-repo-heading-parse 起定义在
+ * change-list.js 并导出；原 stages/plan-postcheck.js 模块内常量上移，plan-postcheck 改
+ * import 同一符号）。段头为 h2/h3：h3 子段形态由本文件消费（currentRepo 设置器），
+ * h2 形态在生态中是既定约定（brainstorm 厚道模板教学、plan-postcheck 覆盖对账
+ * parseDesignCoverageByRepo、design-facts/docs-check 存在性核验、评审清单四处按此解析）。
+ * 容忍可选编号前缀、（…）备注后缀（全/半角括号）与尾随空白/冒号；捕获组 1 = repo-key
+ * （限字母数字._-）；key 是否在注册表由调用方 fail-closed 校验。
+ */
+export const REPO_SECTION_HEADER_RE = /^#{2,3}\s+(?:\d+[.)]\s*)?([A-Za-z0-9_.\-]+)\s*仓变更(?:\s*[（(][^（）()]*[)）])?\s*[:：]?\s*$/
+
 /**
  * 从清单子段标题 / 路径前缀解析跨仓 repoKey（scope-audit-cross-repo-blindness 改进点 2，
  * 2026-09-15）：多仓变更 design 清单按「main 仓 / sub-xxx / spdemo」分段书写，主仓跑
@@ -222,14 +233,16 @@ function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false, repoK
   const sectionMatch = content.match(FILE_LIST_SECTION_RE)
   if (!sectionMatch) return []
 
-  // 从标题后开始，截取到下一个 ## 标题或文件末尾
+  // 从标题后开始，截取到下一个 ## 标题或文件末尾——「<注册key> 仓变更」段头（h2）是本节
+  // 子分段不截断（2026-10-13-h2-repo-heading-parse：段头是生态既定约定——brainstorm 模板/
+  // plan-postcheck 覆盖对账/design-facts 核验四处消费；此前 h2 段头在此终结「文件变更清单」
+  // 节，其后条目整段静默丢失，agent 照告警①书写即丢对账与冻结）。
   const afterSection = content.slice(sectionMatch.index + sectionMatch[0].length)
-  const nextSectionMatch = afterSection.match(/^##\s/m)
-  const relevantContent = nextSectionMatch
-    ? afterSection.slice(0, nextSectionMatch.index)
-    : afterSection
-
-  const lines = relevantContent.split('\n')
+  const lines = []
+  for (const line of afterSection.split('\n')) {
+    if (/^##\s/.test(line) && !REPO_SECTION_HEADER_RE.test(line)) break
+    lines.push(line)
+  }
   let headerSkipped = false
   let pathColIdx = 1            // 默认第 2 列；解析表头后可重定位
   let opColIdx = -1             // 操作列下标（表头扫描后定位；-1 = 无操作列 → operation=null）
@@ -239,6 +252,16 @@ function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false, repoK
   const entries = new Map()     // path -> { path, operation, incidental, repo }（exclude 子段 delete）
 
   for (const line of lines) {
+    // 「<key> 仓变更」段头（h2/h3，REPO_SECTION_HEADER_RE）：仓分段切换——key 须在注册表内
+    // （fail-closed：未注册含 main → 主仓 repo=null，与 detectRepoFromSubsection 同口径）；
+    // 段头重置分类子段态（新分段从 include 起、操作类别清空）。
+    const repoHdr = line.match(REPO_SECTION_HEADER_RE)
+    if (repoHdr) {
+      listMode = 'include'
+      currentOp = null
+      currentRepo = (Array.isArray(repoKeys) && repoKeys.includes(repoHdr[1])) ? repoHdr[1] : null
+      continue
+    }
     // 分类列表子标题：### 新增文件 / ### 修改文件 / ### 不修改文件 / ### sub-grid-security（跨仓段）
     const subHeader = line.match(/^###\s+(.+?)\s*$/)
     if (subHeader) {

package/src/flow-draft.js

@@ -65,6 +65,27 @@ export const DESIGN_QUESTIONS = {
  *  占位句自带词表字样的误放行由 pending 检查（（待撰写 前缀）独立拦截，不依赖本判据）。 */
 const FR_STRENGTH_RE = /\b(SHALL|MUST|SHOULD)\b|必须|禁止/
 
+/** 去 whitespace 字符 bigram Jaccard 相似度（design 问题行回填定位——2026-10-13-design-question-autorepair）。
+ *  改述行由锚问题衍生、共享绝大多数字符对，天然高于任何答案行；≥0.5 视为可原位替换。 */
+function charBigramSimilarity(a, b) {
+  const grams = (s) => {
+    const t = String(s || '').replace(/\s+/g, '')
+    const set = new Set()
+    for (let i = 0; i < t.length - 1; i++) set.add(t.slice(i, i + 2))
+    return set
+  }
+  const A = grams(a), B = grams(b)
+  let inter = 0
+  for (const g of A) if (B.has(g)) inter++
+  const union = A.size + B.size - inter
+  return union === 0 ? 0 : inter / union
+}
+
+/** design 问题行回填阈值：bigram 相似度 ≥ 此值定位到改述行（插入点=其上方），低于则节首插入。
+ *  回填只插入永不删除（评审 P1 清偿：引用问题原文的作答行相似度可胜过真改述行，任何替换式
+ *  回填都有静默销毁 agent 内容的面——插入式把「绝不删除」做成结构不变量，不再依赖阈值甄别）。 */
+const QUESTION_REPAIR_SIM_THRESHOLD = 0.5
+
 /** sidecar 台账路径（.runtime 下，verify-draft sidecar 同族；命名空间=文件:段键）。 */
 export function draftLedgerPath(runtimeRoot, changeName) {
   return join(runtimeRoot, `draft-ledger-${changeName}.json`)
@@ -303,25 +324,66 @@ function draftTasksV2({ change, criteria, withTasks }) {
 export function verifyThinDocsV2({ changeDir, ledger, skipDesign = false }) {
   const violations = []
   const advisories = []
+  const repairs = []
   const anchorCriteria = Array.isArray(ledger?.anchor?.criteria) ? ledger.anchor.criteria : []
   const read = (f) => {
     try { return readFileSync(join(changeDir, f), 'utf8').replace(/\r\n/g, '\n') } catch { return null }
   }
 
-  // design 四节：问题在场（对锚逐字）+ 实质作答
+  // design 四节：问题在场（对锚逐字）+ 实质作答。问题行漂移（节标题在场）→ 机器按锚回填
+  // （2026-10-13-design-question-autorepair：sess_dcb57f25 实证 Write 整文件重写滑误——原文
+  // 3 秒前刚 Read 过仍被整段改述，事前提示是概率性防护；确定防线=锚对比，修被拦后的恢复面：
+  // 高相似改述原位替换、低相似/删除节首插入，agent 作答零丢失，repairs 留痕交 flow.js 渲染）。
   if (!skipDesign) {
     const dText = read('design.md')
     if (dText === null) violations.push('design.md 缺失（v2 起草件在案）——删除后重入 flow start 补生成')
     else {
       const anchorSections = ledger?.anchor?.designQuestions?.sections || DESIGN_QUESTIONS.sections
-      const dLines = dText.split('\n')
+      let dLines = dText.split('\n')
+      // 回填通道：改写先到不了归档（回填后进归档的就是锚文本，与人工恢复等价），写盘失败降级
+      // 回带全文的拒收文案（不抛异常阻断 CLI）。
+      const allQuestionLines = new Set(anchorSections.flatMap((s) => s.lines))
+      const repairedLines = [...dLines]
+      const repairEntries = []
+      for (const sec of anchorSections) {
+        for (const q of sec.lines) {
+          if (repairedLines.some((l) => l.trim() === q)) continue
+          const hIdx = repairedLines.findIndex((l) => l.trim() === `## ${sec.heading}`)
+          if (hIdx === -1) continue // 节整删 → 下方校验环拒收（文案带全文）
+          let end = repairedLines.findIndex((l, i) => i > hIdx && /^##\s/.test(l))
+          if (end === -1) end = repairedLines.length
+          let bestIdx = -1, bestSim = 0
+          for (let i = hIdx + 1; i < end; i++) {
+            const t = repairedLines[i].trim()
+            if (!t || allQuestionLines.has(t)) continue
+            const sim = charBigramSimilarity(t, q)
+            if (sim > bestSim) { bestSim = sim; bestIdx = i }
+          }
+          // 只插入不替换（评审 P1 清偿）：高相似定位 → 插在改述行上方（原文与改述相邻、可读性
+          // 最好）；未定位 → 节首。任何路径都不改动既有行——误定位的最坏结果是插入位置欠佳。
+          const insertAt = bestIdx >= 0 && bestSim >= QUESTION_REPAIR_SIM_THRESHOLD
+            ? bestIdx
+            : (repairedLines[hIdx + 1] === '' ? hIdx + 2 : hIdx + 1)
+          repairedLines.splice(insertAt, 0, q, '')
+          repairEntries.push({ heading: sec.heading, q })
+        }
+      }
+      if (repairEntries.length > 0) {
+        try {
+          writeAtomicSync(join(changeDir, 'design.md'), repairedLines.join('\n'))
+          dLines = repairedLines
+          for (const e of repairEntries) repairs.push(`design「${e.heading}」问题行曾被改写——已按锚回填原文（agent 作答保留）：${e.q}`)
+        } catch {
+          for (const e of repairEntries) violations.push(`design「${e.heading}」问题文本被改写——原文：${e.q}（机器回填写盘失败，请手工恢复此行，答案写在下方）`)
+        }
+      }
       for (const sec of anchorSections) {
         if (!dLines.some((l) => l.trim() === `## ${sec.heading}`)) {
-          violations.push(`design「${sec.heading}」节被删（标题缺失）——恢复小节与四问原文后作答`)
+          violations.push(`design「${sec.heading}」节被删（标题缺失）——恢复小节与四问原文后作答；问题原文：${sec.lines.join('／')}`)
           continue
         }
         for (const q of sec.lines) {
-          if (!dLines.some((l) => l.trim() === q)) violations.push(`design「${sec.heading}」问题文本被改写：「${q.slice(0, 30)}…」——恢复原文（问题钉死，答案写在下方）`)
+          if (!dLines.some((l) => l.trim() === q)) violations.push(`design「${sec.heading}」问题文本被改写——原文：${q}（问题钉死，答案写在下方）`)
         }
         // 实质作答：节内非空行 - 标题行 - 问题行 - 引导行（> 开头）≥1
         const start = dLines.findIndex((l) => l.trim() === `## ${sec.heading}`)
@@ -332,7 +394,7 @@ export function verifyThinDocsV2({ changeDir, ledger, skipDesign = false }) {
           const t = l.trim()
           return t && !qSet.has(t) && !t.startsWith('>') && !t.startsWith('##')
         })
-        if (!answered) violations.push(`design「${sec.heading}」未作答——每节至少一行（小改动可写「不适用：<理由>」）`)
+        if (!answered) violations.push(`design「${sec.heading}」未作答——每节至少一行（小改动可写「不适用：<理由>」）；问题原文：${sec.lines.join('／')}`)
       }
     }
   }
@@ -399,7 +461,7 @@ export function verifyThinDocsV2({ changeDir, ledger, skipDesign = false }) {
     const inFr = rText !== null && rText.includes(c)
     if (!inFr) advisories.push(`成功标准第 ${i + 1} 条原文未在 requirements 见到（FR 标题锚漂移嫌疑——若属有意改写请核对语义未失真）：${c.slice(0, 40)}${c.length > 40 ? '…' : ''}`)
   }
-  return { violations, advisories }
+  return { violations, advisories, repairs }
 }
 
 

package/src/flow-state.js

@@ -0,0 +1,21 @@
+// flow-state.yaml 单一源读取（2026-10-13-thin-sync-stage：自 flow.js 上移的叶子模块）。
+// 依赖仅 node:fs / node:path / js-yaml——供 progress.js（同步投影）与 flow.js（协议主
+// 实现，re-export 保持 `import('../flow.js')` 既有引用面）共享；叶子化让 progress.js
+// 不必为读一个状态文件拉入 flow 协议整条依赖链（评审 P3：非循环依赖问题，flow.js 静态
+// import 闭包实测不达 progress.js）。
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import yaml from 'js-yaml'
+
+export const FLOW_STATE_FILE = 'flow-state.yaml'
+
+/** 读 flow-state（缺文件/损坏 → null = 未参与 thin）。 */
+export function readFlowState(changeDir) {
+  try {
+    const raw = readFileSync(join(changeDir, FLOW_STATE_FILE), 'utf8')
+    const obj = yaml.load(raw)
+    return obj && typeof obj === 'object' ? obj : null
+  } catch {
+    return null
+  }
+}

package/src/flow.js

@@ -33,21 +33,15 @@ import { writeAtomicSync } from './fs-atomic.js'
 import { resolveRuntimeRoot, triggerSync, assertDatedChangeName } from './run/shared.js'
 import { detectUiTouch, buildUiGuidanceLines, runUiVisualProbe, readUiVisualGate, UI_EVIDENCE_FILENAME } from './ui-visual.js'
 import { runHunkAttributionGate, readHunkGate, renderHunkAttributionLines } from './hunk-attribution.js'
+// 2026-10-13-thin-sync-stage：FLOW_STATE_FILE/readFlowState 单一源上移叶子模块 flow-state.js
+// （progress.js 同步投影也要读；叶子化避免 progress.js 为读一个状态文件拉入本协议整条
+// 依赖链——评审 P3 勘误：非静态循环依赖，本文件 import 闭包实测不达 progress.js）；
+// re-export 保持 `import('../flow.js')`（run/command.js 既有动态引用）导出面不变。
+import { FLOW_STATE_FILE, readFlowState } from './flow-state.js'
+export { FLOW_STATE_FILE, readFlowState }
 
-const FLOW_STATE_FILE = 'flow-state.yaml'
 const SUBSTEPS = ['artifacts', 'ledger', 'patch', 'review', 'probes', 'distill', 'archive', 'events']
 
-/** 读 flow-state（缺文件/损坏 → null = 未参与 thin）。 */
-export function readFlowState(changeDir) {
-  try {
-    const raw = readFileSync(join(changeDir, FLOW_STATE_FILE), 'utf8')
-    const obj = yaml.load(raw)
-    return obj && typeof obj === 'object' ? obj : null
-  } catch {
-    return null
-  }
-}
-
 /** 原子写 flow-state（patch 合并，幂等）。 */
 export function writeFlowState(changeDir, patch) {
   const cur = readFlowState(changeDir) || {}
@@ -536,6 +530,7 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
           `requirements 测试绑定槽（收编追加）每条 FR 至少一行作答；写码前后顺手填。`,
           `✅ 任务面归你（工作分解契约）：tasks.md 是你的工作队列（机器种子可增删改，保持 \`- [ ] task-NN:\` 行形态）——CLI 以 checkbox 为进度状态机（task tick/flow status 实时读它），TodoWrite 类工具不替代；`,
           `   勾选是收口证据面（逐格核提交 token/review.json）：做一件 → 勾一格（task tick 即时回显进度与下一任务）→ 继续下一条，勿攒一把勾；`,
+          `   任务拟法：收口/推送/发布类动作不单列 task（协议自身承担，成功标准照写 requirements）；确需单列的，勾选前先有消息预埋 task-NN token 的交付提交（回执类证据写进提交消息）。`,
           `   flow status --change ${change} 为自愿查看/恢复面（非协议必需，D-007 中间零必需交互；恢复时给下一任务指针与进度）。`,
           `⚠️ 交付纪律：收口前交付代码显式 pathspec 提交——冻结件范围=baseline..HEAD，未提交不进审计件。`,
           ``,
@@ -773,6 +768,53 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
   try {
     digest = await flowKnowledgeDigest({ specBase, change, changeDir, input, filesOverride: await extractRoutingInputPaths(cwd, specBase, input) })
   } catch { /* 注入 best-effort 不阻断 start */ }
+  // 跨仓清单写法提示（2026-10-13-thin-empty-face-crosscheck）：注册仓非空时提示段头契约——
+  // thin 通道此前零跨仓指引（fire-ledger-form-strict 实证：契约只活在厚流程模板里，裸写仓目录
+  // 前缀撞空面即静默丢对账）。注册为空 → 零新增输出（横幅逐字节不变）。
+  let crossRepoHintLines = []
+  try {
+    const { loadRegisteredRepoKeys } = await import('./scope-audit.js')
+    const _repoKeys = loadRegisteredRepoKeys(specBase)
+    if (_repoKeys && _repoKeys.length > 0) crossRepoHintLines = [
+      `🌐 跨仓交付：清单跨仓文件另用段头「## <注册key> 仓变更」段内写仓根相对路径（或子段「### <注册key>」/条目前缀 cross-repo:<注册key>:）——key 以 local.yaml repos 注册为准（本仓注册 ${_repoKeys.length} 个）；`,
+      `   裸写「仓目录名/路径」前缀不触发跨仓对账与冻结（收口空面门将点名阻断）。`,
+      ``,
+    ]
+  } catch { /* 注册仓读取失败 → 零提示（与无注册仓同形态） */ }
+  // FR 域预判（2026-10-13-batchtick-evidence-domain-hint）：--input 提及路径 × 模块图（discoverModuleIndex
+  // 读 docs/<project>/modules/_module-map.yaml——与 distill 域路由同一匹配面）。第一次知道「路径未登记」
+  // 不该是收口模块门（最贵时点）。纯提示不设门：input 路径可能不全，路由真相以实际交付文件为准；
+  // 绿地无图/零路径 → 零新增输出（与模块门「绿地无图不拦」语义对齐）。fr-index.js 零编辑——
+  // resolveTouchedDomains（内部即 pseudoDomainFromPaths+词典守卫）复用 distill 同一伪域回退链。
+  let domainHintLines = []
+  try {
+    const _routingFace = await extractRoutingInputPaths(cwd, specBase, input)
+    if (_routingFace.length > 0) {
+      const { discoverModuleIndex } = await import('./decision-distill.js')
+      const { matchedModuleIds, resolveTouchedDomains } = await import('./fr-index.js')
+      const _knowledgeRoot = join(specBase, 'knowledge')
+      const _moduleIndex = discoverModuleIndex(_knowledgeRoot)
+      if (_moduleIndex && Object.keys(_moduleIndex).length > 0) {
+        const _hitRows = []
+        const _missFiles = []
+        for (const f of _routingFace) {
+          const ids = matchedModuleIds(_moduleIndex, f)
+          if (ids.length > 0) _hitRows.push({ f, ids })
+          else _missFiles.push(f)
+        }
+        if (_hitRows.length > 0 || _missFiles.length > 0) {
+          const _lines = ['🗺️ FR 域预判（按 --input 提及路径；最终以收口实际交付文件路由为准）：']
+          for (const r of _hitRows) _lines.push(`   ✓ ${r.f} → fr/${r.ids.join('、')}`)
+          if (_missFiles.length > 0) {
+            const _pseudo = (resolveTouchedDomains(changeDir, _moduleIndex, _missFiles, _knowledgeRoot)[0]) || 'unmapped'
+            _lines.push(`   ⚠️ ${_missFiles.slice(0, 5).join('、')}${_missFiles.length > 5 ? ' 等' : ''} → 未命中知识模块图，FR 蒸馏将落域 ${_pseudo}（按 distill 同一伪域回退链预判——未吸附为 auto-<段>，词典吸附命中既有真域）`)
+            _lines.push('   建议现在登记模块条目（docs/<project>/modules/_module-map.yaml 的 modules.<id>.paths 覆盖该目录）——登记后蒸馏自动落真域（收口模块门仍会兜底拦未登记目录）')
+          }
+          domainHintLines = _lines
+        }
+      }
+    }
+  } catch { /* 域预判 best-effort：图/路径读取失败零输出 */ }
   const lines = [
     `🏃 flow start（${thick ? 'thick 厚档（--thick 显式声明，人声明不做启发式）' : 'thin 轻量跑道'}）: ${change}`,
     `══════════════════════════════════════`,
@@ -795,6 +837,7 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
     `   文档内零指纹标记、零槽注释、零书写指导（规则以本横幅与命令卡为唯一源）；成功标准漂移只出 advisory 不拒收。`,
     `⚠️ design.md 四节动码前后顺手作答；列改动文件用独立「## 文件变更清单」节+表格（| 操作 | 路径 | 说明 |）`,
     `   ——勿写在「接口契约」节内（收口按节名解析声明面）。`,
+    ...crossRepoHintLines,
     `📜 requirements 每条 FR = 标题锚 + 行为句 + 按需场景块（#### 场景：名 + Given/When/Then）；`,
     `   测试绑定节每条 FR 一行 \`FR-NN: test/路径「用例」\`（无测试面写「不适用：理由」）。`,
     `📦 冻结面在 flow done 时点采集（baseline..HEAD 提交面）：未提交交付文件——会话专属 worktree 自动并入；`,
@@ -812,6 +855,9 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
     `   （sillyspec task tick --change ${change} --task task-NN 即时回显进度 N/M 与下一任务指针，flow status 同源；或直接 Edit 翻格 \`- [ ]\`→\`- [x]\`），watcher 实时上平台。`,
     `   ⚠️ harness 的 TodoWrite 类工具是会话内便利面，不替代 tasks.md——平台进度/收口证据只读它（0/12 事故实证：todo 全 completed 而 tasks.md 0 勾）；`,
     `   勾选是收口证据面：每格勾选要有对应提交（消息带 task-NN——逐个列出或 /、，连写如 task-01/02/03，「task-01..task-05」区间写法不认）或 review.json，全勾但零证据会被拒收；勿攒一把勾（收口硬门拒单拍多格）；`,
+    // 任务拟法指引（2026-10-12-closeout-task-guidance，三次「哨兵抓收口型任务零证据」复盘）：
+    // 成功标准≠工作分解——收口/推送/发布是协议自身承担的动作；单列则证据（token 提交）必须先于勾选存在。
+    `   任务拟法：收口/推送/发布类动作不单列 task（提交、归档、推送是 flow start→done 协议自身承担的动作——成功标准照写 requirements，勿逐字搬进任务清单）；确需单列的收口/操作型任务，勾选前先做消息预埋 task-NN token 的交付提交——回执类证据（push/publish 回执、构建日志路径）写进提交消息，勿依赖勾选后补；`,
     `   flow status --change ${change} 为自愿查看/恢复面（恢复时给下一任务指针与进度）。`,
     ``,
     `🛑 三断点纪律（可控性要求——用户没说「全跑完」就必须在每个断点向用户汇报并等确认）：`,
@@ -838,6 +884,7 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
     ...materials.map((p) => `  - ${p}`),
     ``,
     ...digest.lines,
+    ...(domainHintLines.length > 0 ? ['', ...domainHintLines] : []),
   ]
   if (json) {
     console.log(JSON.stringify({ change, tier: thick ? 'thick' : 'thin', baseline, materials, knowledgeDigest: digest.summary }))
@@ -900,7 +947,7 @@ export function remainingSubstepsAtFail({ snapshotSubsteps = {}, doneList = [],
   return SUBSTEPS.filter((k) => k !== failed && snapshotSubsteps?.[k] !== 'done' && !doneNow.has(k))
 }
 
-export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null, confirmArchive = true, freezeDirty = false, acceptDirtyGap = false, acceptOrphanFace = false, allowBatchTick = false, acceptUnmapped = false }) {
+export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null, confirmArchive = true, freezeDirty = false, acceptDirtyGap = false, acceptOrphanFace = false, allowBatchTick = false, acceptUnmapped = false, acceptEmptyFace = false }) {
   const changeDir = join(specBase, 'changes', change)
   const st = readFlowState(changeDir)
   if (!st) {
@@ -968,6 +1015,9 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
     const r = verifyFlowDrafts({ changeDir, change, runtimeRoot, skipDesign: adoptedDesign })
     if (r.applicable && r.schema === 2) {
       // v2 纯 markdown 轨（2026-10-04-thin-docs-v2）：violations 拒收 → 漂移 advisory → spec 断点机器门
+      // 问题行机器回填留痕（2026-10-13-design-question-autorepair）：先于拒收渲染（评审 P3 清偿：
+      // 混合拒收场景回填已落盘，若渲染在 exit(1) 之后则留痕不可达且幂等重跑后永久丢失）。
+      for (const p of r.repairs || []) console.log(`🔧 [design 问题行机器回填] ${p}`)
       if (r.violations.length > 0) {
         console.error(`❌ 工件校验拒收（v2 文档↔锚对比）：`)
         for (const v of r.violations) console.error(`   - ${v}`)
@@ -1041,6 +1091,7 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
     // 哨兵断言（2026-09-25-sentinel-wiring）：tasks.md 全勾但零完成证据（区间提交消息标题与正文
     // 均无 task-NN token 且无对应 review.json）→ 拒收——L0 硬门接线，两道收口同一哨兵（quick 侧同判）。
     let _sentinelNonMirrorTasks = null // 镜像豁免面外的任务数（null=哨兵未跑；0=纯镜像任务面——节奏 advisory 静默）
+    let _sentinelEvidenceComplete = false // 哨兵证据完备（status=complete——每格已勾任务均有 token/review.json）：单拍降级判据（2026-10-13-batchtick-evidence-domain-hint）
     let _autopilotTicked = 0 // 机器代勾格数（>0 时勾选节奏门降 advisory——代勾是单拍多格机械写，非 agent 纪律面）
     // 证据面=整条提交消息（2026-09-25-thin-done-gate-calibration 坑2：%s 只取标题行，正文里的
     // token 被判零证据，与文案「提交带 task-NN」口径漂移）——%B%x1e 按提交切记录，advisory 的
@@ -1107,6 +1158,7 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
         }
         _sentinelNonMirrorTasks = sent.claimTotal
         if (sent.status === 'complete') {
+          _sentinelEvidenceComplete = true
           console.log(`🛡️ 哨兵：全勾 ${sent.checked}/${sent.claimTotal} 证据齐（提交 token/review.json）`)
           // 勾选时点判定（2026-09-26-tick-loop-nudge，R19 行为发现）：tasks.md 的 git 首次提交
           // == 收口窗口最后提交（一把勾模式）→ 放行但打行为提醒（不阻断——token 证据已验，
@@ -1156,16 +1208,24 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
         // 单源（resolveBatchTickAction）四态与豁免优先序见其 JSDoc——代勾须解释整跳才降级
         const _persistedAuto = Number(st?.autopilot_ticked) || 0
         const _autoN = Math.max(_autopilotTicked, _persistedAuto)
-        const v = resolveBatchTickAction({ batchTick: batch, nonMirrorCount: _sentinelNonMirrorTasks, allowBatchTick, autopilotTicked: _autoN })
+        const v = resolveBatchTickAction({ batchTick: batch, nonMirrorCount: _sentinelNonMirrorTasks, allowBatchTick, autopilotTicked: _autoN, evidenceComplete: _sentinelEvidenceComplete })
         const at = Number.isFinite(batch.ts) ? new Date(batch.ts).toLocaleTimeString() : '未知时刻'
         if (v.action === 'bypass') {
           try { writeFlowState(changeDir, { allow_batch_tick: true }) } catch { /* 留痕 best-effort */ }
           console.warn(`⚠️ --allow-batch-tick：单拍多格勾选（${batch.detail}，${at}）硬门显式旁路——留痕 flow-state 与平台时间线`)
         } else if (v.action === 'advisory') {
-          const why = v.reason === 'autopilot-ticked'
-            ? `机器代勾 ${_autoN} 格（governance-autopilot 单拍机械写，非 agent 纪律面；本拍 ${_autopilotTicked}/持久化 ${_persistedAuto}）`
-            : '哨兵任务面未知（fail-open 防误拒）'
-          console.warn(`⚠️ 勾选节奏：单拍多格勾选（${batch.detail}，${at}）——${why}，降级提醒不拒`)
+          // 证据完备降级（2026-10-13-batchtick-evidence-domain-hint）：同形态 git 时点检查（一把勾
+          // 模式）因 token 证据齐放行——事件流门对齐该语义；损害只剩 per-task 时间戳信号面，advisory
+          // + flow-state 留痕与损害对齐。证据缺失形态不走此态（哨兵先拒 / 决策函数维持 reject）。
+          if (v.reason === 'evidence-complete') {
+            try { writeFlowState(changeDir, { batch_ticked: true }) } catch { /* 留痕 best-effort */ }
+            console.warn(`⚠️ 勾选节奏：单拍多格勾选（${batch.detail}，${at}）——哨兵证据完备（每格已勾任务均有 token 提交/review.json），降级提醒不拒（batch_ticked 已留痕；下次完成单元即勾）`)
+          } else {
+            const why = v.reason === 'autopilot-ticked'
+              ? `机器代勾 ${_autoN} 格（governance-autopilot 单拍机械写，非 agent 纪律面；本拍 ${_autopilotTicked}/持久化 ${_persistedAuto}）`
+              : '哨兵任务面未知（fail-open 防误拒）'
+            console.warn(`⚠️ 勾选节奏：单拍多格勾选（${batch.detail}，${at}）——${why}，降级提醒不拒`)
+          }
         } else if (v.action === 'reject') {
           console.error(`🚫 单拍勾选拒收：事件流观测到一拍勾选 ${batch.detail}（${at}）——勾选纪律要求逐格（做一件→勾一格→下一个），勾选任务 ${_sentinelNonMirrorTasks} 格`)
           console.error('   出口：①节奏违例已既成——认知后重跑带 --allow-batch-tick 显式留痕过门（平台时间线可见旁路）；②疑观测误判→sillyspec doctor 核对事件流')
@@ -1521,6 +1581,76 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
             }
           } catch { /* 守卫异常不阻断（fail-safe 不新造阻断面） */ }
         }
+        // ── 声明面自证前置（2026-10-13-thin-empty-face-crosscheck）：planEntries 解析与跨仓防呆
+        //    告警提到 ownFiles 判空之前——空面也要跑。fire-ledger-form-strict 实证（multi-agent-platform
+        //    docs/sillyspec/thin-done-empty-face-no-declared-crosscheck.md 37c7d146b）：跨仓交付撞空面时
+        //    本段整挂在非空 else 分支内从未执行，归档件永久缺 patch 且零告警；空面恰是高危形态。
+        let planEntries = []
+        try {
+          const { parseFileChangeListDetailed } = await import('./change-list.js')
+          // repoKeys（2026-10-10-cross-repo-patch-freeze D-002@v1）：注册仓清单传入——跨仓
+          // 子段/cross-repo: 前缀条目才带 repo 标注（不传则跨仓声明全落主仓口径， thin 跨仓
+          // 对账无从谈起）
+          const { loadRegisteredRepoKeys } = await import('./scope-audit.js')
+          planEntries = parseFileChangeListDetailed(join(changeDir, 'design.md'), { keepSillyspecDocs: true, repoKeys: loadRegisteredRepoKeys(specBase) })
+        } catch { /* 清单缺失/不可解析 → 实际侧 only 快照行（无 verdict，与主链路降级同语义） */ }
+        // 跨仓声明防呆（坑 design-filelist-crossrepo-prefix-silent-main）：嫌疑判定从「首段命中
+        // 注册仓」放宽为「声明路径主仓不存在即点名」（仓根相对路径形态首段不命中是盲区）；
+        // 首段命中注册仓的条目额外标注 key，点名+三种正确语法指引。
+        const _declared = []
+        for (const e of planEntries) {
+          const pe = String((e && e.path) || '').split('\\').join('/')
+          if (!pe || pe.startsWith('.sillyspec/')) continue
+          if (e.repo) continue
+          _declared.push({ path: pe })
+        }
+        let _repoAliases = null
+        try {
+          const _yamlText = existsSync(join(specBase, 'local.yaml')) ? readFileSync(join(specBase, 'local.yaml'), 'utf8') : ''
+          if (_yamlText) {
+            const { parseRepoRegistry } = await import('./stages/plan-postcheck.js')
+            const _repos = parseRepoRegistry(_yamlText)
+            if (_repos && _repos.size > 0) {
+              _repoAliases = new Map()
+              for (const [k, v] of _repos) {
+                _repoAliases.set(k, k)
+                const norm = String(v || '').split('\\').join('/')
+                const bn = norm.replace(/\/+$/, '').split('/').pop()
+                if (bn) _repoAliases.set(bn, k)
+              }
+            }
+          }
+        } catch { /* 注册表读取失败 → 别名标注缺席，存在性判定不受影响 */ }
+        const _suspects = []
+        for (const d of _declared) {
+          if (existsSync(join(cwd, d.path))) continue
+          _suspects.push({ path: d.path, key: (_repoAliases && _repoAliases.get(d.path.split('/')[0])) || null })
+        }
+        if (_suspects.length > 0) {
+          console.warn(`⚠️ 疑似跨仓声明未按规范标注（${_suspects.length} 条已按主仓路径对账）：${_suspects.slice(0, 5).map((x) => `${x.path}（主仓不存在${x.key ? `，首段命中注册仓 ${x.key}` : ''}）`).join('、')}${_suspects.length > 5 ? ' 等' : ''}`)
+          console.warn('   主仓无这些路径 → 冻结面将标「计划未动」、跨仓对账与 patch 冻结不触发。正确写法三选一：① 段头「## <注册key> 仓变更」段内写仓根相对路径；② 子段「### <注册key>」；③ 条目前缀 cross-repo:<注册key>:<仓根相对路径>——key 以 local.yaml repos 注册为准')
+        }
+        // ── 空面门：空冻结面 + 声明清单有未标注交付条目 → 阻断（三处置一次给全；fire-ledger-form-strict 形态补位）──
+        if (ownFiles.length === 0 && _declared.length > 0 && !acceptEmptyFace && !st.accept_empty_face) {
+          console.error(`❌ 冻结面为空但 design 声明清单有 ${_declared.length} 条未标注交付条目（实现不在冻结窗口——跨仓交付撞空面的实证形态）——收口阻断（不归档；处置后重跑同一条命令从断点续）：`)
+          for (const x of _suspects.slice(0, 5)) console.error(`   - ${x.path}${x.key ? `（首段命中注册仓 ${x.key}）` : '（主仓不存在）'}`)
+          console.error('   ① 实现在主仓：先提交后重跑')
+          console.error('   ② 跨仓交付：清单按规范标注后重跑——正确写法三选一：段头「## <注册key> 仓变更」段内写仓根相对路径；子段「### <注册key>」；条目前缀 cross-repo:<注册key>:<仓根相对路径>（key 以 local.yaml repos 注册为准）')
+          console.error(`   ③ 纯文档变更/清单误列：同步裁剪 design 清单后重跑；或显式签收：flow done --change ${change} --accept-empty-face（留痕 flow-state，重跑免重拦）`)
+          reportMidFail('patch')
+          process.exit(1)
+        }
+        if (ownFiles.length === 0 && _declared.length > 0 && (acceptEmptyFace || st.accept_empty_face)) {
+          if (acceptEmptyFace && !st.accept_empty_face) {
+            writeFlowState(changeDir, { accept_empty_face: { at: new Date().toISOString(), declaredCount: _declared.length, by: process.env.SILLYSPEC_SESSION_ID || null } })
+            st.accept_empty_face = true
+          }
+          console.warn(`⚠️ --accept-empty-face：显式签收空冻结面与声明面矛盾（${_declared.length} 条声明交付不进冻结面，留痕 flow-state accept_empty_face）`)
+        }
+        // 纯跨仓规范标注空面：合规书写不拦，advisory 点名 thin 空面分支不做跨仓冻结的已知缺口
+        if (ownFiles.length === 0 && _declared.length === 0 && planEntries.some((e) => e && e.repo)) {
+          console.warn('⚠️ 声明清单全部为跨仓规范标注且主仓冻结面为空——thin 空面分支不做跨仓冻结与 patch 留档（缺口已知：归档件将无 patch 两件；如需冻结请主仓侧交付或待后续版本支持空面跨仓冻结）')
+        }
         if (ownFiles.length === 0) {
           console.log('📦 patch 留档跳过：本变更可归属文件面为空（无交付面改动——治理工件不入冻结面；若实现代码应在此，先提交后重跑）')
           patchOk = true
@@ -1586,15 +1716,7 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
           // 收口留痕单套写（2026-10-09-close-trace-single-set）：共用 writeCloseTraceArtifacts
           // 只写 change.patch + change-patch.json 两件——对账面数据并入 JSON 的 scopeAudit
           // 子对象（thin 通道同样有对账面），旧名 scope-audit.* 停写、读侧兼容兜存量归档。
-          let planEntries = []
-          try {
-            const { parseFileChangeListDetailed } = await import('./change-list.js')
-            // repoKeys（2026-10-10-cross-repo-patch-freeze D-002@v1）：注册仓清单传入——跨仓
-            // 子段/cross-repo: 前缀条目才带 repo 标注（不传则跨仓声明全落主仓口径， thin 跨仓
-            // 对账无从谈起）
-            const { loadRegisteredRepoKeys } = await import('./scope-audit.js')
-            planEntries = parseFileChangeListDetailed(join(changeDir, 'design.md'), { keepSillyspecDocs: true, repoKeys: loadRegisteredRepoKeys(specBase) })
-          } catch { /* 清单缺失/不可解析 → 实际侧 only 快照行（无 verdict，与主链路降级同语义） */ }
+          // planEntries 解析与跨仓防呆告警已前移至 ownFiles 判空之前（2026-10-13-thin-empty-face-crosscheck）。
           // 跨仓声明在场 → 共享集成层分仓对账 + patch 冻结（D-001/D-002@v1）：与 heavy 通道
           // （execute --done）同源 reconcileCrossRepoPlan，repos[]（锚点/计数/patch 正文）
           // 随 snapObj 进 change-patch.json；任何异常 fail-soft 退 ⊘ 补行现行为（不阻断收口）
@@ -2380,7 +2502,7 @@ export async function cmdFlow(args, cwd, specDir = null, opts = {}) {
         console.log('🔄 --refreeze：patch 子步标记已重置，本次 done 将重新冻结（change.patch 按 baseline..HEAD 最新面重建）')
       }
     }
-    return cmdFlowDone({ change, cwd, specBase, runtimeRootOpt, freezeDirty: hasFlag('--freeze-dirty'), acceptDirtyGap: hasFlag('--accept-dirty-gap'), acceptOrphanFace: hasFlag('--accept-orphan-face'), allowBatchTick: hasFlag('--allow-batch-tick'), acceptUnmapped: hasFlag('--accept-unmapped') })
+        return cmdFlowDone({ change, cwd, specBase, runtimeRootOpt, freezeDirty: hasFlag('--freeze-dirty'), acceptDirtyGap: hasFlag('--accept-dirty-gap'), acceptOrphanFace: hasFlag('--accept-orphan-face'), allowBatchTick: hasFlag('--allow-batch-tick'), acceptUnmapped: hasFlag('--accept-unmapped'), acceptEmptyFace: hasFlag('--accept-empty-face') })
   }
   if (sub === 'amend-draft') {
     // 机器稿唯一留痕修改通道（R7 切片三 / FR-08）：重锚哈希 + ledger amendment 审计；

package/src/fr-index.js

@@ -594,8 +594,17 @@ export function indexRequirements({ changeDir, knowledgeRoot, headHash = '', del
       // 落域机械改进（2026-09-27-knowledge-digest）：伪域告警附交付路径推导的建议域——
       // 归档时转达人工 1 秒确认（建议器与 digest 信号卡共用 suggestDomainFromFiles 单源）
       const suggested = suggestDomainFromFiles(deliverableFiles || [], { knowledgeRoot })
+      // 坑 fr-redomain-advisory-and-selectivity-gap（2026-10-13）：告警接专用命令 +
+      // --by-change 条目级过滤 + D-001 迁域不换号铁律明示（防手工迁移按序重编号断
+      // supersede 链）。锚定域取告警列出的伪域文件名（auto-x.md → auto-x）。
+      const pseudoDomains = [...new Set(pseudoHits.map((w) => String(w.file || '').replace(/\.md$/, '')))].filter(Boolean)
       console.warn(`⚠️ [FR 域路由降级] 本变更 ${pseudoHits.length} 条 FR 落伪域/unmapped（${[...new Set(pseudoHits.map((w) => w.file))].join('、')}）${suggested ? `——按交付路径建议域：${suggested}（确认后可迁移；` : '（'}补模块卡（docs/<项目>/modules/_module-map.yaml 登记该目录）后，新变更将自动落回真域；绿地仓可跑 sillyspec run scan 校准）`)
-      if (suggested) console.warn(`   迁移/存量清单：sillyspec knowledge digest（伪域信号卡）`)
+      if (suggested) {
+        console.warn(`   域级整体迁移：sillyspec tests --redomain --from <伪域> --to ${suggested} --write（干跑去 --write）；只迁本变更条目：加 --by-change <本变更名>`)
+        if (pseudoDomains.length > 0) console.warn(`   例：sillyspec tests --redomain --from ${pseudoDomains[0]} --to ${suggested} --by-change <本变更名> --write`)
+        console.warn(`   ⚠️ 迁域不换号（D-001 铁律）：条目 ID 保持原样（绑定/supersede 链按 ID 寻址）——手工搬移时勿按目标域接续重编号`)
+        console.warn(`   迁移/存量清单：sillyspec knowledge digest（伪域信号卡）`)
+      }
     }
     const unm = all.get('unmapped')
     if (unm && unm.sections.length > 50) {

package/src/index.js

@@ -4044,6 +4044,53 @@ SillySpec worktree — git worktree 隔离管理
           }
           break;
         }
+        case 'deps': {
+          // deps 状态显式覆写（坑 deps-gate-offline-fragile，2026-10-12 实证：离线环境
+          // npm ci 必败 + lockfile 本地改动致链接快路径失效，agent 被迫手改 meta.json 绕过
+          // ——未定义行为且零留痕。本命令把绕过通道 CLI 化：--set 显式值 + --reason 强制
+          // 留痕（写 depsOverrideNote / depsOverrideAt），审计面可对账。合法值收敛工具
+          // 认知集（n/a/linked/installed/failed）。
+          const setIdx = filteredArgs.indexOf('--set')
+          const setVal = setIdx !== -1 && filteredArgs[setIdx + 1] && !String(filteredArgs[setIdx + 1]).startsWith('--') ? String(filteredArgs[setIdx + 1]).trim() : null
+          const rIdx = filteredArgs.indexOf('--reason')
+          const reason = rIdx !== -1 && filteredArgs[rIdx + 1] ? String(filteredArgs[rIdx + 1]).trim() : null
+          if (!wtName || !setVal || !reason) {
+            console.error('用法: sillyspec worktree deps --change <变更名> --set <n/a|linked|installed|failed> --reason "<事实依据——必填留痕>"')
+            console.error('   离线/内网环境供给链失败时的显式覆写通道（写 meta.json + 覆写留痕）；先确认 node_modules 确实可用再 set linked')
+            process.exit(2)
+          }
+          if (!['n/a', 'linked', 'installed', 'failed'].includes(setVal)) {
+            console.error(`❌ --set 值非法 "${setVal}"（合法：n/a | linked | installed | failed）`)
+            process.exit(2)
+          }
+          try {
+            const specBaseWd = resolvePlatformSpecDir(dir, specDir)
+            const wtBase = join(specBaseWd, '.runtime', 'worktrees')
+            const wtDir = join(wtBase, wtName)
+            const metaPath = join(wtDir, 'meta.json')
+            // 跨仓 worktree：主 specBase 下无实体时扫各注册仓（简化：本命令聚焦主仓 worktree，
+            // 跨仓路径用 --spec-dir 指到对应 specBase；两形态 meta.json 同款）
+            if (!existsSync(metaPath)) {
+              console.error(`❌ 找不到 worktree meta：${metaPath}`)
+              console.error('   跨仓 worktree 用 --spec-dir 指向其 specBase 后重跑；变更名核对 sillyspec worktree list')
+              process.exit(1)
+            }
+            const meta = JSON.parse(String(readFileSync(metaPath, 'utf8')).replace(/^\uFEFF/, ''))
+            const prev = meta.depsStatus
+            meta.depsStatus = setVal
+            meta.depsOverrideNote = `手工覆写: ${reason}（前值 ${prev ?? 'null'}）`
+            meta.depsOverrideAt = new Date().toISOString()
+            const { writeAtomicSync } = await import('./fs-atomic.js')
+            writeAtomicSync(metaPath, JSON.stringify(meta, null, 2) + '\n')
+            console.log(`✅ deps 状态已覆写：${wtName} depsStatus ${prev ?? 'null'} → ${setVal}`)
+            console.log(`   留痕：${meta.depsOverrideNote}`)
+            console.log('   verify/archive 对账时以 depsOverrideNote 为审计锚——事实依据不实属未定义行为')
+          } catch (e) {
+            console.error(`❌ 覆写失败: ${e.message}`)
+            process.exit(1)
+          }
+          break;
+        }
         default:
           console.error(`❌ 未知子命令: worktree ${wtSubCmd}`);
           console.log('   运行 sillyspec worktree --help 查看帮助');

package/src/progress.js

@@ -23,6 +23,10 @@ import { StepStore } from './progress/step-store.js';
 import { StageMachine } from './progress/stage-machine.js';
 import { stageRegistry } from './stages/index.js';
 import { STAGE_ORDER, MAIN_FLOW_ORDER, VALID_STAGES, STAGE_LABELS, SPEC_DIR_NAME, CURRENT_VERSION, emptyStage } from './progress/shared.js';
+// 2026-10-13-thin-sync-stage：叶子模块（无内部依赖），同步投影读 thin 出身用——
+// 叶子化避免本文件为读一个状态文件拉入 flow 协议整条依赖链（评审 P3 勘误：
+// flow.js 静态 import 闭包实测不达本文件，非循环依赖问题）。
+import { readFlowState } from './flow-state.js';
 // resolveSpecDir 单一真相源在 src/run/shared.js（含 home 拒绝守卫，坑 cwd-correction-home-collision
 // 根治：home 下 .sillyspec 恒不命中，防 smoke/临时目录污染自我延续）。此处 re-export 保持
 // 既有 import 路径兼容；run/shared.js 对 progress.js 只有动态 import，无静态循环。
@@ -600,6 +604,18 @@ export class ProgressManager {
       // → 上行恒无标题，平台只能落 change_key（「英文 key」病灶的同步链一侧）。
       title: changeRow.title ?? null,
     };
+    // thin 出身上行投影（2026-10-13-thin-sync-stage）：tier=thin 且行 status=active 时
+    // current_stage 上报 'thin'——平台 StageEnum.THIN / 列表「轻量」徽章与筛选 / ingest
+    // 双守卫均按该值消费；本地行出生恒 'brainstorm'（thin 不走阶段机），照抄上行会让
+    // 平台读侧 is_thin 判定三分支全不命中（实证：进行中轻量变更无徽章）。仅覆写载荷，
+    // 本地 DB 行不动；归档（status=archived，行已翻 'archive'）与升厚（tier=thick）不
+    // 覆写；flow-state 缺失/损坏 readFlowState→null 按行值上行（fail-open 现状行为）。
+    if (
+      changeRow.status === 'active' &&
+      readFlowState(this._changePath(cwd, changeName))?.tier === 'thin'
+    ) {
+      changeProj.current_stage = 'thin';
+    }
 
     // 2. project 全局单行（只投影稳定字段 name/schema_version；created_at/updated_at 是本地库元数据，
     //    同步无意义且破坏 round-trip 跨库等值——与 changes 排除 created_at 同理，B2）

package/src/sentinel-assertions.js

@@ -168,21 +168,27 @@ export function detectBatchCheckCadence(events) {
 /**
  * 单拍勾选门决策（2026-09-29-batch-tick-gate，纯函数）：检出单拍跳（batchTick 非 null）
  * 时的收口动作裁决。镜像豁免分支退役（2026-10-07-thin-tasks-v3——任务面统一为 agent
- * 工作分解，无镜像面）。四态（决策顺序即豁免优先序）：
+ * 工作分解，无镜像面）。五态（决策顺序即豁免优先序）：
  *   'silent'   无单拍跳；
  *   'bypass'   --allow-batch-tick 显式旁路——留痕放行（同意门先例）；
- *   'advisory' 机器代勾可解释整跳（autopilotTicked >= 跳幅——governance-autopilot 代勾是
- *              单拍多格机械写，非 agent 纪律面；代勾数不可解释最大跳时落到 reject——防「留
- *              一格给代勾补、自身大跳蹭豁免」的对抗绕过，二轮评审 P3-E）；
- *   'reject'   非旁路、代勾解释不了整跳——agent 一把勾，拒收。
- * @param {{batchTick:object|null, nonMirrorCount?:number|null, allowBatchTick?:boolean, autopilotTicked?:number}} args
+ *   'advisory' 三路：哨兵面未知（fail-open 防误拒）；哨兵证据完备（status=complete——
+ *              2026-10-13-batchtick-evidence-domain-hint：同形态 git 时点检查「一把勾模式」
+ *              因 token 证据齐放行，事件流门对齐该语义——证据是提交哈希锚定的客观面，
+ *              损害只剩 per-task 时间戳信号面；证据缺失形态不走此态，维持 reject）；机器代勾
+ *              可解释整跳（autopilotTicked >= 跳幅——governance-autopilot 代勾是单拍多格机械写，
+ *              非 agent 纪律面；代勾数不可解释最大跳时落到 reject——防「留一格给代勾补、自身
+ *              大跳蹭豁免」的对抗绕过，二轮评审 P3-E）；
+ *   'reject'   非旁路、证据不完备、代勾解释不了整跳——agent 一把勾，拒收。
+ * @param {{batchTick:object|null, nonMirrorCount?:number|null, allowBatchTick?:boolean, autopilotTicked?:number, evidenceComplete?:boolean}} args
  *   nonMirrorCount 保留为哨兵面未知信号（null → fail-open advisory）；镜像-only 语义已退役。
+ *   evidenceComplete 缺省 false（additive——既有调用方零感知）。
  * @returns {{action:'silent'|'advisory'|'bypass'|'reject', reason:string}}
  */
-export function resolveBatchTickAction({ batchTick, nonMirrorCount = null, allowBatchTick = false, autopilotTicked = 0 } = {}) {
+export function resolveBatchTickAction({ batchTick, nonMirrorCount = null, allowBatchTick = false, autopilotTicked = 0, evidenceComplete = false } = {}) {
   if (!batchTick) return { action: 'silent', reason: 'no-batch-tick' };
   if (allowBatchTick === true) return { action: 'bypass', reason: 'flag' };
   if (nonMirrorCount === null) return { action: 'advisory', reason: 'sentinel-unknown' };
+  if (evidenceComplete === true) return { action: 'advisory', reason: 'evidence-complete' };
   if (autopilotTicked >= batchTick.to - batchTick.from) return { action: 'advisory', reason: 'autopilot-ticked' };
   return { action: 'reject', reason: 'agent-batch-tick' };
 }

package/src/stage-review.js

@@ -138,6 +138,9 @@ export function renderReviewJsonContract({ stage, changeDir, reviewRunId, tier,
     '## review.json 产物契约(CLI Stage Review Gate 将硬校验,以下为精确 schema —— 事前给的 == 事后查的)',
     '',
     '> 路径:`{SPEC_ROOT}/.runtime/stage-reviews/' + stageLbl + '-' + runIdLbl + '/review.json`(本次 reviewType=' + reviewType + ',主审查文档=' + mainDocRel + ')',
+    ...(changeDir
+      ? ['> **本次完整绝对路径（直接复制给审查子代理，勿手拼 runId/漏阶段前缀——坑 stage-review-path-prefix 2026-10-10 实证：marker 只有裸 runId，子代理按 runId 直写漏「<stage>-」前缀即错位）**: `' + join(dirname(dirname(changeDir)), '.runtime', 'stage-reviews', stageLbl + '-' + runIdLbl, 'review.json') + '`']
+      : []),
     '',
     '### 必填字段(validateStageReviewSchema 硬校验,缺任一即 schema 失败阻断)',
     '- `schemaVersion`: ' + REVIEW_SCHEMA_VERSION,

package/src/stages/knowledge.js

@@ -596,6 +596,28 @@ async function tryImportSubcommandImpl(importPath, moduleName) {
  * @param {object} opts - { specDir }
  */
 export async function cmdKnowledge(args, dir, opts = {}) {
+  // --help/-h 全局拦截（坑：探索型调用 knowledge refresh --help 被当默认参数直接执行
+  // ——cmdRefresh 无参即全量重写 generated/，副作用写 34 文件。帮助请求在任何子命令
+  // 前消化，危险面子命令不再被误触发）。
+  if (args.includes('--help') || args.includes('-h')) {
+    const lines = [
+      '用法: sillyspec knowledge <子命令> [参数]',
+      '',
+      '子命令:',
+      '  search "<关键词>"     检索知识库（命中自动注入 prompt 的同源面）',
+      '  inspect <文件>        查看单个知识文件条目结构',
+      '  validate              校验知识库完整性（INDEX 锚点/注册/幽灵条目——纯读）',
+      '  digest                治理信号卡（rot/伪域/坏绑定——纯读）',
+      '  stats                 覆盖率/死条目统计（纯读）',
+      '  refresh               重扫 scan 文档重写 generated/ 区（**写盘**——先 validate 再用）',
+      '  propose / classify / inbox / graph / stats',
+      '',
+      '写盘面子命令（refresh/propose/classify）先跑同名只读命令确认现状；探索用法先看本帮助。',
+    ]
+    for (const l of lines) console.log(l)
+    output(true, { help: true, subcommands: ['search', 'inspect', 'validate', 'digest', 'refresh', 'propose', 'classify', 'inbox', 'graph', 'stats'] })
+    return
+  }
   const subCommand = args[0] || ''
 
   switch (subCommand) {

package/src/stages/plan-postcheck.js

@@ -17,7 +17,7 @@ const readFileSync = (filePath, encoding) => _readFileSync(filePath, encoding).r
 import { join as pJoin, basename } from 'path'
 import { tmpdir } from 'os'
 import jsYaml from 'js-yaml'
-import { parseFileChangeList, pathMatches } from '../change-list.js'
+import { parseFileChangeList, pathMatches, REPO_SECTION_HEADER_RE } from '../change-list.js'
 import { getRule } from '../stage-contract-spec.js'
 import { TASKCARD_PLACEHOLDERS } from '../taskcard-placeholders.js'
 import { validateScriptCommands } from './cmd-existence.js'
@@ -942,13 +942,10 @@ export function validateTaskCommands(changeDir, projectRoot, modules = null, rep
 // design 清单解析与 allowed_paths 对账共用同一套匹配语义，避免两处逻辑漂移。
 
 /**
- * design §6 按仓分段段头识别（D-014）：`## <repo> 仓变更`（如 `## sillyspec 仓变更`）。
- * 段头为 h2/h3，repo 名取段头首 token（去空白/编号前缀）。容忍可选编号前缀、（…）备注后缀
- * （`（跨仓，X1-X4）` 等，全/半角括号均可）与尾随空白/冒号——后缀不容忍时（用户实证
- * 2026-08-29）`### sillyspec 仓变更（跨仓，X1-X4）` 整段判 main、跨仓文件全量误报未覆盖。
- * 不命中（非仓变更段头）→ null。
+ * 「<repo> 仓变更」段头识别（D-014）：`## <repo> 仓变更`（如 `## sillyspec 仓变更`）。
+ * 正则已上移 change-list.js 导出（单一源，2026-10-13-h2-repo-heading-parse——thin 收口
+ * 对账解析器同步消费该段头形态），此处 import 使用；容忍语义见 change-list.js 处注释。
  */
-const REPO_SECTION_HEADER_RE = /^#{2,3}\s+(?:\d+[.)]\s*)?([A-Za-z0-9_.\-]+)\s*仓变更(?:\s*[（(][^（）()]*[)）])?\s*[:：]?\s*$/
 
 /**
  * 疑似段头宽匹配：标题行含「<token> 仓变更」字样（token 与仓变更间有空白）。
@@ -1566,6 +1563,44 @@ export function validateTaskcardsCli({ changeDir, projectRoot = null }) {
             errors.push(`${id}: target_files 形态非法——${bad.map(b => `${b.raw}（${b.invalid}）`).join('；')}`)
           }
         }
+        // provides/expects_from 结构校验（坑 taskcard-validate-vs-postcheck-gap，2026-10-10
+        // 实证：散文行 `- contract Foo fields [a, b]` 是合法 YAML 字符串数组，--validate 过、
+        // 契约解析器静默过滤（无 contract 键即丢）→ plan --done 才报「provider 未声明」。
+        // 在填卡自检轮暴露：字符串元素/缺 contract/fields·needs 非数组 = 形态错，给出映射式模板。
+        const id2 = (content.match(/^id:\s*(.+)/m)?.[1] || '').trim() || f
+        const fm = fmParse.fm || {}
+        const _tpl = '映射式：- contract: <名> / fields: [a, b]（expects_from 同构，needs 替 fields）'
+        if (Array.isArray(fm.provides)) {
+          for (const pe of fm.provides) {
+            const bad = typeof pe === 'string'
+              || !pe || typeof pe !== 'object'
+              || typeof pe.contract !== 'string' || !pe.contract.trim()
+              || (pe.fields !== undefined && !Array.isArray(pe.fields))
+            if (bad) {
+              errors.push(`${id2}: provides 条目形态非法（${typeof pe === 'string' ? `散文行「${pe.slice(0, 40)}」` : '缺 contract 键或 fields 非数组'}）——${_tpl}`)
+              break
+            }
+          }
+        }
+        if (fm.expects_from && typeof fm.expects_from === 'object' && !Array.isArray(fm.expects_from)) {
+          for (const [prov, contracts] of Object.entries(fm.expects_from)) {
+            if (!Array.isArray(contracts)) {
+              errors.push(`${id2}: expects_from.${prov} 应为契约数组（映射式：- contract: <名>
+  needs: [a, b]）`)
+              continue
+            }
+            for (const ce of contracts) {
+              const bad = typeof ce === 'string'
+                || !ce || typeof ce !== 'object'
+                || typeof ce.contract !== 'string' || !ce.contract.trim()
+                || (ce.needs !== undefined && !Array.isArray(ce.needs))
+              if (bad) {
+                errors.push(`${id2}: expects_from.${prov} 条目形态非法（${typeof ce === 'string' ? `散文行「${ce.slice(0, 40)}」` : '缺 contract 键或 needs 非数组'}）——${_tpl}`)
+                break
+              }
+            }
+          }
+        }
       }
     }
   } catch {