progmune-runtime 3.7.4 → 3.7.5

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [3.7.5] — 2026-08-27
+
+### C 真实语料验证 + 注解驱动演示 + 引擎修复（DSH 双轮评审合入）
+
+- **修复（DSH）：单行指针返回函数系统性漏提取**——`char *foo(`/`SSL *foo(` 类定义被 `(?:^|\s)` 锚点漏掉（名字前是 `*` 非空白）；改为 lookbehind `(?<![a-zA-Z0-9_])` + 回归测试。openssl 等指针密集型仓库补回 ~1,500 函数（如 openssl 15,539 含指针修复与表面过滤的净效果）
+- **修复：P4.6 展开兆级序列**（DSH 实测 openssl 单序列可达 1M+ 调用、全扫描 15–25 分钟）——`buildCallSequences` 预算制展开（`MAX_SEQUENCE_CALLS=2000` 可注入，入口自身调用按序优先、超预算即停，`CallSequence.truncated` 标记，不去重——重复调用对状态机有语义）；openssl 全扫描 **15–25 分钟 → 222s**。零漂移前置实测：Python 盲测语料最大序列 23、TS 自身 IR 最大 824（预算零影响），Python 盲测复跑 64 违规不变。**截断是诚实的召回边界**（超大序列尾部违规不可见，非静默回归）
+- **真实语料四仓库**（libssh/redis/nginx/openssl）：24 flags 全部人工标注 FP（0 TP）——误报类别稳定（OS API 桥接 11、回调 endState、包装器词段、跨函数窗口），keyword 白名单方向的观测前提已达标待决策；稳定指标 = 黄金函数恢复率 97–100%
+
+- **真实 C 语料验证 v1**（`blind-benchmark/scan-real-c.ts` + `REALWORLD_C_V1.md`）：生产管线扫 libssh/redis/nginx——表面过滤后 16 flags 逐条人工标注全 FP（真实误报率观测：标记精确率 0%）；「命名鸿沟」发现（exact-name 0 次触发，合成金标 95.7% F1 全靠按名+注解命中）；误报源分类：回调生命周期 endState 12 / OS API 关键词桥接 3 / 跨函数窗口 1
+- **提取器非生产表面过滤**（对齐 `tools/extract_ir.py` Python 先例）：`collectCFiles` 跳过 `tests/test/examples/docs/docs_src/scripts/deps/vendor/third_party` 目录与 `test_*.c`/`*_test.c`——libssh 63→1、redis 1→0 条 flags；C 金标恢复率零漂移（97/97/89/98/100/99）
+- **注解驱动真实项目演示**（`demo-real-c-redis/` + `REALWORLD_C_V2.md`）：真实 redis acl.c 代码 + 3 条注解 → 合法流 APPROVED 85 零误报、植入 missing-auth-check 精确定位；标注成本 ~3 注解/协议——**注解驱动是 C 生产化的现实形态，可行性已验证**
+- **引擎修复①（CamelCase 注解规则不可触达）**：注解合并同步注册 normalized 形态（加性，snake_case 注解零变化）
+- **引擎修复②（注解合并晚于序列构建）**：P4.5 合并移到 `extractCallSequencesFromProject` 之前——有函数体的注解原语不再被内联掉、post 状态生效；与盲测 harness 语义对齐
+- **引擎修复③（fixPath 输出真实函数名）**：`StateAnnotation.displayName` 机制——注解合并记录真实函数名，BFS 展开项目原语优先（stable sort 零漂移）+ 渲染映射；修复建议从通用规则名（`verify_token`）变为项目真实函数（`checkPasswordBasedAuth`），sdk 修复解析直接插入真实调用。三处边界如实记录：establish 赋值状态机不可见（L4 不投入）、模块认证 hook 在状态机外、单条 medium 违规不翻转 APPROVED（决策阈值层独立议题）
+- **零漂移验证**：Python 协议盲测 v1.2 复跑 64 违规（报告仅时间戳差异）；引擎相关套件 113/113 + 2 个新回归测试（tests/trust/engine.test.ts）
+- **如实记录**：C 语言状态标签维持「研究」；不修项（按评估决策）——establish 赋值不可见（L4 不投入）、medium 违规不翻转 APPROVED（累计扣分设计逻辑，非缺陷）
+
 ## [3.7.4] — 2026-08-26
 
 ### 新增：C 语言 IR 提取（注册表第三语言）
@@ -7,7 +24,7 @@
 - **`src/extract-ir-c.ts`**：纯 TS C 提取器（无子进程桥、无原生依赖）——函数签名（含多行、`static`/`inline`/`__attribute__`、指针/数组/函数指针参数）、调用列表（成员调用取 `->`/`.` 后的调用名，`goto` 合成 `goto_<label>`）、`@progmune`/`@protocol` 注解与 `@purpose/@tags/@requires/@produces/@useWhen/@inputs/@outputs` 文档标签（C 注释块镜像 Python 装饰器语法）；注释/字符串感知的括号计数（修复 v2 提取器已知缺口，未改动 `sequence-extractor`——C 金标基准管线保持不动）
 - **`LANGUAGE_EXTRACTORS` 注册 `c`**（detect `.c`/`.h`，extract `extractIRC`）——agent 循环、execute() 的 ir.json 写入与 MCP 自动生效；C 项目从纯正则回退切换到 IR-first 序列验证 + SSG 状态机，C 函数名进入词段匹配门控（仅项目函数）；协议行与 protocols.json 规则名（`verify_password` 等）按名命中
 - **端到端验证**：临时 C 项目上 extractProjectIR → evaluateTrust 走通——4 条植入违规全部精确定位（内置 auth×2 / db×1 + 自定义 pay 命名空间注解×1），合法链零误报（NEEDS_REVIEW 72 分）；**应用级 C 金标 v1**（`blind-benchmark/scan-protocol-c-app.ts`，镜像 Python 盲测方法学）：10 clean × 7 违规 → **P=87.5% / R=100% / F1=93.3%**（唯一 FP 为跨函数窗口边界，与 Python 盲测 T2×S5 同类）
-- **规模化提取**（`blind-benchmark/scan-protocol-c.ts`）：6 个 vendored 仓库（curl 4192 / libssh 3689 / nginx 2970 / openssl 14394 / nghttp2 1274 / redis 9590 函数）秒级提取，黄金函数恢复率 81–99%；旧 TLS 级金标上 SSG 命中 0/38（口径差异：SSG 无 TLS 规则，如实记录）；nginx 3 FP 为 `ngx_*` 前缀包装器撞词段匹配（引擎层问题，记录待议，未动 SSG 桥避免 TS/Python 漂移）
+- **规模化提取**（`blind-benchmark/scan-protocol-c.ts`）：6 个 vendored 仓库（curl 5068 / libssh 3989 / nginx 3199 / openssl 15896 / nghttp2 1315 / redis 10170 函数，3.7.4 发布时代码状态——后续版本口径见 3.7.5）秒级提取，黄金函数恢复率 89–100%；旧 TLS 级金标上 SSG 命中 0/38（口径差异：SSG 无 TLS 规则，如实记录）；nginx 3 FP 为 `ngx_*` 前缀包装器撞词段匹配（引擎层问题，记录待议，未动 SSG 桥避免 TS/Python 漂移）
 - **修复：签名正则指数级回溯**——v2 风格类型 token 循环对 `name = ssh_userauth_kbdint_getname(...)` 类行穷举标识符切分（44 字符缓冲 ~11s），改为候选迭代（跳过关键字/类型名候选，返回类型从缓冲区前缀推导）；libssh 提取 >15min（病态）→ 1.8s，回归测试已加
 - **评审修复轮（detect/extract 口径、死代码、TU 绑定等）**：①`hasSourceFiles` SKIP_DIRS 补 `benchmarks`（与 extract 口径一致，本仓库自身不再误标 C）；②`#if 0` 死代码块预处理剥离（真实仓库不平衡花括号不再腐蚀函数体计数）；③顶层 `#` 行只跳自身不再吞相邻函数（openssl 14,394→15,896 函数，黄金函数恢复率升至 89–100%）；④`buildCallSequences` 同文件定义优先绑定（跨文件同名 static 不再 last-wins 错绑，入口判定文件化；Python 盲测 v1.2 复测零漂移——报告与基线逐字节一致仅时间戳不同）；⑤提取器取消调用去重（状态机重复调用有语义，双 close/重复 logout 可检出，与 TS/Python 提取器一致）；⑥删死代码 `isCProject`；⑦混合 TS+C 项目回归测试。应用级 C 金标扩至 v2（11 clean × 11 违规 + helper 中介风格 + 逐命名空间分解）：**TP 11/11 FP 1 FN 0 → P=91.7% / R=100% / F1=95.7%**（唯一 FP 为 do_logout 跨函数窗口边界）。已知系统性风险文档化：C 前缀包装器（`ngx_*` 等）撞词段匹配（nginx 3 FP），缓解方案（前缀剥离/连续词段）留待下一轮并强制盲测复跑
 - **限制如实记录**：函数指针分发静态不可见（L3 结论不变）、宏/K&R/C++ 不解析、无数据流/指针分析（L4 无计划）；提取器遍历跳过 vendored `benchmarks/`；`docs/c-language-status.md` 已更新（新路线小节 + 基准结果 + Decision record）

package/README.md

@@ -154,7 +154,7 @@ Public, reproducible precision data. All numbers measured against gold-annotated
 
 ### C (IR extraction + app-level protocol verification — research status)
 
-Since 3.7.4, C has an IR extractor in the multi-language registry: C projects flow into IR-first sequence validation + the SSG state machine. App-level protocol lifecycles (auth/db/file/payment) are verifiable on C — app-level gold v2: **11/11 violations caught (Recall 100%), 1 FP, F1=95.7%**; extraction scales to 10k+ functions per repo in seconds with 89–100% gold-function recovery (curl/libssh/nginx/openssl/nghttp2/redis). Two boundaries remain: the old regex-route gold benchmark F1=16.5% measured **TLS-level misuse** (SSG has no TLS state machines — that gap is unchanged), and L3/L4 conclusions stand (function-pointer dispatch is statically invisible; no pointer/CFG analysis planned). See [C Language Status](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/c-language-status.md) for the full picture and reasoning.
+Since 3.7.4, C has an IR extractor in the multi-language registry: C projects flow into IR-first sequence validation + the SSG state machine. App-level protocol lifecycles (auth/db/file/payment) are verifiable on C — app-level gold v2: **11/11 violations caught (Recall 100%), 1 FP, F1=95.7%**; annotation-driven verification validated on real redis ACL code (demo-real-c-redis). Extraction covers large real repos in seconds (openssl 15.5k / redis 5.7k / curl 4.2k functions, gold-function recovery 97–100%). Two boundaries remain: the old regex-route gold benchmark F1=16.5% measured **TLS-level misuse** (SSG has no TLS state machines — that gap is unchanged), and L3/L4 conclusions stand (function-pointer dispatch is statically invisible; no pointer/CFG analysis planned). See [C Language Status](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/c-language-status.md) for the full picture and reasoning.
 
 ### P0-P3 Rule Injection (2026-08)
 

package/README.zh-CN.md

@@ -154,7 +154,7 @@ Progmune 对能验证什么、不能验证什么保持诚实。
 
 ### C（IR 提取 + 应用级协议验证——研究状态）
 
-3.7.4 起 C 拥有多语言注册表中的 IR 提取器：C 项目进入 IR-first 序列验证 + SSG 状态机。应用级协议生命周期（认证/数据库/文件/支付）在 C 上可验证——应用级金标 v2：**11/11 违规全检出（召回 100%）、1 误报、F1=95.7%**；提取规模化至每仓库 1 万+ 函数、秒级完成、黄金函数恢复率 89–100%（curl/libssh/nginx/openssl/nghttp2/redis）。两条边界不变：旧正则口径黄金基准 F1=16.5% 测的是 **TLS 级误用**（SSG 无 TLS 状态机，该口径不变）；L3/L4 结论维持（函数指针分发静态不可见；无指针/CFG 分析计划）。详见 [C 语言状态](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/c-language-status.md)。
+3.7.4 起 C 拥有多语言注册表中的 IR 提取器：C 项目进入 IR-first 序列验证 + SSG 状态机。应用级协议生命周期（认证/数据库/文件/支付）在 C 上可验证——应用级金标 v2：**11/11 违规全检出（召回 100%）、1 误报、F1=95.7%**；注解驱动验证在真实 redis ACL 代码上走通（demo-real-c-redis）。提取覆盖大型真实仓库（openssl 15.5k / redis 5.7k / curl 4.2k 函数，秒级，黄金函数恢复率 97–100%）。两条边界不变：旧正则口径黄金基准 F1=16.5% 测的是 **TLS 级误用**（SSG 无 TLS 状态机，该口径不变）；L3/L4 结论维持（函数指针分发静态不可见；无指针/CFG 分析计划）。详见 [C 语言状态](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/c-language-status.md)。
 
 ### P0-P3 规则注入（2026-08）
 

package/dist/call-sequence.js

@@ -13,10 +13,17 @@
  * 不做数据流/指针/分支分析；跨文件依赖 IR 的 calls[] 图。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SEQUENCE_CALLS = void 0;
 exports.isProjectFn = isProjectFn;
 exports.collectProjectFunctionNames = collectProjectFunctionNames;
 exports.buildCallSequences = buildCallSequences;
 const MAX_DEPTH = 4;
+/**
+ * 每序列调用预算上限。真实语料实测：Python 盲测语料 350 序列最大 23、
+ * TS 自身 IR 469 序列最大 824——2,000 对现有语料零影响；C 巨型函数
+ * （openssl 单序列可达 1M+ 调用）在预算处截断。
+ */
+exports.MAX_SEQUENCE_CALLS = 2000;
 /** 项目函数判定：有真实文件且非外部导入条目（external 条目无函数体可内联）。 */
 function isProjectFn(f) {
     return !f.external && !!f.file && f.file !== "(external)";
@@ -53,7 +60,7 @@ function collectProjectFunctionNames(ir) {
  *   （其调用名保留给规则匹配），不内联其函数体——否则 create_session 等
  *   规则函数的平凡函数体会把调用名"吞掉"
  */
-function buildCallSequences(ir, keepNames) {
+function buildCallSequences(ir, keepNames, maxCalls = exports.MAX_SEQUENCE_CALLS) {
     // 全局按名回退 + 同文件优先映射：C 中跨文件同名 static 函数极常见
     // （每个 .c 都有 static cleanup/helper），名字级 Map 会让 last-wins 的
     // 定义绑定到错误的调用方。同翻译单元（文件）定义优先解析——
@@ -88,12 +95,23 @@ function buildCallSequences(ir, keepNames) {
                 calledBy.add(fnKey(resolved.file, resolved.name));
         }
     }
+    /** 调用预算：预算制展开——入口自身调用按序优先，预算耗尽即停（截断），
+     *  不在事后截断百万级序列（内存/时间双浪费） */
+    const budget = { left: maxCalls, truncated: false };
     /** 展开函数体内的调用（入口序列 = 函数体调用，不含函数自己的名字） */
     const expandBody = (fn, depth, visiting) => {
+        if (budget.left <= 0) {
+            budget.truncated = true;
+            return [];
+        }
         const out = [];
         for (const c of fn.calls || []) {
             if (typeof c !== "string" || c.startsWith("__progmune_"))
                 continue;
+            if (budget.left <= 0) {
+                budget.truncated = true;
+                return out;
+            }
             out.push(...expandCall(c, depth, visiting, fn.file));
         }
         return out;
@@ -102,14 +120,19 @@ function buildCallSequences(ir, keepNames) {
         if (depth > MAX_DEPTH || visiting.has(name))
             return [];
         const fn = resolveCall(fromFile, name);
-        // 外部调用或规则函数：调用名保留给匹配层，不内联
-        if (!fn || (keepNames && keepNames.has(name)))
+        // 外部调用或规则函数：调用名保留给匹配层，不内联（记 1 个调用）
+        if (!fn || (keepNames && keepNames.has(name))) {
+            budget.left--;
             return [name];
+        }
         // 叶子函数（函数体只调外部原语）是协议原语或叶子 helper：
         // 保留名字，不内联——否则 S5 改名协议函数的平凡函数体会吞掉调用名
         const hasProjectCalls = (fn.calls || []).some((c) => resolveCall(fn.file, c));
-        if (!hasProjectCalls)
+        if (!hasProjectCalls) {
+            budget.left--;
             return [name];
+        }
+        // 内联：函数体自身的调用在递归内各自记账
         visiting.add(name);
         const out = expandBody(fn, depth + 1, visiting);
         visiting.delete(name);
@@ -123,10 +146,12 @@ function buildCallSequences(ir, keepNames) {
             continue; // 非入口：片段并入调用方
         if (keepNames && keepNames.has(f.name))
             continue; // 协议原语不是入口：只在调用链内验证
+        budget.left = maxCalls;
+        budget.truncated = false;
         const calls = expandBody(f, 0, new Set());
         if (calls.length === 0)
             continue;
-        sequences.push({ calls, file: f.file, function: f.name });
+        sequences.push({ calls, file: f.file, function: f.name, truncated: budget.truncated || undefined });
     }
     return sequences;
 }

package/dist/call-sequence.test.js

@@ -82,6 +82,46 @@ function fn(name, file, calls) {
         (0, vitest_1.expect)(seqs[0].calls).toEqual(["verify_password"]);
     });
 });
+(0, vitest_1.describe)("buildCallSequences（调用预算 / 截断，兆级序列防护）", () => {
+    (0, vitest_1.it)("超预算截断：序列长度 = maxCalls，truncated 标记", () => {
+        const ext = Array.from({ length: 15 }, (_, i) => `ext_${i}`);
+        const ir = [fn("entry", "a.c", ext)];
+        const seqs = (0, call_sequence_1.buildCallSequences)(ir, undefined, 10);
+        (0, vitest_1.expect)(seqs).toHaveLength(1);
+        (0, vitest_1.expect)(seqs[0].calls).toHaveLength(10);
+        (0, vitest_1.expect)(seqs[0].calls).toEqual(ext.slice(0, 10)); // 入口自身调用按序优先
+        (0, vitest_1.expect)(seqs[0].truncated).toBe(true);
+    });
+    (0, vitest_1.it)("预算内序列：无 truncated 标记（现有语料零影响）", () => {
+        const ir = [fn("entry", "a.c", ["g", "h"])];
+        const seqs = (0, call_sequence_1.buildCallSequences)(ir, undefined, 2000);
+        (0, vitest_1.expect)(seqs).toHaveLength(1);
+        (0, vitest_1.expect)(seqs[0].calls).toEqual(["g", "h"]);
+        (0, vitest_1.expect)(seqs[0].truncated).toBeUndefined();
+    });
+    (0, vitest_1.it)("内联超预算：已发出的调用保留，入口后续调用被截（召回边界语义）", () => {
+        const bigBody = Array.from({ length: 20 }, (_, i) => `big_call_${i}`);
+        const ir = [
+            fn("helper", "a.c", ["ext"]), // 项目函数：big 因调它而可内联（叶子规则）
+            fn("big", "a.c", ["helper", ...bigBody]),
+            fn("entry", "a.c", ["big", "tail_call"]),
+        ];
+        const seqs = (0, call_sequence_1.buildCallSequences)(ir, undefined, 5);
+        (0, vitest_1.expect)(seqs).toHaveLength(1);
+        (0, vitest_1.expect)(seqs[0].calls).toEqual(["helper", "big_call_0", "big_call_1", "big_call_2", "big_call_3"]);
+        (0, vitest_1.expect)(seqs[0].truncated).toBe(true);
+    });
+    (0, vitest_1.it)("多入口各自独立预算", () => {
+        const ext = Array.from({ length: 8 }, (_, i) => `ext_${i}`);
+        const ir = [fn("e1", "a.c", ext), fn("e2", "b.c", ext)];
+        const seqs = (0, call_sequence_1.buildCallSequences)(ir, undefined, 5);
+        (0, vitest_1.expect)(seqs).toHaveLength(2);
+        for (const s of seqs) {
+            (0, vitest_1.expect)(s.calls).toHaveLength(5);
+            (0, vitest_1.expect)(s.truncated).toBe(true);
+        }
+    });
+});
 (0, vitest_1.describe)("collectProjectFunctionNames", () => {
     (0, vitest_1.it)("全名/裸名/小写三形态收录", () => {
         const ir = [fn("FlowService.svc_x", "a.ts", [])];

package/dist/extract-ir-c.js

@@ -64,6 +64,22 @@ const SKIP_DIRS = new Set([
     "node_modules", "dist", "build", ".git", ".progmune_corpus",
     "__pycache__", "venv", ".venv", "benchmarks",
 ]);
+/**
+ * 非生产表面目录（与 tools/extract_ir.py 的 Python 先例对齐：
+ * "Skip test files — tests are not production surface for a security
+ * scanner"）：安全扫描只看随产品发布的生产代码路径。真实 C 仓库验证
+ * （libssh/redis/nginx，scan-real-c.ts）中 65/79 条误报来自 tests/
+ * examples/ 与 vendored deps/（jemalloc）。
+ */
+const NON_SURFACE_DIRS = new Set([
+    "tests", "test", "examples", "docs", "docs_src", "scripts",
+    "deps", "vendor", "third_party",
+]);
+/** 测试文件名模式（test_*.c / *_test.c / *_test.h，Python 先例同款） */
+function isTestFilename(name) {
+    const base = name.replace(/\.[^.]+$/, "");
+    return base.startsWith("test_") || base.endsWith("_test");
+}
 /** Copied from sequence-extractor.ts:107-111 (kept local — decoupled benchmark path must not change). */
 const C_KEYWORDS = new Set([
     "if", "for", "while", "switch", "return", "sizeof", "typeof",
@@ -384,8 +400,12 @@ function stripAttributes(s) {
  * type-name candidates, and derive the return type from the buffer text
  * BEFORE the chosen candidate. `[^;]*?` keeps the params scan bounded.
  * Groups: 1 = name, 2 = params.
+ * Lookbehind anchor: the old `(?:^|\s)` silently dropped every single-line
+ * pointer-return definition (`char *foo(`, `SSL *foo(` — name preceded by
+ * `*`/`&`, not whitespace). `(?<![a-zA-Z0-9_])` allows those while still
+ * rejecting identifiers glued to the name.
  */
-const FUNC_CAND_RE = /(?:^|\s)([a-zA-Z_][a-zA-Z0-9_]*)\s*\(([^;]*?)\)\s*\{/g;
+const FUNC_CAND_RE = /(?<![a-zA-Z0-9_])([a-zA-Z_][a-zA-Z0-9_]*)\s*\(([^;]*?)\)\s*\{/g;
 /** struct/union/enum definition bodies must be skipped, not parsed as functions. */
 const STRUCT_DECL_RE = /^(?:typedef\s+)?(?:struct|union|enum)\b/;
 /** Call-name + goto extraction filters. */
@@ -675,10 +695,10 @@ function collectCFiles(projectRoot) {
         for (const e of entries) {
             const full = path.join(dir, e.name);
             if (e.isDirectory()) {
-                if (!SKIP_DIRS.has(e.name) && !e.name.startsWith("."))
+                if (!SKIP_DIRS.has(e.name) && !NON_SURFACE_DIRS.has(e.name) && !e.name.startsWith("."))
                     stack.push(full);
             }
-            else if (C_EXTENSIONS.has(path.extname(e.name))) {
+            else if (C_EXTENSIONS.has(path.extname(e.name)) && !isTestFilename(e.name)) {
                 out.push(full);
             }
         }

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

@@ -359,6 +359,24 @@ 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)("非生产表面目录被跳过：tests/examples/deps 与测试文件名（Python 先例同款）", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-surface-"));
+        try {
+            fs.writeFileSync(path.join(dir, "main.c"), "void prod(void) {}\n");
+            fs.mkdirSync(path.join(dir, "tests"), { recursive: true });
+            fs.writeFileSync(path.join(dir, "tests", "torture_x.c"), "void in_tests(void) {}\n");
+            fs.mkdirSync(path.join(dir, "examples"), { recursive: true });
+            fs.writeFileSync(path.join(dir, "examples", "demo.c"), "void in_examples(void) {}\n");
+            fs.mkdirSync(path.join(dir, "deps", "vendor_lib"), { recursive: true });
+            fs.writeFileSync(path.join(dir, "deps", "vendor_lib", "lib.c"), "void in_deps(void) {}\n");
+            fs.writeFileSync(path.join(dir, "helper_test.c"), "void testfile(void) {}\n");
+            const ir = (0, extract_ir_c_1.extractIRC)(dir);
+            (0, vitest_1.expect)(ir.map((f) => f.name)).toEqual(["prod"]);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
     (0, vitest_1.it)("#if 0 死代码块被剥离：体内不平衡花括号不腐蚀计数", () => {
         const ir = parse(`
 void f(void) {
@@ -398,3 +416,23 @@ void after(void) { h(); }
         (0, vitest_1.expect)(fn(ir, "maybe_live").calls).toEqual(["g"]);
     });
 });
+(0, vitest_1.describe)("extract-ir-c pointer-return regression", () => {
+    (0, vitest_1.it)("单行指针返回函数必须被提取（char */SSL */const char */FILE * 等）", () => {
+        const src = [
+            "int a(void) { return 1; }",
+            "char *b(void) { return 0; }",
+            "SSL *c(SSL_CTX *ctx) { return 0; }",
+            "const char *d(int x) { return 0; }",
+            "static FILE *f(void) { return 0; }",
+            "int (*handler)(int) { return 0; }",
+        ].join("\n");
+        const fns = (0, extract_ir_c_1.parseCSource)(src, "ptr.c", "/");
+        const names = fns.map((f) => f.name);
+        (0, vitest_1.expect)(names).toEqual(vitest_1.expect.arrayContaining(["b", "c", "d", "f"]));
+        // 函数指针变量不是函数定义
+        (0, vitest_1.expect)(names).not.toContain("handler");
+        // 返回类型保留指针
+        const c = fns.find((f) => f.name === "c");
+        (0, vitest_1.expect)(c?.returnType).toBe("SSL *");
+    });
+});

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

package/dist/ssg-validator.js

@@ -163,6 +163,13 @@ function findFixPathStatic(rules, namespace, current, targetPreStates) {
             nsFuncs.push({ name: fn, rule });
         }
     }
+    // 项目注解原语优先展开（修复路径输出真实函数名而非通用规则名）；
+    // stable sort：无 displayName 的规则（内置/TS/Python 惯例）相对顺序不变
+    nsFuncs.sort((a, b) => {
+        const pa = a.rule.displayName ? 0 : 1;
+        const pb = b.rule.displayName ? 0 : 1;
+        return pa - pb;
+    });
     // BFS
     const startKey = [...new Set(current)].sort().join(",");
     const visited = new Set();

package/dist/trust/engine.js

@@ -722,28 +722,15 @@ async function collectProtocolViolations(ctx, callGraph) {
         }
         // ── SSG State Machine: load protocol rules once ──
         protocolRulesData = (0, ssg_bridge_1.loadProtocolRules)(ctx.projectPath);
-        // ── Phase 1-5 Semantic Pipeline ──
-        // 规则名集合作为展开的保留单元：规则函数不内联（调用名保留给匹配层）
-        const callSequences = extractCallSequencesFromProject(ctx.projectPath, ctx.language, protocolRulesData ? new Set(protocolRulesData.rules.keys()) : undefined);
-        const flaggedCount = { value: 0 };
-        const cleanCount = { value: 0 };
-        // ── P4.6.1: 词段匹配门控的项目函数集合（best-effort，与注解合并共用 ir.json） ──
-        // 词段匹配只对项目函数适用（改名协议原语）；外部库调用走 alias/关键词桥接。
-        let projectFunctions;
-        try {
-            const fs = require("fs");
-            const irPath = path.join(ctx.projectPath, "ir.json");
-            if (fs.existsSync(irPath)) {
-                const ir = JSON.parse(fs.readFileSync(irPath, "utf-8"));
-                const functions = Array.isArray(ir) ? ir : (ir.functions || []);
-                projectFunctions = (0, call_sequence_1.collectProjectFunctionNames)(functions);
-            }
-        }
-        catch { /* best-effort */ }
         // ── P4.5: 合并项目 IR 注解协议（IR 优先，缺 namespace 继承内置 JSON） ──
         // 内置 protocols.json 的规则是通用弱约束（如 generate_jwt pre=[]），
         // 项目文件里的 @protocol 注解才是项目真实协议（如 pre=[PASSWORD_VERIFIED]）。
         // planner 已用此合并语义，trust 引擎需对齐，否则项目级前置约束不生效。
+        // 合并必须在序列构建【之前】：规则名是展开的保留单元（不内联），若合并
+        // 晚于 extractCallSequencesFromProject，注解原语（有函数体、调项目函数的）
+        // 会被内联掉，其 post 状态永不生效——真实 redis ACL 演示暴露（
+        // checkPasswordBasedAuth 被内联 → AUTHENTICATED 未建立 → good 流误报）。
+        // 与盲测 harness（scan-protocol-python）先合并后建序列的语义对齐。
         if (protocolRulesData) {
             try {
                 const fs = require("fs");
@@ -761,12 +748,40 @@ async function collectProtocolViolations(ctx, callGraph) {
                         if (existing?.namespace && !protocol.namespace) {
                             protocol.namespace = existing.namespace;
                         }
+                        // 修复路径渲染真实函数名（fixPath 输出项目原语而非通用规则名）
+                        protocol.displayName = String(f.name);
                         protocolRulesData.rules.set(String(f.name), protocol);
+                        // CamelCase 真实命名（C 代码普遍，如 ACLCheckAllPerm）注册的规则
+                        // 原样无法被任何匹配策略触达（normalize 只作用于调用名；词段匹配
+                        // 要求 ≥2 个下划线词段）——同步注册规范化形态使注解原语可被按名命中。
+                        // 加性改动：snake_case 注解（TS/Python 惯例）normalized === 原名，无变化。
+                        const normalized = (0, ssg_bridge_1.normalizeName)(String(f.name));
+                        if (normalized !== String(f.name)) {
+                            protocolRulesData.rules.set(normalized, protocol);
+                        }
                     }
                 }
             }
             catch { /* best-effort */ }
         }
+        // ── Phase 1-5 Semantic Pipeline ──
+        // 规则名集合作为展开的保留单元：规则函数不内联（调用名保留给匹配层）
+        const callSequences = extractCallSequencesFromProject(ctx.projectPath, ctx.language, protocolRulesData ? new Set(protocolRulesData.rules.keys()) : undefined);
+        const flaggedCount = { value: 0 };
+        const cleanCount = { value: 0 };
+        // ── P4.6.1: 词段匹配门控的项目函数集合（best-effort，与注解合并共用 ir.json） ──
+        // 词段匹配只对项目函数适用（改名协议原语）；外部库调用走 alias/关键词桥接。
+        let projectFunctions;
+        try {
+            const fs = require("fs");
+            const irPath = path.join(ctx.projectPath, "ir.json");
+            if (fs.existsSync(irPath)) {
+                const ir = JSON.parse(fs.readFileSync(irPath, "utf-8"));
+                const functions = Array.isArray(ir) ? ir : (ir.functions || []);
+                projectFunctions = (0, call_sequence_1.collectProjectFunctionNames)(functions);
+            }
+        }
+        catch { /* best-effort */ }
         for (const seq of callSequences) {
             try {
                 const semantic = await (0, api_semantic_mapper_1.mapSequenceToSemanticWithLLM)(seq.calls);

package/dist/trust/ssg-bridge.js

@@ -50,6 +50,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeName = normalizeName;
 exports.validateSequenceWithSSG = validateSequenceWithSSG;
 exports.ssgViolationsToTrustViolations = ssgViolationsToTrustViolations;
 exports.loadProjectAliases = loadProjectAliases;
@@ -421,6 +422,8 @@ projectFunctions) {
                 let fixPath = [];
                 try {
                     fixPath = (0, ssg_validator_1.findFixPathStatic)(rules, ruleNamespace, rejection.currentState, rejection.requiredState);
+                    // 修复路径渲染真实函数名：项目注解原语的 displayName 优先于通用规则名
+                    fixPath = fixPath.map((n) => rules.get(n)?.displayName ?? n);
                 }
                 catch {
                     fixPath = rejection.missingFunctions || [];
@@ -482,18 +485,20 @@ projectFunctions) {
         if (!cur.includes(hs.state))
             continue;
         violatedCalls++;
+        // 释放函数渲染真实名（项目注解原语的 displayName 优先）
+        const releaseDisplay = rules.get(hs.releaseFn)?.displayName ?? hs.releaseFn;
         violations.push({
             callName: "(end-of-sequence)",
             namespace: hs.namespace,
             currentState: cur,
             requiredState: [],
-            fixPath: [hs.releaseFn],
+            fixPath: [releaseDisplay],
             matchedRule: hs.releaseFn,
             endState: true,
             explanation: `SSG end-state violation: resource state [${hs.state}] ` +
                 `acquired in this function is still held at end of sequence ` +
                 `(namespace ${hs.namespace}, current [${cur.join(", ")}]) — ` +
-                `missing release call: ${hs.releaseFn}.`,
+                `missing release call: ${releaseDisplay}.`,
         });
         trace.push({
             call: "(end-of-sequence)",

package/package.json

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