sillyspec 3.27.2 → 3.27.5

package/eval/tasks/001-slugify/task.json

@@ -0,0 +1,6 @@
+{
+  "id": "001-slugify",
+  "title": "实现 slugify 工具函数",
+  "tags": ["greenfield", "utility", "edge-case"],
+  "instruction": "在当前目录新建 src/slugify.mjs（package.json 已存在且 type=module，禁止安装任何第三方依赖），实现并导出具名函数 slugify（同时提供指向同一函数的 default 导出）。\n\n函数签名：slugify(value, options = {})，返回字符串。\n\n转换规则（按顺序执行，分隔符记为 sep，默认 '-'）：\n1. value 为 null 或 undefined 时返回空字符串；其余值先 String() 转字符串。\n2. 整体 toLowerCase() 小写化。\n3. 连续空白字符（\\s+）替换为单个 sep。\n4. 删除所有不属于 [a-z0-9] 且不等于 sep 的字符。\n5. 连续多个 sep 合并为一个，并去掉首尾的 sep。\n\noptions 支持：\n- options.hyphen：分隔符 sep，默认 '-'。必须是长度为 1 的字符串，否则抛出 TypeError('hyphen must be a single character')。\n\n示例：\nslugify('  Hello   World!  ') === 'hello-world'\nslugify('a--b') === 'a-b'\nslugify('Ünïcode Test') === 'ncode-test'\nslugify(null) === ''\nslugify(42) === '42'\nslugify('Hello World', { hyphen: '_' }) === 'hello_world'"
+}

package/eval/tasks/001-slugify/verify.mjs

@@ -0,0 +1,28 @@
+// 判分脚本：以「被测工作目录」为 cwd 运行（node <本文件>，cwd=workdir）。退出码 0 = 通过。
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+import { pathToFileURL } from 'node:url';
+
+const mod = await import(pathToFileURL(join(cwd(), 'src', 'slugify.mjs')).href);
+const slugify = mod.slugify ?? mod.default?.slugify;
+assert.equal(typeof slugify, 'function', '应导出具名函数 slugify');
+assert.equal(typeof mod.default, 'function', '应提供 default 导出');
+
+assert.equal(slugify(null), '');
+assert.equal(slugify(undefined), '');
+assert.equal(slugify(''), '');
+assert.equal(slugify(42), '42');
+assert.equal(slugify('  Hello   World!  '), 'hello-world');
+assert.equal(slugify('Foo Bar BAZ'), 'foo-bar-baz');
+assert.equal(slugify('a--b'), 'a-b');
+assert.equal(slugify('!!!'), '');
+assert.equal(slugify('Ünïcode Test'), 'ncode-test');
+assert.equal(slugify('tab\tand\nnewline'), 'tab-and-newline');
+assert.equal(slugify('-leading and trailing-'), 'leading-and-trailing');
+assert.equal(slugify('Hello World', { hyphen: '_' }), 'hello_world');
+assert.equal(slugify('a b', { hyphen: '+' }), 'a+b');
+assert.throws(() => slugify('a b', { hyphen: '--' }), TypeError);
+assert.throws(() => slugify('a b', { hyphen: '' }), TypeError);
+
+console.log('001-slugify verify OK');

package/eval/tasks/002-each-day/files/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "task-each-day",
+  "version": "1.0.0",
+  "type": "module",
+  "private": true
+}

package/eval/tasks/002-each-day/files/src/dates.mjs

@@ -0,0 +1,4 @@
+// 待实现：eachDay(start, end) —— 契约见任务说明
+export function eachDay(start, end) {
+  throw new Error('not implemented');
+}

package/eval/tasks/002-each-day/solution/src/dates.mjs

@@ -0,0 +1,30 @@
+// 参考解（dry-run 假 agent 使用，也供人工对照）。
+const DATE_PREFIX = /^(\d{4})-(\d{2})-(\d{2})(?:[T ].*)?$/;
+const DAY_MS = 86_400_000;
+
+function parseUtc(value) {
+  if (typeof value !== 'string') throw new TypeError('invalid date');
+  const m = DATE_PREFIX.exec(value.trim());
+  if (!m) throw new TypeError('invalid date');
+  const y = Number(m[1]);
+  const mo = Number(m[2]);
+  const d = Number(m[3]);
+  const ts = Date.UTC(y, mo - 1, d);
+  const dt = new Date(ts);
+  // 往返校验拦住 '2024-02-30' 这类被 Date 自动进位的假日期
+  if (dt.getUTCFullYear() !== y || dt.getUTCMonth() !== mo - 1 || dt.getUTCDate() !== d) {
+    throw new TypeError('invalid date');
+  }
+  return ts;
+}
+
+export function eachDay(start, end) {
+  const s = parseUtc(start);
+  const e = parseUtc(end);
+  if (e < s) throw new RangeError('end must not be before start');
+  const days = [];
+  for (let t = s; t <= e; t += DAY_MS) {
+    days.push(new Date(t).toISOString().slice(0, 10));
+  }
+  return days;
+}

package/eval/tasks/002-each-day/task.json

@@ -0,0 +1,6 @@
+{
+  "id": "002-each-day",
+  "title": "实现 eachDay 日期区间函数（棕地补全）",
+  "tags": ["brownfield", "date", "validation"],
+  "instruction": "src/dates.mjs 已有函数骨架 eachDay(start, end)（当前直接 throw），在原文件完成实现，保持具名导出 eachDay 不变，禁止引入第三方依赖。\n\n契约：\n- 入参为字符串，接受 'YYYY-MM-DD'，或以它开头的时间形式（如 '2024-01-01T10:00:00Z'、'2024-01-01 08:00'）；只取日期部分参与运算。\n- 返回闭区间 [start, end] 内每一天的 'YYYY-MM-DD' 字符串数组（含两端；起止同天返回单元素数组）。\n- 日期运算一律用 UTC（避免时区/DST 干扰）。\n- end 的日期小于 start 时抛 RangeError。\n- 格式非法（不匹配 'YYYY-MM-DD' 前缀、日期不存在如 '2024-02-30'、或非字符串）抛 TypeError('invalid date')。\n\n示例：\neachDay('2024-02-27', '2024-03-02') → ['2024-02-27','2024-02-28','2024-02-29','2024-03-01','2024-03-02']\neachDay('2024-01-15', '2024-01-15') → ['2024-01-15']"
+}

package/eval/tasks/002-each-day/verify.mjs

@@ -0,0 +1,31 @@
+// 判分脚本：cwd=被测工作目录，退出码 0 = 通过。
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+import { pathToFileURL } from 'node:url';
+
+const mod = await import(pathToFileURL(join(cwd(), 'src', 'dates.mjs')).href);
+const eachDay = mod.eachDay ?? mod.default?.eachDay;
+assert.equal(typeof eachDay, 'function', '应导出具名函数 eachDay');
+
+assert.deepEqual(
+  eachDay('2024-02-27', '2024-03-02'),
+  ['2024-02-27', '2024-02-28', '2024-02-29', '2024-03-01', '2024-03-02'],
+);
+assert.deepEqual(
+  eachDay('2024-12-30', '2025-01-02'),
+  ['2024-12-30', '2024-12-31', '2025-01-01', '2025-01-02'],
+);
+assert.deepEqual(eachDay('2024-01-15', '2024-01-15'), ['2024-01-15']);
+assert.deepEqual(
+  eachDay('2024-01-01T10:00:00Z', '2024-01-03T23:00:00Z'),
+  ['2024-01-01', '2024-01-02', '2024-01-03'],
+);
+// 2100 是「逢百年不闰」的非闰年
+assert.deepEqual(eachDay('2100-02-28', '2100-03-01'), ['2100-02-28', '2100-03-01']);
+assert.throws(() => eachDay('2024-03-01', '2024-02-28'), RangeError);
+assert.throws(() => eachDay('2024-02-30', '2024-03-01'), TypeError);
+assert.throws(() => eachDay('2024-1-1', '2024-01-02'), TypeError);
+assert.throws(() => eachDay(null, '2024-01-02'), TypeError);
+
+console.log('002-each-day verify OK');

package/eval/tasks/003-word-report/files/data/notes.txt

@@ -0,0 +1,5 @@
+the quick brown fox jumps over the lazy dog
+the dog barks and the fox runs
+quick quick slow
+Apple apple APPLE
+tea for two and two for tea

package/eval/tasks/003-word-report/files/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "task-word-report",
+  "version": "1.0.0",
+  "type": "module",
+  "private": true
+}

package/eval/tasks/003-word-report/solution/bin/report.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// 参考解（dry-run 假 agent 使用，也供人工对照）。
+import { readFileSync } from 'node:fs';
+
+function parseArgs(argv) {
+  const out = { input: 'data/notes.txt', top: 5, minLen: 1 };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--input') out.input = argv[++i];
+    else if (a === '--top') out.top = Number(argv[++i]);
+    else if (a === '--min-len') out.minLen = Number(argv[++i]);
+  }
+  return out;
+}
+
+const { input, top, minLen } = parseArgs(process.argv.slice(2));
+let text;
+try {
+  text = readFileSync(input, 'utf8');
+} catch (err) {
+  console.error(`无法读取输入文件: ${input}（${err.code ?? err.message}）`);
+  process.exit(1);
+}
+
+const counts = new Map();
+for (const word of text.toLowerCase().split(/\s+/)) {
+  if (!word || word.length < minLen) continue;
+  counts.set(word, (counts.get(word) ?? 0) + 1);
+}
+const totalWords = [...counts.values()].reduce((a, b) => a + b, 0);
+const topWords = [...counts.entries()]
+  .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1))
+  .slice(0, top)
+  .map(([word, count]) => ({ word, count }));
+
+process.stdout.write(`${JSON.stringify({ totalWords, top: topWords })}\n`);

package/eval/tasks/003-word-report/task.json

@@ -0,0 +1,6 @@
+{
+  "id": "003-word-report",
+  "title": "实现词频统计 CLI",
+  "tags": ["greenfield", "cli", "output-contract"],
+  "instruction": "当前目录 data/notes.txt 已提供输入样本。新建 bin/report.mjs（纯 Node 实现，禁止第三方依赖，package.json 已是 type=module）。\n\n功能：词频统计 CLI。用法：node bin/report.mjs [--input <路径>] [--top N] [--min-len M]\n- --input：输入文件路径，默认 data/notes.txt（相对当前工作目录解析）。\n- 读取文本，小写化后按空白切分为词。\n- --min-len：过滤掉长度小于 M 的词，默认 1。\n- --top：输出频次最高的前 N 个词，默认 5；频次相同时按词的字典序升序排列。\n- stdout 输出且仅输出一行 JSON：{\"totalWords\":<过滤后的总词数>,\"top\":[{\"word\":<词>,\"count\":<次数>}, ...]}\n- 输入文件不存在或不可读时：向 stderr 输出错误信息，退出码 1。"
+}

package/eval/tasks/003-word-report/verify.mjs

@@ -0,0 +1,38 @@
+// 判分脚本：cwd=被测工作目录，退出码 0 = 通过。
+// 期望值基于 data/notes.txt 的固定内容硬编码，保证判分独立于被测实现。
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+
+const reportCli = join(cwd(), 'bin', 'report.mjs');
+const run = (args) => spawnSync('node', [reportCli, ...args], { encoding: 'utf8' });
+
+const run1 = run(['--top', '3']);
+assert.equal(run1.status, 0, `CLI 应成功运行: ${run1.stderr}`);
+assert.ok(run1.stdout.trim().startsWith('{'), 'stdout 应为 JSON');
+assert.equal(run1.stdout.trim().split('\n').length, 1, '只允许输出一行 JSON');
+assert.deepEqual(JSON.parse(run1.stdout), {
+  totalWords: 29,
+  top: [
+    { word: 'the', count: 4 },
+    { word: 'apple', count: 3 },
+    { word: 'quick', count: 3 },
+  ],
+});
+
+const run2 = run(['--top', '2', '--min-len', '5']);
+assert.equal(run2.status, 0);
+assert.deepEqual(JSON.parse(run2.stdout), {
+  totalWords: 9,
+  top: [
+    { word: 'apple', count: 3 },
+    { word: 'quick', count: 3 },
+  ],
+});
+
+const run3 = run(['--input', 'no-such-file.txt']);
+assert.notEqual(run3.status, 0, '文件不存在应非零退出');
+assert.ok((run3.stderr ?? '').trim().length > 0, '应向 stderr 输出错误信息');
+
+console.log('003-word-report verify OK');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sillyspec",
-  "version": "3.27.2",
+  "version": "3.27.5",
   "description": "SillySpec CLI — 流程状态机，让 AI 严格按步骤来",
   "icon": "logo.jpg",
   "homepage": "https://sillyspec.ppdmq.top/",
@@ -25,7 +25,9 @@
   "license": "MIT",
   "scripts": {
     "test": "node test/run-tests.mjs",
-    "lint": "node test/check-syntax.mjs"
+    "lint": "node test/check-syntax.mjs",
+    "eval:dry": "node eval/run.mjs --dry-run",
+    "eval:pilot": "node eval/run.mjs --pilot"
   },
   "dependencies": {
     "@inquirer/prompts": "^7.10.1",

package/src/agent-session-log.js

@@ -71,10 +71,14 @@ function toPosix(p) {
   return String(p).replace(/\\/g, '/');
 }
 
-/** cwd 等值比较口径：正斜杠归一 + Windows 大小写不敏感。 */
+/** cwd 等值比较口径：正斜杠归一 + Windows 形态路径大小写不敏感。
+ * 按数据形态判而非宿主平台——平台 hub 场景 daemon 跑在任意平台，都要能与 Windows
+ * agent 上报的 cwd（盘符 `c:/x` 或 UNC `\\server\share`）等值比较；toPosix 在前，
+ * UNC 的反斜杠此时已成 `//`。POSIX 形态路径保持大小写敏感（文件系统语义如此）。 */
 function normCwd(p) {
   const s = toPosix(p);
-  return process.platform === 'win32' ? s.toLowerCase() : s;
+  const winForm = /^[a-zA-Z]:\//.test(s) || s.startsWith('//');
+  return winForm ? s.toLowerCase() : s;
 }
 
 function cwdsMatch(a, b) {
@@ -85,6 +89,17 @@ function statSafe(p) {
   try { return statSync(p); } catch { return null; }
 }
 
+/**
+ * 会话化上下文 id 消毒（2026-08-23-agent-activity-sessions）：非空字符串 trim 后返回，
+ * 其余（undefined/null/空白）返回 null——best-effort 语义：ctx 解析失败不带、不抛错。
+ * 只用于标识类值（hubSessionId / changeKey / quickId），非 flag 值。
+ */
+function pickCtxId(v) {
+  if (typeof v !== 'string') return null;
+  const t = v.trim();
+  return t || null;
+}
+
 /**
  * 读文件首行并 JSON.parse（只读前 maxBytes 字节，防大日志整读）。
  * codex rollout 首行是 session_meta（含 cwd/originator），这是 cwd 精确匹配的数据源。
@@ -574,7 +589,8 @@ export function readAgentLogArtifact(runtimeRoot) {
  * 登记 agent 会话日志路径进 <runtimeRoot>/agent-session-log.json（run 命令入口调用）。
  *
  * 合并语义：按 log_path 去重——同路径 invocations+1 / 刷新 last_seen_at 与文件 stat；
- * 新路径追加；entries 按 last_seen_at 新→旧排序，上限 10 条（超出淘汰最旧）。
+ * 新路径追加；entries 按 last_seen_at 新→旧排序（同毫秒平局按 seq 登记序决胜），
+ * 上限 10 条（超出淘汰最旧）。
  * 探测不到（非 agent 环境）不写盘不上报。全程 best-effort：失败 warn 一行返回 null 不抛。
  * 落盘后立即 REST 上报平台（POST /api/agent-logs，主通道），上报失败本地产物兜底。
  *
@@ -584,6 +600,10 @@ export function readAgentLogArtifact(runtimeRoot) {
  * @param {object}   [p.platformOpts] - 平台参数（workspaceId/scanRunId 进产物元信息）
  * @param {string}   p.specBase     - 规范基路径（本地模式 cwd/.sillyspec；平台模式 specRoot）
  * @param {string}   [p.command]    - 触发登记的命令描述（flag 名级，不含 flag 值）
+ * @param {object}   [p.context]    - 会话化上下文（2026-08-23-agent-activity-sessions，可选）：
+ *   {hubSessionId, changeKey, quickId}——hubSessionId 为 body 级（run 所属平台会话唯一，
+ *   daemon 注入 env SILLYHUB_SESSION_ID 的兜底也在此读取）；changeKey/quickId 为 entry 级
+ *   （本次 run 检出/更新的 entry 随 run 持久化，quick 会话 quickId 优先互斥）。缺省全不带。
  * @param {object}   [p.env]        - 探测用 env（默认 process.env；测试注入用）
  * @param {string}   [p.homeDir]    - 探测用 home（默认 homedir()；测试注入用）
  * @param {number}   [p.now]        - 探测用时钟（默认 Date.now()；测试注入用）
@@ -591,13 +611,20 @@ export function readAgentLogArtifact(runtimeRoot) {
  * @returns {Promise<{artifactPath:string, detected:number, latestLogPath:string|null, isNew:boolean, pushed:boolean|null}|null>}
  *   null = 未探测到 / 失败（调用方无需区分）
  */
-export async function recordAgentLogInvocation({ cwd, invokedCwd, platformOpts = {}, specBase, command, env, homeDir, now, windowMs } = {}) {
+export async function recordAgentLogInvocation({ cwd, invokedCwd, platformOpts = {}, specBase, command, context = {}, env, homeDir, now, windowMs } = {}) {
   try {
     if (!cwd || !specBase) return null;
     const cwdCandidates = [...new Set([invokedCwd, cwd].filter(Boolean))];
     const detected = detectAgentLogEntries({ cwdCandidates, env, homeDir, now, windowMs });
     if (detected.length === 0) return null;
 
+    // 会话化上下文（best-effort 消毒，解析失败不带）：entry 级 ctx（changeKey/quickId）随
+    // 检出/更新该 entry 的本次 run 持久化；hubSessionId 为 body 级——context 显式传入优先，
+    // 缺省回落 env SILLYHUB_SESSION_ID（daemon 派发平台会话时的注入通道，见 protocol 文档 §1）。
+    const hubSessionId = pickCtxId(context.hubSessionId) || pickCtxId((env || process.env).SILLYHUB_SESSION_ID);
+    const ctxChangeKey = pickCtxId(context.changeKey);
+    const ctxQuickId = pickCtxId(context.quickId);
+
     const runtimeRoot = resolveRuntimeRoot(platformOpts, specBase);
     const artifactPath = join(runtimeRoot, AGENT_LOG_ARTIFACT_FILENAME);
     const nowIso = new Date().toISOString();
@@ -607,6 +634,11 @@ export async function recordAgentLogInvocation({ cwd, invokedCwd, platformOpts =
       const existing = readAgentLogArtifact(runtimeRoot);
       const byPath = new Map((existing?.entries || []).map(e => [e.log_path, e]));
 
+      // 平局决胜序号：last_seen_at 是毫秒精度 ISO，快机器上连续登记落在同一毫秒打平，
+      // 稳定排序会让旧条目留在首位（latestLogPath 假"未更新"）。seq 按登记触及顺序单调
+      // 递增并随条目持久化，平局时后触及者胜（存量产物无 seq 视为 0，老条目间次序不变）。
+      let seq = (existing?.entries || []).reduce((m, e) => Math.max(m, Number(e.seq) || 0), 0);
+
       for (const det of detected) {
         const st = statSafe(det.log_path);
         const prev = byPath.get(det.log_path);
@@ -619,6 +651,10 @@ export async function recordAgentLogInvocation({ cwd, invokedCwd, platformOpts =
           agent_cwd: det.agent_cwd,
           session_id: det.session_id ?? prev?.session_id ?? null,
           originator: det.originator ?? prev?.originator ?? null,
+          // entry 级 ctx（D-009）：本次 run 非空者写入；context 未带（如无 --change 的 run）
+          // 保留原值——未被本次 run 触及的存量 entry 不进此循环，展开即保留原 ctx 不追新
+          change_key: ctxChangeKey ?? prev?.change_key ?? null,
+          quick_id: ctxQuickId ?? prev?.quick_id ?? null,
           exists: Boolean(st),
           size_bytes: st ? st.size : null,
           mtime_ms: st ? st.mtimeMs : (det.mtime_ms ?? null),
@@ -626,11 +662,12 @@ export async function recordAgentLogInvocation({ cwd, invokedCwd, platformOpts =
           last_seen_at: nowIso,
           invocations: (prev?.invocations || 0) + 1,
           last_command: command || null,
+          seq: ++seq,
         });
       }
 
       const entries = [...byPath.values()]
-        .sort((a, b) => (b.last_seen_at || '').localeCompare(a.last_seen_at || ''))
+        .sort((a, b) => (b.last_seen_at || '').localeCompare(a.last_seen_at || '') || ((b.seq || 0) - (a.seq || 0)))
         .slice(0, MAX_ENTRIES);
 
       const artifact = {
@@ -660,6 +697,9 @@ export async function recordAgentLogInvocation({ cwd, invokedCwd, platformOpts =
         agent_cwd: toPosix(invokedCwd || cwd),
         workspace_id: platformOpts.workspaceId ?? null,
         scan_run_id: platformOpts.scanRunId ?? null,
+        // body 级会话关联键（run 所属平台会话唯一；非空才带，schema_version 保持 1 纯可选增量）
+        ...(hubSessionId ? { hub_session_id: hubSessionId } : {}),
+        // entries 各自带 entry 级 ctx（change_key/quick_id，随 entry 持久化的原值或本次 run 的新值）
         entries: merged.entries,
       },
     });

package/src/change-risk-profile.js

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

package/src/config-schema.js

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