sillyspec 3.28.8 → 3.28.9

package/src/worktree-deps.js

@@ -13,8 +13,8 @@
  * node 校验与 java 校验各说各话。新生态补一行表项即可；表外项目落 generic → n/a 不阻断。
  */
 
-import { existsSync, readFileSync, realpathSync, lstatSync, readdirSync, unlinkSync } from 'fs';
-import { join, isAbsolute, relative, resolve as resolvePath, sep as pathSep } from 'path';
+import { existsSync, readFileSync, realpathSync, lstatSync, readdirSync, readlinkSync, unlinkSync } from 'fs';
+import { join, dirname, isAbsolute, relative, resolve as resolvePath, sep as pathSep } from 'path';
 import { fileURLToPath } from 'url';
 import { execFileSync } from 'child_process';
 import { createHash } from 'crypto';
@@ -387,6 +387,86 @@ function isSafeModulePath(p) {
   return !segs.includes('..');
 }
 
+/**
+ * resolved 路径是否严格位于 root 目录之下（不含 root 自身）。win32 大小写不敏感比较由
+ * path.win32.relative 自带（与 detectEditableInstallEscape 的越界判定同口径）。
+ */
+function isUnderDir(child, root) {
+  if (!child || !root) return false;
+  const rel = relative(resolvePath(root), resolvePath(child));
+  return rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+}
+
+/**
+ * ql-20260915-003 修复①（坑 junction-foreign-ownership，2026-09-15 用户实证：主仓
+ * frontend/node_modules 内部发现 junction 指向 session-export worktree 的 .pnpm——跨会话
+ * node_modules 污染，apply 后被迫 --force 重装）。
+ *
+ * 归属判定：链接方向 wt/node_modules → main 是 SillySpec 的正确设计（worktree 共享主仓
+ * 依赖）；反向——main node_modules 内出现指向 .sillyspec/.runtime/worktrees/ 之下目标的
+ * junction/symlink——是 install 兜底/包管理器穿透写坏留下的污染，任何合法流程都不依赖它，
+ * 一律视为外来（foreign）。pnpm 自建的包链接（node_modules/<pkg> → 同 node_modules 内
+ * .pnpm/...）与全局 store 链接目标都不在 worktrees 区之下，零误伤。
+ *
+ * 扫描口径：main 的 node_modules（根 + 各子模块 node_modules）**顶层目录项**——单层
+ * readdir+lstat，不递归 .pnpm 内部（顶层已覆盖包链接；递归大仓 node_modules 的性能与
+ * 误删面都不可接受）。子模块清单：submodules 直传相对路径列表，或给 specBase 自动读
+ * local.yaml modules 块。
+ *
+ * 删除安全：junction/symlink 删除不跟随目标（win32 cmd /c rmdir / POSIX unlinkSync——与
+ * worktree.js unlinkNodeModulesLinks :82 同款安全删法）；单个清理失败 fail-open 记入
+ * failed 不阻断（清扫是治理动作，不拦主流程）。
+ *
+ * @param {string} mainDir 主仓根目录（node_modules 所在）
+ * @param {{ worktreesRoot?: string, specBase?: string|null, submodules?: string[]|null, dryRun?: boolean, onlyUnder?: string|null }} opts
+ *   - worktreesRoot 外来边界：resolved target 落在其下才算外来（缺省直接空手而归）
+ *   - submodules 为 null 且给了 specBase 时，自动读 local.yaml modules 块补子模块清单
+ *   - dryRun=true 只报清单零写盘
+ *   - onlyUnder 进一步收窄：只认 target 落在该目录之下的（install 兜底前只清指向本 worktree 的）
+ * @returns {{ foreign: Array<{link: string, target: string}>, removed: Array<{link: string, target: string}>, failed: Array<{link: string, error: string}> }}
+ *   dryRun 时 foreign=将清清单、removed/failed 恒空；非 dryRun 时 removed=实际已清、failed=清理失败
+ */
+export function sweepForeignNodeModulesJunctions(mainDir, { worktreesRoot, specBase = null, submodules = null, dryRun = false, onlyUnder = null } = {}) {
+  const result = { foreign: [], removed: [], failed: [] };
+  if (!mainDir || !worktreesRoot || !existsSync(mainDir)) return result;
+  let mods = submodules;
+  if (mods === null && specBase) mods = extractModulePaths(readLocalYaml(specBase, null));
+  const nmDirs = [join(mainDir, 'node_modules')];
+  for (const sp of Array.isArray(mods) ? mods : []) {
+    if (!isSafeModulePath(sp)) continue;
+    nmDirs.push(join(mainDir, sp, 'node_modules'));
+  }
+  for (const nmDir of nmDirs) {
+    let names;
+    try { names = readdirSync(nmDir); } catch { continue; } // 目录不存在/不可读 → 该层跳过
+    for (const nm of names) {
+      const linkPath = join(nmDir, nm);
+      let st;
+      try { st = lstatSync(linkPath); } catch { continue; }
+      if (!st.isSymbolicLink()) continue; // junction（reparse point）与 symlink 的 lstat 均报 isSymbolicLink
+      let target;
+      try { target = readlinkSync(linkPath); } catch { continue; }
+      // 相对 target（pnpm 自建包链接常态）相对链接所在目录解析
+      const resolved = resolvePath(dirname(linkPath), target);
+      if (!isUnderDir(resolved, worktreesRoot)) continue;
+      if (onlyUnder && !isUnderDir(resolved, onlyUnder)) continue;
+      result.foreign.push({ link: linkPath, target: resolved });
+      if (dryRun) continue;
+      try {
+        if (process.platform === 'win32') {
+          execFileSync('cmd.exe', ['/c', 'rmdir', linkPath], { stdio: ['pipe', 'pipe', 'pipe'] });
+        } else {
+          unlinkSync(linkPath);
+        }
+        result.removed.push({ link: linkPath, target: resolved });
+      } catch (e) {
+        result.failed.push({ link: linkPath, error: e.message });
+      }
+    }
+  }
+  return result;
+}
+
 /**
  * 对单个子模块目录 tryLink main 的 node_modules → wt 的 node_modules（modules 子模块专用）。
  * 仅走 link 快路径（不 install——子模块 install 慢且易失败；lockfile 不一致时交给用户 pnpm install）。
@@ -464,6 +544,24 @@ export function provisionDeps(worktreePath, mainCwd, opts = {}) {
     }
     if (!linked) {
       // 兜底：install
+      // ql-20260915-003 修复①（坑 junction-foreign-ownership）防再犯：install 在 worktree cwd
+      // 执行，若 main node_modules 内残留指向**本次 worktree** 的外来 junction，包管理器会经
+      // 反向链接穿透写坏主仓 node_modules（2026-09-15 实证的污染源头）——先清再装。
+      // 只清指向本 worktree 的（onlyUnder），全量治理交给 create/cleanup 挂点
+      // （worktree.js _sweepMainForeignJunctionLinks）。
+      if (mainCwd && existsSync(join(mainCwd, 'node_modules'))) {
+        try {
+          const preSweep = sweepForeignNodeModulesJunctions(mainCwd, {
+            worktreesRoot: resolvePath(mainCwd, '.sillyspec', '.runtime', 'worktrees'),
+            submodules: extractModulePaths(yamlText),
+            onlyUnder: worktreePath,
+          });
+          if (preSweep.removed.length > 0) {
+            console.warn(`⚠️ install 前清理：主仓 node_modules 内检测到指向本 worktree 的外来 junction（坑 junction-foreign-ownership），已移除 ${preSweep.removed.length} 个`);
+            for (const r of preSweep.removed) console.warn(`   ${r.link} → ${r.target}`);
+          }
+        } catch { /* 清扫自身异常 fail-open，交 install 自然暴露问题 */ }
+      }
       const installResult = tryInstall(installCmd, worktreePath, timeout);
       result = installResult.ok
         ? { depsStatus: 'installed', depsMethod: 'install', depsSource: 'install', depsLockHash: wtHash }

package/src/worktree.js

@@ -12,7 +12,8 @@ import { execFileSync } from 'child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync, statSync, lstatSync, readlinkSync, unlinkSync, copyFileSync } from 'fs';
 import { join, resolve, dirname, relative, isAbsolute, basename } from 'path';
 import { createHash } from 'crypto';
-import { provisionDeps, checkDepsFreshness, detectEditableInstallEscape } from './worktree-deps.js';
+import { provisionDeps, checkDepsFreshness, detectEditableInstallEscape, sweepForeignNodeModulesJunctions } from './worktree-deps.js';
+import { resolveRuntimeRoot } from './run/shared.js';
 import { writeAtomicSync } from './fs-atomic.js';
 import { openDatabase } from './db-engine.js';
 import { git, gitQuiet } from './git-helper.js';
@@ -478,6 +479,44 @@ export class WorktreeManager {
     return resolve(this.worktreeBase, changeName);
   }
 
+  /**
+   * ql-20260915-003 修复①（坑 junction-foreign-ownership，2026-09-15 用户实证：主仓
+   * frontend/node_modules 内 junction 指向历史 worktree 的 .pnpm——跨会话 node_modules
+   * 污染）：清扫主仓 node_modules（根 + local.yaml modules 子模块）内指向 worktrees 区的
+   * 外来 junction/symlink。正确链接方向只有 wt/node_modules → main；main 侧指向 worktrees
+   * 区的反向链接一律是 install 兜底/包管理器穿透写坏的污染，发现即清 + warn。
+   *
+   * 挂点：create 依赖供给前（5.7b，防新供给经污染链接写坏）与 cleanup（把本 worktree 可能
+   * 遗留的反向链接一并清）。清扫失败 fail-open 不阻断主流程（治理动作非卡点）。
+   *
+   * @param {string} label 调用场景（warn/details 文案用）
+   * @param {string[]|null} [details] 可选，cleanup details 兼容
+   * @returns {{ foreign: Array, removed: Array, failed: Array }} sweep 结果（异常时空集）
+   */
+  _sweepMainForeignJunctionLinks(label, details = null) {
+    try {
+      const mainRoot = this._resolveMainRepoRoot();
+      const sweep = sweepForeignNodeModulesJunctions(mainRoot, {
+        worktreesRoot: this.worktreeBase,
+        specBase: join(mainRoot, '.sillyspec'),
+      });
+      if (sweep.removed.length > 0) {
+        console.warn(`⚠️ 检测到主仓 node_modules 内指向历史 worktree 的外来 junction，已移除 ${sweep.removed.length} 个（坑 junction-foreign-ownership，${label}）`);
+        for (const r of sweep.removed) console.warn(`   ${r.link} → ${r.target}`);
+        if (details) details.push(`foreign junctions swept (${label}): ${sweep.removed.length}`);
+      }
+      if (sweep.failed.length > 0) {
+        console.warn(`⚠️ 主仓 node_modules 外来 junction 清理未全成（${sweep.failed.length} 个失败，可重跑 sillyspec worktree doctor 或手工 rmdir）: ${sweep.failed.map(f => f.link).join('、')}`);
+        if (details) details.push(`foreign junction sweep partial fail (${label}): ${sweep.failed.map(f => f.link).join('; ')}`);
+      }
+      return sweep;
+    } catch (e) {
+      // fail-open：清扫自身异常不阻断 create/cleanup 主流程
+      console.warn(`⚠️ 主仓 node_modules 外来 junction 清扫跳过（${e && e.message ? e.message : e}）`);
+      return { foreign: [], removed: [], failed: [] };
+    }
+  }
+
   /**
    * 读取 worktree 元数据
    * @param {string} changeName
@@ -696,6 +735,10 @@ export class WorktreeManager {
 
     // 5.8 依赖供给（change 2026-06-28-worktree-deps-provision）
     // baseline overlay 后让 worktree 立即可构建/测试；失败不阻断 create，只记 meta。
+    // 5.7b ql-20260915-003 修复①（坑 junction-foreign-ownership）：依赖供给前清扫主仓
+    // node_modules 内指向历史 worktree 的外来 junction（反向链接污染，install 兜底穿透
+    // 写坏的源头）——发现即清 + warn，防新供给再经污染链接写坏主仓依赖。
+    this._sweepMainForeignJunctionLinks('worktree create');
     let deps = {};
     try {
       deps = provisionDeps(worktreePath, this.cwd, { specBase: join(this.cwd, '.sillyspec') }) || {};
@@ -1046,16 +1089,76 @@ export class WorktreeManager {
     }
   }
 
+  /**
+   * ql-20260915-003 修复②（坑 cleanup-meta-fallback，2026-09-15 用户实证：cleanup 报
+   * 「mode: null 跳过清理」但 worktree 目录实际创建过——meta 在 apply 后丢失 + cwd/specRoot
+   * 漂移让 getWorktreePath 解析到别处时，meta/worktreePath/metaDir 三缺被误判「什么都不
+   * 存在」早退）：meta 缺失时的 worktree 残留兜底探测。两路探针（异常一律 fail-open 视为
+   * 未命中）：
+   *   (a) `git worktree list --porcelain` 中分支 refs/heads/sillyspec/<name> 的注册路径——
+   *       git 注册是权威口径，不受本进程 worktreeBase 解析漂移影响；目录在不在都算命中
+   *       （注册残留本身就该 prune，目录在则连目录一起清）
+   *   (b) resolveRuntimeRoot 口径（cwd/.sillyspec 为 localSpecBase）下 worktrees/<name>
+   *       目录存在性——平台 runtimeRoot / cwd 漂移时的第二解析口径
+   * 全不命中 → hit:null + candidates（三路探针描述，供 CLI 诊断式跳过输出）。
+   * @param {string} name changeName（已过 validateChangeName）
+   * @returns {{ hit: { path: string, via: string }|null, candidates: string[] }}
+   */
+  _probeWorktreeRemnants(name) {
+    const stdPath = this.getWorktreePath(name);
+    const candidates = [`meta/目录探针（getWorktreePath 口径）: ${stdPath} 不存在`];
+    try {
+      const out = gitQuiet(this.cwd, ['worktree', 'list', '--porcelain'], { timeout: 30000 });
+      const wantBranch = `branch refs/heads/${BRANCH_PREFIX}${name}`;
+      let curPath = null;
+      let regHit = null;
+      for (const line of String(out || '').split('\n')) {
+        if (line.startsWith('worktree ')) curPath = line.slice('worktree '.length).trim();
+        else if (curPath && line.trim() === wantBranch) { regHit = curPath; break; }
+      }
+      if (regHit) {
+        candidates.push(`git 分支探针: 分支 ${BRANCH_PREFIX}${name} 注册于 ${regHit} —— 命中`);
+        return { hit: { path: regHit, via: `git worktree list 分支 ${BRANCH_PREFIX}${name} 注册路径` }, candidates };
+      }
+      candidates.push(`git 分支探针: git worktree list 无分支 ${BRANCH_PREFIX}${name} 注册`);
+    } catch {
+      candidates.push(`git 分支探针: git worktree list 失败（fail-open 视为未命中）`);
+    }
+    try {
+      const alt = join(resolveRuntimeRoot(null, join(this.cwd, '.sillyspec')), 'worktrees', name);
+      if (existsSync(alt)) {
+        candidates.push(`runtimeRoot 口径目录探针: ${alt} 存在 —— 命中`);
+        return { hit: { path: alt, via: `resolveRuntimeRoot 口径目录 ${alt}` }, candidates };
+      }
+      candidates.push(`runtimeRoot 口径目录探针: ${alt} 不存在`);
+    } catch {
+      candidates.push('runtimeRoot 口径目录探针: 解析失败（fail-open 视为未命中）');
+    }
+    return { hit: null, candidates };
+  }
+
   cleanup(changeName, { force = false, maxRetries = 3 } = {}) {
     const name = validateChangeName(changeName);
     const meta = this.getMeta(name);
-    const worktreePath = this.getWorktreePath(name);
+    let worktreePath = this.getWorktreePath(name);
     const metaDir = join(this.worktreeBase, name);
     const details = [];
 
-    // 幂等：什么都不存在 → 直接跳过
+    // 幂等：什么都不存在 → 直接跳过。
+    // ql-20260915-003 修复②（坑 cleanup-meta-fallback）：meta 缺失时不轻信「三缺 = 什么都不
+    // 存在」——先跑 _probeWorktreeRemnants 兜底（git 注册路径 + resolveRuntimeRoot 口径目录），
+    // 任一命中 → 不走早退，按命中路径继续清理（mode 推断 'worktree'，details 记兜底依据）；
+    // 全不命中才跳过，跳过结果带 probePaths 探针清单（CLI 诊断式输出 + doctor 指引）。
     if (!meta && !existsSync(worktreePath) && !existsSync(metaDir)) {
-      return { result: 'skipped', mode: null, details };
+      const probes = this._probeWorktreeRemnants(name);
+      if (probes.hit) {
+        worktreePath = probes.hit.path;
+        const note = `meta 缺失，目录/分支探测兜底（命中：${probes.hit.via}）`;
+        details.push(note);
+        console.warn(`⚠️ ${note}`);
+      } else {
+        return { result: 'skipped', mode: null, details, probePaths: probes.candidates };
+      }
     }
 
     const mode = meta?.mode || 'worktree';
@@ -1076,7 +1179,11 @@ export class WorktreeManager {
     if (!force) {
       const check = this.hasUnappliedChanges(name);
       if (check.hasChanges) {
-        console.error(`🚫 worktree cleanup 拒绝：${check.changedFiles.length} 个交付变更未落地主工作区 HEAD，清理会丢失代码。`);
+        // ql-20260915-003 修复② 配套：no-meta fail-closed 拦截时 changedFiles 为空，裸报
+        // 「0 个交付变更」让人误解——0 文件时改报无法判定的原因（保守保留语义不变）。
+        console.error(check.changedFiles.length > 0
+          ? `🚫 worktree cleanup 拒绝：${check.changedFiles.length} 个交付变更未落地主工作区 HEAD，清理会丢失代码。`
+          : `🚫 worktree cleanup 拒绝：无法判定交付是否已全部落地（${check.reason || 'meta 缺失，保守保留'}），保守不清理。`);
         for (const f of check.changedFiles) console.error(`   ${f}`);
         console.error('   请先落地（sillyspec worktree apply <name>）或 commit 到分支，或显式 --force 强制清理。');
         return { result: 'blocked', mode, details: [...details, 'blocked: uncommitted deliverable changes'], residual: [] };
@@ -1098,6 +1205,11 @@ export class WorktreeManager {
       unlinkNodeModulesLinks(worktreePath, meta, details)
     }
 
+    // ql-20260915-003 修复①（坑 junction-foreign-ownership）：cleanup 时同款清扫主仓
+    // node_modules——把本 worktree（及其他历史 worktree）可能遗留的反向链接一并清，
+    // 否则污染 junction 永久滞留主仓，直到下次人工 --force 重装依赖才发现。
+    this._sweepMainForeignJunctionLinks('worktree cleanup', details);
+
     // 1. git worktree remove（带 retry）—— in-place 跳过：无 git worktree 注册，且 worktreePath 即主工作区
     let gitRemoveOk = false;
     if (!isInPlace && existsSync(worktreePath)) {

package/templates/agents-instruction.md

@@ -7,9 +7,9 @@
 1. **禁止绕过本文件规则和 SillySpec 流程**。所有变更走 sillyspec 流程，不裸改裸提交。
 2. **改代码前必须先说明依据**——依据的文档路径（design.md / 模块文档 / file-lifecycle.md）或现有代码依据，无依据不改。
 3. **新功能 / 大改动走完整流程**：`brainstorm → plan → execute → verify → archive`。
-4. **小修复 / 小调整走 quick**：`sillyspec run quick`。
+4. **小修复 / 小调整走 quick**（= 无需要落盘的设计决策的改动，选道判据见第 6 条）：`sillyspec run quick`。
 5. **执行顺序**：文档 → 读代码 → 写测试 → 写实现 → 跑测试 → 验收 → 更新文档。
-6. **判规模选档**：≤3 文件、范围明确走 `quick`；多阶段 / 架构级走完整流程。
+6. **判规模选档**：看本次改动有无需要落盘的设计决策——有（新能力 / 行为契约变更 / 跨模块取舍 / 多阶段推进）走完整流程，无（范围明确的局部修补）走 `quick`。文件数不是选道判据，只作出口绊线——改动大或跨模块时 quick 收尾门禁会自动加查（分级提示补文件注记 / 测试增量 / 模块文档认领）。
 7. **代码先行不补流程（倒推 B 模式）**：代码若已先写好，**不回头补 brainstorm/plan 装样子**——用 `quick --done` 收尾 + 补 quicklog 条目，把已落盘改动如实登记进进度库。
 8. **实证核验再 `--done`**：触及 `src`/`test` 的改动，CLI 会在 `quick --done` 时**亲自实测** `.sillyspec/local.yaml` 的 `commands.test` / `commands.lint`（门禁：实测失败阻断 --done 回 pending；纯 doc/配置与未配置命令自动跳过；倒推 B 模式按 --files 声明边界兜底判定）。agent 侧预跑**可选**——想省「--done 被拦→修复→重跑」一轮时才预跑；纯 doc/配置改动无需跑。以落盘文件与测试结果为准，不信口头"已完成"。
 9. **中途停下不靠额外命令存进度**——进度已由上一次 `--done` 自动落盘；恢复时用 `sillyspec progress show` 查看进度，再用 `sillyspec run <stage>` 续跑，不直接 commit 半成品。

package/templates/prompts/testcase-design.md

@@ -9,4 +9,5 @@
 3. **行为 vs 实现**：走公开 API 测行为；重构后功能不变，测试不应失败。
 4. **契约与回归**：覆盖本次改动会破坏的既有行为与相邻模块接口；改公共签名/文案/常量时同步修复受影响既有测试并跑全量，禁止删断言凑绿。
 5. **时间敏感分支**：超时/重试/并发分支别真等——超时参数做成可注入，测试传毫秒级极小值或注入可控时钟推进，再断言超时后的行为（走哪个分支/返回什么/资源是否回收）。
-6. **隔离确定性**：独立 fixture、可重复跑，不依赖共享状态/执行顺序。
+6. **隔离确定性**：独立 fixture、可重复跑，不依赖共享状态/执行顺序。
+7. **覆盖对账**：每条 TaskCard acceptance 至少对应一个测试用例，或显式标注 non-testable（文档/部署类——证据列写一句理由）；对应关系由 verify 探针 7 矩阵机械核对（判定 covered/partial 须给测试锚点）——写测试前先读卡的 acceptance 列表逐条对齐，勿只覆盖顺手的主路径。

package/templates/prompts/verify-probes.md

@@ -3,7 +3,7 @@
 > 🔧 **先跑 CLI 机械探针（一条命令）**：`sillyspec verify-probes --change <change-name> [--init]`
 > 输出已包含四个纯机械探针的结果（可直接进验证报告）：**探针 1** 未实现标记扫描（design 清单文件逐行 TODO/FIXME 命中 + 行号）、**探针 3** 测试文件递归查找（含 co-located tests/，逐 task 覆盖）、**探针 5** API 契约对账表（endpoints.json × 前端调用 diff）、**探针 6** 删除对账三态（git 事实 × design 声明）。`--init` 顺带生成 verify-result.md 九章节骨架（探针结果已预填，`<!--TODO-->` 占位替换即可）。
 >
-> 下列条目中，只有**半语义部分**需要你执行：探针 2（关键词提取）、探针 3.4 集成盲区标注、探针 3.5 断言有效性抽查、探针 4（决策追踪闭环判定）。CLI 已跑的部分勿重复手跑——对 CLI 输出的 warning 项做语义复核即可。
+> 下列条目中，只有**半语义部分**需要你执行：探针 2（关键词提取）、探针 3.4 集成盲区标注、探针 3.5 断言有效性抽查、探针 4（决策追踪闭环判定）、探针 7（验收×测试覆盖矩阵判定填槽）。CLI 已跑的部分勿重复手跑——对 CLI 输出的 warning 项做语义复核即可。
 
 **探针 2：设计关键词覆盖探针（你执行——关键词提取是语义）**
 1. 读取 design.md，从中提取所有能力关键词（如"登录"、"导出"、"批量"、"删除"、"搜索"等动作词）
@@ -31,3 +31,6 @@ CLI 的 missing backend endpoint 是 advisory（不硬阻断归档）——但 c
 
 **探针 6 补充（CLI 已出三态判定，你做终审）**
 以 git 事实为准（真实 > 声明）；CLI 的三态（合规/高风险/未声明）是机械判定，是否构成 FAIL blocker 由你诚实判定，务必如实记录——静默删除代码是 verify 的最大盲区。
+
+**探针 7 补充（CLI 已预填矩阵归属与提示，你填判定与证据）**
+验收×测试覆盖矩阵：CLI 机械半边已预填——逐 task 解析 TaskCard acceptance（frontmatter）、双源结构归属测试文件（allowed_paths 测试模式 ∪ execute review changedFiles 中 test/ 路径）、关键词命中提示（命中≠判定，仅提示）。你逐行填判定槽四枚举（covered / partial / uncovered / non-testable——non-testable 是文档/部署类显式逃生门）与证据：covered/partial 附测试锚点（`.test.` 文件或 file:line），non-testable 附一句理由；判定或证据未填 fail-closed，阻断 verify `--done`。与探针 3 口径差异：探针 3 查模块目录有没有测试文件（存在性面），探针 7 查每条 acceptance 由哪些测试承接（承接面）；两者并排冲突以 7 为准。

package/.patch16-tmp.mjs

@@ -1,169 +0,0 @@
-import { readFileSync, writeFileSync, rmSync } from 'node:fs'
-
-// ── ① task-review.js：四 writer provenance 戳 + emptyDiff 报错直显 ──
-{
-  const f = 'src/task-review.js'
-  let t = readFileSync(f, 'utf8')
-
-  // helper（放 REVIEW_SCHEMA_VERSION 常量后）
-  const a0 = "export const REVIEW_SCHEMA_VERSION = 1"
-  const b0 = `export const REVIEW_SCHEMA_VERSION = 1
-
-/**
- * review.json 写入溯源戳（坑 review-json-mystery-overwrite，2026-09-12 驾驭第十七批①，
- * 用户实证 task-04 review 被覆写成空壳、gate 报零改动伪造重写恢复——四个 writer 均有
- * 覆盖守卫，无堆栈钉不死覆写者）：每次写入附 writtenBy（写入通道 + PID）+ writtenAt，
- * emptyDiff 伪造 error 直显两字段——下次复现自曝身份，事后可归因。
- */
-export function reviewProvenanceStamp(channel) {
-  return { writtenBy: \`\${channel}#pid\${process.pid}\`, writtenAt: new Date().toISOString() }
-}`
-  if (!t.includes(a0)) { console.error('a0 missing'); process.exit(1) }
-  t = t.replace(a0, b0)
-
-  // writer 1/2：两处 draft（reviewerNotes 行后追加 stamp 到对象）——draft 对象构造尾
-  const a1 = `      if (draftRepo) draft.repo = draftRepo
-      // fail-open（对齐函数头契约 + execute-run-dir-fail-loud 测试锁定的「写失败返回统计不抛」）：
-      // 无归属草稿写入失败（如 tasks/ 被普通文件占位 ENOTDIR）降级 skipped，不崩整个草稿生成
-      try {
-        mkdirSync(reviewDir, { recursive: true })
-        writeFileSync(reviewPath, JSON.stringify(draft, null, 2) + '\\n')`
-  const b1 = `      if (draftRepo) draft.repo = draftRepo
-      Object.assign(draft, reviewProvenanceStamp('generateTaskReviewDrafts:no-attribution'))
-      // fail-open（对齐函数头契约 + execute-run-dir-fail-loud 测试锁定的「写失败返回统计不抛」）：
-      // 无归属草稿写入失败（如 tasks/ 被普通文件占位 ENOTDIR）降级 skipped，不崩整个草稿生成
-      try {
-        mkdirSync(reviewDir, { recursive: true })
-        writeFileSync(reviewPath, JSON.stringify(draft, null, 2) + '\\n')`
-  if (!t.includes(a1)) { console.error('a1 missing'); process.exit(1) }
-  t = t.replace(a1, b1)
-
-  const a2 = `    if (draftRepo) draft.repo = draftRepo
-    mkdirSync(reviewDir, { recursive: true })
-    writeFileSync(reviewPath, JSON.stringify(draft, null, 2) + '\\n')
-    generated++
-  }`
-  const b2 = `    if (draftRepo) draft.repo = draftRepo
-    Object.assign(draft, reviewProvenanceStamp('generateTaskReviewDrafts'))
-    mkdirSync(reviewDir, { recursive: true })
-    writeFileSync(reviewPath, JSON.stringify(draft, null, 2) + '\\n')
-    generated++
-  }`
-  if (!t.includes(a2)) { console.error('a2 missing'); process.exit(1) }
-  t = t.replace(a2, b2)
-
-  // writer 3：adopt（merged 写回前）
-  const a3 = `    try {
-      if (mechanicsChanged || verdictTouched || evidenceFilled) {
-        writeFileSync(reviewPath, JSON.stringify(merged, null, 2) + '\\n')`
-  const b3 = `    try {
-      if (mechanicsChanged || verdictTouched || evidenceFilled) {
-        Object.assign(merged, reviewProvenanceStamp('adoptTaskReviewMechanics'))
-        writeFileSync(reviewPath, JSON.stringify(merged, null, 2) + '\\n')`
-  if (!t.includes(a3)) { console.error('a3 missing'); process.exit(1) }
-  t = t.replace(a3, b3)
-
-  // writer 4：writeTaskReview（schema 自检前）
-  const a4 = `  const schemaResult = validateReviewSchema(review)
-  if (!schemaResult.ok) {
-    return { ok: false, errors: schemaResult.errors, warnings }
-  }
-  try {
-    mkdirSync(reviewDir, { recursive: true })
-    writeFileSync(reviewPath, JSON.stringify(review, null, 2) + '\\n')`
-  const b4 = `  Object.assign(review, reviewProvenanceStamp('writeTaskReview' + (force ? ':force' : '')))
-  const schemaResult = validateReviewSchema(review)
-  if (!schemaResult.ok) {
-    return { ok: false, errors: schemaResult.errors, warnings }
-  }
-  try {
-    mkdirSync(reviewDir, { recursive: true })
-    writeFileSync(reviewPath, JSON.stringify(review, null, 2) + '\\n')`
-  if (!t.includes(a4)) { console.error('a4 missing'); process.exit(1) }
-  t = t.replace(a4, b4)
-
-  // emptyDiff 报错直显 provenance（validateTaskReviews 两处 emptyDiff error）
-  const a5 = `          errors.push(\`\${taskId}: base..head（\${review.base.slice(0, 8)}..\${review.head.slice(0, 8)}）无任何代码变更 — 评审了一个零改动的任务，review 疑似伪造\${scopeNote}\`)`
-  const b5 = `          const prov = (review.writtenBy || review.writtenAt) ? \`［写入溯源：\${review.writtenBy || '?'} @ \${review.writtenAt || '?'}］\` : '［无写入溯源—— older writer 产物］'
-          errors.push(\`\${taskId}: base..head（\${review.base.slice(0, 8)}..\${review.head.slice(0, 8)}）无任何代码变更 — 评审了一个零改动的任务，review 疑似伪造\${scopeNote}\${prov}\`)`
-  if (!t.includes(a5)) { console.error('a5 missing'); process.exit(1) }
-  t = t.replace(a5, b5)
-
-  writeFileSync(f, t)
-  console.log('provenance ok')
-}
-
-// ── ② gate-snapshot.js：symlink-store 布局探测 → null 回退 ──
-{
-  const f = 'src/run/gate-snapshot.js'
-  let t = readFileSync(f, 'utf8')
-  const a = `export function createGateSnapshot({ cwd, files, sourceRoot = null }) {
-  let snapshotRoot = null
-  try {
-    // 前置：主仓须是 git 仓且有 HEAD（无 git 环境回退主仓现行为）
-    git(cwd, ['rev-parse', 'HEAD'])`
-  const b = `export function createGateSnapshot({ cwd, files, sourceRoot = null }) {
-  let snapshotRoot = null
-  try {
-    // 前置：主仓须是 git 仓且有 HEAD（无 git 环境回退主仓现行为）
-    git(cwd, ['rev-parse', 'HEAD'])
-
-    // symlink-store 布局探测（坑 gate-snapshot-pnpm-store-break，2026-09-12 驾驭第十七批②，
-    // 用户第三次踩「lint 沙箱临时目录跑 pnpm 必假败」）：pnpm/bun/lerna 的 node_modules 内部
-    // 是指向 store 的相对/绝对符号链接网——junction 进临时目录后跨根解析失效，实测必假败。
-    // 与其让沙箱报无关错误逼 advisory，不如布局命中即作废快照回退主仓（宁可主仓口径）。
-    const layoutHit = detectSymlinkStoreLayout(cwd)
-    if (layoutHit) {
-      console.warn(\`⚠️ 门禁快照对 \${layoutHit} 布局不可靠（node_modules 符号链接 store 经 junction 跨根失效，实测必假败）——跳过快照回退主仓实测；主仓失败再做污染归属鉴定\`)
-      return null
-    }`
-  if (!t.includes(a)) { console.error('layout anchor missing'); process.exit(1) }
-  t = t.replace(a, b)
-
-  const helper = `
-/** symlink-store 包管理布局探测：命中即 junction 快照不可靠。返回布局名或 null。 */
-export function detectSymlinkStoreLayout(cwd) {
-  try {
-    if (existsSync(join(cwd, 'pnpm-lock.yaml'))) return 'pnpm'
-    if (existsSync(join(cwd, 'bun.lockb')) || existsSync(join(cwd, 'bun.lock'))) return 'bun'
-    if (existsSync(join(cwd, 'lerna.json'))) return 'lerna'
-    try {
-      const pkg = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'))
-      const pm = pkg && pkg.packageManager ? String(pkg.packageManager) : ''
-      if (/pnpm@/.test(pm)) return 'pnpm(packageManager)'
-      if (/yarn@/.test(pm)) return 'yarn(packageManager)'
-      if (/bun@/.test(pm)) return 'bun(packageManager)'
-    } catch { /* 无 package.json/损坏 → 仅锁文件判据 */ }
-    return null
-  } catch { return null }
-}
-`
-  const anchor = '/**\n * 环境目录名集（根与子包通用） */'
-  if (!t.includes(anchor)) { console.error('helper2 anchor missing'); process.exit(1) }
-  t = t.replace(anchor, helper + '\n' + anchor)
-  writeFileSync(f, t)
-  console.log('layout ok')
-}
-
-// ── ③ verify-probes.js：probe1 剥 NEW: 前缀 ──
-{
-  const f = 'src/verify-probes.js'
-  let t = readFileSync(f, 'utf8')
-  const a = `    let abs = join(cwd, e.path)
-    if (!existsSync(abs)) {
-      const wtAbs = wtRoot ? join(wtRoot, e.path) : null`
-  const b = `    // NEW: 待建前缀剥离（坑 probe1-new-prefix-miss，2026-09-12 驾驭第十七批③，用户实证
-    // 「NEW: 前缀文件已合入主仓」时 existsSync(join(cwd,'NEW:src/x')) 恒 miss 落 skippedFiles
-    // 留 ⚠️ 噪声）：design 清单的 NEW: 是「新建意图」标记，文件 apply 后已是无前缀实体——
-    // 探针按目标文件扫（与 pathMatches 比对侧剥除同源）。
-    const probePath = String(e.path).replace(/^NEW:\\s*/, '')
-    let abs = join(cwd, probePath)
-    if (!existsSync(abs)) {
-      const wtAbs = wtRoot ? join(wtRoot, probePath) : null`
-  if (!t.includes(a)) { console.error('probe anchor missing'); process.exit(1) }
-  t = t.replace(a, b)
-  writeFileSync(f, t)
-  console.log('probe ok')
-}
-
-rmSync('.patch16-tmp.mjs', { force: true })

package/sa-rename-probe/src/new.js

@@ -1,4 +0,0 @@
-a
-b
-c
-d