progmune-runtime 3.7.32 → 3.7.35

package/CHANGELOG.md

@@ -1,5 +1,100 @@
 # 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 陈旧性判定（两次会话级误判的根因修复）

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 形态）。
+ */

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

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * 污点标记管线三处结构性修复（C1/C2/C3）的定向回归（2026-09-19）。
+ *
+ * 立项背景：这三处是从「污点源数据流试点 V1」里拆出来的**正确性修复**——
+ * 它们让标记管线对真实 TS 工程「看得见」，但不改变判别逻辑（判别力是 G1
+ * PATH_GUARD_EVIDENCE 的事，另一个条目）。
+ *
+ * 为什么必须有本文件（重要）：
+ *   TS 795 盲测对这三处【零覆盖】——实测把整份 generated 语料重跑后，
+ *   per-function calls 差异 0、__progmune 标记 826 vs 826、flags 3086 LOST 0/ADDED 0。
+ *   即「TS 795 零漂移」在这里是**空过**（vacuous pass）：它不是说这三处没风险，
+ *   而是说盲测语料根本走不到这些分支。因此真正的门是本文件的定向用例。
+ *
+ * 三处修复：
+ *   C3 UNTRUSTED_ROOTS   —— 污点根由「Express 专属变量名」改为「按传输面声明」
+ *   C1 methodSinkParamMap—— 除类方法外，纳入**顶层函数**的 sink 形参
+ *   C2 directCallRe      —— 跨函数传播除成员调用外，识别**裸调用** func(x)
+ */
+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-struct-"));
+    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)("C3：污点根按传输面声明（不再只认 Express 的 req.*）", () => {
+    (0, vitest_1.it)("Express 形态仍必须标记（不得因改表回归）", () => {
+        const dir = makeProject({
+            "legacy.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 });
+        }
+    }, 150000);
+    (0, vitest_1.it)("MCP 工具实参 params.arguments 作为根（fr-012 形态）", () => {
+        const dir = makeProject({
+            "mcp.ts": `
+import * as fs from "fs";
+export function uploadMarkdown(args: any) {
+  const filePath = params.arguments.file_path;
+  return fs.readFileSync(filePath, "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "uploadMarkdown")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }, 150000);
+    (0, vitest_1.it)("反例：常量路径不得标记（防止根表放宽后过度标记）", () => {
+        const dir = makeProject({
+            "benign.ts": `
+import * as fs from "fs";
+export function readDocs() {
+  return fs.readFileSync("/data/terms.md", "utf-8");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "readDocs")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }, 150000);
+});
+(0, vitest_1.describe)("C1：顶层函数的 sink 形参必须入表（此前只登记类方法）", () => {
+    (0, vitest_1.it)("顶层函数 + 污点实参 → 跨函数传导后被标记", () => {
+        const dir = makeProject({
+            "handler.ts": `
+import * as fs from "fs";
+export function markdownUpload(filePath: string) {
+  return fs.readFileSync(filePath, "utf-8");
+}
+export function dispatchTool(args: any) {
+  const target = params.arguments.file_path;
+  return markdownUpload(target);
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "markdownUpload")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }, 150000);
+});
+(0, vitest_1.describe)("C2：裸调用形态的跨函数传播（此前只匹配 obj.sink(...)）", () => {
+    (0, vitest_1.it)("顶层函数被裸调用且传入污点 → 标记（fr-012 的 markdownUpload 形态）", () => {
+        const dir = makeProject({
+            "store.ts": `
+import * as fs from "fs";
+export function save(name: string, content: string) {
+  fs.writeFileSync("/flows/" + name, content);
+}
+`,
+            "route.ts": `
+import { save } from "./store";
+export function createFlow(req: any) {
+  const name = req.body.name;
+  save(name, "{}");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "createFlow")).toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }, 150000);
+    (0, vitest_1.it)("反例：给裸调用传常量不得标记", () => {
+        const dir = makeProject({
+            "store.ts": `
+import * as fs from "fs";
+export function save(name: string, content: string) {
+  fs.writeFileSync("/flows/" + name, content);
+}
+`,
+            "route.ts": `
+import { save } from "./store";
+export function seedFlow() {
+  save("default.json", "{}");
+}
+`,
+        });
+        try {
+            (0, vitest_1.expect)(marksFor(dir, "seedFlow")).not.toContain(PATH_MARK);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }, 150000);
+});
+/**
+ * C5（2026-09-19）：不可信根**直接写在 sink 实参里**（无中间变量）此前不标记。
+ *
+ * 发现途径：新建的 blind-benchmark taintpath 语料族里有两条最朴素的用例
+ * （`readFileSync("/d/" + req.params.name)`、模板字符串形态）跑出「不标记」。
+ * 根因是外层 `tainted.size > 0` 的闸门——而 SSRF 侧从来不要求中间变量。
+ *
+ * 按 R6：**每条「不得标记」都要配正对照**。这里的负对照是同形状无污点的常量路径。
+ */
+(0, vitest_1.describe)("C5：内联不可信根（不经中间变量）必须标记", () => {
+    const cases = [
+        {
+            name: "字符串拼接直连",
+            fn: "readInline",
+            code: `export function readInline(req: any) {
+  return fs.readFileSync("/srv/data/" + req.params.name, "utf-8");
+}`,
+            expectMark: true,
+            why: "真实 Express 工程最常见的写法",
+        },
+        {
+            name: "模板字符串直连",
+            fn: "readTemplate",
+            code: "export function readTemplate(req: any) {\n  return fs.readFileSync(`/srv/data/${req.query.name}`, \"utf-8\");\n}",
+            expectMark: true,
+            why: "query 根 + 模板插值",
+        },
+        {
+            name: "写侧 header 根",
+            fn: "writeHeader",
+            code: `export function writeHeader(request: any, data: any) {
+  return fs.writeFileSync("/srv/data/" + request.headers["x-name"], data);
+}`,
+            expectMark: true,
+            why: "写 sink + request.headers 根",
+        },
+        {
+            name: "MCP 实参直连",
+            fn: "writeMcp",
+            code: `export function writeMcp(params: any, data: any) {
+  return fs.writeFileSync(params.arguments.path, data);
+}`,
+            expectMark: true,
+            why: "传输面里的第二个根：MCP 工具实参",
+        },
+        {
+            name: "负对照：常量路径不得标记",
+            fn: "readConstant",
+            code: `export function readConstant() {
+  return fs.readFileSync("/srv/data/index.html", "utf-8");
+}`,
+            expectMark: false,
+            why: "R6：证明前面的用例不是靠「只要有 fs sink 就标记」蒙对",
+        },
+        {
+            name: "负对照：有守卫时内联根仍不标记",
+            fn: "readInlineGuarded",
+            code: `export function readInlineGuarded(req: any) {
+  const target = path.resolve("/srv/data", req.params.name);
+  if (!target.startsWith("/srv/data")) throw new Error("outside");
+  return fs.readFileSync(target, "utf-8");
+}`,
+            expectMark: false,
+            why: "C5 只补召回，不得绕过 G1 的判别力",
+        },
+    ];
+    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,156 @@ function extractDirectCalls(func, preText) {
 // 与 protocol-detector 的同名规则（source-level benchmark 路径）。
 // ═══════════════════════════════════════════════════════════════
 const PATH_TRAVERSAL_MARKER = "__progmune_path_traversal__";
+const PATH_GUARD_RULES = [
+    {
+        id: "G-A",
+        // resolve(p).startsWith(resolve(root)+sep) / x.startsWith(baseDir)
+        re: /(?:resolve|realpath|normalize)\s*\([^()]*\)\s*\.\s*startsWith\s*\(/,
+        why: "目录包含性校验（canonical 形态）：规范化后判断是否落在基目录内",
+        source: "设计形态，canonical；fr-016 Redocly 修复的同族（见 G-C）",
+    },
+    {
+        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",
+    },
+    {
+        id: "G-B1",
+        re: /\b(?:path\.)?isAbsolute\s*\(/,
+        why: "绝对路径拒绝：绝对路径不受 join(root, p) 约束",
+        source: "fr-012 gitlab-mcp 下载侧 localPath 既有守卫块（pre/post 同一段，@ index.ts:7968）",
+    },
+    {
+        id: "G-B2",
+        // startsWith(".." + sep) / includes(sep + ".." + sep) / === ".."
+        re: /\.\s*(?:startsWith|includes)\s*\(\s*(?:[^()]*["'`]\.\.)/,
+        why: "上跳拒绝：显式检测 .. 段",
+        source: "fr-012 gitlab-mcp 下载侧 localPath 既有守卫块（index.ts:7968-7977）",
+    },
+    {
+        id: "G-B3",
+        re: /(?:===?|!==)\s*["'`]\.\.["'`]/,
+        why: "上跳拒绝：与 .. 字面量直接比较",
+        source: "fr-012 gitlab-mcp 下载侧 localPath 既有守卫块（normalizedLocalPath === \"..\"）",
+    },
+    // 注：G-C 不放在本数组里——它是「按函数名判定」，需要配反例名单
+    // （见 PATH_GUARD_FN_CALL_RE / PATH_GUARD_FN_DENY 与下方注释）。
+    {
+        id: "G-D",
+        // /^[A-Za-z0-9_-]+$/ —— 锚定的字符集白名单，天然排除 / \ .
+        re: /\/\^\[[^\]]*\]\s*[+*?]\$\//,
+        why: "锚定字符集白名单：^…$ 且字符类不含 ./\\ 时无法构造上跳",
+        source: "fr-007 openhop `FLOW_ID_PATTERN = /^[A-Za-z0-9_-]+$/`（flow-id.ts）",
+    },
+];
+/**
+ * 明确**不算**守卫的形态（反例清单）。
+ *
+ * N-A `path.basename` 是这张表里最重要的一行：它只去目录、不去 `..`，
+ * 却极常被当成「已经 sanitize 过」。fr-012 pre 的实测反例：漏洞态代码里
+ * 就有 `path.basename`，漏洞依然成立。一旦把 basename 算作守卫，
+ * fr-012 的真值会被自己压掉 —— 见 src/extract-ir-taint-guard.test.ts。
+ */
+const PATH_NON_GUARD_NOTE = "N-A path.basename / N-B 单独出现的 join·resolve / N-C 长度或字符数检查 / N-D if (!p) throw —— 均不计入守卫";
+/**
+ * G-C：独立校验函数被调用（项目自有命名）。
+ *
+ * 后缀刻意**不收** `Dir` / `Name` / 裸的 `Valid` —— 实证代价：
+ *   - `ensureDir()`（fr-007 openhop store.ts:46）与 `s.isDirectory()` 都会被
+ *     `…Dir(` 命中，而它们是**建目录 / 类型判断**，与校验无关；第一版词表
+ *     因此把 fr-007 的 pre 侧 5 条全部误压成 0（召回归零）。
+ *   - `isValid(x)` / `isSub(a,b)` 同理，会把判别力稀释成猜函数名。
+ * 保留 `Id`（fr-007 `assertValidFlowId`）、`Within`（fr-016 `assertWithinDir`）、
+ * `Safe|Path|Inside|InDir|Contained|Traversal|Root|Base`。
+ */
+const PATH_GUARD_FN_CALL_RE = /\b(?:assert|ensure|check|validate|verify|sanitize|is)[A-Za-z$]*(?:Safe|Path|Paths|Within|Inside|InDir|Contained|Traversal|Id|Root|Base)[A-Za-z0-9_$]*(?=\s*\()/g;
+/** 形态上会命中 G-C 但**确定不是**路径校验的名字（实证反例，逐个加） */
+const PATH_GUARD_FN_DENY = /^(?:ensureDir|isDirectory|isDir|assertDir|makeDir|mkdir|checkExists|isValid|isRoot|ensureId|getId)$/i;
+function callsPathGuardFn(text) {
+    PATH_GUARD_FN_CALL_RE.lastIndex = 0;
+    let m;
+    while ((m = PATH_GUARD_FN_CALL_RE.exec(text)) !== null) {
+        if (!PATH_GUARD_FN_DENY.test(m[0]))
+            return true;
+    }
+    return false;
+}
+/** 返回命中的守卫规则 id；无校验证据返回 null。 */
+function hasPathGuardEvidence(text) {
+    for (const r of PATH_GUARD_RULES) {
+        if (r.re.test(text))
+            return r.id;
+    }
+    if (callsPathGuardFn(text))
+        return "G-C";
+    return null;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * 项目内「自身含校验证据」的函数名集合，并向调用方传播一跳（有界）。
+ *
+ * 为什么必须传播：fr-007 的修复是把 `assertValidFlowId(id)` 放进 `filePath()`，
+ * 真正含 sink 的 `FlowStore.get/save/...` 与外层 `flowRoutes` 里**一个校验词汇都没有**——
+ * 只看函数体等于没做。传播上限 3 轮（防止公共函数名导致的无限扩散）。
+ */
+function pathGuardFunctionNames(project) {
+    const guarded = new Set();
+    const bodies = [];
+    const note = (names, text) => {
+        if (!text)
+            return;
+        bodies.push({ names, text });
+        if (hasPathGuardEvidence(text))
+            for (const n of names)
+                if (n)
+                    guarded.add(n);
+    };
+    for (const sf of project.getSourceFiles()) {
+        for (const cls of sf.getClasses()) {
+            const cn = cls.getName();
+            if (!cn)
+                continue;
+            for (const m of cls.getMethods()) {
+                const mn = m.getName();
+                if (!mn)
+                    continue;
+                note([mn, `${cn}.${mn}`], m.getText());
+            }
+        }
+        for (const fn of sf.getFunctions()) {
+            const fnName = fn.getName();
+            if (!fnName)
+                continue;
+            note([fnName], fn.getText());
+        }
+    }
+    // 向调用方传播：调用了一个已校验函数 ⇒ 这条流已被拦截（有界 3 轮）
+    for (let round = 0; round < 3; round++) {
+        const names = [...guarded].filter((n) => !n.includes("."));
+        if (names.length === 0)
+            break;
+        const re = new RegExp(`\\b(?:${names.map(escapeRe).join("|")})\\s*\\(`, "g");
+        let added = false;
+        for (const b of bodies) {
+            if (b.names.every((n) => guarded.has(n)))
+                continue;
+            re.lastIndex = 0;
+            if (re.test(b.text)) {
+                for (const n of b.names)
+                    if (n && !guarded.has(n)) {
+                        guarded.add(n);
+                        added = true;
+                    }
+            }
+        }
+        if (!added)
+            break;
+    }
+    return guarded;
+}
 const TS_FILE_SINK_NAMES = [
     "readFile", "readFileSync", "writeFile", "writeFileSync",
     "appendFile", "appendFileSync", "unlink", "unlinkSync", "rm", "rmSync",
@@ -584,12 +734,22 @@ function collectUrlParamNames(params) {
  *   项目方法体内的文件 sink（跨函数一跳，onMethodHit 回调登记方法条目）
  * - SSRF：URL 形参/request 污点 → HTTP fetch sink，无守卫词汇
  */
-function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit) {
+function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit, guardFns) {
     const markers = [];
     // ── 路径穿越 ──
+    // G1（2026-09-19）：有流还不够，必须【没有校验证据】才标记——
+    // 与 SSRF 侧「无 SSRF_GUARD_EVIDENCE 才标记」对齐。
+    // 未传 guardFns（旧调用点/单测）时按「不做校验识别」的旧语义处理。
     if (hasRequestRootedExpr(text)) {
         const tainted = collectTaintedNames(text);
-        if (tainted.size > 0) {
+        const selfGuarded = guardFns ? hasPathGuardEvidence(text) !== null : false;
+        // C5（2026-09-19）：不可信根可以直接写在 sink 实参里，不需要中间变量。
+        // 此前外层要求 collectTaintedNames 非空，于是
+        //   `fs.readFileSync("/data/" + req.params.name)` —— 真实工程里最常见的形态
+        // 不标记；只有写成 `const n = req.params.name; readFileSync("/data/" + n)` 才标。
+        // SSRF 侧从来不是这样（它把 UNTRUSTED_ROOT_SRC 并进 taint 模式去匹配实参窗口），
+        // 这是同一条数据流上的又一处口径不一致。
+        if (!selfGuarded) {
             if (hasTaintedSinkCall(text, tainted)) {
                 markers.push("__progmune_path_traversal__");
             }
@@ -609,6 +769,9 @@ function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit) {
                             const rec = sinkParams.get(m[1]);
                             if (!rec || rec.idxs.size === 0)
                                 continue;
+                            // G1：被调用方自身已校验 ⇒ 这条跨函数流已被拦截，不标记
+                            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));
                             if (hit) {
@@ -727,6 +890,8 @@ function _extractSingleProject(absRoot, tsconfigPath) {
     // sinkParams = 项目方法名 → 方法体内流入文件 sink 的形参下标 + 方法条目；
     // pendingMethodMarks = 跨函数命中待标记的方法条目（主循环后统一应用）
     const sinkParams = methodSinkParamMap(project, absRoot);
+    // G1（2026-09-19）：路径校验识别。自身含校验证据的函数名 + 向调用方传播一跳。
+    const guardFns = pathGuardFunctionNames(project);
     const pendingMethodMarks = new Set();
     const onMethodHit = (rec) => {
         for (const me of rec.entries)
@@ -744,7 +909,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));
+            fCalls.push(...computeMarkerCalls(fText, fParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns));
             funcs.push({
                 name,
                 params: fParams.map(p => ({
@@ -774,7 +939,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));
+                initCalls.push(...computeMarkerCalls(initText, initParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns));
                 funcs.push({
                     name,
                     params: initParams.map(p => ({
@@ -800,7 +965,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));
+                        argCalls.push(...computeMarkerCalls(argText, argParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns));
                         funcs.push({
                             name,
                             params: argParams.map(p => ({
@@ -834,7 +999,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);
+                const mCalls = computeMarkerCalls(mText, mParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns);
                 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.32";
+exports.RUNTIME_VERSION = "3.7.35";
 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.32",
+  "version": "3.7.35",
   "description": "Progmune — AI Trust Decision Engine. Verify AI-generated code before it reaches production. Outputs APPROVED / NEEDS_REVIEW / BLOCKED with evidence.",
   "files": [
     "dist/",