progmune-runtime 3.7.35 → 3.7.37

package/CHANGELOG.md

@@ -1,5 +1,98 @@
 # Changelog
 
+## [3.7.37] — 2026-09-19
+
+### G2：自定义校验函数的调用点抑制（判别力）
+
+缺口实证（taintpath_B `dispatchToolGuarded`，measured）：
+
+```ts
+assertTemplateName(args.name);   // 函数体内是 /^[A-Za-z0-9_-]+$/ —— 真校验
+return loadTemplate(args.name);  // 仍被标记（误报）
+```
+
+`assertTemplateName` 名字不含路径语义后缀——`Name` 在修 `ensureDir()` 误判时被
+整体移出了 G-C 后缀表，于是调用点侧认不出来。这是 G1 收紧词表的已知代价。
+
+修法**不是**把 `Name` 加回词表（那是按名字猜语义，G-C 已经为这份宽松付过代价：
+fr-007 pre 侧召回归零），而是看**被调用方函数体内到底有没有校验证据**：
+
+- `pathGuardFunctionNames` 拆两档：tier-0 `direct`（自身含证据）/ tier-1+ `all`（推断）
+- `collectSanitizedExprs`：被调用方属 tier-0 ⇒ 把调用实参里的取值表达式收进
+  「已净化」集合；sink 实参命中污点但已被净化 ⇒ 不算污点
+
+### 三处精度取舍（全部比 G1 的函数级 selfGuarded 窄）
+
+| 取舍 | 说明 |
+|---|---|
+| 表达式级，非函数级 | G1 是一个校验词汇压掉整个函数体的所有流；G2 只净化被传进守卫调用的那个表达式，同函数体里另一条未校验的流仍标记 |
+| 只认 tier-0 | 推断出来的守卫不用于抑制 —— 升为方法学规则 **R9-no-inferred-suppression**（抑制不可逆，压掉的真阳性不会出现在任何回归统计里） |
+| 前缀 `(?:^\|[^\w$.])` | 净化 `name` 不连坐 `other.name`；但 `args.name` 能命中 `path.join(DIR, args.name)` |
+
+### 验收
+
+- taintpath 闸门 **24/24**（`dispatchToolGuarded` mark → suppressed；正对照
+  `dispatchToolBare` 仍 mark）
+- **fr-007 openhop 真实语料维持 pre 5 / post 0** —— G2 未压掉真阳性
+- TS 盲测（102 项目）：**LOST 1 / ADDED 0**，唯一变化就是本条；覆盖力 19 → 18
+- `extract-ir-taint-guard.test.ts` 新增 G2 组 6 条（含正/负对照，R6）
+- 反向验证：回退 v3.7.36 后 G2 两条正例失败，其余 18 条仍绿
+- 新增 `blind-benchmark/check-fr-corpus.ts` —— 把 fr-007 的 pre/post 复测固化成
+  一条命令；快照置于 `blind-benchmark/fr-corpus/`（**受保护资产**，不再放 /tmp）
+
+### 已知缺口 G2b
+
+经项目自有 helper 转手的校验证据不生效（`checkName(n)` 内部再调守卫函数）——
+只认 tier-0 的代价，与 C4b 同族。缺口是可见的（仍有误报），压掉的真阳性不可见。
+
+## [3.7.36] — 2026-09-19
+
+### C4：污点经路径塑形表达式包装后仍传播
+
+缺口实证（taintpath_A，measured）：`readBasename` / `readResolveOnly` /
+`readJoinWrapped` / `readNormalizeWrapped` 四条语义上应标记、实测不标记——
+传播只认 `x = <污点>` 直赋，而 `path.join/resolve/normalize/basename` 是真实
+工程构造路径的**默认写法**，这条断链等于把最常见形态整片漏掉。
+
+政策是**白名单传播**，不是「RHS 含污点就传播」：
+- 只经 path.* 家族与保值的字符串方法（trim/replace/…）传播；拼接与模板字面量
+  同样只塑形、不改来源；有界迭代 3 跳（`normalize → join` 这类链式能接上）
+- **认不出的调用不传播** ⇒ `const safe = sanitizeName(p)` 天然不污染。
+  未知函数默认站在精度一侧——这是白名单相对黑名单的决定性优势
+- 代价（记为缺口 C4b）：项目自有 helper（如 `buildPath(p)`）仍不传播
+
+### 两处必须一并改的「假通过」（C4 把它们顶出来了）
+
+C4 之前，下列用例的「不标记」**不是因为判别力对，而是污点根本没走到 sink**
+——方法学规则 R7 的第二种形态。C4 一放开它们就会翻成误报：
+
+1. **G-A2 漏 `startsWith(base)`**：原正则要求标识符在 base/root/dir 之外还有
+   前导字符，最朴素的 `target.startsWith(base)` 匹配不上。改为取出整个实参再
+   判定，并加 `database` 等反例名单（`database` 以 base 结尾但与目录无关）
+2. **G-A2 漏字符串字面量形态**：`startsWith("/srv/data")` 同样匹配不上。
+   现支持绝对路径字面量（长度 >1，排除 `startsWith("/")`——那只是判绝对路径）
+
+### 闸门改为实时提取（第二处空过）
+
+`check-taintpath.ts` 原默认读 `reports/batch-scan-results.json`——那是别人跑
+batch-scan 留下的**陈旧产物**。实测踩到：C4 落地后 4 条 known-gap 已翻正，
+闸门仍报「未标记，符合预期」。已改为默认对 `generated/taintpath_*` 实时跑
+extractIR（需走报告时显式 `--report`）。
+
+### 验收
+
+- taintpath 闸门 **24/24，失败 0、缺口闭合待更新 0**；4 条 known-gap 转 mark
+- fr-007 openhop 真实语料维持 **pre 5 / post 0** —— C4 只补召回，未削弱 G1 判别力
+- `extract-ir-taint-structural.test.ts` 新增 C4 组 11 条（7 正 + 4 负对照，R6）
+- 反向验证：回退 v3.7.35 后 **7 条正例全失败**，4 条负对照仍绿
+- 全组回归 72 passed；`tsc -p tsconfig.json` 零错误
+
+### 实现期踩的一个坑（已入注释）
+
+`taintedViaShaper` 最初写了 `if (tainted.size === 0) return`——而这 4 条
+known-gap 的共同形态恰恰是「全函数没有任何直赋污点」，等于整条 C4 不生效。
+种子是根模式（taintPattern 恒定并入 UNTRUSTED_ROOT_SRC），不该依赖已有污点。
+
 ## [3.7.35] — 2026-09-19
 
 ### 重建盲测覆盖：taintpath 语料族（TS 795 空过的终结）

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

@@ -356,6 +356,157 @@ export function read(req: any) {
         }
     });
 });
+(0, vitest_1.describe)("G2：调用点抑制 —— 按被调用方的实际证据定案（种子=taintpath_B assertTemplateName）", () => {
+    // 缺口形态（2026-09-19 measured，taintpath_B dispatchToolGuarded）：
+    //   `assertTemplateName(args.name); return loadTemplate(args.name);`
+    // `assertTemplateName` 函数体内是锚定字符集白名单（G-D），是真校验，
+    // 但它的名字不含路径语义后缀 —— `Name` 在修 `ensureDir()` 误判时被整体
+    // 移出了 G-C 守卫后缀表，于是调用点侧认不出来，仍被标记。
+    //
+    // G2 的修法不是把 `Name` 加回词表（那是按【名字】猜语义，G-C 已经为这份
+    // 宽松付过一次代价：fr-007 pre 侧召回归零），而是看**被调用方函数体内
+    // 到底有没有校验证据**。
+    //
+    // 精度取舍：净化作用在【表达式】上，不是整函数 —— 同函数体里另一条未被
+    // 校验的流仍会标记。这是 G2 相对 G1（函数级 selfGuarded）的收窄。
+    const body = (guardCall) => `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+${guardCall}  return fs.readFileSync("/data/" + name, "utf-8");
+}
+function assertTemplateName(name: string): void {
+  if (!/^[A-Za-z0-9_-]+$/.test(name)) throw new Error("bad template name");
+}
+`;
+    (0, vitest_1.it)("正对照：去掉自定义校验调用后必须标记", () => {
+        const dir = makeProject({ "a.ts": body("") });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("自定义校验函数（名字不含路径语义后缀）被调用 → 不得标记", () => {
+        const dir = makeProject({ "a.ts": body("  assertTemplateName(name);\n") });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("负对照：被调用方体内**没有**校验证据时，调用它不得抑制（不能见调用就净化）", () => {
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+  logIt(name);
+  return fs.readFileSync("/data/" + name, "utf-8");
+}
+function logIt(x: string): void { console.log(x); }
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("表达式级净化：同函数体里另一条未被校验的流仍要标记", () => {
+        // G1 的函数级 selfGuarded 会把整个函数体一起静默；G2 只净化真正被传进
+        // 守卫调用的表达式 —— 这条用例锁住这个差别。
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+  const other = req.params.other;
+  assertTemplateName(name);
+  fs.readFileSync("/data/" + name, "utf-8");
+  return fs.writeFileSync("/data/" + other, "x");
+}
+function assertTemplateName(name: string): void {
+  if (!/^[A-Za-z0-9_-]+$/.test(name)) throw new Error("bad template name");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("跨函数（taintpath_B 形态）：净化只发生在调用点，被调用方定义照旧被反标", () => {
+        // 语料里 `loadTemplate` 自身不含任何不可信根，它被标记是因为调用点命中了
+        // 跨函数一跳（onMethodHit 反标）。故本用例在同一文件里放两个几乎相同的
+        // 调用点 —— 一个净化、一个不净化 —— 才能同时锁住两侧。
+        const dir = makeProject({
+            "store.ts": `
+import * as fs from "fs";
+export function loadTemplate(p: string): string {
+  return fs.readFileSync("/srv/templates/" + p, "utf-8");
+}
+`,
+            "handler.ts": `
+import { loadTemplate } from "./store";
+export function dispatchToolGuarded(params: any) {
+  const args = params.arguments;
+  assertTemplateName(args.name);
+  return loadTemplate(args.name);
+}
+export function dispatchToolBare(params: any) {
+  const args = params.arguments;
+  return loadTemplate(args.name);
+}
+function assertTemplateName(name: string): void {
+  if (!/^[A-Za-z0-9_-]+$/.test(name)) throw new Error("bad template name");
+}
+`,
+        });
+        try {
+            // 净化侧：污点表达式已被校验 ⇒ 调用点不标记
+            (0, vitest_1.expect)(marksFor(dir, "dispatchToolGuarded")).not.toContain(PATH_MARK);
+            // 正对照：同形状去掉校验 ⇒ 照旧标记，且被调用方被反标
+            (0, vitest_1.expect)(marksFor(dir, "dispatchToolBare")).toContain(PATH_MARK);
+            (0, vitest_1.expect)(marksFor(dir, "loadTemplate")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("已知缺口 G2b：经项目自有 helper 转手的校验证据不生效（保守边界，仍标记）", () => {
+        // 只认 tier-0（函数体自身含校验证据）。经 helper 转手 ⇒ 那是【推断】出来
+        // 的守卫，拿推断结果做抑制会把推断误差直接放大成误报消除。
+        // 代价：这类形态仍会误报，与 C4b（helper 不传播）是同一族缺口。
+        const dir = makeProject({
+            "a.ts": `
+import * as fs from "fs";
+export function read(req: any) {
+  const name = req.params.name;
+  checkName(name);
+  return fs.readFileSync("/data/" + name, "utf-8");
+}
+function checkName(name: string): void {
+  assertTemplateName(name);
+}
+function assertTemplateName(name: string): void {
+  if (!/^[A-Za-z0-9_-]+$/.test(name)) throw new Error("bad template name");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "read")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
 /**
  * ── 已知边界（本次写用例时实测踩到，记录以免后人重复踩）──
  *

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

@@ -287,3 +287,159 @@ export function seedFlow() {
         }, 150000);
     }
 });
+// ═══════════════════════════════════════════════════════════════
+// C4（2026-09-19）：污点经「路径塑形表达式」包装后仍应传播
+//
+// 缺口实证：taintpath_A 的 readBasename / readResolveOnly / readJoinWrapped /
+// readNormalizeWrapped 四条，语义上应标记、实测不标记 —— 传播只认 `x = <污点>`
+// 直赋，而 `path.join/resolve/normalize/basename` 是真实工程构造路径的**默认
+// 写法**，这条断链等于把最常见的形态整片漏掉。
+//
+// 政策是**白名单传播**：只经 path.* 家族与保值的字符串方法传播，认不出的调用
+// 不传播。于是 `const safe = sanitizeName(p)` 天然不污染 —— 未知函数默认站在
+// 精度一侧。代价是项目自有 helper（buildPath(p)）仍不传播（缺口 C4b）。
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("C4：污点经路径塑形表达式包装后仍传播", () => {
+    const cases = [
+        {
+            name: "path.join 包装",
+            fn: "readJoin",
+            code: `export function readJoin(req: any) {
+  const target = path.join("/data", req.params.name);
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: true,
+            why: "最基础的塑形包装：join(root, taint) 不得断链",
+        },
+        {
+            name: "path.normalize 包装",
+            fn: "readNormalize",
+            code: `export function readNormalize(req: any) {
+  const target = path.normalize(req.params.name);
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: true,
+            why: "normalize 只规范化、不改变来源",
+        },
+        {
+            name: "path.basename 包装（N-A）",
+            fn: "readBasename",
+            code: `export function readBasename(req: any) {
+  const name = path.basename(req.params.name);
+  return fs.readFileSync("/data/" + name, "utf-8");
+}`,
+            expectMark: true,
+            why: "N-A：basename 不算守卫（fr-012 pre 实测反例），包装后污点仍须流动",
+        },
+        {
+            name: "resolve 无包含性比较（N-C）",
+            fn: "readResolveOnly",
+            code: `export function readResolveOnly(req: any) {
+  const base = path.resolve("/data");
+  const target = path.resolve(base, req.params.name);
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: true,
+            why: "N-C：只有 resolve、没有 startsWith(base) 比较，不算守卫",
+        },
+        {
+            name: "链式两跳塑形",
+            fn: "readChained",
+            code: `export function readChained(req: any) {
+  const norm = path.normalize(req.params.dir);
+  const target = path.join(norm, "index.html");
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: true,
+            why: "fr-012 下载侧就是这个形状：normalize → join 两跳，须接上",
+        },
+        {
+            name: "模板字面量拼接",
+            fn: "readTemplate",
+            code: `export function readTemplate(req: any) {
+  const target = \`/data/\${req.params.name}\`;
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: true,
+            why: "模板字面量只塑形、不改来源",
+        },
+        {
+            name: "字符串方法 trim（须先经 C4 才能到这一步）",
+            fn: "readTrim",
+            // 注意形态：不能写成 `const n = req.params.name.trim()` —— 那样根就在
+            // 开头、旧版也能标记，用例就失去判别力了（反向验证时实测通过，白锁一场）。
+            // 必须先经一次塑形调用，trim 才是 C4 链条上的第二跳。
+            code: `export function readTrim(req: any) {
+  const normalized = path.normalize(req.params.name);
+  const trimmed = normalized.trim();
+  return fs.readFileSync("/data/" + trimmed, "utf-8");
+}`,
+            expectMark: true,
+            why: "保值的字符串方法不得断链；本条同时验证 C4 的迭代（normalize → trim 两跳）",
+        },
+        // ── 负向：每一条都有同形状的正对照（方法学规则 R6）──
+        {
+            name: "负对照：守卫仍在（startsWith(base) 形态）",
+            fn: "readGuardWithinBase",
+            code: `export function readGuardWithinBase(req: any) {
+  const base = path.resolve("/data");
+  const target = path.resolve(base, req.params.name);
+  if (!target.startsWith(base)) throw new Error("outside");
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: false,
+            why: "正对照 = readResolveOnly（同形状去掉 startsWith 必须重新报出）",
+        },
+        {
+            name: "负对照：常量路径不因塑形而标记",
+            fn: "readConstantJoin",
+            code: `export function readConstantJoin() {
+  const target = path.join("/data", "index.html");
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: false,
+            why: "正对照 = readJoin（把 \"index.html\" 换成 req.params.name 必须报出）",
+        },
+        {
+            name: "负对照：未知 helper 不传播（白名单的精度代价，缺口 C4b）",
+            fn: "readUnknownHelper",
+            code: `function buildPath(name: string): string {
+  return "/data/" + name;
+}
+export function readUnknownHelper(req: any) {
+  const target = buildPath(req.params.name);
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: false,
+            why: "白名单外一律不传播（精度优先）；正对照 = readJoin 必须报出",
+        },
+        {
+            name: "负对照：净化函数不传播",
+            fn: "readSanitized",
+            code: `function sanitizeName(name: string): string {
+  return name.replace(/[^a-z0-9]/gi, "");
+}
+export function readSanitized(req: any) {
+  const safe = sanitizeName(req.params.name);
+  return fs.readFileSync("/data/" + safe, "utf-8");
+}`,
+            expectMark: false,
+            why: "未知（疑似净化）调用默认不传播——这是白名单相对黑名单的决定性优势",
+        },
+    ];
+    for (const c of cases) {
+        (0, vitest_1.it)(`${c.name} —— ${c.why}`, () => {
+            const dir = makeProject({ "a.ts": `import * as fs from "fs";\nimport * as path from "path";\n\n${c.code}\n` });
+            try {
+                const marks = marksFor(dir, c.fn);
+                if (c.expectMark)
+                    (0, vitest_1.expect)(marks).toContain(PATH_MARK);
+                else
+                    (0, vitest_1.expect)(marks).not.toContain(PATH_MARK);
+            }
+            finally {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+        }, 150000);
+    }
+});

package/dist/extract-ir.js

@@ -378,6 +378,21 @@ function extractDirectCalls(func, preText) {
 // 与 protocol-detector 的同名规则（source-level benchmark 路径）。
 // ═══════════════════════════════════════════════════════════════
 const PATH_TRAVERSAL_MARKER = "__progmune_path_traversal__";
+/**
+ * 标识符是否「看起来像基目录」—— G-A2 的定案依据。
+ *
+ * 判定：以 base / root / dir 结尾（大小写与 camel、下划线均可），
+ * 前缀任意（`base` / `baseDir` / `allowedRoot` / `root_dir` 都算）。
+ *
+ * 反例名单是实证加的：`database` 以 base 结尾但与目录无关，若不排除，
+ * 一旦有人写 `p.startsWith(database)` 就会被当成守卫 —— 那是精度漏洞。
+ */
+const BASE_DIR_IDENT_DENY = /^(?:database|databases|codebase|knowledgebase|base64|basename|dirname|basenames)$/i;
+function isBaseDirIdent(id) {
+    if (BASE_DIR_IDENT_DENY.test(id))
+        return false;
+    return /^(?:[A-Za-z_$][\w$]*)?(?:base|root|dir)$/i.test(id);
+}
 const PATH_GUARD_RULES = [
     {
         id: "G-A",
@@ -388,9 +403,35 @@ const PATH_GUARD_RULES = [
     },
     {
         id: "G-A2",
-        re: /\.\s*startsWith\s*\(\s*[A-Za-z_$][\w$]*(?:[Bb]ase|[Rr]oot|[Dd]ir|Dir|Root|Base)[\w$]*\s*\)/,
-        why: "目录包含性校验（基目录名形态）：startsWith(baseDir/rootDir/...)",
-        source: "设计形态，canonical",
+        // 粗筛：任意 `.startsWith(<ident>)`；定案交给 decide —— 实参名是否像基目录。
+        re: /\.\s*startsWith\s*\(\s*([^)]*?)\s*\)/,
+        // 2026-09-19 两次修订，都是被 C4「顶出来」的真问题（C4 之前相关用例
+        // 的「不标记」是空过——污点根本没走到 sink，见方法学规则 R7）：
+        //  ① 原正则 `[A-Za-z_$][\w$]*(?:[Bb]ase|…)` 要求标识符在 base/root/dir
+        //     **之外**还至少有一个前导字符，于是最朴素的 `startsWith(base)`
+        //     （taintpath_A readGuardWithin）匹配不上；
+        //  ② `startsWith("/srv/data")` —— 基目录写成**字符串字面量**——同样匹配
+        //     不上（C5 负对照 readInlineGuarded 就是这形态）。
+        // 故改为：先取出 startsWith 的整个实参，再判定它是「基目录名」还是
+        // 「绝对路径字面量」。
+        decide: (text) => {
+            const re = /\.\s*startsWith\s*\(\s*([^)]*?)\s*\)/g;
+            let m;
+            while ((m = re.exec(text)) !== null) {
+                const arg = m[1] || "";
+                // 形参里的标识符：`base` / `base + path.sep` / `rootDir + "/"`
+                const idm = /([A-Za-z_$][\w$]*)/.exec(arg);
+                if (idm && isBaseDirIdent(idm[1]))
+                    return true;
+                // 绝对路径字面量：`"/srv/data"`。长度 >1 是为了排除 `startsWith("/")`
+                // —— 那只是「是否绝对路径」，不构成包含性。
+                if (/["'`]\/[^"'`]+["'`]/.test(arg))
+                    return true;
+            }
+            return false;
+        },
+        why: "目录包含性校验（基目录名或绝对路径字面量）：startsWith(base / baseDir / \"/srv/data\" / base + sep）",
+        source: "设计形态，canonical；2026-09-19 补 `base` 单标识符（taintpath_A readGuardWithin）与绝对路径字面量（C5 负对照 readInlineGuarded）",
     },
     {
         id: "G-B1",
@@ -456,7 +497,7 @@ function callsPathGuardFn(text) {
 /** 返回命中的守卫规则 id；无校验证据返回 null。 */
 function hasPathGuardEvidence(text) {
     for (const r of PATH_GUARD_RULES) {
-        if (r.re.test(text))
+        if (r.decide ? r.decide(text) : r.re.test(text))
             return r.id;
     }
     if (callsPathGuardFn(text))
@@ -475,15 +516,20 @@ function escapeRe(s) {
  */
 function pathGuardFunctionNames(project) {
     const guarded = new Set();
+    /** tier-0：函数体自身含校验证据的名字（G1 原语义） */
+    const direct = new Set();
     const bodies = [];
     const note = (names, text) => {
         if (!text)
             return;
         bodies.push({ names, text });
-        if (hasPathGuardEvidence(text))
+        if (hasPathGuardEvidence(text)) {
             for (const n of names)
-                if (n)
+                if (n) {
                     guarded.add(n);
+                    direct.add(n);
+                }
+        }
     };
     for (const sf of project.getSourceFiles()) {
         for (const cls of sf.getClasses()) {
@@ -526,7 +572,55 @@ function pathGuardFunctionNames(project) {
         if (!added)
             break;
     }
-    return guarded;
+    return { all: guarded, direct };
+}
+// ═══════════════════════════════════════════════════════════════
+// G2（2026-09-19）：调用点抑制 —— 污点【表达式级】净化
+// ═══════════════════════════════════════════════════════════════
+// 缺口实证（taintpath_B，2026-09-19 measured）：
+//   `assertTemplateName(args.name); return loadTemplate(args.name);`
+// 仍被标记。`assertTemplateName` 的函数体内是锚定字符集白名单（G-D），
+// 是**真的**校验，但它的名字不含路径语义后缀 —— `Name` 在修 `ensureDir()`
+// 误判时被整体移出了 G-C 守卫后缀表，于是调用点侧认不出来。
+//
+// 为什么不直接放宽后缀表：那是按【名字】猜语义，会把判别力稀释成猜函数名
+// （G-C 的实证代价已经量过一次：放宽 ⇒ fr-007 pre 侧召回归零）。
+// 本实现改为按【被调用方的实际证据】定案：
+//   函数体内调用了 tier-0 守卫函数（自身含校验证据），且污点表达式被当作
+//   实参传进去 ⇒ 该表达式视为已净化，再流进 sink 不算污点。
+//
+// 精度取舍（关键点）：净化作用在【表达式】上，不是整函数。
+//   G1 的 selfGuarded 是函数级的（一个校验词汇压掉整个函数体所有流）；
+//   G2 只净化真正被传进守卫调用的那个表达式 —— 同函数体里另一条未被校验
+//   的流仍会标记。这是 G2 相对 G1 的收窄，而不是又一次放宽。
+// ═══════════════════════════════════════════════════════════════
+/**
+ * 收集函数体内「被传进 tier-0 守卫函数」的实参表达式，编译成一个判定正则。
+ *
+ * 边界：只收**简单取值表达式**（标识符 / 成员 / 下标 / 字符串字面量），
+ * 复杂表达式（模板串、拼接、调用）不收 —— 那些形态无法在 sink 侧可靠比对。
+ */
+function collectSanitizedExprs(text, directGuardFns) {
+    if (!directGuardFns || directGuardFns.size === 0)
+        return null;
+    const names = [...directGuardFns].filter((n) => !n.includes("."));
+    if (names.length === 0)
+        return null;
+    const callRe = new RegExp(`(?:^|[^\\w$.])(?:${names.map(escapeRe).join("|")})\\s*\\(([\\s\\S]{0,250}?)\\)`, "g");
+    const exprs = new Set();
+    let m;
+    while ((m = callRe.exec(text)) !== null) {
+        for (const a of splitArgWindow(m[1] || "")) {
+            const t = a.trim();
+            if (t && /^[A-Za-z_$][\w$]*(?:\s*\.\s*[\w$]+|\[[^\]]*\])*$/.test(t))
+                exprs.add(t.replace(/\s+/g, ""));
+        }
+    }
+    if (exprs.size === 0)
+        return null;
+    // 前缀 `(?:^|[^\w$.])` 是精度关键：`name` 不能匹配 `other.name` 里的 name，
+    // 但 `args.name` 能匹配 `path.join(DIR, args.name)` 里的 args.name。
+    return new RegExp([...exprs].map((e) => `(?:^|[^\\w$.])${escapeRe(e)}\\b`).join("|"));
 }
 const TS_FILE_SINK_NAMES = [
     "readFile", "readFileSync", "writeFile", "writeFileSync",
@@ -569,7 +663,29 @@ function hasRequestRootedExpr(text) {
 function tsSinkCallRegex() {
     return new RegExp(`(?:^|[^\\w.$])(?:await\\s+)?(?:[\\w$]+\\.)?(${TS_FILE_SINK_NAMES.join("|")})\\s*\\(([\\s\\S]{0,250}?)\\)`, "g");
 }
-/** 函数体内被不可信根污染的局部名（含解构与单跳赋值，深度 ≤2） */
+/**
+ * C4（2026-09-19）：污点经「路径塑形表达式」包装后仍然传播。
+ *
+ * 缺口实证（taintpath_A，2026-09-19 measured）：
+ *   `const target = path.join(ROOT, req.params.name); fs.readFileSync(target)`
+ * 不标记 —— 因为传播只认 `x = <污点>` 直赋，`path.join(...)` 把流掐断了。
+ * 真实工程里 `join/resolve/normalize/basename` 是路径构造的**默认写法**，
+ * 这条断链等于把最常见的形态整片漏掉。
+ *
+ * 政策：**白名单传播**，不是「RHS 含污点就传播」。
+ *   - 只经【路径塑形】的调用传播（path.* 家族 + 保值的字符串方法）；
+ *   - 字符串拼接与模板字面量同样只塑形、不改来源，故一并传播；
+ *   - 认不出的调用**不传播** —— 于是 `const safe = sanitizeName(p)` 天然
+ *     不污染。这是白名单相对黑名单的决定性优势：未知函数默认站在精度一侧。
+ *   代价：项目自有 helper（如 `buildPath(p)`）仍不传播，记为 C4b 缺口。
+ *
+ * 已知限制：只扫单行赋值（`const x = …;` 一行写完）。跨行书写的调用
+ * 链不传播——保持简单，等 C4b 一并处理。
+ */
+const TS_PATH_SHAPER_RE = /(?:path\s*\.\s*(?:posix|win32)\s*\.\s*|path\s*\.\s*)?\b(?:join|resolve|normalize|basename|dirname|extname|relative|format|toNamespacedPath)\s*\(|\.\s*(?:trim|trimStart|trimEnd|replace|replaceAll|toLowerCase|toUpperCase|toString|slice|substring|substr|padStart|padEnd|concat|normalize)\s*\(/;
+/** 拼接形态：`+` 或反引号（模板字面量）—— 同样只是塑形 */
+const TS_CONCAT_RE = /\+|`/;
+/** 函数体内被不可信根污染的局部名（含解构、单跳赋值与 C4 塑形传播，深度 ≤3） */
 function collectTaintedNames(text) {
     const tainted = new Set();
     let m;
@@ -588,6 +704,7 @@ function collectTaintedNames(text) {
     const bareAssign = new RegExp(`(?:^|[^\\w$.])([\\w$]+)\\s*=\\s*(?:await\\s+)?(?:${root})`, "g");
     while ((m = bareAssign.exec(text)) !== null)
         tainted.add(m[1]);
+    taintedViaShaper(text, tainted);
     // 单跳传播（深度 ≤2）
     for (let depth = 0; depth < 2; depth++) {
         if (tainted.size === 0)
@@ -606,6 +723,41 @@ function collectTaintedNames(text) {
     }
     return tainted;
 }
+/**
+ * C4：把「经路径塑形表达式包装」的赋值名补进污点集合（有界迭代 ≤3 轮）。
+ *
+ * 按行扫描 `[(const|let|var)] NAME = RHS`：RHS 含污点证据 且
+ * （含塑形调用 或 含拼接/模板）⇒ NAME 污染。迭代是为了让
+ * `normalized = path.normalize(p)` → `savePath = path.join(normalized, f)`
+ * 这类链式构造能接上（fr-012 下载侧守卫块就是这个形状）。
+ */
+function taintedViaShaper(text, tainted) {
+    for (let depth = 0; depth < 3; depth++) {
+        // 注意：这里**不能**以 `tainted.size === 0` 提前退出 —— 种子是根模式
+        // （taintPattern 恒定并入 UNTRUSTED_ROOT_SRC）。本轮这 4 条 known-gap
+        // 的共同形态恰恰是「全函数没有任何直赋污点，根只出现在塑形调用里」，
+        // 加这道闸门等于整条 C4 不生效（2026-09-19 实测踩到）。
+        const taintRe = taintPattern(tainted);
+        if (!taintRe)
+            return;
+        let added = false;
+        for (const line of text.split("\n")) {
+            const m = /^\s*(?:const|let|var)?\s*([\w$]+)\s*=\s*(?:await\s+)?(.+)$/.exec(line);
+            if (!m)
+                continue;
+            const name = m[1];
+            const rhs = m[2];
+            if (tainted.has(name))
+                continue;
+            if (taintRe.test(rhs) && (TS_PATH_SHAPER_RE.test(rhs) || TS_CONCAT_RE.test(rhs))) {
+                tainted.add(name);
+                added = true;
+            }
+        }
+        if (!added)
+            return;
+    }
+}
 function taintPattern(tainted) {
     const parts = [UNTRUSTED_ROOT_SRC];
     if (tainted.size > 0) {
@@ -613,16 +765,33 @@ function taintPattern(tainted) {
     }
     return new RegExp(parts.join("|"));
 }
-/** 本函数体内：文件 sink 的实参窗口含 request 污点 → true */
-function hasTaintedSinkCall(text, tainted) {
+/**
+ * 本函数体内：文件 sink 的实参窗口含 request 污点 → true。
+ *
+ * `sanitizedRe` 非空时（G2）：实参里被净化过的表达式不再算污点 ——
+ * 逐实参判定，只要还有一个实参含【未被净化】的污点就照旧标记。
+ */
+function hasTaintedSinkCall(text, tainted, sanitizedRe) {
     const taint = taintPattern(tainted);
     if (!taint)
         return false;
     const sinkRe = tsSinkCallRegex();
     let m;
     while ((m = sinkRe.exec(text)) !== null) {
-        if (taint.test(m[2] || ""))
-            return true;
+        const win = m[2] || "";
+        if (!taint.test(win))
+            continue;
+        if (sanitizedRe) {
+            const args = splitArgWindow(win);
+            if (args.length > 0) {
+                if (!args.some((a) => taint.test(a) && !sanitizedRe.test(a)))
+                    continue;
+            }
+            else if (sanitizedRe.test(win)) {
+                continue;
+            }
+        }
+        return true;
     }
     return false;
 }
@@ -734,7 +903,7 @@ function collectUrlParamNames(params) {
  *   项目方法体内的文件 sink（跨函数一跳，onMethodHit 回调登记方法条目）
  * - SSRF：URL 形参/request 污点 → HTTP fetch sink，无守卫词汇
  */
-function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit, guardFns) {
+function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit, guardFns, directGuardFns) {
     const markers = [];
     // ── 路径穿越 ──
     // G1（2026-09-19）：有流还不够，必须【没有校验证据】才标记——
@@ -743,6 +912,10 @@ function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit, guardFns)
     if (hasRequestRootedExpr(text)) {
         const tainted = collectTaintedNames(text);
         const selfGuarded = guardFns ? hasPathGuardEvidence(text) !== null : false;
+        // G2：调用点抑制 —— 被传进「自身含校验证据的函数」的表达式视为已净化。
+        // 与 selfGuarded（函数级、按词形）互补：这条按【被调用方的实际证据】定案，
+        // 因此认得出 assertTemplateName 这类不含路径语义后缀的自定义校验函数。
+        const sanitizedRe = collectSanitizedExprs(text, directGuardFns);
         // C5（2026-09-19）：不可信根可以直接写在 sink 实参里，不需要中间变量。
         // 此前外层要求 collectTaintedNames 非空，于是
         //   `fs.readFileSync("/data/" + req.params.name)` —— 真实工程里最常见的形态
@@ -750,7 +923,7 @@ function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit, guardFns)
         // SSRF 侧从来不是这样（它把 UNTRUSTED_ROOT_SRC 并进 taint 模式去匹配实参窗口），
         // 这是同一条数据流上的又一处口径不一致。
         if (!selfGuarded) {
-            if (hasTaintedSinkCall(text, tainted)) {
+            if (hasTaintedSinkCall(text, tainted, sanitizedRe)) {
                 markers.push("__progmune_path_traversal__");
             }
             else {
@@ -773,7 +946,7 @@ function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit, guardFns)
                             if (guardFns && guardFns.has(m[1]))
                                 continue;
                             const args = splitArgWindow(m[2] || "");
-                            const hit = args.some((arg, i) => rec.idxs.has(i) && taint.test(arg));
+                            const hit = args.some((arg, i) => rec.idxs.has(i) && taint.test(arg) && !(sanitizedRe && sanitizedRe.test(arg)));
                             if (hit) {
                                 markers.push("__progmune_path_traversal__");
                                 onMethodHit(rec);
@@ -891,7 +1064,10 @@ function _extractSingleProject(absRoot, tsconfigPath) {
     // pendingMethodMarks = 跨函数命中待标记的方法条目（主循环后统一应用）
     const sinkParams = methodSinkParamMap(project, absRoot);
     // G1（2026-09-19）：路径校验识别。自身含校验证据的函数名 + 向调用方传播一跳。
-    const guardFns = pathGuardFunctionNames(project);
+    // direct = tier-0（自身含校验证据）；all = 再向调用方传播一跳后的集合。
+    // G2 只用 direct —— 传播得到的名字是「被推断为守卫」，拿它做抑制会把
+    // 推断误差直接放大成误报消除。
+    const { all: guardFns, direct: directGuardFns } = pathGuardFunctionNames(project);
     const pendingMethodMarks = new Set();
     const onMethodHit = (rec) => {
         for (const me of rec.entries)
@@ -909,7 +1085,7 @@ function _extractSingleProject(absRoot, tsconfigPath) {
             const fParams = f.getParameters();
             const fText = f.getText();
             const fCalls = extractDirectCalls(f, fText);
-            fCalls.push(...computeMarkerCalls(fText, fParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns));
+            fCalls.push(...computeMarkerCalls(fText, fParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns, directGuardFns));
             funcs.push({
                 name,
                 params: fParams.map(p => ({
@@ -939,7 +1115,7 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                 const initParams = init.getParameters();
                 const initText = init.getText();
                 const initCalls = extractDirectCalls(init, initText);
-                initCalls.push(...computeMarkerCalls(initText, initParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns));
+                initCalls.push(...computeMarkerCalls(initText, initParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns, directGuardFns));
                 funcs.push({
                     name,
                     params: initParams.map(p => ({
@@ -965,7 +1141,7 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                         const argParams = arg.getParameters();
                         const argText = arg.getText();
                         const argCalls = extractDirectCalls(arg, argText);
-                        argCalls.push(...computeMarkerCalls(argText, argParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns));
+                        argCalls.push(...computeMarkerCalls(argText, argParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns, directGuardFns));
                         funcs.push({
                             name,
                             params: argParams.map(p => ({
@@ -999,7 +1175,7 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                     continue;
                 const mParams = m.getParameters();
                 const mText = m.getText();
-                const mCalls = computeMarkerCalls(mText, mParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns);
+                const mCalls = computeMarkerCalls(mText, mParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns, directGuardFns);
                 funcs.push({
                     name: `${cn}.${mn}`,
                     params: mParams.map((p) => ({ name: p.getName(), type: getParamType(p), typeDetail: getParamTypeDetail(p) })),

package/dist/sdk.js

@@ -20,7 +20,7 @@ const risk_model_1 = require("./risk-model");
 const protocol_knowledge_1 = require("./protocol-knowledge");
 const evidence_repository_1 = require("./evidence-repository");
 /** Runtime version — stable public identifier. Internal layers evolve underneath. */
-exports.RUNTIME_VERSION = "3.7.35";
+exports.RUNTIME_VERSION = "3.7.37";
 function verify(filePath) {
     const cert = (0, certify_1.certify)(filePath);
     const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "progmune-runtime",
-  "version": "3.7.35",
+  "version": "3.7.37",
   "description": "Progmune — AI Trust Decision Engine. Verify AI-generated code before it reaches production. Outputs APPROVED / NEEDS_REVIEW / BLOCKED with evidence.",
   "files": [
     "dist/",