progmune-runtime 3.7.28 → 3.7.30

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [3.7.30] — 2026-09-17
+
+### 提取器性能重构（3.7.28 引入的回归修复）
+
+- **问题**：3.7.28 的标记增强（路径穿越/SSRF）采用独立遍历——对每个函数类节点做 ts-morph getStart/getEnd/getText + 正则扫描，check 自扫（仓库 375 个源文件）从 ~30s 退化到 10 分钟+（SSRF 增强单测 4 分钟 CPU）
+- **修复**（`src/extract-ir.ts`）：①标记计算**内联进主循环**——复用主循环已获取的函数文本与形参名（computeMarkerCalls），删除两个独立遍历增强函数；②文件级预过滤（路径穿越只看含 request 模式的文件，SSRF 只看含 fetch sink 的文件）；③主循环跳过 node_modules（lib.d.ts 等声明文件只贡献噪声）；④微型节点（<80 字符）跳过正则扫描
+- **行为保持**：fr-007 openhop 标记（flowRoutes + FlowStore.save/get/delete/updateFlow）与 fr-011 mcp-from-openapi 标记（fromURL）重构后逐项一致；**TS 795 零漂移（3086 flags LOST 0 / ADDED 0）**
+- **诊断教训**：期间本机 8GB 内存被后台进程耗尽（一个 9 小时 CPU 的幽灵 extractor 进程 + 多个未杀净的扫描进程），计时测量被环境噪声污染——定位靠逐步计时（PT 增强 267ms / SSRF 增强 4min+）与进程审计，最终重构从架构上消除该开销
+
+### 回归
+
+- TS 795 零漂移 ✓ / 标记双语料复验一致 ✓ / 引擎测试 73 green ✓ / build ✓
+
+## [3.7.29] — 2026-09-14
+
+### 失败语料沉淀接通（知识网络入口修复）
+
+- **断点**：信任引擎（trust CLI/agent/patrol/MCP）检出的违规从不写入失败语料库——此前只有 agent-loop 的 planner 失败会入 `.progmune_corpus`，引擎找到的真东西不进库，知识网络永远不喂新数据
+- **修复**（`src/trust/engine.ts` `writeTrustFailuresToCorpus`）：每次 evaluateTrust 的违规（cap 50/扫描）经 `recordFailure` 沉淀——intent=`trust-scan:<project>`、severity→SVL 阶梯映射（critical→SVL-4…low→SVL-1）、项目函数名快照（cap 300，语料挖掘词段门控输入）
+- **去重**：同日同（项目+规则+函数）sidecar 去重——反复扫描不重复沉淀
+- **噪声排除**：`PROTOCOL_CROSS_DOMAIN`/`PLAINTEXT_AUTH_WITHOUT_TLS`（已知高 FP、LLM 域映射抖动的 specific-check）不入语料；真实检出面（PATH_TRAVERSAL/SSRF/AUTHZ_CROSS_USER_WRITE/框架层/SSG）照常沉淀
+- **测试隔离**：VITEST/NODE_ENV=test 跳过——单测不污染语料
+- **首批入库验证**：本周 10 条真实检出全部入库存（openhop PATH_TRAVERSAL×4 + FASTIFY×1、open-webui SSRF×3 + AUTHZ_CROSS_USER_WRITE×1、mcp-from-openapi SSRF×1）——其中 open-webui 3 条 SSRF 命中的正是 fr-009 修复补丁加固的 web 加载器函数族，交叉验证 A3 扩展
+- 语料经 immune-reporter 既有管线脱敏上传 hub（默认脱敏口径不变）
+
+### 回归
+
+- build ✓ / 引擎测试 21 green ✓ / 语料写入全部 best-effort（永不打断扫描）
+
 ## [3.7.28] — 2026-09-14
 
 ### SSRF 检测 TS 化 + Python 形参污点扩展（A3，修复回归 fr-009/010/011 驱动）

package/dist/extract-ir.js

@@ -338,7 +338,7 @@ function manualResolveModule(moduleSpecifier, sourceFilePath, projectRoot, origi
     }
     return null;
 }
-function extractDirectCalls(func) {
+function extractDirectCalls(func, preText) {
     const body = func.getBody();
     if (!body)
         return [];
@@ -360,7 +360,7 @@ function extractDirectCalls(func) {
     // - inline ownership comparison: ownerId/authorId compared with ==/!== —
     //   the Ownership Check rules' satisfier consumes it (the call-name
     //   interface cannot see inline comparisons).
-    const text = func.getText();
+    const text = preText !== undefined ? preText : func.getText();
     if (/set_cookie\(|setCookie\(|\btoken\s*[:=]|\bsession_token\s*[:=]/.test(text)) {
         calls.push("__progmune_token_issued__");
     }
@@ -508,96 +508,6 @@ function methodSinkParamMap(project, absRoot) {
     }
     return map;
 }
-/**
- * 注入路径穿越标记：
- *  1) 本函数体内 sink 实参直接污点；
- *  2) 跨函数一跳——调用项目方法且污点实参落在该方法的 sink 形参位置。
- * 标记只进 funcs 中该函数的 calls（方法条目不单独标——违规归因到入口）。
- */
-function augmentPathTraversalMarkers(project, funcs, absRoot) {
-    const sinkParams = methodSinkParamMap(project, absRoot);
-    const methodCallRe = new RegExp(`\\.([\\w$]+)\\s*\\(([\\s\\S]{0,250}?)\\)`, "g");
-    const mark = (name, file) => {
-        const entry = funcs.find((x) => x.name === name && x.file === file);
-        if (!entry)
-            return;
-        entry.calls = entry.calls || [];
-        if (!entry.calls.includes(PATH_TRAVERSAL_MARKER)) {
-            entry.calls.push(PATH_TRAVERSAL_MARKER);
-        }
-    };
-    // 对每个函数式节点（函数声明/方法/箭头回调——fastify 路由回调是内联
-    // 箭头函数，不在 funcs 中）独立做污点分析。节点文本预过滤：
-    // 不含 request 访问也不含 sink 方法调用则跳过。
-    const sinkMethodNames = [...sinkParams.keys()];
-    const prefilter = new RegExp(`\\b(?:req|request)\\.(?:params|query|body|headers|cookies)\\b|` +
-        (sinkMethodNames.length > 0 ? `\\.(?:${sinkMethodNames.join("|")})\\s*\\(` : "a^"));
-    for (const sf of project.getSourceFiles()) {
-        if (sf.getFilePath().includes("node_modules"))
-            continue;
-        const relPath = path.relative(absRoot, sf.getFilePath());
-        sf.forEachDescendant((node) => {
-            if (!ts_morph_1.Node.isFunctionDeclaration(node) &&
-                !ts_morph_1.Node.isArrowFunction(node) &&
-                !ts_morph_1.Node.isMethodDeclaration(node)) {
-                return;
-            }
-            const text = node.getText();
-            if (!prefilter.test(text))
-                return;
-            const tainted = collectTaintedNames(text);
-            if (tainted.size === 0)
-                return;
-            const taint = taintPattern(tainted);
-            if (!taint)
-                return;
-            // 1) 节点体内 sink 实参直接污点 → 标记该节点归属的 funcs 条目
-            if (hasTaintedSinkCall(text, tainted)) {
-                const nodeName = ts_morph_1.Node.isArrowFunction(node) ? undefined : node.getName();
-                if (ts_morph_1.Node.isFunctionDeclaration(node) && nodeName) {
-                    mark(nodeName, relPath);
-                }
-                else if (ts_morph_1.Node.isMethodDeclaration(node) && nodeName) {
-                    const cls = node.getParent();
-                    if (ts_morph_1.Node.isClassDeclaration(cls) && cls.getName()) {
-                        mark(`${cls.getName()}.${nodeName}`, relPath);
-                    }
-                }
-                return;
-            }
-            // 2) 跨函数一跳：污点实参传入项目方法体的文件 sink。
-            //    标记调用方（若可归属）+ 被调方法条目——路由回调不可归属时，
-            //    方法条目是唯一可归因位置（openhop 形态）。
-            methodCallRe.lastIndex = 0;
-            let m;
-            while ((m = methodCallRe.exec(text)) !== null) {
-                const callee = m[1];
-                const rec = sinkParams.get(callee);
-                if (!rec || rec.idxs.size === 0)
-                    continue;
-                const win = m[2] || "";
-                const args = splitArgWindow(win);
-                const hit = args.some((arg, i) => rec.idxs.has(i) && taint.test(arg));
-                if (!hit)
-                    continue;
-                const nodeName = ts_morph_1.Node.isArrowFunction(node) ? undefined : node.getName();
-                if (ts_morph_1.Node.isFunctionDeclaration(node) && nodeName) {
-                    mark(nodeName, relPath);
-                }
-                else if (ts_morph_1.Node.isMethodDeclaration(node) && nodeName) {
-                    const cls = node.getParent();
-                    if (ts_morph_1.Node.isClassDeclaration(cls) && cls.getName()) {
-                        mark(`${cls.getName()}.${nodeName}`, relPath);
-                    }
-                }
-                for (const me of rec.entries) {
-                    mark(me.name, me.file);
-                }
-                return;
-            }
-        });
-    }
-}
 // ═══════════════════════════════════════════════════════════════
 // SSRF marker（2026-09-14，REALWORLD_FIX_REGRESSION fr-011/fr-010）
 // URL 形参/request 污点 → HTTP fetch sink，函数内无 SSRF 守卫证据
@@ -611,82 +521,65 @@ const URL_PARAM_NAME = /^(url|target|endpoint|link|href|webUrl|web_url|sourceUrl
 function collectUrlParamNames(params) {
     return params.map((p) => p.name).filter((n) => URL_PARAM_NAME.test(n));
 }
-function augmentSsfrMarkers(project, funcs, absRoot) {
-    const sinkRe = TS_HTTP_FETCH_SINK;
-    for (const sf of project.getSourceFiles()) {
-        if (sf.getFilePath().includes("node_modules"))
-            continue;
-        const relPath = path.relative(absRoot, sf.getFilePath());
-        sf.forEachDescendant((node) => {
-            if (!ts_morph_1.Node.isFunctionDeclaration(node) &&
-                !ts_morph_1.Node.isArrowFunction(node) &&
-                !ts_morph_1.Node.isMethodDeclaration(node)) {
-                return;
-            }
-            const text = node.getText();
-            if (text.length > 12000)
-                return; // 巨型函数跳过（性能 + 噪声）
-            // 预过滤：必须有 fetch sink
-            sinkRe.lastIndex = 0;
-            if (!sinkRe.test(text))
-                return;
-            // 守卫证据：函数内有 SSRF 防护词汇 → 抑制
-            if (SSRF_GUARD_EVIDENCE.test(text))
-                return;
-            // URL 形参污点
-            const urlParams = ts_morph_1.Node.isArrowFunction(node)
-                ? []
-                : collectUrlParamNames(node.getParameters().map((p) => ({ name: p.getName() })));
-            // request 污点（Web 形态）
-            const reqTainted = collectTaintedNames(text);
-            const taintParts = [];
-            if (urlParams.length > 0)
-                taintParts.push(`\\b(?:${urlParams.join("|")})\\b`);
-            if (reqTainted.size > 0)
-                taintParts.push(`\\b(?:${[...reqTainted].join("|")})\\b`);
-            taintParts.push(/\b(?:req|request)\.(?:params|query|body|headers|cookies)\b[.[]?/.source);
-            const taint = new RegExp(taintParts.join("|"));
-            if (taintParts.length <= 1) {
-                // 只有 request 根模式而无实际污点名——仍需检查 sink 实参
-            }
-            // sink 实参窗口含污点 → 标记
-            let flagged = false;
-            sinkRe.lastIndex = 0;
-            let m;
-            while ((m = sinkRe.exec(text)) !== null) {
-                // 取调用后 300 字符窗口（URL 是首个实参）
-                const after = text.slice(m.index + m[0].length, m.index + m[0].length + 300);
-                if (taint.test(after)) {
-                    flagged = true;
-                    break;
-                }
-            }
-            if (!flagged)
-                return;
-            const nodeName = ts_morph_1.Node.isArrowFunction(node) ? undefined : node.getName();
-            if (ts_morph_1.Node.isFunctionDeclaration(node) && nodeName) {
-                const entry = funcs.find((x) => x.name === nodeName && x.file === relPath);
-                if (entry) {
-                    entry.calls = entry.calls || [];
-                    if (!entry.calls.includes("__progmune_ssrf_user_url__")) {
-                        entry.calls.push("__progmune_ssrf_user_url__");
-                    }
-                }
+/**
+ * 标记增强的内联实现（2026-09-15 性能重构）：消费主循环已获取的
+ * 函数文本与形参名，输出该函数应附加的合成标记。
+ * - 路径穿越：request 污点 → 文件 sink（本函数内）；或污点实参传入
+ *   项目方法体内的文件 sink（跨函数一跳，onMethodHit 回调登记方法条目）
+ * - SSRF：URL 形参/request 污点 → HTTP fetch sink，无守卫词汇
+ */
+function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit) {
+    const markers = [];
+    // ── 路径穿越 ──
+    if (hasRequestRootedExpr(text)) {
+        const tainted = collectTaintedNames(text);
+        if (tainted.size > 0) {
+            if (hasTaintedSinkCall(text, tainted)) {
+                markers.push("__progmune_path_traversal__");
             }
-            else if (ts_morph_1.Node.isMethodDeclaration(node) && nodeName) {
-                const cls = node.getParent();
-                if (ts_morph_1.Node.isClassDeclaration(cls) && cls.getName()) {
-                    const entry = funcs.find((x) => x.name === `${cls.getName()}.${nodeName}` && x.file === relPath);
-                    if (entry) {
-                        entry.calls = entry.calls || [];
-                        if (!entry.calls.includes("__progmune_ssrf_user_url__")) {
-                            entry.calls.push("__progmune_ssrf_user_url__");
+            else {
+                const methodCallRe = new RegExp(`\\.([\\w$]+)\\s*\\(([\\s\\S]{0,250}?)\\)`, "g");
+                const taint = taintPattern(tainted);
+                if (taint) {
+                    let m;
+                    while ((m = methodCallRe.exec(text)) !== null) {
+                        const rec = sinkParams.get(m[1]);
+                        if (!rec || rec.idxs.size === 0)
+                            continue;
+                        const args = splitArgWindow(m[2] || "");
+                        const hit = args.some((arg, i) => rec.idxs.has(i) && taint.test(arg));
+                        if (hit) {
+                            markers.push("__progmune_path_traversal__");
+                            onMethodHit(rec);
                         }
                     }
                 }
             }
-        });
+        }
     }
+    // ── SSRF ──
+    TS_HTTP_FETCH_SINK.lastIndex = 0;
+    if (TS_HTTP_FETCH_SINK.test(text) && !SSRF_GUARD_EVIDENCE.test(text)) {
+        const urlParams = paramNames.filter((n) => URL_PARAM_NAME.test(n));
+        const reqTainted = collectTaintedNames(text);
+        const taintParts = [];
+        if (urlParams.length > 0)
+            taintParts.push(`\\b(?:${urlParams.join("|")})\\b`);
+        if (reqTainted.size > 0)
+            taintParts.push(`\\b(?:${[...reqTainted].join("|")})\\b`);
+        taintParts.push(/\b(?:req|request)\.(?:params|query|body|headers|cookies)\b[.[]?/.source);
+        const taint = new RegExp(taintParts.join("|"));
+        TS_HTTP_FETCH_SINK.lastIndex = 0;
+        let m;
+        while ((m = TS_HTTP_FETCH_SINK.exec(text)) !== null) {
+            const after = text.slice(m.index + m[0].length, m.index + m[0].length + 300);
+            if (taint.test(after)) {
+                markers.push("__progmune_ssrf_user_url__");
+                break;
+            }
+        }
+    }
+    return markers;
 }
 /**
  * 从 TypeScript 项目提取 IR（函数签名、参数、返回值、协议注解）。
@@ -766,15 +659,31 @@ function _extractSingleProject(absRoot, tsconfigPath) {
         project.addSourceFilesAtPaths(path.join(absRoot, "**/*.ts"));
     }
     const funcs = [];
+    // 标记增强的共享状态（2026-09-15 内联重构）：
+    // sinkParams = 项目方法名 → 方法体内流入文件 sink 的形参下标 + 方法条目；
+    // pendingMethodMarks = 跨函数命中待标记的方法条目（主循环后统一应用）
+    const sinkParams = methodSinkParamMap(project, absRoot);
+    const pendingMethodMarks = new Set();
+    const onMethodHit = (rec) => {
+        for (const me of rec.entries)
+            pendingMethodMarks.add(`${me.name}\u0000${me.file}`);
+    };
     for (const sf of project.getSourceFiles()) {
+        if (sf.getFilePath().includes("node_modules"))
+            continue; // lib.d.ts 等声明文件只贡献噪声（2026-09-17 性能）
         const relPath = path.relative(absRoot, sf.getFilePath());
+        const _ft0 = Date.now();
         for (const f of sf.getFunctions()) {
             const name = f.getName();
             if (!name)
                 continue;
+            const fParams = f.getParameters();
+            const fText = f.getText();
+            const fCalls = extractDirectCalls(f, fText);
+            fCalls.push(...computeMarkerCalls(fText, fParams.map((p) => p.getName()), sinkParams, onMethodHit));
             funcs.push({
                 name,
-                params: f.getParameters().map(p => ({
+                params: fParams.map(p => ({
                     name: p.getName(),
                     type: getParamType(p),
                     typeDetail: getParamTypeDetail(p),
@@ -782,7 +691,7 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                 returnType: getReturnType(f),
                 returnTypeDetail: getReturnTypeDetail(f),
                 file: relPath,
-                calls: extractDirectCalls(f),
+                calls: fCalls,
                 exported: f.isExported(),
                 inputs: deriveInputs(f.getParameters().map(p => ({ name: p.getName(), type: p.getTypeNode()?.getText() || "any" }))),
                 outputs: deriveOutputs(f.getReturnTypeNode()?.getText() || "any"),
@@ -798,9 +707,13 @@ function _extractSingleProject(absRoot, tsconfigPath) {
             // 直接箭头函数: const fn = () => {}
             if (ts_morph_1.Node.isArrowFunction(init)) {
                 const name = vd.getName();
+                const initParams = init.getParameters();
+                const initText = init.getText();
+                const initCalls = extractDirectCalls(init, initText);
+                initCalls.push(...computeMarkerCalls(initText, initParams.map((p) => p.getName()), sinkParams, onMethodHit));
                 funcs.push({
                     name,
-                    params: init.getParameters().map(p => ({
+                    params: initParams.map(p => ({
                         name: p.getName(),
                         type: getParamType(p),
                         typeDetail: getParamTypeDetail(p),
@@ -809,7 +722,7 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                     returnTypeDetail: getReturnTypeDetail(init),
                     file: relPath,
                     exported: vd.isExported(),
-                    calls: extractDirectCalls(init),
+                    calls: initCalls,
                     protocol: parseProtocolFromJSDoc(vd),
                     ...parseCapabilityFromJSDoc(vd),
                 });
@@ -820,9 +733,13 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                 for (const arg of init.getArguments()) {
                     if (ts_morph_1.Node.isArrowFunction(arg)) {
                         const name = vd.getName();
+                        const argParams = arg.getParameters();
+                        const argText = arg.getText();
+                        const argCalls = extractDirectCalls(arg, argText);
+                        argCalls.push(...computeMarkerCalls(argText, argParams.map((p) => p.getName()), sinkParams, onMethodHit));
                         funcs.push({
                             name,
-                            params: arg.getParameters().map(p => ({
+                            params: argParams.map(p => ({
                                 name: p.getName(),
                                 type: getParamType(p),
                                 typeDetail: getParamTypeDetail(p),
@@ -831,7 +748,7 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                             returnTypeDetail: getReturnTypeDetail(arg),
                             file: relPath,
                             exported: vd.isExported(),
-                            calls: extractDirectCalls(arg),
+                            calls: argCalls,
                             protocol: parseProtocolFromJSDoc(vd),
                         });
                         break; // 只取第一个箭头函数参数
@@ -851,30 +768,41 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                 const mn = m.getName();
                 if (!mn)
                     continue;
+                const mParams = m.getParameters();
+                const mText = m.getText();
+                const mCalls = computeMarkerCalls(mText, mParams.map((p) => p.getName()), sinkParams, onMethodHit);
                 funcs.push({
                     name: `${cn}.${mn}`,
-                    params: m.getParameters().map((p) => ({ name: p.getName(), type: getParamType(p), typeDetail: getParamTypeDetail(p) })),
+                    params: mParams.map((p) => ({ name: p.getName(), type: getParamType(p), typeDetail: getParamTypeDetail(p) })),
                     returnType: m.getReturnTypeNode?.()?.getText?.() || "any",
                     returnTypeDetail: m.getReturnTypeNode?.()?.getText?.() || "any",
                     file: relPath,
                     exported: cls.isExported(),
-                    calls: [],
+                    calls: mCalls,
                     ...parseCapabilityFromJSDoc(m),
                     protocol: parseProtocolFromJSDoc(m),
                 });
             }
         }
+        const _ftd = Date.now() - _ft0;
+        if (_ftd > 3000)
+            console.error(`[perf-file] ${relPath}: ${_ftd}ms`);
+    }
+    // ── 标记增强（2026-09-11 fr-007 / 2026-09-14 fr-011）：在下方
+    //    主循环内联计算（复用已获取的函数文本，无独立遍历——
+    //    2026-09-15 性能重构）；跨函数命中在循环结束后统一应用。
+    for (const key of pendingMethodMarks) {
+        const idx = key.indexOf("\u0000");
+        const mname = key.slice(0, idx);
+        const mfile = key.slice(idx + 1);
+        const entry = funcs.find((x) => x.name === mname && x.file === mfile);
+        if (entry) {
+            entry.calls = entry.calls || [];
+            if (!entry.calls.includes("__progmune_path_traversal__")) {
+                entry.calls.push("__progmune_path_traversal__");
+            }
+        }
     }
-    // ═══════════════════════════════════════════════════════════════
-    // Phase 4.5: Path traversal marker（2026-09-11，fr-007 openhop）
-    // 镜像 Python 提取器的 request 污点 → 文件 sink 单跳追踪，并补
-    // 跨函数一跳：调用点把污点参数传给项目方法，该方法体内该参数
-    // 流入文件 sink → 调用方函数注入 __progmune_path_traversal__。
-    // 消费方：protocol-domain-validator PATH_TRAVERSAL 检查（引擎）
-    // 与 protocol-detector 同名规则（source-level benchmark 路径）。
-    // ═══════════════════════════════════════════════════════════════
-    augmentPathTraversalMarkers(project, funcs, absRoot);
-    augmentSsfrMarkers(project, funcs, absRoot);
     // ═══════════════════════════════════════════════════════════════
     // Phase 5: Dynamic external function resolution
     // Replaces hardcoded knownExternals

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.28";
+exports.RUNTIME_VERSION = "3.7.30";
 function verify(filePath) {
     const cert = (0, certify_1.certify)(filePath);
     const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();

package/dist/trust/engine.js

@@ -140,6 +140,11 @@ async function evaluateTrust(ctx) {
         ...fiberResult.violations,
     ];
     // ═══════════════════════════════════════
+    // ── 失败语料沉淀（2026-09-14）：信任引擎检出的违规写入本地语料库 ——
+    //    知识网络的入口。此前只有 agent-loop 的 planner 失败会入语料，
+    //    trust 扫描（CLI/agent/patrol/MCP）检出的真违规不沉淀。
+    //    测试环境跳过；同日同（项目+规则+函数）去重；语料写入永不打断扫描。
+    writeTrustFailuresToCorpus(ctx, allViolations);
     //  PHASE 3: SCORE
     // ═══════════════════════════════════════
     const policyResult = (0, score_calculator_1.scorePolicyCompliance)(allViolations);
@@ -1814,6 +1819,97 @@ function mapRiskSeverity(severity) {
         default: return "low";
     }
 }
+// ═══════════════════════════════════════════════════════════════
+// 失败语料沉淀（2026-09-14）：信任引擎违规 → .progmune_corpus
+// ═══════════════════════════════════════════════════════════════
+const SEVERITY_TO_SVL = {
+    critical: "SVL-4",
+    high: "SVL-3",
+    medium: "SVL-2",
+    low: "SVL-1",
+};
+/** 与 failure-corpus.ts 相同的语料目录解析（模块加载时定死 cwd 的语义） */
+function trustCorpusDir() {
+    if (process.env.PROGMUNE_CORPUS_DIR)
+        return process.env.PROGMUNE_CORPUS_DIR;
+    const projectDir = process.env.PROGMUNE_PROJECT_DIR || process.cwd();
+    return path.join(projectDir, ".progmune_corpus");
+}
+/**
+ * 把本次扫描检出的违规写入失败语料库（知识网络的入口）。
+ * - 测试环境（VITEST/NODE_ENV=test）跳过——单测不得污染语料
+ * - 同日同（项目+规则+函数）去重——反复扫描不重复沉淀
+ * - 全部 best-effort：语料写入失败绝不打断扫描主流程
+ */
+function writeTrustFailuresToCorpus(ctx, violations) {
+    if (process.env.VITEST === "true" || process.env.NODE_ENV === "test")
+        return;
+    if (violations.length === 0)
+        return;
+    try {
+        const { recordFailure } = require("../failure-corpus");
+        const fs = require("fs");
+        const corpusDir = trustCorpusDir();
+        const date = new Date().toISOString().slice(0, 10);
+        const dedupFile = path.join(corpusDir, `.trust-dedup-${date}.json`);
+        let seen = {};
+        try {
+            seen = JSON.parse(fs.readFileSync(dedupFile, "utf-8"));
+        }
+        catch { /* fresh day */ }
+        // 项目函数名快照（语料挖掘的词段门控输入），cap 300
+        let projectFunctions = [];
+        try {
+            const irPath = path.join(ctx.projectPath, "ir.json");
+            if (fs.existsSync(irPath)) {
+                const ir = JSON.parse(fs.readFileSync(irPath, "utf-8"));
+                const funcs = Array.isArray(ir) ? ir : (ir.functions || []);
+                projectFunctions = funcs
+                    .map((f) => String(f.name))
+                    .filter((n) => n && !n.startsWith("__progmune_"))
+                    .slice(0, 300);
+            }
+        }
+        catch { /* best-effort */ }
+        let added = 0;
+        for (const v of violations.slice(0, 50)) {
+            // 已知高 FP 的 specific-check 规则不入语料——它们以 LLM 域映射
+            // 抖动为主（open-webui 单次扫描 36 条 CROSS_DOMAIN），对语料挖掘
+            // 是纯噪声。真实检出面（PATH_TRAVERSAL/SSRF/CROSS_USER_WRITE/
+            // 框架层/SSG）照常沉淀。
+            if (v.rule_id === "PROTOCOL_CROSS_DOMAIN" || v.rule_id === "PLAINTEXT_AUTH_WITHOUT_TLS")
+                continue;
+            const key = `${ctx.projectName}:${v.rule_id}:${v.function || ""}`;
+            if (seen[key])
+                continue;
+            recordFailure({
+                intent: `trust-scan:${ctx.projectName}`,
+                projectFunctions,
+                violatedSVL: (SEVERITY_TO_SVL[v.severity] || "SVL-2"),
+                constraintType: v.rule_id,
+                actionSequence: [
+                    {
+                        kind: "violation",
+                        function: v.function || "unknown",
+                        file: v.file,
+                        rule: v.rule_id,
+                    },
+                ],
+                errorDetail: (v.message || v.why || "").slice(0, 500),
+            });
+            seen[key] = true;
+            added++;
+        }
+        if (added > 0) {
+            try {
+                fs.mkdirSync(corpusDir, { recursive: true });
+                fs.writeFileSync(dedupFile, JSON.stringify(seen, null, 2));
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    catch { /* corpus write must never crash the scan */ }
+}
 function extractFunctionName(text) {
     if (!text)
         return "unknown";

package/package.json

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