progmune-runtime 3.7.31 → 3.7.35

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",
@@ -385,21 +535,49 @@ const TS_FILE_SINK_NAMES = [
     "createWriteStream", "existsSync", "readdir", "readdirSync",
     "copyFile", "rename", "stat", "lstat", "rmdir", "truncate",
 ];
+// ═══════════════════════════════════════════════════════════════
+// 不可信入口根表 —— 污点数据流试点（2026-09-18）
+//
+// 此前整条污点链路只锚定 Express 形态的
+// `(?:req|request)\.(?:params|query|body|headers|cookies)`，
+// 即**根集合只有一种来源**。后果是 MCP 工具实参、CLI 参数、URL 解码产物
+// 等来源天然不可见：fr-012 的 `args.file_path`（← params.arguments）与
+// fr-015 的 `font.path`（← URL 解码）都因此 MISS。往 URL_PARAM_NAME 里加
+// 名字解决不了——那只是在已经认错了根的前提下扩充变量名清单（打地鼠）。
+//
+// 本表改为按**传输面**声明根：判定依据是值的来源性质，而不是变量叫什么。
+// 每条根必须窄且可解释，新增需附 `why`（closes #taint-pilot）。
+// ═══════════════════════════════════════════════════════════════
+const UNTRUSTED_ROOTS = [
+    {
+        id: "http_request",
+        expr: String.raw `\b(?:req|request)\.(?:params|query|body|headers|cookies)\b[.[]?`,
+        why: "HTTP 请求对象字段，Express/Koa/Fastify/Nest 等通用形态",
+    },
+    {
+        id: "mcp_tool_args",
+        expr: String.raw `\bparams\.arguments\b[.[]?`,
+        why: "MCP CallToolRequest.params.arguments —— 工具调用实参，调用方可控（fr-012）",
+    },
+];
+/** 所有根的来源片段，供 **无标志** 的布尔探测正则使用 */
+const UNTRUSTED_ROOT_SRC = UNTRUSTED_ROOTS.map((r) => `(?:${r.expr})`).join("|");
+/** 既有的 request 根语义，改由根表统一提供 */
+function hasRequestRootedExpr(text) {
+    return new RegExp(UNTRUSTED_ROOT_SRC).test(text);
+}
 function tsSinkCallRegex() {
     return new RegExp(`(?:^|[^\\w.$])(?:await\\s+)?(?:[\\w$]+\\.)?(${TS_FILE_SINK_NAMES.join("|")})\\s*\\(([\\s\\S]{0,250}?)\\)`, "g");
 }
-/** request 根表达式：req.params / request.body / req.query['x'] … */
-function hasRequestRootedExpr(text) {
-    return /\b(?:req|request)\.(?:params|query|body|headers|cookies)\b[.[]?/.test(text);
-}
-/** 函数体内被 request 污染的局部名（含解构与单跳赋值，深度 ≤2） */
+/** 函数体内被不可信根污染的局部名（含解构与单跳赋值，深度 ≤2） */
 function collectTaintedNames(text) {
     const tainted = new Set();
     let m;
-    const direct = /(?:const|let|var)\s+([\w$]+)\s*=\s*(?:await\s+)?(?:req|request)\.(?:params|query|body|headers|cookies)\b[.[]?/g;
+    const root = UNTRUSTED_ROOT_SRC;
+    const direct = new RegExp(`(?:const|let|var)\\s+([\\w$]+)\\s*=\\s*(?:await\\s+)?(?:${root})`, "g");
     while ((m = direct.exec(text)) !== null)
         tainted.add(m[1]);
-    const destr = /(?:const|let|var)\s*\{\s*([^}=]*?)\s*\}\s*=\s*(?:await\s+)?(?:req|request)\.(?:params|query|body|headers|cookies)\b/g;
+    const destr = new RegExp(`(?:const|let|var)\\s*\\{\\s*([^}=]*?)\\s*\\}\\s*=\\s*(?:await\\s+)?(?:${root})`, "g");
     while ((m = destr.exec(text)) !== null) {
         for (const part of m[1].split(",")) {
             const name = part.trim().split(":")[0].trim();
@@ -407,7 +585,7 @@ function collectTaintedNames(text) {
                 tainted.add(name);
         }
     }
-    const bareAssign = /(?:^|[^\w$.])([\w$]+)\s*=\s*(?:req|request)\.(?:params|query|body|headers|cookies)\b[.[]?/g;
+    const bareAssign = new RegExp(`(?:^|[^\\w$.])([\\w$]+)\\s*=\\s*(?:await\\s+)?(?:${root})`, "g");
     while ((m = bareAssign.exec(text)) !== null)
         tainted.add(m[1]);
     // 单跳传播（深度 ≤2）
@@ -429,9 +607,7 @@ function collectTaintedNames(text) {
     return tainted;
 }
 function taintPattern(tainted) {
-    const parts = [
-        /\b(?:req|request)\.(?:params|query|body|headers|cookies)\b[.[]?/.source,
-    ];
+    const parts = [UNTRUSTED_ROOT_SRC];
     if (tainted.size > 0) {
         parts.push(`\\b(?:${[...tainted].join("|")})\\b`);
     }
@@ -474,6 +650,27 @@ function splitArgWindow(win) {
 /** 项目方法名 → 方法体内流入文件 sink 的形参下标集合 */
 function methodSinkParamMap(project, absRoot) {
     const map = new Map();
+    const register = (keyName, fullName, text, relPath, params) => {
+        const sinkRe = tsSinkCallRegex();
+        let sm;
+        while ((sm = sinkRe.exec(text)) !== null) {
+            const win = sm[2] || "";
+            params.forEach((pname, idx) => {
+                if (!pname)
+                    return;
+                if (!new RegExp(`\\b${pname}\\b`).test(win))
+                    return;
+                if (!map.has(keyName)) {
+                    map.set(keyName, { idxs: new Set(), entries: [] });
+                }
+                const rec = map.get(keyName);
+                rec.idxs.add(idx);
+                if (!rec.entries.some((e) => e.name === fullName)) {
+                    rec.entries.push({ name: fullName, file: relPath });
+                }
+            });
+        }
+    };
     for (const sf of project.getSourceFiles()) {
         const relPath = path.relative(absRoot, sf.getFilePath());
         for (const cls of sf.getClasses()) {
@@ -484,27 +681,23 @@ function methodSinkParamMap(project, absRoot) {
                 const params = m.getParameters().map((p) => p.getName());
                 if (params.length === 0)
                     continue;
-                const text = m.getText();
-                const sinkRe = tsSinkCallRegex();
-                let sm;
-                while ((sm = sinkRe.exec(text)) !== null) {
-                    const win = sm[2] || "";
-                    params.forEach((pname, idx) => {
-                        if (new RegExp(`\\b${pname}\\b`).test(win)) {
-                            if (!map.has(m.getName())) {
-                                map.set(m.getName(), { idxs: new Set(), entries: [] });
-                            }
-                            const rec = map.get(m.getName());
-                            rec.idxs.add(idx);
-                            const fullName = `${cn}.${m.getName()}`;
-                            if (!rec.entries.some((e) => e.name === fullName)) {
-                                rec.entries.push({ name: fullName, file: relPath });
-                            }
-                        }
-                    });
-                }
+                register(m.getName(), `${cn}.${m.getName()}`, m.getText(), relPath, params);
             }
         }
+        // ── 污点数据流试点（2026-09-18）──
+        // 此前只登记**类方法**。真实 TS 工程大量使用顶层函数声明（MCP handler、
+        // Nuxt runtime binding、工具函数），跨函数一跳对它们完全不生效——fr-012 的
+        // `markdownUpload` 正是顶层函数，因此从未进入本表，即使上游 taint 已识别，
+        // 也无法传导到 sink。这里按同样的「形参 → 文件 sink」规则纳入函数声明。
+        for (const fn of sf.getFunctions()) {
+            const fnName = fn.getName();
+            if (!fnName)
+                continue;
+            const params = fn.getParameters().map((p) => p.getName());
+            if (params.length === 0)
+                continue;
+            register(fnName, fnName, fn.getText(), relPath, params);
+        }
     }
     return map;
 }
@@ -541,29 +734,50 @@ 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__");
             }
             else {
                 const methodCallRe = new RegExp(`\\.([\\w$]+)\\s*\\(([\\s\\S]{0,250}?)\\)`, "g");
+                // ── 污点数据流试点（2026-09-18）──
+                // 此前只识别成员调用（`obj.sink(...)`）。顶层/模块内函数是真实 TS 工程
+                // 的主要形态（fr-012 的 `markdownUpload(...)` 就是裸调用），缺这一则
+                // 即使该函数的形参已登记为 sink 形参，taint 也无法传导过去。
+                const directCallRe = new RegExp(`(?:^|[^\\w$.])([\\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);
+                    for (const callRe of [methodCallRe, directCallRe]) {
+                        callRe.lastIndex = 0;
+                        let m;
+                        while ((m = callRe.exec(text)) !== null) {
+                            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) {
+                                markers.push("__progmune_path_traversal__");
+                                onMethodHit(rec);
+                            }
                         }
                     }
                 }
@@ -580,7 +794,7 @@ function computeMarkerCalls(text, paramNames, sinkParams, onMethodHit) {
             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);
+        taintParts.push(UNTRUSTED_ROOT_SRC);
         const taint = new RegExp(taintParts.join("|"));
         const fetchSinkIter = tsHttpFetchSinkIter();
         let m;
@@ -676,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)
@@ -693,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 => ({
@@ -723,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 => ({
@@ -749,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 => ({
@@ -783,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/ir-staleness.js

@@ -0,0 +1,233 @@
+"use strict";
+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 });
+exports.inspectIrFreshness = inspectIrFreshness;
+exports.reextractMode = reextractMode;
+exports.reextractEnabled = reextractEnabled;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * ir.json 陈旧性判定（2026-09-19，独立于污点试点立项）。
+ *
+ * 背景（真实事故，两次会话级误判）：
+ * - trust 引擎的自动提取是「缺才提取」：项目已有 ir.json 就以文件为准、不重生成。
+ * - 该语义在【源码变了但 ir.json 没变】的场景下静默过期——
+ *   ① 分析器读的是旧调用序列（fix-regression 复测结论可能是哑值）；
+ *   ② P4.5 注解合并读同一个 ir.json，旧文件让新加的 @protocol 注解不生效。
+ * - fr-005 首扫报 0（`rm ir.json` 后才报出）、污点试点 V1 的「标记注入但 trust 报 0」
+ *   根因都是同一处。
+ *
+ * 政策：mtime 比对，不做「每次全量重提」。
+ * - 全量重提对 skyvern 级项目是 5–10 分钟量级成本，不能默认付；
+ * - 只在【存在源文件 mtime > ir.json mtime】时才重提，常量级开销（一次 stat 遍历）。
+ * 政策：mtime 比对，不做「每次全量重提」。
+ * - 全量重提对 skyvern 级项目是 5–10 分钟量级成本，不能默认付；对本仓库
+ *   （22k 源文件）足以触发单测 30s 超时——实测教训，见 tests/trust/engine.test.ts。
+ * - 只在【存在源文件 mtime > ir.json mtime】时才重提（一次 stat 遍历，恒定成本）。
+ * - 超大仓库（遍历被 MAX_STATS 截断）默认【只警告不重提】：此时 freshness 证据
+ *   不完整，自动重提会把 CLI 拖到分钟级。确需重提时显式 PROGMUNE_IR_REEXTRACT=always。
+ *
+ * 策略阀 `PROGMUNE_IR_REEXTRACT`：
+ * - 未设（auto）：遍历完整且陈旧 → 重提；遍历被截断 → 只警告
+ * - always      ：只要陈旧就重提（自担成本，用于批量语料复测）
+ * - never       ：回到旧语义（永不重提），但会打「IR 可能陈旧」警告——不允许静默。
+ */
+/** 会被提取器读取的源码后缀（跨语言；不在表内的文件不影响 IR 内容）。 */
+const SOURCE_EXT = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+    ".py", ".c", ".h", ".cc", ".cpp", ".hpp",
+    ".go", ".java", ".rs", ".rb", ".php", ".cs", ".swift", ".kt", ".scala",
+]);
+/** 不可能是业务源码、且体量足以毁掉遍历成本的目录。 */
+const SKIP_DIRS = new Set([
+    "node_modules", ".git", "dist", "build", "out", "coverage", ".next",
+    ".nuxt", ".turbo", ".cache", "__pycache__", ".venv", "venv", "vendor",
+    "target", "bin", "obj", ".gradle", ".idea", ".vscode", ".workbuddy",
+]);
+/** 防御性上限：超大仓库不做无界遍历（宁可漏判也不卡死）。 */
+const MAX_STATS = 20000;
+const MAX_DEPTH = 12;
+/**
+ * auto 模式下愿意为「一次 IR 重提」买单的项目规模上限（源码文件数）。
+ * 超过则只警告不自动重提——重提成本随文件数超线性增长，本仓库（万级源文件）
+ * 实测足以把单测推过 30s 超时。
+ */
+const AUTO_REEXTRACT_FILE_BUDGET = 5000;
+/**
+ * 扫描项目目录，找出最新修改的源码文件。
+ *
+ * 必须【完整遍历】（不做「找到第一个更新的就早退」）：早退会在超大仓库上
+ * 把 truncated 信号抹掉——本仓库（22k 源文件）就是活例：早退后 evidenceComplete
+ * 误为真 → 自动全量重提 → 单测 30s 超时。stat 扫一遍的成本远低于一次 IR 提取，
+ * 换来的是可靠的 fresh 判定与可靠的大仓信号。
+ *
+ * @requires PROJECT_PATH @produces NEWEST_SOURCE
+ * @tags ir, staleness, mtime
+ */
+function newestSourceUnder(root, opts) {
+    const maxStats = opts.maxStats ?? MAX_STATS;
+    const maxDepth = opts.maxDepth ?? MAX_DEPTH;
+    let newestMs = null;
+    let newestFile = null;
+    let scanned = 0;
+    let truncated = false;
+    const walk = (dir, depth) => {
+        if (depth > maxDepth || truncated)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // 权限 / 竞态删除：跳过
+        }
+        for (const ent of entries) {
+            if (truncated)
+                return;
+            if (ent.isDirectory()) {
+                if (SKIP_DIRS.has(ent.name))
+                    continue;
+                if (ent.name.startsWith("."))
+                    continue; // 隐藏目录多为工具产物
+                walk(path.join(dir, ent.name), depth + 1);
+                continue;
+            }
+            if (!ent.isFile())
+                continue;
+            if (!SOURCE_EXT.has(path.extname(ent.name).toLowerCase()))
+                continue;
+            if (scanned >= maxStats) {
+                truncated = true;
+                return;
+            }
+            const full = path.join(dir, ent.name);
+            let st;
+            try {
+                st = fs.statSync(full, { throwIfNoEntry: false }) ?? undefined;
+            }
+            catch {
+                st = undefined;
+            }
+            if (!st)
+                continue;
+            scanned++;
+            if (newestMs === null || st.mtimeMs > newestMs) {
+                newestMs = st.mtimeMs;
+                newestFile = full;
+            }
+        }
+    };
+    walk(root, 0);
+    return { mtimeMs: newestMs, file: newestFile, scannedFiles: scanned, truncated };
+}
+/**
+ * 判定 ir.json 是否需要重新生成。
+ *
+ * - ir.json 不存在 → missing（需提取）
+ * - 存在源码 mtime > ir.json mtime → source-newer（需重提）
+ * - 其余 → fresh / no-sources（沿用磁盘文件）
+ *
+ * @requires PROJECT_PATH @produces IR_FRESHNESS
+ * @tags ir, staleness, mtime
+ * @useWhen evaluateTrust 决定是否自动提取 IR
+ */
+function inspectIrFreshness(projectPath, irPathOverride, opts = {}) {
+    const irPath = irPathOverride || path.join(projectPath, "ir.json");
+    let irStat;
+    try {
+        irStat = fs.statSync(irPath, { throwIfNoEntry: false }) ?? undefined;
+    }
+    catch {
+        irStat = undefined;
+    }
+    const irMtimeMs = irStat ? irStat.mtimeMs : null;
+    const src = newestSourceUnder(projectPath, opts);
+    const exceedsAutoBudget = src.scannedFiles > (opts.autoBudget ?? AUTO_REEXTRACT_FILE_BUDGET);
+    if (!irStat) {
+        return {
+            exists: false,
+            stale: true,
+            reason: "missing",
+            irMtimeMs: null,
+            newestSourceMtimeMs: src.mtimeMs,
+            newestSourcePath: src.file,
+            scannedFiles: src.scannedFiles,
+            truncated: src.truncated,
+            evidenceComplete: false, // 是否有证据都不影响：缺就必须提
+            exceedsAutoBudget,
+        };
+    }
+    if (src.mtimeMs === null) {
+        // 扫不到源码（目标目录不是真源码根，或全是跳过后缀）：无证据 → 保守沿用。
+        return {
+            exists: true,
+            stale: false,
+            reason: "no-sources",
+            irMtimeMs,
+            newestSourceMtimeMs: null,
+            newestSourcePath: null,
+            scannedFiles: 0,
+            truncated: src.truncated,
+            evidenceComplete: !src.truncated,
+            exceedsAutoBudget,
+        };
+    }
+    // 严格大于：ir.json 与源码同刻写出（写源码→随后写 ir.json 的常见顺序）
+    // 判为 fresh，避免把正常管线推入全量重提。
+    const stale = irMtimeMs !== null && src.mtimeMs > irMtimeMs;
+    return {
+        exists: true,
+        stale,
+        reason: stale ? "source-newer" : "fresh",
+        irMtimeMs,
+        newestSourceMtimeMs: src.mtimeMs,
+        newestSourcePath: src.file,
+        scannedFiles: src.scannedFiles,
+        truncated: src.truncated,
+        evidenceComplete: !src.truncated,
+        exceedsAutoBudget,
+    };
+}
+function reextractMode() {
+    const v = (process.env.PROGMUNE_IR_REEXTRACT || "").toLowerCase();
+    if (v === "always")
+        return "always";
+    if (v === "never" || v === "off" || v === "0" || v === "false")
+        return "never";
+    return "auto";
+}
+function reextractEnabled() {
+    return reextractMode() !== "never";
+}