sillyspec 3.31.0 → 3.32.0

package/src/sentinel-assertions.js

@@ -52,7 +52,12 @@ function listReviewEvidence(changeDir, opts) {
 }
 
 /**
- * 假勾选三态判定（L0 收口拒收支点，下批接线）。
+ * 假勾选三态判定（L0 收口拒收支点）。
+ *
+ * 证据判据统一（2026-10-07-thin-tasks-v3，镜像豁免退役）：tasks.md 是 agent 的工作分解
+ * 队列，每格勾选都是 agent 的完成主张——一律按 per-task 证据判（提交消息含完整 token
+ * task-NN（负向前瞻，task-01 不证 task-010）或对应 review.json 在场）。机器种子与
+ * agent 改写行同判，不再区分「镜像/覆写」。
  *
  * @param {object} args
  * @param {string|null} args.changeDir 变更目录（推导 specBase 定位 execute-runs；null/探测
@@ -63,7 +68,7 @@ function listReviewEvidence(changeDir, opts) {
  * @param {{listReviewsImpl?: Function}} [args.opts] 注入面（测试替身）
  * @returns {{status:'complete'|'fake'|'none', claimTotal:number, checked:number, missing:string[]}}
  *   none=无完成主张（判集空或未全勾）；complete=全勾且零 missing；fake=全勾且有零证据
- *   任务（missing 列其 id，收口侧拒收依据）。
+ *   任务（missing 列其 id，收口侧拒收依据）
  */
 export function detectFakeCheckCompletion({ changeDir, tasksMd, commits, opts = {} } = {}) {
   const entries = [];
@@ -73,14 +78,15 @@ export function detectFakeCheckCompletion({ changeDir, tasksMd, commits, opts =
   }
   const claimTotal = entries.length;
   const checked = entries.filter((e) => e.checked).length;
+  const messages = (Array.isArray(commits) ? commits : [])
+    .map((c) => (typeof c === 'string' ? c : String((c && (c.message ?? c.subject)) || '')));
   if (claimTotal === 0 || checked < claimTotal) {
     return { status: 'none', claimTotal, checked, missing: [] };
   }
-  const messages = (Array.isArray(commits) ? commits : [])
-    .map((c) => (typeof c === 'string' ? c : String((c && (c.message ?? c.subject)) || '')));
   const reviews = listReviewEvidence(changeDir, opts);
   const missing = entries
     .filter((e) => {
+      if (!e.checked) return false;
       const re = taskTokenRe(e.id);
       const byCommit = messages.some((msg) => re.test(msg));
       const byReview = reviews.some((p) => p.includes(`/tasks/${e.id}/`));
@@ -91,24 +97,69 @@ export function detectFakeCheckCompletion({ changeDir, tasksMd, commits, opts =
 }
 
 /**
- * 勾选节奏检测（2026-09-26-thin-check-cadence）：watcher 事件流里 task-done 单拍跳 ≥2 格 =
- * 一把全勾（未按工作单元逐个勾）——thin-agent-tasks 纪律的收口侧 advisory 判定面（warn 不
- * 阻断，接线在 flow done ledger 子步；节奏是习惯问题非造假主张，L0 硬门另有其人）。
- * 纯函数：事件清单→最大跳格记录；无多格跳返回 null。detail 与 watcher inferEvents 生成
- * 格式成对（`checked N→M`）；解析失配（格式漂移/坏行/非 task-done）按无证据静默——fail-open。
+ * 勾选节奏检测（2026-09-26-thin-check-cadence；2026-10-07-thin-tasks-v3 采样去重）：
+ * 事件流里 task-done 单拍跳 ≥2 格 = 一把全勾（未按工作单元逐个勾）。
+ * 事件两源同流：`task tick` 命令直写的精确事件（source:'task-tick'，一次一格）与 watcher
+ * 3s 轮询的采样事件（快速连续 tick 被合并成一跳）。判最大跳以 CLI 精确事件为权威：
+ *   ① 采样事件落点计数 M 与任一 CLI 事件落点相同 → 整跳被 CLI 精确序列覆盖，剔除；
+ *   ② 其余采样事件起点按「小于其落点的最大 CLI 落点」抬高（CLI 已勾到的格不重复计入跳幅）。
+ * 纯函数：事件清单→最大跳格记录；无多格跳返回 null。detail 与事件生成格式成对
+ * （`checked N→M`）；解析失配（格式漂移/坏行/非 task-done）按无证据静默——fail-open。
  */
 export function detectBatchCheckCadence(events) {
-  let worst = null;
+  const taskEvents = [];
   for (const e of events || []) {
-    if (!e || e.kind !== 'task-done') continue;
+    if (e && e.kind === 'task-done') taskEvents.push(e);
+  }
+  const parse = (e) => {
     const m = /^checked (\d+)→(\d+)$/.exec(String(e.detail || ''));
-    if (!m) continue;
-    const from = Number(m[1]);
-    const to = Number(m[2]);
-    if (to - from < 2) continue;
-    if (!worst || to - from > worst.to - worst.from) worst = { from, to, detail: e.detail, ts: e.ts };
+    return m ? { from: Number(m[1]), to: Number(m[2]) } : null;
+  };
+  const cliParsed = [];
+  for (const e of taskEvents) {
+    if (e.source !== 'task-tick') continue;
+    const r = parse(e);
+    if (r) cliParsed.push(r);
+  }
+  const cliTargets = new Set(cliParsed.map((r) => r.to));
+  const maxCliBelow = (to) => {
+    let best = 0;
+    for (const r of cliParsed) if (r.to < to && r.to > best) best = r.to;
+    return best;
+  };
+  let worst = null;
+  for (const e of taskEvents) {
+    const r = parse(e);
+    if (!r) continue;
+    const isCli = e.source === 'task-tick';
+    if (!isCli && cliTargets.has(r.to)) continue; // 采样合并跳被 CLI 精确序列覆盖
+    const from = isCli ? r.from : Math.max(r.from, maxCliBelow(r.to));
+    if (r.to - from < 2) continue;
+    if (!worst || r.to - from > worst.to - worst.from) worst = { from, to: r.to, detail: e.detail, ts: e.ts };
   }
   return worst;
 }
 
+/**
+ * 单拍勾选门决策（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
+ *   nonMirrorCount 保留为哨兵面未知信号（null → fail-open advisory）；镜像-only 语义已退役。
+ * @returns {{action:'silent'|'advisory'|'bypass'|'reject', reason:string}}
+ */
+export function resolveBatchTickAction({ batchTick, nonMirrorCount = null, allowBatchTick = false, autopilotTicked = 0 } = {}) {
+  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 (autopilotTicked >= batchTick.to - batchTick.from) return { action: 'advisory', reason: 'autopilot-ticked' };
+  return { action: 'reject', reason: 'agent-batch-tick' };
+}
+
 export default { detectFakeCheckCompletion, detectBatchCheckCadence };

package/src/stage-contract-engine.js

@@ -10,7 +10,7 @@
  *     (plan-postcheck 注入 LF-normalizing reader),引擎拿到什么判什么,不在引擎层二次引入差异。
  *   - regex 每次 new RegExp:manifest 存 {pattern, flags} 字符串,规避 lastIndex 状态坑
  *     (旧代码多处 /g 正则跨调用复用需手写 lastIndex=0,是潜在 bug)。
- *   - 内容规则(literal-any、literal-all、regex、contains-section、field-present、header-field、list-non-empty、
+ *   - 内容规则(literal-any、literal-all、literal-none、regex、contains-section、field-present、header-field、list-non-empty、
  *     min-lines/no-placeholder-line)在 target 文件不存在时自动 skip(不报错)——存在性由独立的
  *     file-exists 规则保证,避免"文件缺失"被内容规则重复报。
  *   - custom kind 引擎 skip(不计 errors/warnings),由调用方 validator 保留判定算法,
@@ -75,6 +75,9 @@ function dispatchPure(rule, entry) {
   switch (rule.kind) {
     case 'literal-any': return (rule.data.literals || []).some(s => scoped.includes(s))
     case 'literal-all': return (rule.data.literals || []).every(s => scoped.includes(s))
+    // literal-none(2026-09-29-brainstorm-closure-gates):「不得含字面量」判定——与 literal-any 互补,
+    // 服务 must-not-contain 契约(残留标记类:待确认/自审存疑等"在场即未闭合"语义)。
+    case 'literal-none': return !(rule.data.literals || []).some(s => scoped.includes(s))
     case 'regex': return new RegExp(rule.data.pattern, rule.data.flags || '').test(scoped)
     case 'contains-section': return hasAllSections(scoped, rule.data.sections || [])
     case 'no-placeholder-line': return hasNoPlaceholderLine(scoped, rule.data.patterns)

package/src/stage-contract-spec.js

@@ -25,11 +25,12 @@
  *               (小变更只产 design.md)。判定见 stage-contract-engine.js conditionHolds(fail-safe:ctx 字段缺失时 ne 成立)。
  *
  * 纯 kind(stage-contract-engine.dispatchPure 直接判定):
- *   file-exists / dir-exists / literal-any / literal-all / regex / contains-section /
+ *   file-exists / dir-exists / literal-any / literal-all / literal-none / regex / contains-section /
  *   no-placeholder-line / field-present / header-field / list-non-empty / min-lines / dir-non-empty
- *   —— 语义:若 target 文件不存在,内容类规则(literal-any、literal-all、regex、contains-section、…、list-non-empty、
- *   min-lines)自动 skip(不报错,存在性由独立的 file-exists 规则保证);file-exists/dir-exists
- *   则是"不存在即 fail"。
+ *   —— 语义:若 target 文件不存在,内容类规则(literal-any、literal-all、literal-none、regex、contains-section、…、
+ *   list-non-empty、min-lines)自动 skip(不报错,存在性由独立的 file-exists 规则保证);file-exists/dir-exists
+ *   则是"不存在即 fail"。literal-none 是「不得含字面量」判定(2026-09-29-brainstorm-closure-gates),
+ *   服务 must-not-contain 契约(残留标记类:在场即未闭合)。
  *
  * custom kind(引擎 skip,validator 保留判定算法,但 import 本 manifest 的 data + failMessage):
  *   见 CUSTOM_KINDS。这些是复杂条件校验(lifecycle 多层豁免 / 入口接线多步对账 / decisions 解析 /
@@ -44,6 +45,9 @@ const CUSTOM_KINDS = new Set([
   'entry-point-wiring',      // design.md 入口实例化 → task allowed_paths 覆盖对账(validatePlanOutputs)
   'id-traceability',         // FR/D 引用追踪(extractIds / warnMissingIds)
   'decision-blocker',        // decisions.md P0/P1 未决阻塞(parseDecisionRecords)
+  'decision-coverage',       // requirements.md 对 decisions.md 当前版本 D 的覆盖缺口点名(2026-09-29-brainstorm-closure-gates,validateBrainstormOutputs)
+  'doubt-closure',           // design.md「自审存疑：」应用形态标记行的闭合 token 判定(同上)
+  'risk-mitigation',         // design.md 风险登记表 R-xx 行应对策略列空/占位判定(同上)
   'cross-task-contract',     // task 卡片 provides/expects_from 对账(plan-postcheck)
   'design-file-coverage',    // design.md 文件清单 vs allowed_paths 覆盖(plan-postcheck)
   'task-id-continuity',      // task-NN id 连续性
@@ -151,6 +155,101 @@ const BRAINSTORM_RULES = [
     spec: 'tasks.md 至少有一个任务列表项(行首 `-` / `*` / `数字.`)',
     failMessage: 'tasks.md 没有任务列表项',
   },
+  // ── 闭环收口规则(2026-09-29-brainstorm-closure-gates)────────────────────────────
+  // 判据:开放可以,但每个开口必须能回答「谁、在哪个阶段、以什么证据关掉它」。六类无主开口全部
+  // 补机器收口,severity 全 warning 不阻断(存量零破坏——故障面/退役判据软警告棘轮先例,观测一个
+  // 周期误报率后再评估升 error)。纯 kind 走引擎,复杂判定 custom kind 留 validateBrainstormOutputs。
+  {
+    id: 'brainstorm.proposal.success-criteria',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'literal-any',
+    target: { root: 'change', path: 'proposal.md', scope: 'full' },
+    data: { literals: ['成功标准', 'Success Criteria', 'success criteria'] },
+    condition: { ctxField: 'scale', ne: 'small' },
+    spec: 'proposal.md 含「成功标准 / Success Criteria」章节(字面命中;问题→方案→成功标准主环最后一环——轻量道 flow start --input 对成功标准 0 条 exit 2,完整路径同理)',
+    failMessage: 'proposal.md 缺少「成功标准」章节(需字面命中其一:成功标准 / Success Criteria)——可验证的成功标准是收口验收面,轻量道同款要求',
+  },
+  {
+    id: 'brainstorm.design.no-placeholder',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'no-placeholder-line',
+    target: { root: 'change', path: 'design.md', scope: 'full' },
+    data: { patterns: ['待补充', 'TODO', 'TBD', '未分析', '根据项目情况', '根据实际情况', '按需填写', '待完善', '待设计', '待确认'] },
+    spec: 'design.md 无独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等——占位符在场=开口无人认领)',
+    failMessage: 'design.md 存在独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)——占位符须替换为真实内容或删除该行',
+  },
+  {
+    id: 'brainstorm.proposal.no-placeholder',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'no-placeholder-line',
+    target: { root: 'change', path: 'proposal.md', scope: 'full' },
+    data: { patterns: ['待补充', 'TODO', 'TBD', '未分析', '根据项目情况', '根据实际情况', '按需填写', '待完善', '待设计', '待确认'] },
+    condition: { ctxField: 'scale', ne: 'small' },
+    spec: 'proposal.md 无独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)',
+    failMessage: 'proposal.md 存在独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)——占位符须替换为真实内容或删除该行',
+  },
+  {
+    id: 'brainstorm.requirements.no-placeholder',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'no-placeholder-line',
+    target: { root: 'change', path: 'requirements.md', scope: 'full' },
+    data: { patterns: ['待补充', 'TODO', 'TBD', '未分析', '根据项目情况', '根据实际情况', '按需填写', '待完善', '待设计', '待确认'] },
+    condition: { ctxField: 'scale', ne: 'small' },
+    spec: 'requirements.md 无独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)',
+    failMessage: 'requirements.md 存在独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)——占位符须替换为真实内容或删除该行',
+  },
+  {
+    id: 'brainstorm.tasks.no-placeholder',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'no-placeholder-line',
+    target: { root: 'change', path: 'tasks.md', scope: 'full' },
+    data: { patterns: ['待补充', 'TODO', 'TBD', '未分析', '根据项目情况', '根据实际情况', '按需填写', '待完善', '待设计', '待确认'] },
+    condition: { ctxField: 'scale', ne: 'small' },
+    spec: 'tasks.md 无独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)',
+    failMessage: 'tasks.md 存在独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)——占位符须替换为真实内容或删除该行',
+  },
+  {
+    id: 'brainstorm.design.pending-confirm-residue',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'literal-none',
+    target: { root: 'change', path: 'design.md', scope: 'full' },
+    data: { literals: ['待确认'] },
+    spec: 'design.md 无「待确认」残留——design-init 决策追踪表预填的「待确认」须逐行补覆盖点后改「已覆盖」(确无决策记录时删除预填行或写「无决策记录」)',
+    failMessage: 'design.md 残留「待确认」——决策追踪表(design-init 预填)须逐行补覆盖点并把「待确认」改为「已覆盖」;确无决策记录时删除预填行或写「无决策记录」',
+  },
+  // decision-coverage(custom):requirements.md 必须引用 decisions.md 全部当前版本 D-xxx@vN
+  // (裸号词边界匹配,D-001 即算引用 D-001@v1,大小写不敏感——与 warnMissingIds 同语义)。
+  // 「剩余风险」行含裸号亦算归属(显式登记为剩余风险=开口有主)。算法留 validateBrainstormOutputs
+  // (复用 extractCurrentDecisionIds),匹配口径/failMessage 从本 manifest 同源。
+  {
+    id: 'brainstorm.requirements.decision-coverage',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'decision-coverage',
+    target: { root: 'change', path: 'requirements.md', scope: 'full' },
+    data: {},
+    spec: 'requirements.md 引用 decisions.md 的全部当前版本 D-xxx@vN(裸号 D-001 词边界匹配即算;未覆盖的在「决策覆盖矩阵」补行,或显式标注为剩余风险——被覆盖或显式登记为剩余风险都算归属,不出现才算开口)',
+    failMessage: 'requirements.md 未引用 decisions.md 中的 ${id} — 在「决策覆盖矩阵」补覆盖行,或在剩余风险中显式标注该决策未覆盖(每个 D 须有归属:被覆盖或显式登记为剩余风险)',
+  },
+  // doubt-closure(custom):「自审存疑：」应用形态标记行须含闭合 token。查带冒号的应用形态而非
+  // 裸词——design-init 自审 checklist 模板行含裸词,裸词判定必常驻误报。算法留 validator。
+  {
+    id: 'brainstorm.design.doubt-closure',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'doubt-closure',
+    target: { root: 'change', path: 'design.md', scope: 'full' },
+    data: {
+      markerPattern: { pattern: '自审存疑\\s*[:：]', flags: '' },
+      closureTokens: ['D-\\d+', 'R-\\d+', '已解决', '已闭合', '已确认', '不适用'],
+    },
+    spec: 'design.md 的「自审存疑：」标记行须含闭合 token(D-xxx/R-xx/已解决/已闭合/已确认)——已解决的改写为结论并引用 D/R,未解决的转 decisions.md D-xxx 或风险登记 R-xx;存疑标记不得原样带进 plan',
+    failMessage: 'design.md 存在未闭合的自审存疑:「${line}」——已解决的改写为结论并引用 D-xxx/R-xx,未解决的转 decisions.md 决策或风险登记 R-xx 后去标记;开放须有归属,存疑标记不得带进 plan',
+  },
+  // risk-mitigation(custom):风险登记表 R-xx 行应对策略列(行末单元格)非空且非占位。design-init
+  // 骨架预填「（待填应对策略）」——骨架行命中即提醒填语义;显式「接受」是合法闭合(接受=归属明确)。
+  {
+    id: 'brainstorm.design.risk-mitigation',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'risk-mitigation',
+    target: { root: 'change', path: 'design.md', scope: 'full' },
+    data: {
+      rowPattern: { pattern: '^\\|\\s*(R-\\d+)', flags: '' },
+      placeholderCell: '待填|待补充|待定|TODO|TBD|仅占位|^\\s*[-—–]?\\s*$',
+      acceptToken: '接受',
+    },
+    spec: 'design.md 风险登记表每行 R-xx 的应对策略列(行末单元格)非空且非占位词(待填/待补充/待定/TODO/TBD)——每条风险须有应对;确实接受的风险显式写「接受：<理由>」(接受也是闭合),不得留空/占位',
+    failMessage: 'design.md 风险登记 ${id} 的应对策略列为空/占位——每条风险须有应对策略;确实接受的风险显式写「接受：<理由>」,不得留空或占位(风险无应对=开口无归属)',
+  },
   // lifecycle(custom kind):design.md 命中生命周期关键词时必须含契约表或紧邻豁免。判定算法留 validator
   // (trigger/exemption/table 三段短路),data + failMessage/exemptionPassedMessage 从本 manifest 同源。
   {

package/src/stage-contract.js

@@ -350,7 +350,9 @@ function validateBrainstormOutputs(cwd, changeName, context = {}) {
     const frKnowledgeRoot = specRoot ? join(specRoot, 'knowledge') : join(cwd, '.sillyspec', 'knowledge')
     const req = parseChangeRequirements(changeDir)
     if (!req.missing && req.frs.length > 0) {
-      const domains = resolveTouchedDomains(changeDir, discoverModuleIndex(frKnowledgeRoot))
+      // unmapped 过滤对齐 frDupGateFlow（2026-09-29-rot-retire-inject-cap）：停车场池不进
+      // 跨域标题比对——原全量载入 723 条做 CPU 税且产出跨域误指认
+      const domains = resolveTouchedDomains(changeDir, discoverModuleIndex(frKnowledgeRoot)).filter((d) => d !== 'unmapped')
       const active = readActiveFrDigest(frKnowledgeRoot, domains)
       if (active.length > 0) {
         for (const fr of req.frs) {
@@ -411,6 +413,37 @@ function validateBrainstormOutputs(cwd, changeName, context = {}) {
         )
       }
     }
+
+    // ── 闭环收口 custom 判定（2026-09-29-brainstorm-closure-gates）──
+    // doubt-closure：「自审存疑：」应用形态行须含闭合 token——只查带冒号的应用形态，裸词
+    // 判定会撞 design-init 自审 checklist 模板行（含裸词）常驻误报。
+    {
+      const doubtRule = getRule('brainstorm.design.doubt-closure')
+      const markerRe = new RegExp(doubtRule.data.markerPattern.pattern, doubtRule.data.markerPattern.flags)
+      const closureRe = new RegExp(doubtRule.data.closureTokens.join('|'), 'i')
+      for (const line of content.split(/\r?\n/)) {
+        if (!markerRe.test(line) || closureRe.test(line)) continue
+        warnings.push(doubtRule.failMessage.replaceAll('${line}', line.trim().slice(0, 60)))
+      }
+    }
+    // risk-mitigation：风险登记表 R-xx 行的应对策略列（行末单元格）非空且非占位——design-init
+    // 骨架预填「（待填应对策略）」命中即提醒填语义；「接受」显式接受是合法闭合（归属明确）。
+    {
+      const riskRule = getRule('brainstorm.design.risk-mitigation')
+      const rowRe = new RegExp(riskRule.data.rowPattern.pattern, riskRule.data.rowPattern.flags)
+      const cellPlaceholderRe = new RegExp(riskRule.data.placeholderCell, 'i')
+      for (const line of content.split(/\r?\n/)) {
+        const rowMatch = line.match(rowRe)
+        if (!rowMatch) continue
+        let cells = line.split('|').slice(1).map(c => c.trim())
+        if (cells.length > 0 && cells[cells.length - 1] === '' && line.trimEnd().endsWith('|')) cells.pop()
+        if (cells.length < 2) continue // 行形态不完整（仅编号列）——表结构问题交 Grill 审查，不在此硬判
+        const lastCell = cells[cells.length - 1].replace(/^[（(]/, '').replace(/[）)]$/, '').trim()
+        if (cellPlaceholderRe.test(lastCell)) {
+          warnings.push(riskRule.failMessage.replaceAll('${id}', rowMatch[1]))
+        }
+      }
+    }
   }
 
   const decisionsFile = join(changeDir, 'decisions.md')
@@ -425,10 +458,22 @@ function validateBrainstormOutputs(cwd, changeName, context = {}) {
       warnings.push('decisions.md 存在但没有当前版本 D-xxx@vN 决策 ID')
     } else {
       const design = readIfExists(join(changeDir, 'design.md'))
-      const requirements = readIfExists(join(changeDir, 'requirements.md'))
-      const tasks = readIfExists(join(changeDir, 'tasks.md'))
-      // decision 的天然引用落点是 design.md；requirements（需求按 FR 组织）与
-      // tasks（骨架，待 plan 展开）不强求逐条引用每个架构决策，否则批量误报。
+      // requirements 的 D 覆盖点名（2026-09-29-brainstorm-closure-gates）：prompt 一直要求
+      // 「requirements.md 必须引用全部当前版本 D-xxx@vN，未覆盖的标注为剩余风险」，机器面原只盯
+      // design.md——闭环收口补齐：裸号词边界匹配（同 warnMissingIds 语义），裸号出现在决策覆盖
+      // 矩阵或「剩余风险」行都算归属（覆盖或显式登记=开口有主），不出现才点名。tasks 仍不强求
+      // （骨架，plan 阶段展开——plan --done 的 id-traceability 已覆盖 plan.md 侧）。
+      const requirementsForCoverage = readIfExists(join(changeDir, 'requirements.md'))
+      if (requirementsForCoverage) {
+        const reqUpper = requirementsForCoverage.toUpperCase()
+        const coverageFail = getRule('brainstorm.requirements.decision-coverage').failMessage
+        for (const id of decisionIds) {
+          const base = id.replace(/@V\d+$/, '')
+          if (!new RegExp(`\\b${base}\\b`).test(reqUpper)) {
+            warnings.push(coverageFail.replaceAll('${id}', id))
+          }
+        }
+      }
       warnMissingIds(warnings, decisionIds, design, 'design.md', 'decisions.md')
     }
     // 故障面/退役判据软警告（FR-01，2026-09-15-tax-governance）：architecture+accepted 缺字段
@@ -1204,12 +1249,15 @@ export function judgeApiCoverageMatrix(args) {
     if (!apiEvidenceHasAnchorForm(e)) {
       // 分诊（2026-09-23 执行会话实证：design接口表# 字样在场但 # 后非 METHOD /path 形态时，
       // 泛化「缺五形态之一」让人无法区分「形态没写对」与「写了没算数」——三轮试错后 agent 被逼
-      // 换更弱的 DDL@ 形态过门，fail-closed 反而促成了更泛的锚点。定向报出该形态的命中条件。）
+      // 换更弱的 DDL@ 形态过门，fail-closed 反而促成了更泛的锚点。定向报出该形态的命中条件。
+      // 2026-09-30 二次实证（multi-agent-platform tool-report-activation 会话）：泛化分支文案
+      // 「用例依据锚点」里的「用例依据」是第 3 列列名（caseId），而校验只查第 5 列证据列——
+      // 文案把 agent 引向错误的列，再坑三轮。锚点文案一律点名「证据列」，禁用列名歧义词。）
       API_ANCHOR_DESIGN_API_RE.lastIndex = 0
       const bareDesignAnchor = /design接口表#/.test(e) && !API_ANCHOR_DESIGN_API_RE.test(e)
       anchorViolations.push(bareDesignAnchor
         ? `${rowLabel(r)}：证据含 design接口表# 但 # 后未提取到 METHOD /path——该形态仅 \`design接口表#POST /api/xx\` 形态计命中（仅写表名/行号/散文描述不计）`
-        : `${rowLabel(r)}：证据缺用例依据锚点（五形态之一）`)
+        : `${rowLabel(r)}：证据列（矩阵第 5 列）缺锚点（五形态之一）——锚点只认证据列，写在第 3 列「用例依据」不计`)
     }
   }
   if (anchorViolations.length > 0) {

package/src/stages/brainstorm.js

@@ -54,10 +54,20 @@ export const definition = {
 - 多项目且用户未指定：列出项目列表，需要用户确认本次需求属于哪个子项目
 
 ### 早期规模筛查（判断是否该走轻量变更）
-加载上下文后，用需求描述 + 模块上下文**粗判**本次变更规模：
-- **明显 small**（满足：预计改动 ≤ 2 个文件、单模块、无 schema/API/状态机/权限变更；或属于改文案/修 bug/样式调整/配置微调等纯执行类）→ 输出：「此变更规模较小，建议直接走轻量变更」+ 一句依据，给出建议命令 \`sillyspec flow start --change <名> --input "<需求>"\`（2 调用协议收口）。用户同意则本阶段可在此收尾（\`--done\` 并提示转轻量变更），不必继续走完整设计流程。
-- **拿不准或明显 large**（涉及多模块、schema、状态流转、新架构等）→ 不要提示轻量变更，继续进入下一步「对话式探索与需求澄清」。
-- 这是**粗判**，只为让明显的小变更免走完整设计流程；不确定就继续，后续「生成规范文件」步骤会基于 design.md 文件清单做精判兜底。
+加载上下文后，用需求描述 + 模块上下文**粗判**本次变更规模（判据同 Step 8 复杂度/上下文轴——2026-09-29-brainstorm-exit-thin-default）：
+- **明显 small**（满足：单上下文可吞吐的纯执行类——改文案/修 bug/样式调整/配置微调，预计无 Wave 编排/上下文分片需求）→ 输出：「此变更规模较小，建议直接走轻量变更」+ 一句依据，给出可照抄建议命令（--input 引号内换行合法）：
+
+\`\`\`
+sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>
+
+成功标准：
+- <可验证标准>"
+\`\`\`
+
+（2 调用协议收口）。用户同意则本阶段可在此收尾（\`--done\` 并提示转轻量变更），不必继续走完整设计流程。
+- **明显 large**（需要 Wave 并行编排/上下文分片/多阶段治理，或用户显式要求完整流程）→ 不要提示轻量变更，继续进入下一步「对话式探索与需求澄清」。
+- **拿不准 → 继续探索**（这正是头脑风暴的职责；澄清完成后 Step 8 按同轴精判——注意：经过头脑风暴澄清的需求通常已可单上下文吞吐，出口默认收编轻量道）。
+- 这是**粗判**，只为让明显的纯执行小变更免走设计流程；后续「生成规范文件」步骤做精判兜底。
 
 ### 输出
 项目现状理解摘要（3-5 句话，关键约定和架构决策）+ 可能涉及的模块列表 + 本次需求所属子项目 + （如命中）quick 建议
@@ -203,12 +213,13 @@ export const definition = {
       waitReason: '等待用户选择方案',
       waitOptions: ['方案A', '方案B', '方案C'],
       prompt: `基于需求理解和澄清结果，提出 2-3 种实现方案。
-
+{UI_VISUAL_GUIDANCE}
 ### 操作
 1. 每种方案列出：核心思路、优势、劣势
 2. 如果上一步产生了 D-xxx@vN 决策记录，方案必须说明覆盖/违反哪些当前版本决策
-3. 给出推荐方案和理由
-4. 用户选定方案后，把选择结果**当场追加**到 \`{SPEC_ROOT}/changes/<change-name>/decisions.md\`（增量落盘规则同「对话式探索」步：目录/文件缺失先创建、按 D-xxx@vN 判重）：type 用 architecture、source 用 user、question 记方案取舍问题、answer 记用户所选方案与理由要点、evidence 记方案选择轮次——方案选择是本变更最关键的用户决策，必须随答随落盘，不能只留在对话里
+3. 定稿前机制词检索（固定动作）：方案引入新机制词（如 分类/词表/枚举/门/协议/状态机——例词为举例非机制，不构成封闭清单）时，先跑 \`sillyspec knowledge search --query "<机制词>"\`，命中条目必读（尤其 status=rejected 的防复潮条目）再定稿方案
+4. 给出推荐方案和理由
+5. 用户选定方案后，把选择结果**当场追加**到 \`{SPEC_ROOT}/changes/<change-name>/decisions.md\`（增量落盘规则同「对话式探索」步：目录/文件缺失先创建、按 D-xxx@vN 判重）：type 用 architecture、source 用 user、question 记方案取舍问题、answer 记用户所选方案与理由要点、evidence 记方案选择轮次——方案选择是本变更最关键的用户决策，必须随答随落盘，不能只留在对话里
 
 ### 铁律 — 必须等待用户选择方案
 - 列出方案对比表和推荐后必须暂停等用户选择，**不要自己说"推荐方案 A"然后当用户选了**（命令由 CLI 在下方注入）
@@ -234,9 +245,10 @@ export const definition = {
 1. 简单项目：几句话整体描述
 2. 复杂项目：按模块/Phase 分段展示，每段 200-300 字
 3. 展示完整设计方案（不要逐段停顿，一次性展示）
-4. 确认变更名（格式：\`YYYY-MM-DD-<简短描述>\`，例如 \`2026-05-13-user-auth\`——CLI 已强制：新建/改名不带日期前缀直接 exit 2）
-5. 按「HTML 原型分级」生成原型或写出跳过原因（二选一必填，见下）
-6. 暂停等待用户确认或修改意见
+4. 分段设计含新机制时同上检索（固定动作）：设计的分段内容引入新机制词（例词为举例非机制，不构成封闭清单）时，先跑 \`sillyspec knowledge search --query "<机制词>"\`，命中条目必读（尤其 status=rejected 的防复潮条目）再定稿设计
+5. 确认变更名（格式：\`YYYY-MM-DD-<简短描述>\`，例如 \`2026-05-13-user-auth\`——CLI 已强制：新建/改名不带日期前缀直接 exit 2）
+6. 按「HTML 原型分级」生成原型或写出跳过原因（二选一必填，见下）
+7. 暂停等待用户确认或修改意见
 
 ### HTML 原型分级（按改动程度，不是"是否碰前端文件"）
 判定对象是**改造后的界面相对现状的变化程度**：
@@ -515,11 +527,12 @@ status: passed | needs-user-input | blocked | skipped
       prompt: `按变更规模生成规范文件并给出实现路径建议（设计已在前置步骤确认过，本步不再暂停等确认，生成后展示摘要即可）。
 
 ### 规模评估（展示前先做）
-读取 design.md 的「文件变更清单」，判断本次变更规模：
-- **small（小变更）**：改动 ≤ 2 个文件、单模块、无跨模块依赖、无状态机/schema/API 变更
-- **large（大变更）**：不满足上述任意一条
+按**复杂度/上下文轴**判断本次变更规模（2026-09-29-brainstorm-exit-thin-default：此前文件数轴「≤2 文件才 small」与选道表第 3 行的复杂度措辞不一致，且模糊需求探索完很少只碰 2 文件——出口几乎必然五阶段，实测坐实）：
+- **small（收编轻量道）**：单上下文可吞吐——预计无需 Wave 并行编排、无需上下文分片（单会话吃得下全部任务）、无多阶段治理/设计期人机对抗需求
+- **large（完整五阶段）**：需要 Wave 并行编排、或单任务规模大需上下文分片、或多阶段治理、或用户显式要求完整流程
+- **拿不准 → small**（与 thin-default-flip 同哲学：预判反诱发误升厚——R16 实证；升厚留运行时证据：实测失败自动升厚＋--upgrade-thick 用户决策）
 在 design.md frontmatter 写入 \`scale: small\` 或 \`scale: large\`（frontmatter 不存在则补 \`author\`/\`created_at\`/\`scale\`）。规模决定下面的产物范围和实现路径。
-（注：早期「加载项目上下文」步骤已做过一次粗判并可能建议过走 quick；此处基于 design.md 文件清单做精判兜底。）
+（注：早期「加载项目上下文」步骤已做过一次粗判并可能建议过走 quick；此处基于 design 方案实质做精判兜底——判据同轴。）
 
 ### 操作
 1. **按规模生成规范文件**：

package/src/stages/knowledge.js

@@ -19,7 +19,8 @@
 import { existsSync, readFileSync, readdirSync, mkdirSync, statSync } from 'fs'
 import { join, basename } from 'path'
 import { writeAtomicSync } from '../fs-atomic.js'
-import { parseKnowledgeIndex, matchKnowledge } from '../knowledge-match.js'
+import { parseKnowledgeIndex } from '../knowledge-match.js'
+import { matchKnowledgeHybrid } from '../knowledge-vector.js'
 
 // ── 工具函数 ──
 
@@ -106,8 +107,8 @@ export async function cmdSearch(dir, args, opts = {}) {
     return
   }
 
-  // 复用 knowledge-match 引擎
-  const result = matchKnowledge(knowledgeDir, query)
+  // 复用 knowledge-match 引擎（三层 hybrid：路由→平台向量→本地词片，2026-09-29-knowledge-vector-recall）
+  const result = await matchKnowledgeHybrid(knowledgeDir, query, { cwd: dir })
 
   if (!result.matched) {
     output(true, { query, matches: [] })

package/src/stages/plan-postcheck.js

@@ -21,7 +21,7 @@ import { parseFileChangeList, pathMatches } from '../change-list.js'
 import { getRule } from '../stage-contract-spec.js'
 import { TASKCARD_PLACEHOLDERS } from '../taskcard-placeholders.js'
 import { validateScriptCommands } from './cmd-existence.js'
-import { parseTaskFrontmatter } from '../taskcard-frontmatter.js'
+import { parseTaskFrontmatter, diagnoseTaskYamlError } from '../taskcard-frontmatter.js'
 
 // ═══════════════════════════════════════════════════════════════
 // 解析工具（从 plan.js 迁移）
@@ -614,7 +614,8 @@ export function validateBlueprintConsistency(changeDir, opts = {}) {
       if (ts.length > 1) {
         errors.push(
           `路径 ${p} 被 Wave ${w} 内 ${ts.length} 个 task 修改: ${ts.join(', ')} — 同 Wave 任务 execute 强制并行（execute.js:603），` +
-          `子代理会互相覆盖该文件。解法：把它们拆到不同 Wave（串行）。` +
+          `子代理会互相覆盖该文件。解法：把它们拆到不同 Wave（串行）——手工拆易踩编号/依赖坑（非合法 Wave 号→伪并行串行链），` +
+          `推荐 sillyspec plan-adopt-waves --change <变更名> 按 depends_on 拓扑一键重排（重排后同波文件面有交集会被拒绝，再手工拆分那一个）。` +
           `（注：quick 阶段对同文件并发只提示不阻断——那是轻量流程无并行子代理、最坏后果 git 可分离；` +
           `此处硬拦是因并行覆盖不可自动恢复，两阶段宽严不同是设计使然）`
         )
@@ -1309,8 +1310,12 @@ export function validatePlanFeasibility(changeDir, projectRoot = null) {
     if (!fmParse.ok) {
       const isDupReported = dupKeys.length > 0 && /duplicated mapping key/i.test(fmParse.error.message)
       if (!isDupReported) {
+        // 分诊（2026-10-06-verify-friction-fix task-03）：js-yaml 消息 + 出错行双信号给中文修复
+        // 动作——知识源是 taskcard-rules.md，此前只透传英文原文，厚流程实证连撞 6 轮门禁
+        const errLineText = (content.split('\n')[fmParse.error.line - 1] || '').replace(/\r$/, '')
+        const fmDiag = diagnoseTaskYamlError(fmParse.error.message, errLineText)
         errors.push(
-          `${dupTaskId || file}: frontmatter 非法 YAML（${file}:${fmParse.error.line}:${fmParse.error.column} ${fmParse.error.message}）——契约/验收/标量字段全链路不可读，plan 门禁拒绝放行；修复卡片 frontmatter（值含方括号/全角括号时加引号或改块式列表）`
+          `${dupTaskId || file}: frontmatter 非法 YAML（${file}:${fmParse.error.line}:${fmParse.error.column} ${fmParse.error.message}）——契约/验收/标量字段全链路不可读，plan 门禁拒绝放行；分诊：${fmDiag}`
         )
       }
     }
@@ -1472,6 +1477,45 @@ export function validatePlanFeasibility(changeDir, projectRoot = null) {
   return { ok: errors.length === 0, errors, warnings }
 }
 
+/**
+ * taskcard --validate 的 CLI 入口（2026-10-06-verify-friction-fix task-03）：plan 门禁同源规则
+ * 的零成本自检面——填卡后、--done 门禁前先跑，把「门禁时一次撞一批」前移成「提交前自检」。
+ * 在 validatePlanFeasibility 之上补 target_files 严格形态检查（对账门规则，plan feasibility 不含）。
+ * 注意防环：本函数留在 plan-postcheck（其依赖链已有 taskcard-frontmatter/placeholders），
+ * taskcard.js 不得反向 import 本模块（taskcard-placeholders.js jsdoc 的 ESM 循环告诫同源）。
+ * @param {{ changeDir: string, projectRoot?: string|null }} opts
+ * @returns {{ ok: boolean, errors: string[], warnings: string[], files: number }}
+ */
+export function validateTaskcardsCli({ changeDir, projectRoot = null }) {
+  const res = validatePlanFeasibility(changeDir, projectRoot)
+  const errors = [...res.errors]
+  const warnings = [...res.warnings]
+  let files = 0
+  try {
+    const tasksDir = pJoin(changeDir, 'tasks')
+    if (existsSync(tasksDir)) {
+      const list = readdirSync(tasksDir).filter(f => /^task-\d+\.md$/.test(f)).sort()
+      files = list.length
+      for (const f of list) {
+        const content = _readFileSync(pJoin(tasksDir, f), 'utf8')
+        const fmParse = parseTaskFrontmatter(content)
+        if (!fmParse.ok) continue // 0b 已报，不双报
+        const tf = parseTargetFiles(content)
+        if (!tf.missing) {
+          const bad = tf.entries.filter(e => e.invalid)
+          if (bad.length > 0) {
+            const id = (content.match(/^id:\s*(.+)/m)?.[1] || '').trim() || f
+            errors.push(`${id}: target_files 形态非法——${bad.map(b => `${b.raw}（${b.invalid}）`).join('；')}`)
+          }
+        }
+      }
+    }
+  } catch {
+    // 目录不可读 → 可行性结果原样返回（其 errors/warnings 已如实反映）
+  }
+  return { ok: errors.length === 0, errors, warnings, files }
+}
+
 /**
  * Plan 产物校验：检查 plan.md 和 tasks/ 是否齐全
  * @param {string} changeDir - 变更目录
@@ -2010,7 +2054,46 @@ function deriveModuleIdFor(filePath, mapYaml) {
  * @param {{ cwd: string, specRoot?: string, resolveChangeDir: Function, progress?: object }} context
  * @throws {Error} 校验失败时抛出
  */
+/**
+ * Wave 形态错误自动重排判定（2026-10-07-wave-auto-adopt-review-dedup task-01）：postmortem
+ * （provider-model-list）实测 Wave 返工链三轮——同 Wave 冲突/伪并行串行链都是 adopt-waves
+ * 机械可解的形态，却要 agent 撞 postcheck 后按文案找命令。此处错误全为 Wave 形态类时自动
+ * 跑 plan-adopt-waves 重排并整体复跑 postcheck（预算 1 次，防环）；逃生键 local.yaml
+ * plan.auto_adopt_waves: false（缺省 true）。混有非 Wave 类错误不自动重排（行为=现状）——
+ * 重排会掩盖真实问题的上下文。
+ */
+const WAVE_SHAPE_ERROR_RE = /被 Wave \d+ 内 \d+ 个 task 修改|伪并行串行链|Wave 依赖方向违规/
+function allWaveShapeErrors(errors) {
+  const list = Array.isArray(errors) ? errors : []
+  return list.length > 0 && list.every(e => WAVE_SHAPE_ERROR_RE.test(String(e)))
+}
+function autoAdoptWavesEnabled(specDir) {
+  try {
+    const p = pJoin(specDir, 'local.yaml')
+    if (!existsSync(p)) return true
+    const doc = jsYaml.load(_readFileSync(p, 'utf8'))
+    return !(doc && doc.plan && doc.plan.auto_adopt_waves === false)
+  } catch { return true }
+}
+async function tryAutoAdoptWaves(errors, changeDir, specDir, budget) {
+  if (budget <= 0) return false
+  if (!allWaveShapeErrors(errors)) return false
+  if (!autoAdoptWavesEnabled(specDir)) return false
+  const { adoptPlanWaves } = await import('../plan-adopt-waves.js')
+  const res = adoptPlanWaves({ changeDir })
+  if (!res || !res.ok) {
+    console.warn(`  ⚠️ Wave 自动拓扑重排未成（${res && res.error ? res.error : '未知原因'}）——按原报错处理（手工出口：sillyspec plan-adopt-waves --change <变更名>）`)
+    return false
+  }
+  console.log(`\n🔀 检测到 Wave 形态问题——已自动按 depends_on 拓扑重排 plan.md（plan-adopt-waves，任务总表 W 列同步）并整体复跑校验：`)
+  return true
+}
+
 export async function executePlanPostcheck(context) {
+  return executePlanPostcheckRun(context, { autoAdoptBudget: 1 })
+}
+
+async function executePlanPostcheckRun(context, { autoAdoptBudget = 0 } = {}) {
   const { cwd, specRoot, resolveChangeDir, progress } = context
 
   const specDir = specRoot || pJoin(cwd, '.sillyspec')
@@ -2207,6 +2290,14 @@ export async function executePlanPostcheck(context) {
 
   // ── 聚合输出：一轮 --done 暴露全部失败项（坑6③）──
   if (failures.length > 0) {
+    // Wave 形态自动重排判定（task-01）：唯一失败组是蓝图一致性且错误全为 Wave 形态 → 自动
+    // adopt-waves 重排并整体复跑一次（预算 1）。挂统一收口点而非 consistency 单点：混有
+    // feasibility/coverage 等其他类错误时不重排（重排会掩盖真实问题上下文，实测 WA4 形态）。
+    if (failures.length === 1 && failures[0].name === '蓝图一致性校验') {
+      if (await tryAutoAdoptWaves(failures[0].errors, changeDir, specDir, autoAdoptBudget)) {
+        return executePlanPostcheckRun(context, { autoAdoptBudget: 0 })
+      }
+    }
     console.error(`\n❌ plan postcheck 失败（${failures.length} 类问题，已全部列出——一次修复后重跑，无需逐个迭代）：`)
     for (const f of failures) {
       console.error(`\n   【${f.name}】`)
@@ -2347,6 +2438,10 @@ export async function executePlanPostcheck(context) {
           const structure = assessWaveStructure({ existingWaves, topoWaves: waves, depMap, wavePathSets })
           if (structure.advisory) console.warn(`  ⚠️ ${structure.advisory}`)
           if (structure.error) {
+            // 伪并行碎片自动重排（task-01）：mergeable 对 ≥2 是 adopt-waves 的标准解
+            if (await tryAutoAdoptWaves([structure.error], changeDir, specDir, autoAdoptBudget)) {
+              return executePlanPostcheckRun(context, { autoAdoptBudget: 0 })
+            }
             console.error(`\n❌ ${structure.error}`)
             throw new Error(structure.error)
           }