progmune-runtime 3.7.46 → 3.7.48

package/CHANGELOG.md

@@ -1,5 +1,105 @@
 # Changelog
 
+## [3.7.48] — 2026-09-22
+
+### IR 提取失败必须发声（OOM 杀后的「0 违规假干净」根治）
+
+- **事故**：skyvern E1 重扫时 python3 提取器被 OOM 杀（SIGKILL），ir.json 被写成 2 字节空数组——引擎带着空 IR 照样输出「0 违规、85 分 APPROVED」，结果自洽、无任何迹象表明它是废票（静默降级比 R8 陈旧产物更阴）
+- **修复**（`src/trust/engine.ts` + `types.ts`）：
+  - 提取异常不再静默吞掉——异常信息记入 `extractionWarning`
+  - **提取后验尸**：ir.json 存在但函数数=0 且项目确有源码 ⇒ 记失败并 console.warn
+  - TrustDecision 新增 `overall.extractionWarning` 字段；失败时 `coverageConfidence` 强制降 LOW，摘要明示「本次扫描是废票，不得据此得出干净结论」
+- **E2E 验证**：空 ir.json + 1 个源文件 → warning 触发 / confidence LOW / 摘要正确
+- 回归：engine 21 + ir-staleness 12 + structural 165 全绿；build ✓
+- 后续：python3 提取分块（skyvern 级项目单进程内存峰值不可控，按目录分批提取、引擎侧合并）——机器资源恢复后按四门验收
+
+## [3.7.47] — 2026-09-21
+
+### 类方法的真实调用必须进 IR（状态机在 OO 代码上没有输入）
+
+**一句话**：主 IR 循环的类方法分支**只调了 `computeMarkerCalls`（产 `__progmune_*` 语义
+标记），从来没调过 `extractDirectCalls`（产真实调用名）**；而函数声明 / 箭头 / 包装箭头
+三个分支都是两行齐全。后果是类方法的 `calls` 里永远只有标记、没有真实调用 ⇒ **协议状态
+机在 OO 代码上拿不到输入**。
+
+这不是新引入的回归。Claude 补充的历史事实：修 A1 时类方法提取循环里写死的就是
+`calls: []`，`extractDirectCalls` 只对函数声明和箭头函数调用过，类方法从未接上。A1 只是
+给方法条目挂标记时动过这个数组，基础的调用提取从来没补。**自该功能诞生之日起就空转**，
+taintpath 十一族语料全是函数载体，从来没有东西逼它现形。
+
+**顺带解释了三件悬案**：真实语料 `protocol=0`、引擎自扫「0 误报」、NestJS 语料过分干净
+—— 裁判一直没拿到证据。
+
+**修复**：类方法分支补上 `extractDirectCalls(m, mText)`（签名形参加 `MethodDeclaration`，
+遍历逻辑无需改动），顺序与既有三个载体一致：先真实调用，再追加语义标记。
+
+| 探针形态（18 条） | 修复前 | 修复后 |
+|---|---|---|
+| 类方法（同步 / async / this 成员 / 装饰器 / 构造函数注入） | 全空 | ✓ 全部提出 |
+| static / private / 抽象类实现方法 / `this.a.b()` 链式 / 计算属性名 | 全空 | ✓ 全部提出 |
+| 函数声明 / 箭头（基线对照） | ✓ | ✓ 不变 |
+
+**三条不修**（探针确认后明确登记，避免下一轮重踩）：
+
+1. **getter / setter / 构造函数体 / 对象字面量方法 / 类表达式** —— 这五种不是「calls 空」，
+   而是**条目压根不在 IR 里**（载体未收集）。属另一类缺陷，风险量级不同（新增条目 = 新增
+   检测面），不能与本轮混在一起，否则反向验证无法归因。
+2. **嵌套箭头回调里的调用** —— `extractDirectCalls` 遇嵌套函数即 `traversal.skip()`。实测
+   函数声明 / 箭头 / 类方法三者口径**完全一致**（都只提得到 `setTimeout`），是既有设计。
+3. **计算属性名的名字解算** —— `C.[K]` 名字不可解是另一回事，不影响 calls。
+
+### FP 观测池：把「裁判拿到证据」量化出来
+
+修复后重扫（`fp-pool-scan.ts`，4 切片 / 197 文件）：
+
+| 读数 | 修复前 | 修复后 |
+|---|---|---|
+| 空 calls 函数 | 140 / 197（**71%**） | 23 / 197（**12%**） |
+| 其中类方法空转 | 126 | 9 |
+| NestJS 切片 | 59 / 61 空 | 3 / 61 空 |
+| Express 切片 | 76 / 113 空 | 15 / 113 空 |
+
+**代价也量出来了**：项目级 safeguard 19 → 21，但 **perFunction 层面新增 18 条** —— 类方法
+第一次有了 calls，规则第一次看见这些序列。逐条判定：**FP 15 / 弱真 3 / 真漏洞 0**。四条
+规则侧校准线索已登记在 `fp-pool.json`（迁移与种子脚本应豁免、TypeORM query builder 链被
+Input Validation 误判、内部工具方法不应被要求 Authorization、`validate` 已存在却仍报缺校验
+⇒ 是词表不认 class-validator）。
+
+上一轮 7 条人工判定里那条「无法判定」的 `UserController.login`（Token Security）**本轮变
+成有效票**：有了 calls 才看得出它是标准 `jwt.sign` 签发 ⇒ FP。
+
+### 验收
+
+| 门 | 结果 |
+|---|---|
+| taintpath 闸门 | **160/160** |
+| fr-007 / fr-016 | pre 5→post 0 / pre 7→post 0 **均维持** |
+| 定向用例 | **241 passed / 6 文件**（新增 E1 组 14 条：10 正 2 正对照 2 负对照） |
+| TS 盲测 | 111 项目 / perFunction **3201 条**：**LOST 0 / ADDED 0**，汇总完全一致 |
+| 反向验证 | 三刀，残留 0（见下） |
+| tsc | 零错误 |
+
+**反向验证三刀**（`/tmp/rev_e1.py（原名 rev_c4k.py）`）：
+
+| 刀 | 退回的旧行为 | 转红 |
+|---|---|---|
+| ① 类方法只留标记 | `const mCalls = computeMarkerCalls(...)` | **12 条**：正例 ①–⑩ + 负对照 ①② |
+| ② 类方法不追加标记 | 摘掉 `mCalls.push(...computeMarkerCalls(...))` | 0 条（marker 由**调用方侧**补上） |
+| ③ 同上（闸门视角） | 同 ② | 闸门仍 160/160 |
+
+刀①归因**干净**：转红的 12 条全在类方法组，正对照 ⑪⑫（函数声明 / 箭头）仍绿。
+刀②③顺带证明两件事：marker 链路有调用方侧兜底（不是单点）；**taintpath 语料里根本没有
+类方法 ⇒ 闸门对本轮是空过**，真正的验收在 fp-pool 与定向用例。
+
+### 方法学
+
+- **R22 第三次应验**：负对照·② 一开始写错期望（以为类方法体内有 sink 就会有 marker），
+  跑探针才确认 —— marker 只在**调用方把污点传进来**时才注入到被调用方。写 expect 之前
+  先把判据抄进探针注释，这条规矩已经是第三次救我。
+- **R20 的适用边界**（Claude 指出）：那三问（pre 有无校验 / 污点根是否在切片内 / fix 是否
+  新增校验）只适用于**修复回归语料**，**别误用到 FP 观测池**——池的标准是「真实 + HTTP
+  入口 + 文件操作」，不要求 CVE。两边管的方向不同（召回 vs 精度），标准本来就不同。
+
 ## [3.7.46] — 2026-09-21
 
 ### C4j：载体收口的最后一批 + 一处既有缺陷的回归门

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

@@ -1898,3 +1898,220 @@ const WRITE_LAYER = [
         }, 150000);
     }
 });
+// ═══════════════════════════════════════════════════════════════
+// E1：类方法的**真实调用**必须进 IR（2026-09-21）
+//
+// 命名说明：C4k 已被占用（容器承载轴「属性写入 ⇒ 容器传播」，实测收益上限 0，
+// 判定不修，见设计稿 §十七）。本组是**提取器主干**，另开 E（Extractor）系列。
+//
+// 背景（Claude 补充的历史事实）：主 IR 循环的类方法分支自该功能诞生之日起
+// 只调 computeMarkerCalls（产 __progmune_* 语义标记），从未调 extractDirectCalls
+// （产真实调用名）；函数声明 / 箭头 / 包装箭头三个分支都是两行齐全。
+// 结果：类方法的 calls 里永远只有标记、没有真实调用 ⇒ **状态机在 OO 代码上
+// 拿不到输入**。FP 观测池实测：NestJS 切片 61 个函数里 59 个 calls 为空（97%），
+// 池合计 197 个里 140 个空。此前未暴露是因为 taintpath 十一族语料全是函数载体。
+//
+// 判据：类方法条目的 calls 必须同时含「真实调用名」与「语义标记」——
+//      本轮是**补**真实调用，不是拿它替换标记（负对照·②守这条）。
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("E1：类方法的真实调用必须进 IR（此前只有标记，状态机拿不到输入）", () => {
+    const cases = [
+        // ── 正例：此前全空的五种已知形态 ──────────────────────────
+        {
+            name: "正例·① 类方法（同步）",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export class C { m() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "最基础的类方法；此前 calls 为空",
+        },
+        {
+            name: "正例·② 类方法（async / await）",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export class C { async m() { await helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "async 方法体同样是 Block，此前一样空",
+        },
+        {
+            name: "正例·③ 类方法经 this 成员调用",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+export class C { private repo: any; m() { this.repo.save(); } }
+`,
+            },
+            want: ["save"],
+            why: "NestJS/TypeORM 的实际写法；属性访问取末端名",
+        },
+        {
+            name: "正例·④ 类方法带装饰器",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+function Get(): any { return () => {}; }
+export class C { @Get() m() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "装饰器不得影响方法体遍历",
+        },
+        {
+            name: "正例·⑤ 构造函数注入（方法用注入进来的依赖）",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+export class C { constructor(private repo: any) {} m() { this.repo.save(); } }
+`,
+            },
+            want: ["save"],
+            why: "DI 形态；探针里五种已知失效形态之一",
+        },
+        // ── 正例：顺手测到的、没人提过的形状 ──────────────────────
+        {
+            name: "正例·⑥ static 方法",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export class C { static m() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "static 也在 getMethods() 内，同属本轮",
+        },
+        {
+            name: "正例·⑦ private 方法",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export class C { private m() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "可见性修饰符不得影响提取",
+        },
+        {
+            name: "正例·⑧ 抽象类里的实现方法",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export abstract class C { abstract a(): void; m() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "abstract 无体，但有体的方法照旧要提",
+        },
+        {
+            name: "正例·⑨ 链式调用 this.a.b()",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+export class C { a: any; m() { this.a.b(); } }
+`,
+            },
+            want: ["b"],
+            why: "末端名即被调用的方法名",
+        },
+        {
+            name: "正例·⑩ 计算属性名方法",
+            fn: "C.[K]",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+const K = "m";
+export class C { [K]() { helper(); } }
+`,
+            },
+            want: ["helper"],
+            why: "名字解不解得出是另一回事，calls 不该受名字影响",
+        },
+        // ── 正对照：既有载体不得被误伤 ────────────────────────────
+        {
+            name: "正对照·⑪ 函数声明（基线）",
+            fn: "plain",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export function plain() { helper(); }
+`,
+            },
+            want: ["helper"],
+            why: "本轮只补类方法，函数声明分支不得回归",
+        },
+        {
+            name: "正对照·⑫ 箭头函数（基线）",
+            fn: "arrow",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export const arrow = () => { helper(); };
+`,
+            },
+            want: ["helper"],
+            why: "同上；箭头分支不得回归",
+        },
+        // ── 负对照：防修过头 ─────────────────────────────────────
+        {
+            name: "负对照·① 嵌套箭头回调里的调用仍不提取",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+function helper() { return 1; }
+export class C { m() { setTimeout(() => { helper(); }, 0); } }
+`,
+            },
+            want: ["setTimeout"],
+            dontWant: ["helper"],
+            why: "既有设计：extractDirectCalls 遇嵌套函数即 skip。已实测函数声明/箭头/类方法三者口径一致 ⇒ 本轮不动",
+        },
+        {
+            name: "负对照·② 真实调用不得挤掉语义标记",
+            fn: "Uploader.read",
+            files: {
+                "handler.ts": `
+import * as fs from "fs";
+export class Uploader {
+  read(filePath: string) {
+    return fs.readFileSync(filePath, "utf-8");
+  }
+}
+export function dispatchTool(args: any) {
+  const target = params.arguments.file_path;
+  return new Uploader().read(target);
+}
+`,
+            },
+            want: ["readFileSync", PATH_MARK],
+            why: "本轮是**补**真实调用，标记必须仍在——否则污点轴会整体倒退。" +
+                "（写这条用例时先跑探针确认判据：marker 只在**调用方把污点传进来**时才注入到" +
+                "被调用方，无调用方的类方法本就无 marker —— 探针 ①/④ 一致、②/③ 一致）",
+        },
+    ];
+    for (const c of cases) {
+        (0, vitest_1.it)(`${c.name} —— ${c.why}`, () => {
+            const dir = makeProject(c.files);
+            try {
+                const calls = marksFor(dir, c.fn);
+                for (const w of c.want)
+                    (0, vitest_1.expect)(calls).toContain(w);
+                for (const d of c.dontWant ?? [])
+                    (0, vitest_1.expect)(calls).not.toContain(d);
+            }
+            finally {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+        }, 150000);
+    }
+});

package/dist/extract-ir.js

@@ -338,6 +338,18 @@ function manualResolveModule(moduleSpecifier, sourceFilePath, projectRoot, origi
     }
     return null;
 }
+/**
+ * 提取函数体内**真实出现的调用名**（区别于 computeMarkerCalls 产出的语义标记）。
+ *
+ * 2026-09-21（类方法空转修复）：形参类型补 MethodDeclaration。
+ *   此前本函数只对函数声明 / 箭头 / 包装箭头三个载体调用过；主 IR 循环里的
+ *   **类方法分支从来没调过它**，只调了 computeMarkerCalls ⇒ 类方法的 calls 里
+ *   永远只有标记、没有真实调用 ⇒ 状态机在 OO 代码上拿不到输入（FP 观测池实测：
+ *   NestJS 切片 61 个函数里 59 个 calls 为空）。该空转自类方法提取功能诞生即存在，
+ *   因 taintpath 十一族语料全是函数载体而从未现形。
+ *   MethodDeclaration 与 FunctionDeclaration 一样具备 getBody() / getText()，
+ *   遍历逻辑无需改动。
+ */
 function extractDirectCalls(func, preText) {
     const body = func.getBody();
     if (!body)
@@ -2861,7 +2873,10 @@ 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, directGuardFns, shapers);
+                // 2026-09-21：补上真实调用提取（此前只有 computeMarkerCalls，见 extractDirectCalls 注释）。
+                // 顺序与函数声明 / 箭头两个分支保持一致：先真实调用，再追加语义标记。
+                const mCalls = extractDirectCalls(m, mText);
+                mCalls.push(...computeMarkerCalls(mText, mParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns, directGuardFns, shapers));
                 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.46";
+exports.RUNTIME_VERSION = "3.7.48";
 function verify(filePath) {
     const cert = (0, certify_1.certify)(filePath);
     const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();

package/dist/trust/engine.js

@@ -103,7 +103,7 @@ async function evaluateTrust(ctx) {
     // ── Phase 5: Build call graph for cross-function propagation ──
     const callGraph = (0, call_graph_propagator_1.buildCallGraphFromIR)(path.join(ctx.projectPath, "ir.json"));
     const enterpriseViolations = collectEnterpriseViolations(ctx);
-    const { violations: protocolViolations, coverage: mappingCoverageData, ssgCoverage: ssgCov, annotationSuggestions: cAnnotationSuggestions } = await collectProtocolViolations(ctx, callGraph);
+    const { violations: protocolViolations, coverage: mappingCoverageData, ssgCoverage: ssgCov, annotationSuggestions: cAnnotationSuggestions, extractionWarning } = await collectProtocolViolations(ctx, callGraph);
     const expressResult = collectExpressViolations(ctx);
     const nestjsResult = collectNestJSViolations(ctx);
     const trpcResult = collectTRPCViolations(ctx);
@@ -218,12 +218,20 @@ async function evaluateTrust(ctx) {
             score: effectiveScore,
             decision,
             confidence,
-            coverageConfidence: {
-                score: coverageConfidence.score,
-                margin: coverageConfidence.margin,
-                level: coverageConfidence.level,
-                summary: coverageConfidence.summary,
-            },
+            coverageConfidence: extractionWarning
+                ? {
+                    score: 0,
+                    margin: 25,
+                    level: "LOW",
+                    summary: `${extractionWarning}——本次扫描是废票，不得据此得出「干净」结论`,
+                }
+                : {
+                    score: coverageConfidence.score,
+                    margin: coverageConfidence.margin,
+                    level: coverageConfidence.level,
+                    summary: coverageConfidence.summary,
+                },
+            extractionWarning,
             mappingCoverage: mappingCoverageData.totalApis > 0
                 ? {
                     rate: Math.round(((mappingCoverageData.lookupHits + mappingCoverageData.llmHits) /
@@ -1208,6 +1216,8 @@ async function collectProtocolViolations(ctx, callGraph) {
     const annotationRuleNames = new Set();
     // C 注解建议（函数级作用域——返回值在 try 外组装）
     let annotationSuggestions;
+    // 2026-09-22：提取失败标记（跨 try 作用域，随结果返回）
+    let extractionWarning;
     try {
         // ── P4.5 校准：TS/JS 项目在 ir.json 缺失时先提取 IR ──
         // 序列必须来自「函数体内真实调用」而非「文件内函数声明名单」——
@@ -1255,10 +1265,35 @@ async function collectProtocolViolations(ctx, callGraph) {
                             `需重提取运行 PROGMUNE_IR_REEXTRACT=always 或删除 ir.json）`);
                     }
                     if (shouldExtract) {
-                        const ir = extractFn();
-                        // C 走合并形态（与 execute/MCP 写盘一致）；TS/Python 保持裸数组形态
-                        const payload = lang === "c" ? { typeMap: {}, functions: ir } : ir;
-                        fs.writeFileSync(path.join(ctx.projectPath, "ir.json"), JSON.stringify(payload, null, 2));
+                        try {
+                            const ir = extractFn();
+                            // C 走合并形态（与 execute/MCP 写盘一致）；TS/Python 保持裸数组形态
+                            const payload = lang === "c" ? { typeMap: {}, functions: ir } : ir;
+                            fs.writeFileSync(path.join(ctx.projectPath, "ir.json"), JSON.stringify(payload, null, 2));
+                        }
+                        catch (extractErr) {
+                            // 2026-09-22：提取异常不再静默吞掉——OOM 杀（exit 137）等失败
+                            // 必须发声，否则引擎带着空 IR 输出「0 违规」的假干净结论
+                            extractionWarning = `IR 提取失败（${extractErr?.message || extractErr}）——结果不可信`;
+                        }
+                    }
+                    // 2026-09-22：提取后验尸——ir.json 存在但函数数为 0 且项目确有
+                    // 源码时，说明提取被静默截断（如 python3 被 OOM 杀后留下 2 字节
+                    // 空数组），同样记为失败
+                    if (!extractionWarning) {
+                        try {
+                            const irPath2 = path.join(ctx.projectPath, "ir.json");
+                            if (fs.existsSync(irPath2)) {
+                                const raw = fs.readFileSync(irPath2, "utf-8");
+                                const parsed = JSON.parse(raw);
+                                const fnCount = Array.isArray(parsed) ? parsed.length : (parsed.functions || []).length;
+                                if (fnCount === 0 && freshness.scannedFiles > 0) {
+                                    extractionWarning = `IR 提取产物为空（0 函数，但项目有 ${freshness.scannedFiles} 个源文件）——提取可能被 OOM 截断，结果不可信`;
+                                    console.warn(`[progmune] ⚠️ ${extractionWarning}`);
+                                }
+                            }
+                        }
+                        catch { /* best-effort */ }
                     }
                 }
                 catch { /* best-effort — 回退正则扫描 */ }
@@ -1590,6 +1625,7 @@ async function collectProtocolViolations(ctx, callGraph) {
             },
         } : undefined,
         annotationSuggestions,
+        extractionWarning,
     };
 }
 function extractCallSequencesFromProject(projectPath, language, keepNames) {

package/package.json

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