progmune-runtime 3.7.31 → 3.7.35

package/CHANGELOG.md

@@ -1,5 +1,110 @@
 # Changelog
 
+## [3.7.35] — 2026-09-19
+
+### 重建盲测覆盖：taintpath 语料族（TS 795 空过的终结）
+
+TS 795 盲测对「路径穿越标记」**连续三次零覆盖**——语料里没有任何
+`不可信根 → 文件 sink` 的流，`__progmune_path_traversal__` 出现次数前 0 后 0。
+于是「3086 flags LOST 0 / ADDED 0」这道硬门在这项能力上一直是空过（3.7.32/33/34
+三次验收都把它当作证据）。
+
+- 新增语料族 `generated/taintpath_A`（HTTP 请求面）与 `taintpath_B`
+  （MCP 工具实参面 + 跨文件/跨函数传播），共 24 条期望
+- 新增生成器 `blind-benchmark/generate-projects-taintpath.ts`
+  （**只写自己前缀**，不像 generate-projects.ts 那样清理含 `_` 的目录）
+- 新增闸门 `blind-benchmark/check-taintpath.ts` + 期望表
+  `blind-benchmark/taintpath-expectations.json`：逐函数断言
+  mark / suppressed / no-taint / known-gap 四类，退出码非 0 即失败
+- 覆盖力：`__progmune_path_traversal__` **0 → 15 次**；24/24 符合期望
+- 已有 100 个项目零漂移：LOST 0 / ADDED 0（总数 3086 → 3109，增量全部来自新语料）
+- 升级为方法学规则 **R7-no-vacuous-gate**
+
+### C5：不可信根可以直连 sink（召回）
+
+此前外层要求 `collectTaintedNames` 非空，因此
+`fs.readFileSync("/data/" + req.params.name)` —— 真实 Express 工程最常见的形态
+——不标记，只有先赋给局部变量才标记。SSRF 侧从来不要求中间变量，这是同一条
+数据流上的又一处口径不一致，与 G1 同类。改为：先看 sink 实参窗口有没有污点证据（taint 模式本来就含不可信根），
+跨函数传播仍须有具名污点。
+
+- `src/extract-ir-taint-structural.test.ts` 新增 6 条（4 正 + 2 负对照）
+- 反向验证：回退 v3.7.34 后其中 4 条失败、2 条负对照仍绿
+- fr-007 真实语料维持 pre 5 / post **0**（C5 只补召回，未削弱 G1 判别力）
+
+### 本次暴露、尚未修的两处缺口（已进语料，作为下一轮的验收对象）
+
+- **C4**：污点经表达式包装（`path.join/resolve/normalize/basename`）后不传播。
+  语料里 readBasename / readResolveOnly / readJoinWrapped / readNormalizeWrapped
+  四条语义上应标记、实测不标记，记为 known-gap（闸门会盯着，一旦补上就提醒更新）
+- **G2**（反向）：自定义校验函数名不含路径语义后缀时调用点不被抑制。语料里
+  `dispatchToolGuarded` 调了 `assertTemplateName()`（函数体内有字符集白名单），
+  仍被标记——因为 `Name` 后缀在修 ensureDir 误判时被移出了守卫词表
+
+## [3.7.34] — 2026-09-19
+
+### G1 PATH_GUARD_EVIDENCE —— 路径穿越的「校验识别」
+
+路径穿越标记此前是 `taint → 文件 sink ⇒ 标记`，**不看中间有没有校验**；SSRF 侧
+不是这样（`taint → fetch sink 且无 SSRF_GUARD_EVIDENCE ⇒ 标记`）。两侧数据流同构、
+判别力差一档——这正是根集合不敢放宽的真正原因（fr-012/fr-015 的 MISS 由此从
+「词表缺口」升级为「机制缺口」）。本版把路径侧改成与 SSRF 对齐：
+**`taint → 文件 sink 且无校验证据 ⇒ 标记`**。
+
+守卫形态的种子全部来自语料真实修复，逐条可追溯：
+
+- **G-A 目录包含性**：`resolve(p).startsWith(resolve(root))`、`x.startsWith(baseDir)`
+- **G-B 上跳/绝对路径拒绝**：`path.isAbsolute`、`startsWith(".."+sep)`、`=== ".."`
+  （种子 = fr-012 gitlab-mcp 下载侧 `localPath` 既有守卫块，index.ts:7968-7977）
+- **G-C 独立校验函数**：`assertValidFlowId`（fr-007 openhop）/ `assertWithinDir`（fr-016 Redocly）
+  —— 含向调用方**有界传播 3 跳**：校验被抽进被调用函数时，调用方一个校验词汇都没有
+- **G-D 锚定字符集白名单**：`/^[A-Za-z0-9_-]+$/`（fr-007 `FLOW_ID_PATTERN`）
+
+明确**不算**守卫：`path.basename`（fr-012 pre 实测反例，漏洞态就有它）、
+单独出现的 `join`/`resolve`、长度检查、`if (!p) throw`。
+
+**验收**
+
+- fr-007 openhop 真实语料：**pre 5 条 / post 0 条** —— 真实语料上首次出现
+  「修复后流消失」的判别力证据（G1 之前是 5 / 5）
+- `src/extract-ir-taint-guard.test.ts` 14 passed；反向验证回退 3.7.33 后 5 条失败
+- TS 795 盲测 3086 flags LOST 0 / ADDED 0 —— ⚠️ **空过**：盲测语料里
+  `__progmune_path_traversal__` 出现 0 次，无覆盖；真正的门是 fr-007 与定向用例
+- `tsc -p tsconfig.json` 零错误
+
+**实现期修掉的两个反例**（都写进代码注释与方法学规则）：
+
+1. `ensureDir()` / `isDirectory()` 曾被 G-C 误判为守卫（后缀 `Dir`），导致 fr-007
+   pre 侧 5 条被压成 0、召回归零。已移除 `Dir`/`Name` 后缀并加显式反例名单
+2. 「不得标记」类断言会**假通过**：污点经 `path.join(x)` 包装后不再传播，
+   sink 处根本没污点。已定为方法学规则 **R6**：负向断言必须配同形状正对照
+
+## [3.7.33] — 2026-09-19
+
+### 污点标记管线三处结构性修复（C1/C2/C3，正确性修复，不改变判别逻辑）
+
+从「污点源数据流试点 V1」拆出的**独立正确性条目**——它们只解决「看得见」，
+不解决「看得懂」（判别力是 `PATH_GUARD_EVIDENCE`，另一个条目，尚未实现）。
+
+- **C3 污点根按传输面声明**（`UNTRUSTED_ROOTS`）：此前整条链路只锚 Express 形态的 `req|request.(params|query|body|headers|cookies)`，即**根集合只有一种来源**。MCP 工具实参（`params.arguments`）、CLI 参数等来源天然不可见（fr-012 的 `args.file_path`）。改为按传输面声明根，每条附 `why`，不再靠补变量名清单打地鼠
+- **C1 sink 形参表纳入顶层函数**：`methodSinkParamMap` 此前只遍历 `sf.getClasses()`，真实 TS 工程大量使用顶层函数声明（MCP handler / Nuxt runtime binding），跨函数一跳对它们完全不生效——fr-012 的 `markdownUpload` 正因如此从未入表
+- **C2 跨函数传播识别裸调用**：调用匹配此前要求 `obj.sink(`（成员调用），新增 `directCallRe` 覆盖 `func(` 形态
+- **验收**：
+  - TS 795 盲测 **3086 flags LOST 0 / ADDED 0**
+  - ⚠️ **但这是空过（vacuous pass）**：实测整份 generated 语料重跑后 per-function calls 差异 **0**、`__progmune` 标记 **826 vs 826**——盲测语料根本走不到这三个分支。真正的门是新增的定向用例
+  - 新增 `src/extract-ir-taint-structural.test.ts` **6 green**；**反向验证**：把 `src/extract-ir.ts` 回退到 3.7.32 后其中 **3 项失败**（MCP 根 / 顶层函数 / 裸调用），确认这三个用例真的锁住了行为，而非同义反复。另 3 项（Express 旧语义仍标记、常量路径不标记、常量裸调用不标记）在修复前后均通过——它们锁的是「不得回归 / 不得过度标记」
+- **行为边界**：本条目**不**改变判别逻辑。路径穿越侧仍无「校验识别」，因此放宽根集合后对已校验流同样会标记——这正是试点 V1 记录为未过验收的原因，由后续 `PATH_GUARD_EVIDENCE` 解决
+
+## [3.7.32] — 2026-09-19
+
+### IR 陈旧性判定（两次会话级误判的根因修复）
+
+- **断点**：trust 引擎自动提取是「缺才提取」——项目已有 ir.json 就以文件为准不重生成。源码改了、ir.json 没更新时静默吃旧 IR：fr-005 首扫报 0（`rm ir.json` 后才报出）、污点试点「标记注入但 trust 报 0」同源
+- **修复**（`src/ir-staleness.ts` + `src/trust/engine.ts` 集成）：mtime 比对——仅当有源码新于 ir.json 才重提，不做每次全量重提（skyvern 级项目 5-10 分钟成本）
+- **三档策略 `PROGMUNE_IR_REEXTRACT`**：auto（陈旧 + 遍历完整 + 源码 ≤5000 文件才自动重提，否则**只警告不重提**）／always（语料复测自担成本）／never（旧语义，但必须打「IR 可能陈旧」警告——**不接受静默**）
+- **双闸设计**：完整遍历（不做「找到就早退」——早退会抹掉 truncated 信号，本仓库 22k 源文件实测会把单测推过 30s 超时）+ evidenceComplete + 规模预算闸；stat 一次遍历的常量成本换可靠的 fresh 判定
+- **验收**：`src/ir-staleness.test.ts` 12 green + DSH 陷阱回归 + SSRF 死循环锁 35 passed；**TS 795 零漂移（3086 LOST 0/ADDED 0）**；build ✓
+
 ## [3.7.31] — 2026-09-18
 
 ### 提取器 SSRF 标记正则死循环修复（P0，真实工程可用性故障）

package/dist/extract-ir-taint-guard.test.js

@@ -0,0 +1,372 @@
+"use strict";
+/**
+ * G1 PATH_GUARD_EVIDENCE —— 路径穿越「校验识别」的定向回归（2026-09-19）。
+ *
+ * 立项背景：路径穿越标记此前是 `taint → file sink ⇒ 标记`，**不看中间有没有
+ * 校验**；SSRF 侧不是这样（无 SSRF_GUARD_EVIDENCE 才标记）。两侧数据流同构、
+ * 判别力差一档——这正是根集合不敢放宽的真正原因（fr-012/fr-015 的 MISS 由此
+ * 从「词表缺口」升级为「机制缺口」）。
+ *
+ * G1 把路径侧改成与 SSRF 对齐：`taint → file sink 且无校验证据 ⇒ 标记`。
+ *
+ * 本文件的每条正例/反例都锚定到**语料里真实存在的一段代码**，不是凭空造的词表：
+ *   - fr-007 openhop  `assertValidFlowId(id)`（fix 才出现，G-C）
+ *   - fr-012 gitlab-mcp  下载侧 localPath 守卫块（pre/post 同一段，G-B）
+ *   - fr-016 Redocly  `assertWithinDir(openapiDir, pathFile, pathName)`（G-C）
+ *   - fr-012 pre 实测反例：`path.basename` 在漏洞态就在（N-A）
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const extract_ir_1 = require("./extract-ir");
+const TSCONFIG = JSON.stringify({
+    compilerOptions: {
+        target: "ES2020",
+        module: "commonjs",
+        moduleResolution: "node",
+        strict: false,
+        skipLibCheck: true,
+        noEmit: true,
+    },
+    include: ["**/*.ts"],
+});
+function makeProject(files) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-taint-guard-"));
+    fs.writeFileSync(path.join(dir, "tsconfig.json"), TSCONFIG);
+    fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: "fixture", version: "0.0.0", private: true }));
+    for (const [rel, body] of Object.entries(files)) {
+        const abs = path.join(dir, rel);
+        fs.mkdirSync(path.dirname(abs), { recursive: true });
+        fs.writeFileSync(abs, body);
+    }
+    return dir;
+}
+function marksFor(dir, fnName) {
+    const fns = (0, extract_ir_1.extractIR)(dir);
+    const f = fns.find((x) => x.name === fnName);
+    return f ? (f.calls ?? []) : [];
+}
+const PATH_MARK = "__progmune_path_traversal__";
+(0, vitest_1.describe)("G1 基线：无校验证据时必须照旧标记（不得因加判别力而失召回）", () => {
+    (0, vitest_1.it)("taint → 文件 sink，全程无校验 → 标记", () => {
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+  return fs.readFileSync("/data/" + name, "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+(0, vitest_1.describe)("G-B：上跳/绝对路径拒绝（种子=fr-012 gitlab-mcp 下载侧 localPath 守卫块）", () => {
+    // index.ts:7968-7977 —— pre 与 post 完全一致的一段既有守卫。
+    // 它不能当「修复形态种子」，但它是真实世界的「已校验」样本。
+    //
+    // ⚠️ 写法约束（踩过坑）：污点必须**直接出现在 sink 实参窗口里**。
+    // 「污点经 path.normalize(x) / path.join(x) 包装后仍传播」是另一条独立的
+    // 传播缺口（C4，见文末已知边界）—— 若让污点先被包装再进 sink，
+    // 「不得标记」会**假通过**（污点压根没到 sink，与守卫无关）。
+    // 故本组用例让 sink 直接使用污点名，守卫块则照抄真实代码。
+    const GUARD_BLOCK = `
+    const normalizedLocalPath = path.normalize(localPath);
+    if (
+      path.isAbsolute(normalizedLocalPath) ||
+      normalizedLocalPath === ".." ||
+      normalizedLocalPath.startsWith(".." + path.sep) ||
+      normalizedLocalPath.includes(path.sep + ".." + path.sep)
+    ) {
+      throw new Error("Invalid local_path: directory traversal is not allowed.");
+    }
+`;
+    const wrap = (guard) => `
+import * as fs from "fs";
+import * as path from "path";
+export function save(req: any, buffer: any) {
+  const localPath = req.params.local_path;
+${guard}  fs.writeFileSync(localPath, buffer);
+}
+`;
+    (0, vitest_1.it)("去掉守卫块后必须标记（正对照：证明这条用例真的锁住了判别力）", () => {
+        const dir = makeProject({ "a.ts": wrap("") });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "save")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("真实守卫块存在时不得标记", () => {
+        const dir = makeProject({ "a.ts": wrap(GUARD_BLOCK) });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "save")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+(0, vitest_1.describe)("G-C：独立校验函数（种子=fr-007 openhop / fr-016 Redocly）", () => {
+    // fr-007 的修复形态：把 assertValidFlowId(id) 放进 filePath()，
+    // 真正含 sink 的 get/save 与外层 flowRoutes 里一个校验词汇都没有
+    // —— 只看函数体等于没做，必须向调用方传播。
+    const BASE = `
+import * as fs from "fs";
+import * as path from "path";
+export class FlowStore {
+  private dir = "/data";
+  private filePath(id: string): string {
+    PATHIDGUARD
+    return path.join(this.dir, id + ".yaml");
+  }
+  async get(id: string) {
+    return fs.readFileSync(this.filePath(id), "utf-8");
+  }
+}
+export function flowRoutes(req: any, store: FlowStore) {
+  const id = req.params.id;
+  return store.get(id);
+}
+`;
+    (0, vitest_1.it)("pre（无校验函数）：含 sink 的方法与外层调用点都要标记", () => {
+        const dir = makeProject({ "a.ts": BASE.replace("PATHIDGUARD", "") });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "flowRoutes")).toContain(PATH_MARK);
+            (0, vitest_1.expect)(marksFor(dir, "FlowStore.get")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("post（fr-007 真修复形态 assertValidFlowId）：两侧都不得标记", () => {
+        const dir = makeProject({
+            "flow-id.ts": `
+export function assertValidFlowId(id: string): void {
+  if (!/^[A-Za-z0-9_-]+$/.test(id)) { throw new Error("Invalid flow id: " + id); }
+}
+`,
+            "a.ts": BASE.replace("PATHIDGUARD", "assertValidFlowId(id);"),
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "flowRoutes")).not.toContain(PATH_MARK);
+            (0, vitest_1.expect)(marksFor(dir, "FlowStore.get")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("fr-016 Redocly 形态 assertWithinDir：不得标记", () => {
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+import * as path from "path";
+// 同上：让污点直接进 sink 实参窗口，避免假通过
+export function iteratePathItems(req: any, openapiDir: string, outDir: string) {
+  const pathName = req.params.name;
+  assertWithinDir(openapiDir, path.join(outDir, pathName) + ".yaml", pathName);
+  fs.writeFileSync(path.join(outDir, pathName) + ".yaml", "x");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "iteratePathItems")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+(0, vitest_1.describe)("G-A：目录包含性校验（canonical 形态）", () => {
+    const wrap = (guard) => `
+import * as fs from "fs";
+import * as path from "path";
+export function read(req: any) {
+  const name = req.params.name;
+  const baseDir = path.resolve("/data");
+  const target = path.resolve(baseDir, name);
+${guard}  return fs.readFileSync(path.join(baseDir, name), "utf-8");
+}
+`;
+    (0, vitest_1.it)("去掉包含性判断后必须标记（正对照）", () => {
+        const dir = makeProject({ "a.ts": wrap("") });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("resolve + startsWith(baseDir) → 不得标记", () => {
+        const dir = makeProject({
+            "a.ts": wrap(`  if (!target.startsWith(baseDir)) { throw new Error("outside"); }\n`),
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+(0, vitest_1.describe)("G-D：锚定字符集白名单（种子=fr-007 FLOW_ID_PATTERN）", () => {
+    const wrap = (guard) => `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+${guard}  return fs.readFileSync("/data/" + name, "utf-8");
+}
+`;
+    (0, vitest_1.it)("去掉白名单校验后必须标记（正对照）", () => {
+        const dir = makeProject({ "a.ts": wrap("") });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("/^[A-Za-z0-9_-]+$/ 参与校验 → 不得标记", () => {
+        const dir = makeProject({
+            "a.ts": wrap(`  if (!/^[A-Za-z0-9_-]+$/.test(name)) { throw new Error("bad id"); }\n`),
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+(0, vitest_1.describe)("反例清单：这些形态**不算**守卫（N-A 是头号陷阱）", () => {
+    (0, vitest_1.it)("N-A path.basename —— fr-012 pre 实测反例：漏洞态就有 basename，必须照旧标记", () => {
+        // 注意：污点直接写进 sink 实参窗口（不经 `const x = path.basename(...)` 赋值），
+        // 因为「污点经表达式包装后仍传播」是另一条独立的传播缺口（见文末已知边界），
+        // 本用例只锁「basename 是否算守卫」这一件事。
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+import * as path from "path";
+export function read(req: any) {
+  const name = req.params.name;
+  return fs.readFileSync("/data/" + path.basename(name), "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("N-B 单独出现的 join/resolve —— 拼接本身不阻止上跳，必须标记", () => {
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+import * as path from "path";
+export function read(req: any) {
+  const name = req.params.name;
+  return fs.readFileSync(path.resolve("/data", name), "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("N-C 长度检查 —— 无法阻止上跳，必须标记", () => {
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+  if (name.length > 100) { throw new Error("too long"); }
+  return fs.readFileSync("/data/" + name, "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("N-D 空值检查 —— 空值检查 ≠ 路径包含性检查，必须标记", () => {
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+  if (!name) { throw new Error("missing"); }
+  return fs.readFileSync("/data/" + name, "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+/**
+ * ── 已知边界（本次写用例时实测踩到，记录以免后人重复踩）──
+ *
+ * C4：污点经表达式包装后不再传播。
+ *   `const q = path.normalize(x)` / `path.join(x)` / `path.basename(x)` 之后，
+ *   q **不在** tainted 集合里（collectTaintedNames 的单跳只认 `= <name>` 直赋）。
+ *   后果有二：
+ *     ① 召回缺口（这是 C 组的事，本条目不修）；
+ *     ② **测试陷阱**：写「不得标记」类用例时，若污点被包装后再进 sink，
+ *        用例会**假通过**——不是守卫生效，是污点压根没到 sink。
+ *   因此本文件所有 `not.toContain` 用例都配了一条同形状的正对照
+ *   （去掉守卫后必须重新标记），缺了正对照的负向断言一律视为无效。
+ *   本轮就有 3 条用例最初因此假通过（G-A / G-D / fr-016 形态）。
+ */