progmune-runtime 3.7.3 → 3.7.4

package/dist/extract-ir-c.test.js

@@ -0,0 +1,400 @@
+"use strict";
+/**
+ * C IR extractor tests — fixture-string-based parser tests via parseCSource
+ * (FS I/O limited to one mkdtemp integration case, per repo convention).
+ */
+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_c_1 = require("./extract-ir-c");
+const PROJECT = "/proj";
+/** Parse a string as /proj/x.c → file "x.c". */
+function parse(src, file = "x.c") {
+    return (0, extract_ir_c_1.parseCSource)(src, path.join(PROJECT, file), PROJECT);
+}
+function fn(ir, name) {
+    const f = ir.find((x) => x.name === name);
+    (0, vitest_1.expect)(f, `expected function ${name}`).toBeDefined();
+    return f;
+}
+(0, vitest_1.describe)("extract-ir-c", () => {
+    (0, vitest_1.it)("基础签名 + 调用列表（auth_flow fixture 内容）", () => {
+        const ir = parse(`
+int authenticate(const char* user, const char* pass) {
+    if (!verify_password(user, pass)) return 0;
+    char* token = generate_jwt(user);
+    session_t* sess = create_session(token);
+    return sess ? 1 : 0;
+}
+void do_logout(session_t* sess) {
+    logout(sess);
+}
+`);
+        (0, vitest_1.expect)(ir.map((f) => f.name)).toEqual(["authenticate", "do_logout"]);
+        const auth = fn(ir, "authenticate");
+        (0, vitest_1.expect)(auth.params).toEqual([
+            { name: "user", type: "const char*" },
+            { name: "pass", type: "const char*" },
+        ]);
+        (0, vitest_1.expect)(auth.returnType).toBe("int");
+        (0, vitest_1.expect)(auth.calls).toEqual(["verify_password", "generate_jwt", "create_session"]);
+        (0, vitest_1.expect)(auth.exported).toBe(true);
+        (0, vitest_1.expect)(auth.external).toBe(false); // isProjectFn 契约
+        (0, vitest_1.expect)(auth.file).toBe("x.c");
+        (0, vitest_1.expect)(auth.tags).toEqual(["c"]);
+        const logout = fn(ir, "do_logout");
+        (0, vitest_1.expect)(logout.params).toEqual([{ name: "sess", type: "session_t*" }]);
+        (0, vitest_1.expect)(logout.returnType).toBe("void");
+        (0, vitest_1.expect)(logout.calls).toEqual(["logout"]);
+        (0, vitest_1.expect)(logout.outputs).toEqual([]);
+    });
+    (0, vitest_1.it)("static 函数 → exported=false，仍被提取", () => {
+        const ir = parse(`static int helper(int x) { return x; }`);
+        const h = fn(ir, "helper");
+        (0, vitest_1.expect)(h.exported).toBe(false);
+        (0, vitest_1.expect)(h.params).toEqual([{ name: "x", type: "int" }]);
+    });
+    (0, vitest_1.it)("多行签名 + 无空格星号返回类型", () => {
+        const ir = parse(`
+int
+compute(const char* a) {
+    return strlen(a);
+}
+static const char*
+get_name(void) {
+    return "x";
+}
+`);
+        const c = fn(ir, "compute");
+        (0, vitest_1.expect)(c.returnType).toBe("int");
+        (0, vitest_1.expect)(c.params).toEqual([{ name: "a", type: "const char*" }]);
+        (0, vitest_1.expect)(c.calls).toEqual(["strlen"]);
+        const g = fn(ir, "get_name");
+        (0, vitest_1.expect)(g.returnType).toBe("const char*");
+        (0, vitest_1.expect)(g.exported).toBe(false);
+        (0, vitest_1.expect)(g.params).toEqual([]);
+    });
+    (0, vitest_1.it)("注释与字符串内的花括号不腐蚀括号计数", () => {
+        const ir = parse(`
+void f(void) {
+    /* { */
+    // }
+    const char* s = "}";
+    g();
+}
+void g2(void) { h(); }
+`);
+        (0, vitest_1.expect)(ir.map((x) => x.name)).toEqual(["f", "g2"]);
+        (0, vitest_1.expect)(fn(ir, "f").calls).toEqual(["g"]);
+        (0, vitest_1.expect)(fn(ir, "g2").calls).toEqual(["h"]);
+    });
+    (0, vitest_1.it)("字符串内容不产生调用", () => {
+        const ir = parse(`void f(void) { const char* s = "foo("; g(); }`);
+        (0, vitest_1.expect)(fn(ir, "f").calls).toEqual(["g"]);
+    });
+    (0, vitest_1.it)("块注释 @progmune 注解", () => {
+        const ir = parse(`
+/* @progmune(namespace="auth", pre=["UNAUTHENTICATED"], post=["PASSWORD_VERIFIED"]) */
+void verify(const char* u, const char* p) { check(u, p); }
+`);
+        const v = fn(ir, "verify");
+        (0, vitest_1.expect)(v.protocol).toEqual({
+            namespace: "auth",
+            pre_states: ["UNAUTHENTICATED"],
+            post_states: ["PASSWORD_VERIFIED"],
+        });
+        (0, vitest_1.expect)(v.calls).toEqual(["check"]);
+    });
+    (0, vitest_1.it)("多行注解 + 全部文档标签", () => {
+        const ir = parse(`
+/*
+ * @progmune(namespace="auth", pre=["A"], post=["B"], invalidate=["C"])
+ * @purpose verify user
+ * @description verifies credentials
+ * @tags auth, security
+ * @requires P1, P2
+ * @produces T1
+ * @useWhen login; recovery
+ * @inputs user, pass
+ * @outputs token
+ */
+int auth(const char* user, const char* pass) { return 1; }
+`);
+        const a = fn(ir, "auth");
+        (0, vitest_1.expect)(a.protocol).toEqual({
+            namespace: "auth",
+            pre_states: ["A"],
+            post_states: ["B"],
+            invalidate: ["C"],
+        });
+        (0, vitest_1.expect)(a.purpose).toBe("verify user");
+        (0, vitest_1.expect)(a.description).toBe("verifies credentials");
+        (0, vitest_1.expect)(a.tags).toEqual(["auth", "security"]);
+        (0, vitest_1.expect)(a.requires).toEqual(["P1", "P2"]);
+        (0, vitest_1.expect)(a.produces).toEqual(["T1"]);
+        (0, vitest_1.expect)(a.useWhen).toEqual(["login", "recovery"]);
+        (0, vitest_1.expect)(a.inputs).toEqual(["user", "pass"]);
+        (0, vitest_1.expect)(a.outputs).toEqual(["token"]);
+    });
+    (0, vitest_1.it)("// @progmune 单行变体", () => {
+        const ir = parse(`
+// @progmune(namespace="file", pre=["OPEN"], post=["CLOSED"])
+void open_file(void) { }
+`);
+        (0, vitest_1.expect)(fn(ir, "open_file").protocol).toEqual({
+            namespace: "file",
+            pre_states: ["OPEN"],
+            post_states: ["CLOSED"],
+        });
+    });
+    (0, vitest_1.it)("注解与函数之间允许空行", () => {
+        const ir = parse(`
+/* @progmune(namespace="auth", pre=["A"], post=["B"]) */
+
+void f(void) {}
+`);
+        (0, vitest_1.expect)(fn(ir, "f").protocol?.namespace).toBe("auth");
+    });
+    (0, vitest_1.it)("只有文档标签、无 @progmune → protocol undefined", () => {
+        const ir = parse(`
+/**
+ * @purpose read config
+ * @tags io
+ */
+void read_conf(void) { }
+`);
+        const r = fn(ir, "read_conf");
+        (0, vitest_1.expect)(r.purpose).toBe("read config");
+        (0, vitest_1.expect)(r.tags).toEqual(["io"]);
+        (0, vitest_1.expect)(r.protocol).toBeUndefined();
+    });
+    (0, vitest_1.it)("纯文件头注释不挂载到首个函数", () => {
+        const ir = parse(`
+/* module overview — plain description */
+int f(void) { return 0; }
+`);
+        const f = fn(ir, "f");
+        (0, vitest_1.expect)(f.purpose).toBe("");
+        (0, vitest_1.expect)(f.description).toBe("");
+        (0, vitest_1.expect)(f.protocol).toBeUndefined();
+    });
+    (0, vitest_1.it)("参数边界：数组/多维/函数指针/变参/裸 void/多词类型", () => {
+        const ir = parse(`
+void a(char buf[256]) {}
+void b(int m[2][3]) {}
+void c(void (*cb)(int)) {}
+void d(...) {}
+void e(void) {}
+void g(unsigned long long n) {}
+`);
+        (0, vitest_1.expect)(fn(ir, "a").params).toEqual([{ name: "buf", type: "char" }]);
+        (0, vitest_1.expect)(fn(ir, "b").params).toEqual([{ name: "m", type: "int" }]);
+        (0, vitest_1.expect)(fn(ir, "c").params).toEqual([{ name: "cb", type: "void (*cb)(int)" }]);
+        (0, vitest_1.expect)(fn(ir, "d").params).toEqual([{ name: "...", type: "..." }]);
+        (0, vitest_1.expect)(fn(ir, "e").params).toEqual([]);
+        (0, vitest_1.expect)(fn(ir, "g").params).toEqual([{ name: "n", type: "unsigned long long" }]);
+    });
+    (0, vitest_1.it)("成员调用取 ->/. 之后的调用名（函数指针分发仍静态不可见）", () => {
+        const ir = parse(`void close_conn(conn_t* cf) { cf->close_one(); cf->next->close_two(); obj.method(x); }`);
+        (0, vitest_1.expect)(fn(ir, "close_conn").calls).toEqual(["close_one", "close_two", "method"]);
+    });
+    (0, vitest_1.it)("自调用被排除；重复调用保留（状态机需要重复语义）", () => {
+        const ir = parse(`void f(void) { f(); g(); g(); h(); }`);
+        (0, vitest_1.expect)(fn(ir, "f").calls).toEqual(["g", "g", "h"]);
+    });
+    (0, vitest_1.it)("struct 定义体被跳过（单行 + 多行）", () => {
+        const ir = parse(`
+typedef struct { int x; } Foo;
+void after_struct(void) { g(); }
+typedef struct {
+    int x;
+} Bar;
+void after_struct2(void) { h(); }
+`);
+        (0, vitest_1.expect)(ir.map((x) => x.name)).toEqual(["after_struct", "after_struct2"]);
+        (0, vitest_1.expect)(fn(ir, "after_struct").calls).toEqual(["g"]);
+        (0, vitest_1.expect)(fn(ir, "after_struct2").calls).toEqual(["h"]);
+    });
+    (0, vitest_1.it)("goto 合成 goto_<label> 调用", () => {
+        const ir = parse(`void f(void) { goto cleanup; g(); cleanup: ; }`);
+        (0, vitest_1.expect)(fn(ir, "f").calls).toEqual(["g", "goto_cleanup"]);
+    });
+    (0, vitest_1.it)("函数体内的预处理行整体跳过（花括号与调用均不计数）", () => {
+        const ir = parse(`
+void f(void) {
+#define X {
+#undef X
+    g();
+}
+`);
+        (0, vitest_1.expect)(fn(ir, "f").calls).toEqual(["g"]);
+    });
+    (0, vitest_1.it)("嵌套块括号正确闭合", () => {
+        const ir = parse(`void f(void) { if (x) { g(); } h(); }`);
+        (0, vitest_1.expect)(fn(ir, "f").calls).toEqual(["g", "h"]);
+    });
+    (0, vitest_1.it)("__attribute__ 前缀被剥离，不进返回类型", () => {
+        const ir = parse(`
+static __attribute__((unused)) int helper(void) { return 0; }
+void caller(void) { helper(); }
+`);
+        const h = fn(ir, "helper");
+        (0, vitest_1.expect)(h.returnType).toBe("int");
+        (0, vitest_1.expect)(h.exported).toBe(false);
+        (0, vitest_1.expect)(fn(ir, "caller").calls).toEqual(["helper"]);
+    });
+    (0, vitest_1.it)("头文件原型被忽略；static inline 定义被提取", () => {
+        const ir = parse(`
+int prototype_only(const char* x);
+static inline int add1(int x) { return x + 1; }
+`, "header.h");
+        (0, vitest_1.expect)(ir.map((x) => x.name)).toEqual(["add1"]);
+        (0, vitest_1.expect)(fn(ir, "add1").exported).toBe(false);
+        (0, vitest_1.expect)(fn(ir, "add1").params).toEqual([{ name: "x", type: "int" }]);
+    });
+    (0, vitest_1.it)("extractIRC 集成：真实 fixture 内容", () => {
+        const authFlow = `
+    int authenticate(const char* user, const char* pass) {
+        if (!verify_password(user, pass)) return 0;
+        char* token = generate_jwt(user);
+        session_t* sess = create_session(token);
+        return sess ? 1 : 0;
+    }
+    void do_logout(session_t* sess) {
+        logout(sess);
+    }
+`;
+        const dbHandler = `
+    void run_query(const char* host, const char* sql) {
+        connect_db(host);
+        query_db(sql);
+        disconnect_db();
+    }
+    void run_insert(const char* host, const char* data) {
+        connect_db(host);
+        query_db(data);
+        disconnect_db();
+    }
+    void verify_and_session(const char* user, const char* pass) {
+        verify_password(user, pass);
+        generate_jwt(user);
+        create_session();
+    }
+    void auth_and_logout(const char* user, const char* pass) {
+        verify_password(user, pass);
+        generate_jwt(user);
+        create_session();
+        logout();
+    }
+`;
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-c-"));
+        try {
+            fs.writeFileSync(path.join(dir, "auth_flow.c"), authFlow);
+            fs.mkdirSync(path.join(dir, "src"), { recursive: true });
+            fs.writeFileSync(path.join(dir, "src", "db_handler.c"), dbHandler);
+            const ir = (0, extract_ir_c_1.extractIRC)(dir);
+            (0, vitest_1.expect)(ir.map((f) => f.name).sort()).toEqual([
+                "auth_and_logout", "authenticate", "do_logout",
+                "run_insert", "run_query", "verify_and_session",
+            ]);
+            const runQuery = fn(ir, "run_query");
+            (0, vitest_1.expect)(runQuery.file).toBe(path.join("src", "db_handler.c"));
+            (0, vitest_1.expect)(runQuery.calls).toEqual(["connect_db", "query_db", "disconnect_db"]);
+            (0, vitest_1.expect)(fn(ir, "auth_and_logout").calls).toEqual(["verify_password", "generate_jwt", "create_session", "logout"]);
+            // isProjectFn 契约：全部 external=false + 真实相对路径
+            for (const f of ir) {
+                (0, vitest_1.expect)(f.external).toBe(false);
+                (0, vitest_1.expect)(f.file).toBeTruthy();
+                (0, vitest_1.expect)(f.file).not.toBe("(external)");
+            }
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("回归：顶层长标识符调用赋值行不触发指数级回溯（44 字符缓冲 11s → 即时）", () => {
+        // libssh authentication.c 真实触发：v2 签名正则的类型 token 循环对
+        // `name = ssh_userauth_kbdint_getname(session);` 穷举标识符切分（2^k）
+        const t0 = Date.now();
+        const ir = parse(`
+int f(void) { return 0; }
+name = ssh_userauth_kbdint_getname(session);
+int g(void) { return 1; }
+`);
+        (0, vitest_1.expect)(Date.now() - t0).toBeLessThan(2000);
+        (0, vitest_1.expect)(ir.map((x) => x.name)).toEqual(["f", "g"]);
+    });
+    (0, vitest_1.it)("#if 0 死代码块被剥离：体内不平衡花括号不腐蚀计数", () => {
+        const ir = parse(`
+void f(void) {
+#if 0
+    void dead(void) { { {
+#endif
+    g();
+}
+void g2(void) { h(); }
+`);
+        (0, vitest_1.expect)(ir.map((x) => x.name)).toEqual(["f", "g2"]);
+        (0, vitest_1.expect)(fn(ir, "f").calls).toEqual(["g"]);
+        (0, vitest_1.expect)(fn(ir, "g2").calls).toEqual(["h"]);
+    });
+    (0, vitest_1.it)("#if 0 死代码块被剥离：顶层死函数不产生幻影函数；嵌套 #if 死区内保持死", () => {
+        const ir = parse(`
+#if 0
+void dead_fn(void) { broken {
+#if 1
+void dead_inner(void) { { {
+#endif
+void also_dead(void) { { {
+#endif
+void live_fn(void) { g(); }
+`);
+        (0, vitest_1.expect)(ir.map((x) => x.name)).toEqual(["live_fn"]);
+        (0, vitest_1.expect)(fn(ir, "live_fn").calls).toEqual(["g"]);
+    });
+    (0, vitest_1.it)("#if 0 || X 表达式不求值，按活区处理", () => {
+        const ir = parse(`
+#if 0 || 1
+void maybe_live(void) { g(); }
+#endif
+void after(void) { h(); }
+`);
+        (0, vitest_1.expect)(ir.map((x) => x.name)).toEqual(["maybe_live", "after"]);
+        (0, vitest_1.expect)(fn(ir, "maybe_live").calls).toEqual(["g"]);
+    });
+});

package/dist/extract-project-ir.js

@@ -53,9 +53,11 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const extract_ir_1 = require("./extract-ir");
 const extract_ir_python_1 = require("./extract-ir-python");
+const extract_ir_c_1 = require("./extract-ir-c");
 const SKIP_DIRS = new Set([
     "node_modules", "dist", "build", ".git", ".progmune_corpus",
     "__pycache__", "venv", ".venv",
+    "benchmarks", // vendored C 基准仓库（与 extract-ir-c.ts collectCFiles 口径一致）
 ]);
 /** 有界递归扫描：项目是否含指定扩展名源文件（首个命中即返回）。 */
 function hasSourceFiles(projectRoot, exts) {
@@ -98,6 +100,11 @@ exports.LANGUAGE_EXTRACTORS = [
         detect: (p) => hasSourceFiles(p, new Set([".py"])),
         extract: (p) => (0, extract_ir_python_1.extractIRPython)(p),
     },
+    {
+        language: "c",
+        detect: (p) => hasSourceFiles(p, new Set([".c", ".h"])),
+        extract: (p) => (0, extract_ir_c_1.extractIRC)(p),
+    },
 ];
 /** 项目检测到的语言列表（审计/标签用）。 */
 function detectLanguages(projectRoot) {

package/dist/extract-project-ir.test.js

@@ -45,6 +45,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const extract_project_ir_1 = require("./extract-project-ir");
+const call_sequence_1 = require("./call-sequence");
 (0, vitest_1.describe)("extractProjectIR（注册表合并）", () => {
     (0, vitest_1.it)("合并所有检测到语言的函数", () => {
         const tsFns = [{ name: "getSession", file: "src/auth.ts" }];
@@ -56,6 +57,18 @@ const extract_project_ir_1 = require("./extract-project-ir");
         const ir = (0, extract_project_ir_1.extractProjectIR)("/tmp/fake", extractors);
         (0, vitest_1.expect)(ir).toEqual([...tsFns, ...pyFns]);
     });
+    (0, vitest_1.it)("三语言合并（TS + Python + C）按注册表顺序", () => {
+        const tsFns = [{ name: "getSession", file: "src/auth.ts" }];
+        const pyFns = [{ name: "verify_password", file: "auth_service.py" }];
+        const cFns = [{ name: "authenticate", file: "src/auth_flow.c" }];
+        const extractors = [
+            { language: "typescript", detect: () => true, extract: () => tsFns },
+            { language: "python", detect: () => true, extract: () => pyFns },
+            { language: "c", detect: () => true, extract: () => cFns },
+        ];
+        const ir = (0, extract_project_ir_1.extractProjectIR)("/tmp/fake", extractors);
+        (0, vitest_1.expect)(ir).toEqual([...tsFns, ...pyFns, ...cFns]);
+    });
     (0, vitest_1.it)("未检测到的语言不运行提取器", () => {
         const ran = [];
         const extractors = [
@@ -74,6 +87,15 @@ const extract_project_ir_1 = require("./extract-project-ir");
         const ir = (0, extract_project_ir_1.extractProjectIR)("/tmp/fake", extractors);
         (0, vitest_1.expect)(ir).toEqual([{ name: "f" }]);
     });
+    (0, vitest_1.it)("C 提取器失败被吞，其余语言结果保留", () => {
+        vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
+        const extractors = [
+            { language: "typescript", detect: () => true, extract: () => [{ name: "f" }] },
+            { language: "c", detect: () => true, extract: () => { throw new Error("broken c parse"); } },
+        ];
+        const ir = (0, extract_project_ir_1.extractProjectIR)("/tmp/fake", extractors);
+        (0, vitest_1.expect)(ir).toEqual([{ name: "f" }]);
+    });
     (0, vitest_1.it)("所有检测到的语言都失败时抛错（保留 execute 硬失败语义）", () => {
         vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
         const extractors = [
@@ -113,4 +135,69 @@ const extract_project_ir_1 = require("./extract-project-ir");
             fs.rmSync(dir, { recursive: true, force: true });
         }
     });
+    (0, vitest_1.it)("纯 C 项目（.c）被检测", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-lang3-"));
+        try {
+            fs.writeFileSync(path.join(dir, "main.c"), "int main(void) { return 0; }\n");
+            (0, vitest_1.expect)((0, extract_project_ir_1.detectLanguages)(dir)).toEqual(["c"]);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("仅头文件（.h）也算 C 项目", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-lang4-"));
+        try {
+            fs.writeFileSync(path.join(dir, "header.h"), "int add(int a, int b);\n");
+            (0, vitest_1.expect)((0, extract_project_ir_1.detectLanguages)(dir)).toEqual(["c"]);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("TS + C 混合项目两种语言都被检测", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-lang5-"));
+        try {
+            fs.writeFileSync(path.join(dir, "main.ts"), "export function f() {}");
+            fs.writeFileSync(path.join(dir, "helper.c"), "void helper(void) {}\n");
+            (0, vitest_1.expect)((0, extract_project_ir_1.detectLanguages)(dir).sort()).toEqual(["c", "typescript"]);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("benchmarks/ 下的 C 源不计入检测（vendored 基准仓库，与 extract 口径一致）", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-lang6-"));
+        try {
+            fs.mkdirSync(path.join(dir, "benchmarks", "curl"), { recursive: true });
+            fs.writeFileSync(path.join(dir, "benchmarks", "curl", "lib.c"), "void f(void) {}\n");
+            (0, vitest_1.expect)((0, extract_project_ir_1.detectLanguages)(dir)).toEqual([]);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("TS + C 混合项目：真实注册表合并 IR 含两语言函数，词段门控集合为并集", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-mix-"));
+        try {
+            // ts-morph 需要 tsconfig（无 tsconfig 时 TS 提取抛错、按设计被注册表吞掉）
+            fs.writeFileSync(path.join(dir, "tsconfig.json"), JSON.stringify({
+                compilerOptions: { target: "es2020", module: "commonjs" },
+                include: ["**/*.ts"],
+            }));
+            fs.writeFileSync(path.join(dir, "auth.ts"), "export function verifySession(t: string) { return t; }\n");
+            fs.writeFileSync(path.join(dir, "helper.c"), "void authenticate(void) { verify_password(); generate_jwt(); }\n");
+            const ir = (0, extract_project_ir_1.extractProjectIR)(dir);
+            const names = ir.map((f) => `${f.file}:${f.name}`).sort();
+            (0, vitest_1.expect)(names).toEqual(["auth.ts:verifySession", "helper.c:authenticate"]);
+            // 词段匹配门控集合（ssg-bridge projectFunctions）为两语言并集——
+            // C 函数名进入集合是设计行为（混合项目 C 侧才参与词段匹配）
+            const gate = (0, call_sequence_1.collectProjectFunctionNames)(ir);
+            (0, vitest_1.expect)(gate.has("verifySession")).toBe(true);
+            (0, vitest_1.expect)(gate.has("authenticate")).toBe(true);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
 });

package/dist/failure-collector.js

@@ -46,7 +46,11 @@ exports.loadFailures = loadFailures;
 exports.failureStats = failureStats;
 exports.formatFailureStats = formatFailureStats;
 const fs = __importStar(require("fs"));
-const CORPUS_DIR = "failure-corpus";
+const path = __importStar(require("path"));
+// 统一写入路径：与 failure-corpus.ts 一致，落在项目级 .progmune_corpus/emitter-failures/
+// （旧路径为仓库根 failure-corpus/，已废弃——避免两套语料并存）
+const CORPUS_DIR = path.resolve(process.env.PROGMUNE_CORPUS_DIR ||
+    path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd(), ".progmune_corpus"), "emitter-failures");
 /** Classify a compile error string into a root cause. */
 /** Classify a compile error into a root cause category. */
 /** @requires ERROR_STRING @produces ROOT_CAUSE */

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

package/docs/Progmune_/351/241/271/347/233/256/345/205/250/350/247/243.html

@@ -346,7 +346,7 @@
   <div class="bar"><span class="bl">人工审查能力</span><div class="bt"><div class="bf" style="width:10%"></div></div><span class="bv">1x</span></div>
 
   <h3>3.2 问题本质：AI 写代码的原理决定了它"看不见"错误</h3>
-  <p>大语言模型生成代码的方式是<strong>统计预测</strong>——根据训练数据猜"下一个最可能的词"。这一观点的代表性论述来自 Subbarao Kambhampati 等的立场论文《Stop Anthropomorphizing Intermediate Tokens as Reasoning/Thinking Traces!》（arXiv:2505.22285）及其 ICML 2026 关于 verifier 的主题演讲：LLM 输出的"逐步推理"是统计表演，中间 token 与真实推理之间没有可靠的因果对应。</p>
+  <p>大语言模型生成代码的方式是<strong>统计预测</strong>——根据训练数据猜"下一个最可能的词"。这一观点的代表性论述来自 Subbarao Kambhampati 等的立场论文《Stop Anthropomorphizing Intermediate Tokens as Reasoning/Thinking Traces!》（arXiv:2504.09762）及其 ICML 2026 关于 verifier 的主题演讲：LLM 输出的"逐步推理"是统计表演，中间 token 与真实推理之间没有可靠的因果对应。</p>
   <p>这意味着：AI 写出"看似合理的代码"和"实际正确的代码"是两件事。它会一本正经地调用不存在的函数、跳过关键的认证步骤——<strong>而且完全静默，不报错</strong>。</p>
 
   <h3>3.3 现有方案为什么不够</h3>
@@ -508,7 +508,7 @@ AI 生成: create_session(...)   ← 当前状态 UNAUTHENTICATED
     <tr><td><strong>协议盲测</strong>（Python v1.2，38 项目）</td><td>8 违规类型 × 5 结构/命名风格、66 条可测金标、生产 SSG 桥接校验器（P4.6 跨函数传播）</td><td>召回 <strong>97%</strong> · 精确率 <strong>100%</strong> · 误报 <strong>0</strong>（2 漏检为注解依赖前置，已单列）</td></tr>
     <tr><td><strong>真实应用验证</strong>（PyGoat）</td><td>OWASP 故意脆弱 Django 应用、232 条检测逐条人工核实</td><td>标记精确率 <strong>100%</strong>（67 真阳性 / 0 误报）；覆盖 14 个漏洞类别</td></tr>
     <tr><td><strong>良构应用</strong>（django/fastapi realworld、django-unicorn）</td><td>176 条检测</td><td>0 条误报真阳性；3 条框架内部边界 FP（已定性归档）</td></tr>
-    <tr><td><strong>黄金基准</strong>（C 语言）</td><td>curl/libssh/nginx/openssl 等真实 CVE 案例</td><td>F1 16.5% —— <strong>研究阶段</strong>，诚实披露</td></tr>
+    <tr><td><strong>黄金基准</strong>（C 语言）</td><td>curl/libssh/nginx/openssl 等真实 CVE 案例；3.7.4 起 IR 提取接入注册表</td><td>应用级协议验证金标 v2：<strong>F1 95.7%</strong>（召回 100%）；旧正则口径 F1=16.5% 为 TLS 级历史基线 —— <strong>研究阶段</strong>，诚实披露</td></tr>
     <tr><td><strong>PLSB v1.0</strong></td><td>13 类协议安全弱点、39 个手工验证缺陷案例</td><td>覆盖 <strong>13/13 全类别</strong>（业界唯一）</td></tr>
   </table>
   <div class="plain">
@@ -537,7 +537,7 @@ AI 生成: create_session(...)   ← 当前状态 UNAUTHENTICATED
     <tr><th>能力</th><th>状态</th><th>说明</th></tr>
     <tr><td>TypeScript / JavaScript</td><td><span style="color:var(--green);font-weight:700">✅ 生产</span></td><td>盲测 100 项目：精确率 100%、召回率 98.5%</td></tr>
     <tr><td>Python</td><td><span style="color:var(--green);font-weight:700">✅ 生产</span></td><td>盲测 90 项目：精确率/召回率双 100%；15 条源码级检测规则；PyGoat 真实验证 67 TP / 0 FP</td></tr>
-    <tr><td>C</td><td><span style="color:var(--amber);font-weight:700">⚠️ 研究</span></td><td>F1 16.5%，瓶颈已定位（规则覆盖），L3 实验已终止</td></tr>
+    <tr><td>C</td><td><span style="color:var(--amber);font-weight:700">⚠️ 研究</span></td><td>3.7.4 起 IR 提取 + 应用级协议状态机验证（金标 v2：P=91.7%/R=100%/F1=95.7%）；TLS 级仍无覆盖（旧正则口径 F1=16.5% 为历史基线），L3/L4 结论不变</td></tr>
     <tr><td>Go / Java</td><td><span style="color:var(--ink-3)">❌ 未支持</span></td><td>路线图内</td></tr>
     <tr><td>框架适配</td><td><span style="color:var(--amber);font-weight:700">2/13</span></td><td>Express ✅、tRPC ✅、NestJS 部分；Next.js 版本感知已实现；Django/FastAPI 经 Python 源码级检测间接覆盖</td></tr>
   </table>

package/package.json

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