progmune-runtime 3.7.5 → 3.7.6

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [3.7.6] — 2026-08-28
+
+### C 生产级路径收官：金标 5/5 + 采纳案例 + 正则层噪声治理
+
+- **金标 4/5（libssh 回调分发认证）**（`demo-real-c-libssh-cb/` + `REALWORLD_C_V6.md`）：真实 `samplesshd-cb.c`（359 行）逐字——现代回调分发 API（`ssh_server_callbacks_struct` 的 `auth_password_function` / `channel_open_request_session_function`，决策记录指定的最优模块）。2 注解 → APPROVED 82、真实代码 0 FP、植入 `cb_session_no_auth` 精确定位；认证完成跃迁在 libssh 内部 + main 循环条件（L3 边界），establish 由演示层 wrapper 表达（V5 wrapper 模式）
+- **金标 5/5（uftpd 数据传送授权）**：采纳项目第二个协议——真实 `do_RETR`/`do_STOR` + 2 注解（pre AUTHENTICATED → post AUTHORIZED，镜像 check_resource_ownership 语义）→ 真实代码 0 FP、`ftp_transfer_no_login` 精确定位（fixPath → `establish_login`）；金标累计 5/5 全部 ~2-3 注解/协议
+- **发现 G5（规则面缺口入册）**：SSG 状态机 per-namespace——内置 `check_resource_ownership`（data_integrity，pre=[AUTHENTICATED]）永远不可满足（AUTHENTICATED 在 auth 命名空间，src/tests 全仓库零引用）——规则面设计缺口，非引擎缺陷
+- **正则层噪声治理（V5 发现 4 落地）**：`PLAINTEXT_AUTH_WITHOUT_TLS` 加 `languages` 门控排除 C（真实语料证据 3 FP / 0 TP：libssh 演示 1 + uftpd 采纳案例 2——FTP/SSH 应用层本就明文，Web/TLS 语义对 C 无意义）；SSH 主机密钥规则保留全语言（libssh 演示 1 TP）。`checkSpecificViolations` 加 `language` 参数、engine 传 `ctx.language`、5 个回归测试；**双零漂移**：Python 盲测 v1.2 64 违规（仅时间戳差）、C 应用级金标 F1=95.7% 不变；uftpd 重扫 PLAINTEXT ×2 消失、libssh 演示 FP 消失 TP 保留
+- **标签升级已拍板**：C「⚠️ 研究」→「✅ 注解驱动协议验证（Beta）」——README 双语、覆盖矩阵双语、c-language-status、CLAUDE.md 同步翻新；能力边界如实保留（未注解不检测、TLS 级无覆盖）
+
+### C 定位拍板「注解驱动」+ 库边界机制 + 精度修复
+
+- **定位拍板**（Decision record 定稿）：C = 注解驱动协议验证（研究级）——未注解自动检测 0 TP/3 FP，两条自动检测桥（C 库别名注册表、方言解析器）不排期；文档翻转：README 双语 + 覆盖矩阵双语 C 行「⚠️ 注解驱动（研究级）」
+- **库边界机制（孵化器）**：两层——项目原语注解（`@progmune`，不迁移）+ **库边界别名**（`.progmune_aliases.json` → 共享表 `c-aliases.json`，跨项目迁移）。新增：`scripts/c-annotate.js`（注释块模板 + 别名条目建议脚手架）、`scripts/c-alias-propose.js`（别名校验 + 回写提案 + 人工确认门）；引擎 `loadProtocolRules` 合并共享表 **confirmed** 条目（proposed 不生效、不覆盖全局/项目别名、规则不存在跳过）；`c-aliases.json` 入 npm 包
+- **库边界演示**（`demo-real-c-libssh/` + `REALWORLD_C_V3.md`）：真实 libssh authentication.c 逐字 + 1 别名 + 1 注解 → SSG 层 0 误报、植入 missing-auth 精确定位；正则防护层同跑：SSH_NO_HOST_KEY_CHECK 为**真发现**（示例确实不验证主机密钥）、PLAINTEXT_AUTH_WITHOUT_TLS 为 FP（Web 语义规则误映射 SSH，如实记录）
+- **发现**：多机制认证重试循环的状态机语义缺口（verify 类规则 pre 不可重入——全机制别名映射会误报正常重试流，候选：可重试标记）；fixPath 反向映射（规则名 → 库调用名）候选
+- **陷阱修复（DSH 复测发现）**：`evaluateTrust` 的注解合并依赖 ir.json 写盘，而自动提取此前仅 TS/JS 生效——C/Python 项目直接调用时注解静默失效。现在按语言分派提取器自动写盘（C 走合并形态；TS/JS 路径零变化）+ 回归测试；提取器改静态导入（vitest 下 lazy require 的 CJS 互操作不可靠——该分支从未被测试触发过）
+- **精度修复**：真实语料 24 FP → 3 FP（-87.5%）
+
+### C 精度修复：真实语料 24 FP → 3 FP（-87.5%）
+
+- **Strategy 1 normalized 门控**：Windows API（ReadFile/WriteFile/DeleteFile）经 CamelCase→snake_case 规范化撞上内置规则名是 11/24 FP 的主导源——normalized 分支套用词段门控同款 projectFunctions 门（外部 API 不桥接；注解桥接不受影响——注解原语必为项目函数；原始名精确匹配不限门控）
+- **endState 直接调用溯源**：12/24 FP 是 nginx 回调式生命周期（open 在内联 helper 链、close 在指针注册的回调里——L3 级不可见）——`CallSequence.directCalls` + `validateSequenceWithSSG` 的 `entryDirectCalls` 参数，仅当资源获取调用是入口的直接调用时报告 endState（helper 获取不归因入口）
+- **结果**：真实语料四仓库 24 flags → **3 flags**（nginx 14→0、redis 0、libssh 1、openssl 2；残留 3 条是词段桥接按设计命中项目函数）。双回归门全过：Python 盲测 v1.2 64 违规零漂移（仅时间戳差异）、C 应用级金标 **TP 11/FP 1/FN 0 → F1=95.7% 不变**（leak_file 的 endState TP 保留）、引擎相关套件 120/120
+- **战略记录**：C 产品定位（自动检测 vs 注解驱动）待拍板——写入 `docs/c-language-status.md` Decision record；证据偏向注解驱动（精度修复后未注解自动检测仍 0 TP），金标扩量延后至定位拍板
+
 ## [3.7.5] — 2026-08-27
 
 ### C 真实语料验证 + 注解驱动演示 + 引擎修复（DSH 双轮评审合入）

package/README.md

@@ -103,7 +103,7 @@ Progmune is honest about what it can and cannot verify.
 |----------|--------|----------|
 | **TypeScript / JavaScript** | ✅ Production | Blind benchmark: **recall 98.5% / precision 100%** (795 gold findings, 100 projects) |
 | **Python** | ✅ Production | Blind benchmark: **recall 100% / precision 100%** (729 gold findings, 90 projects); real-world validation: PyGoat (OWASP vulnerable-by-design Django app) **67 TP / 0 FP, 100% labeled precision**; three well-written apps (django/fastapi realworld, django-unicorn) with 0 false-positive true findings |
-| **C** | ⚠️ Research-only | 3.7.4: IR extraction merged via the language registry — app-level protocol lifecycles (auth/db/file/payment) verifiable through the SSG state machine (app-level gold v2: **P=91.7% / R=100% / F1=95.7%**). TLS-level coverage still absent (old regex-route F1=16.5% is the historical baseline); L3/L4 conclusions unchanged. See [C Language Status](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/c-language-status.md). |
+| **C** | ✅ Annotation-driven (Beta) | IR extraction via the registry + SSG state machine; **annotate ~2-3 protocol primitives per protocol to get trusted verification** (gold 5/5 on real modules: redis ACL / libssh client / libssh server / libssh callback-dispatch / uftpd transfer-auth — all 0 FP with precise violation localization; app-level gold v2: **P=91.7% / R=100% / F1=95.7%**). Unannotated auto-detection stays out of scope (0 TP on real corpus — positioning decision recorded in the C Language Status doc); TLS-level coverage still absent. See [C Language Status](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/c-language-status.md). |
 | **Go, Java** | ❌ None | Planned |
 
 **Multi-language IR (registry-based).** TypeScript (ts-morph) and Python (AST) extractors are registered entries in one registry (`src/extract-project-ir.ts`); `extractProjectIR` merges every detected language into a single function IR shared by the agent loop, `execute()`, and the MCP server — the agent composes function-protocol chains across both languages. Adding a language (Go, Java, …) = register one extractor entry; callers don't change.
@@ -152,9 +152,9 @@ Public, reproducible precision data. All numbers measured against gold-annotated
 
 → [Real-world validation report](https://github.com/shenlian19831109/progmune-runtime/blob/main/blind-benchmark/REALWORLD_APP_V1.md) · [Benchmark baseline](https://github.com/shenlian19831109/progmune-runtime/blob/main/blind-benchmark/BASELINE_v6.md)
 
-### C (IR extraction + app-level protocol verification — research status)
+### C (IR extraction + annotation-driven protocol verification — Beta)
 
-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.
+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 is the production shape (Beta as of 3.7.6): gold 5/5 on real modules (redis ACL, libssh client/server/callback-dispatch, uftpd transfer-auth) + one independent adoption case (uftpd) — all 0 FP with precise violation localization, at a steady cost of ~2-3 annotations per protocol. Unannotated auto-detection is out of scope (0 TP on real corpus). 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

@@ -103,7 +103,7 @@ Progmune 对能验证什么、不能验证什么保持诚实。
 |------|------|------|
 | **TypeScript / JavaScript** | ✅ 生产 | 盲测基准：**召回 98.5% / 精确率 100%**（795 条 gold finding，100 个项目） |
 | **Python** | ✅ 生产 | 盲测基准：**召回 100% / 精确率 100%**（729 条 gold finding，90 个项目）；真实应用验证：PyGoat（OWASP 故意脆弱 Django 应用）**67 TP / 0 FP，标记精确率 100%**；三个良构应用（django/fastapi realworld、django-unicorn）0 误报真阳性 |
-| **C** | ⚠️ 仅研究 | 3.7.4：IR 提取接入多语言注册表——应用级协议生命周期（认证/数据库/文件/支付）经 SSG 状态机可验证（应用级金标 v2：**P=91.7% / R=100% / F1=95.7%**）。TLS 级覆盖仍无（旧正则口径 F1=16.5% 为历史基线）；L3/L4 结论不变。见 [C 语言状态](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/c-language-status.md)。 |
+| **C** | ✅ 注解驱动（Beta） | IR 提取接入注册表 + SSG 状态机；**每协议标注 ~2-3 个原语即获得可信验证**（真实模块金标 5/5：redis ACL / libssh 客户端 / libssh 服务端 / libssh 回调分发 / uftpd 传送授权——全部 0 误报 + 违规精确定位；应用级金标 v2：**P=91.7% / R=100% / F1=95.7%**）。未注解自动检测不在范围（真实语料 0 TP——定位决议见 C 语言状态文档）；TLS 级覆盖仍无。见 [C 语言状态](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/c-language-status.md)。 |
 | **Go, Java** | ❌ 无 | 规划中 |
 
 **多语言 IR（注册表式）。** TypeScript（ts-morph）与 Python（AST）提取器是同一注册表（`src/extract-project-ir.ts`）中的注册项；`extractProjectIR` 把检测到的所有语言合并为一份函数 IR，由 agent loop、`execute()` 与 MCP server 共享——agent 可在两种语言上编排函数协议链。新增语言（Go、Java……）= 注册一条提取器，调用方零改动。
@@ -152,9 +152,9 @@ Progmune 对能验证什么、不能验证什么保持诚实。
 
 → [真实验证报告](https://github.com/shenlian19831109/progmune-runtime/blob/main/blind-benchmark/REALWORLD_APP_V1.md) · [基准基线](https://github.com/shenlian19831109/progmune-runtime/blob/main/blind-benchmark/BASELINE_v6.md)
 
-### C（IR 提取 + 应用级协议验证——研究状态）
+### C（IR 提取 + 注解驱动协议验证——Beta）
 
-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)。
+3.7.4 起 C 拥有多语言注册表中的 IR 提取器：C 项目进入 IR-first 序列验证 + SSG 状态机。应用级协议生命周期（认证/数据库/文件/支付）在 C 上可验证——应用级金标 v2：**11/11 违规全检出（召回 100%）、1 误报、F1=95.7%**。注解驱动是 C 的生产形态（3.7.6 起 Beta）：真实模块金标 5/5（redis ACL、libssh 客户端/服务端/回调分发、uftpd 传送授权）+ 1 个独立采纳案例（uftpd）——全部 0 误报 + 违规精确定位，标注成本稳定在每协议 ~2-3 条。未注解自动检测不在范围（真实语料 0 TP）。提取覆盖大型真实仓库（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/c-aliases.json

@@ -0,0 +1,13 @@
+{
+  "description": "C 库边界别名共享表——注解驱动定位的孵化器燃料（跨项目迁移）",
+  "entries": [
+    {
+      "call": "ssh_userauth_password",
+      "rule": "verify_password",
+      "status": "confirmed",
+      "proposedBy": "demo-real-c-libssh",
+      "proposedAt": "2026-08-27",
+      "confirmedAt": "2026-08-27"
+    }
+  ]
+}

package/dist/call-sequence.js

@@ -151,7 +151,13 @@ function buildCallSequences(ir, keepNames, maxCalls = exports.MAX_SEQUENCE_CALLS
         const calls = expandBody(f, 0, new Set());
         if (calls.length === 0)
             continue;
-        sequences.push({ calls, file: f.file, function: f.name, truncated: budget.truncated || undefined });
+        sequences.push({
+            calls,
+            file: f.file,
+            function: f.name,
+            truncated: budget.truncated || undefined,
+            directCalls: f.calls || [],
+        });
     }
     return sequences;
 }

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

package/dist/trust/engine.js

@@ -63,7 +63,20 @@ const protocol_domain_validator_1 = require("./protocol-domain-validator");
 const call_graph_propagator_1 = require("./call-graph-propagator");
 const ssg_bridge_1 = require("./ssg-bridge");
 const call_sequence_1 = require("../call-sequence");
+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");
 // ── Main Entry Point ──
+/**
+ * Trust 决策主入口：收集 → 归一化 → 评分 → 决策 → 组装。
+ *
+ * IR 写盘语义（勿改）：项目缺少 ir.json 时，引擎按 ctx.language 自动提取
+ * 并落盘（TS/JS → extractIR 裸数组；Python → extractIRPython 裸数组；
+ * C → extractIRC 合并形态 { typeMap, functions }）——注解合并（P4.5）依赖
+ * ir.json，调用方【无需】手动 extractProjectIR/写盘（曾是对 C 注解静默
+ * 失效的文档/API 陷阱，回归测试见 tests/trust/engine.test.ts「DSH 陷阱」）。
+ * 若项目已有 ir.json，以现有文件为准（不覆盖）。
+ */
 async function evaluateTrust(ctx) {
     const engineVersion = "trust-runtime-v1.0.0";
     const timestamp = new Date().toISOString();
@@ -709,16 +722,32 @@ async function collectProtocolViolations(ctx, callGraph) {
         // 序列必须来自「函数体内真实调用」而非「文件内函数声明名单」——
         // 声明顺序 ≠ 执行顺序：正则扫描会把声明当调用（auth.ts 误报），
         // 也会因调用数不足阈值漏掉单调用违规文件（bad_flow 漏报）。
-        if (!ctx.language || ctx.language === "typescript" || ctx.language === "javascript") {
-            try {
-                const fs = require("fs");
-                if (!fs.existsSync(path.join(ctx.projectPath, "ir.json"))) {
-                    const { extractIR } = require("../extract-ir");
-                    const ir = extractIR(ctx.projectPath);
-                    fs.writeFileSync(path.join(ctx.projectPath, "ir.json"), JSON.stringify(ir, null, 2));
+        // 注解合并（P4.5）依赖 ir.json 写盘：此前仅 TS/JS 自动提取，C/Python 项目
+        // 直接调 evaluateTrust 时注解静默失效（DSH 复测发现的文档/API 陷阱）——
+        // 按语言分派提取器兜底写盘；TS/JS 路径保持原样（裸数组形态，零变化）。
+        {
+            const lang = ctx.language || "typescript";
+            // 静态导入（vitest 环境下 lazy require 的 CJS 互操作不可靠——
+            // TS 路径从未触发过该分支：仓库根遗留 ir.json 短路了 existsSync 检查）
+            const autoExtractor = {
+                typescript: () => (0, extract_ir_1.extractIR)(ctx.projectPath),
+                javascript: () => (0, extract_ir_1.extractIR)(ctx.projectPath),
+                python: () => (0, extract_ir_python_1.extractIRPython)(ctx.projectPath),
+                c: () => (0, extract_ir_c_1.extractIRC)(ctx.projectPath),
+            };
+            const extractFn = autoExtractor[lang];
+            if (extractFn) {
+                try {
+                    const fs = require("fs");
+                    if (!fs.existsSync(path.join(ctx.projectPath, "ir.json"))) {
+                        const ir = extractFn();
+                        // C 走合并形态（与 execute/MCP 写盘一致）；TS/Python 保持裸数组形态
+                        const payload = lang === "c" ? { typeMap: {}, functions: ir } : ir;
+                        fs.writeFileSync(path.join(ctx.projectPath, "ir.json"), JSON.stringify(payload, null, 2));
+                    }
                 }
+                catch { /* best-effort — 回退正则扫描 */ }
             }
-            catch { /* best-effort — 回退正则扫描 */ }
         }
         // ── SSG State Machine: load protocol rules once ──
         protocolRulesData = (0, ssg_bridge_1.loadProtocolRules)(ctx.projectPath);
@@ -850,7 +879,7 @@ async function collectProtocolViolations(ctx, callGraph) {
                     // A sequence may be a valid protocol operation but still violate
                     // specific security requirements (e.g., TLS without cert verify)
                     try {
-                        const specificViolations = (0, protocol_domain_validator_1.checkSpecificViolations)(semantic, seq.file ? path.join(ctx.projectPath, seq.file) : undefined);
+                        const specificViolations = (0, protocol_domain_validator_1.checkSpecificViolations)(semantic, seq.file ? path.join(ctx.projectPath, seq.file) : undefined, ctx.language);
                         for (const sv of specificViolations) {
                             violations.push({
                                 severity: "medium", // Phase 2: per-function window has inherent limitations
@@ -873,7 +902,7 @@ async function collectProtocolViolations(ctx, callGraph) {
                 // to bridge real API names to abstract protocol function names.
                 if (protocolRulesData) {
                     try {
-                        const ssgResult = (0, ssg_bridge_1.validateSequenceWithSSG)(semantic.steps, protocolRulesData.rules, protocolRulesData.namespaceInitialStates, seq.file, protocolRulesData.aliasIndex, protocolRulesData.wildcardAliases, projectFunctions);
+                        const ssgResult = (0, ssg_bridge_1.validateSequenceWithSSG)(semantic.steps, protocolRulesData.rules, protocolRulesData.namespaceInitialStates, seq.file, protocolRulesData.aliasIndex, protocolRulesData.wildcardAliases, projectFunctions, seq.directCalls ? new Set(seq.directCalls) : undefined);
                         ssgResults.push(ssgResult);
                         ssgTotalCalls += ssgResult.stats.totalCalls;
                         ssgMatchedCalls += ssgResult.stats.matchedCalls;

package/dist/trust/protocol-domain-validator.js

@@ -284,6 +284,10 @@ exports.SPECIFIC_VIOLATION_CHECKS = [
         ruleId: "PLAINTEXT_AUTH_WITHOUT_TLS",
         description: "Authentication credentials transmitted without TLS protection. " +
             "SASL PLAIN, LOGIN, or credential data must be sent over an encrypted channel.",
+        // C 排除（2026-08-28，真实语料证据）：libssh 演示 1 FP（SSH 明文协议被
+        // Web/TLS 语义误映射）+ uftpd 采纳案例 2 FP（handle_USER/main）——FTP/SSH
+        // 应用层本就明文，传输加密在协议自身/进程外，本规则的 Web 语义对 C 无 TP。
+        languages: ["typescript", "javascript", "python"],
         check: (steps) => {
             // Auth data being prepared (credentials + mechanism)
             const hasAuthCred = steps.some((s) => s.domain === "auth_cred");
@@ -649,10 +653,16 @@ exports.SPECIFIC_VIOLATION_CHECKS = [
 /**
  * Run specific violation checks against a semantic sequence.
  * Returns violations found (empty for Phase 1 MVP).
+ *
+ * @param language — project language ("c" | "python" | "typescript" | …);
+ *   checks with a `languages` allowlist are skipped for other languages.
  */
-function checkSpecificViolations(seq, _filePath) {
+function checkSpecificViolations(seq, _filePath, language) {
     const violations = [];
     for (const check of exports.SPECIFIC_VIOLATION_CHECKS) {
+        if (check.languages && language && !check.languages.includes(language)) {
+            continue;
+        }
         if (check.check(seq.steps, _filePath)) {
             violations.push({
                 ruleId: check.ruleId,

package/dist/trust/protocol-domain-validator.test.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * protocol-domain-validator.test.ts — specific violation checks 的语言门控回归
+ *
+ * 2026-08-28 语言门控（REALWORLD_C_V6.md）：PLAINTEXT_AUTH_WITHOUT_TLS 的
+ * Web/TLS 语义在 C 真实项目上 3 FP / 0 TP（libssh 演示 1 + uftpd 采纳案例 2，
+ * FTP/SSH 应用层本就明文）。SSH 主机密钥规则保留全语言（libssh 演示 1 TP）。
+ *
+ * 测试避免文件系统 I/O——直接构造 SemanticSequence。
+ */
+const vitest_1 = require("vitest");
+const protocol_domain_validator_1 = require("./protocol-domain-validator");
+/** PLAINTEXT 触发序列：auth 凭证 + 网络发送 + 无 TLS 保护 */
+function plaintextSequence() {
+    return {
+        steps: [
+            { api: "create_credentials", domain: "auth_cred", description: "", source: "lookup" },
+            { api: "network_send", domain: "conn_mgmt", description: "", source: "lookup" },
+        ],
+        domains: ["auth_cred", "conn_mgmt"],
+        primaryDomain: "conn_mgmt",
+    };
+}
+/** SSH 无主机密钥校验触发序列：≥4 个 ssh_ops + userauth + 凭证、无 hostkey */
+function sshNoHostKeySequence() {
+    return {
+        steps: [
+            { api: "ssh_bind_accept", domain: "ssh_ops", description: "", source: "lookup" },
+            { api: "ssh_handle_key_exchange", domain: "ssh_ops", description: "", source: "lookup" },
+            { api: "ssh_userauth_password", domain: "ssh_ops", description: "", source: "lookup" },
+            { api: "ssh_event_dopoll", domain: "ssh_ops", description: "", source: "lookup" },
+            { api: "password_compare", domain: "auth_cred", description: "", source: "lookup" },
+        ],
+        domains: ["ssh_ops", "auth_cred"],
+        primaryDomain: "ssh_ops",
+    };
+}
+(0, vitest_1.describe)("protocol-domain-validator language gating", () => {
+    (0, vitest_1.it)("PLAINTEXT_AUTH_WITHOUT_TLS fires for typescript", () => {
+        const v = (0, protocol_domain_validator_1.checkSpecificViolations)(plaintextSequence(), undefined, "typescript");
+        (0, vitest_1.expect)(v.map((x) => x.ruleId)).toContain("PLAINTEXT_AUTH_WITHOUT_TLS");
+    });
+    (0, vitest_1.it)("PLAINTEXT_AUTH_WITHOUT_TLS fires for python", () => {
+        const v = (0, protocol_domain_validator_1.checkSpecificViolations)(plaintextSequence(), undefined, "python");
+        (0, vitest_1.expect)(v.map((x) => x.ruleId)).toContain("PLAINTEXT_AUTH_WITHOUT_TLS");
+    });
+    (0, vitest_1.it)("PLAINTEXT_AUTH_WITHOUT_TLS does NOT fire for C (language gate)", () => {
+        const v = (0, protocol_domain_validator_1.checkSpecificViolations)(plaintextSequence(), undefined, "c");
+        (0, vitest_1.expect)(v.map((x) => x.ruleId)).not.toContain("PLAINTEXT_AUTH_WITHOUT_TLS");
+    });
+    (0, vitest_1.it)("SSH_NO_HOST_KEY_CHECK still fires for C (ungated — libssh TP 保留)", () => {
+        const v = (0, protocol_domain_validator_1.checkSpecificViolations)(sshNoHostKeySequence(), undefined, "c");
+        (0, vitest_1.expect)(v.map((x) => x.ruleId)).toContain("SSH_NO_HOST_KEY_CHECK");
+    });
+    (0, vitest_1.it)("undefined language keeps legacy behavior (all checks run)", () => {
+        const v = (0, protocol_domain_validator_1.checkSpecificViolations)(plaintextSequence());
+        (0, vitest_1.expect)(v.map((x) => x.ruleId)).toContain("PLAINTEXT_AUTH_WITHOUT_TLS");
+    });
+});

package/dist/trust/ssg-bridge.js

@@ -251,29 +251,32 @@ function inferRuleName(apiName, domain, description, ruleNames, namespace, alias
         if (ruleName)
             return ruleName;
     }
-    // Strategy 1: Exact normalized match against rule names
-    for (const ruleName of ruleNames) {
-        if (normalized === ruleName || lowerApi === ruleName) {
-            return ruleName;
-        }
-    }
-    // Strategy 2: Word-segment match — only match on complete word boundaries.
-    // Split both the rule name and normalized call name into word segments
-    // (separated by _). Match if every word in the rule name appears as a
-    // word segment in the normalized call name. This prevents "status" from
-    // matching "poll_status" via raw substring, since "status" must appear
-    // as a complete _-delimited segment.
-    //
-    // 门控（P4.6.1）：词段匹配只对「项目函数」适用——它是为改名协议原语设计的
-    // （协议原语必然是项目内函数，如 S5 的 create_active_session）。外部库调用
-    // （如 Node 的 readFileSync）经词段撞上 read_file 是纯噪声：外部 API 的语义
-    // 桥接走 alias 配置（Strategy 0b）或 domain 关键词（Strategy 3），不走词段。
+    // 门控判定（P4.6.1 词段门控同款）：项目函数才能按规范化/词段形态命中——
+    // 外部 API（如 Windows 的 ReadFile → snake_case 撞上 read_file）是纯噪声，
+    // 其语义桥接走 alias 配置（Strategy 0b）或 domain 关键词（Strategy 3）。
     // 未提供 projectFunctions 时保持旧行为（向后兼容测试与无 IR 的调用方）。
     const isProjectFn = !projectFunctions
         || projectFunctions.has(apiName)
         || projectFunctions.has(lowerApi)
         || projectFunctions.has(normalized)
         || (dotIdx >= 0 && projectFunctions.has(lowerApi.slice(dotIdx + 1)));
+    // Strategy 1: Exact match against rule names.
+    // 原始名（含小写）精确匹配不限门控；规范化形态（CamelCase → snake_case）
+    // 仅项目函数适用——真实 C 语料验证中 ReadFile/WriteFile/DeleteFile 经
+    // normalized 撞上 read_file/write_file/delete_file 是 11/24 FP 的主导源，
+    // 而注解桥接（ACLCheckAllPerm → acl_check_all_perm）全是项目函数，不受影响。
+    for (const ruleName of ruleNames) {
+        if (lowerApi === ruleName) {
+            return ruleName;
+        }
+    }
+    if (isProjectFn) {
+        for (const ruleName of ruleNames) {
+            if (normalized === ruleName) {
+                return ruleName;
+            }
+        }
+    }
     for (const ruleName of ruleNames) {
         if (projectFunctions && !isProjectFn)
             continue;
@@ -319,7 +322,12 @@ function inferRuleName(apiName, domain, description, ruleNames, namespace, alias
  */
 function validateSequenceWithSSG(steps, rules, namespaceInitialStates, file, aliasIndex, wildcardAliases, 
 /** 项目函数名集合（含裸名/全名/小写变体由调用方构造）——提供后词段匹配只对项目函数适用 */
-projectFunctions) {
+projectFunctions, 
+/** 入口函数的直接调用集合——endState 检查的资源获取溯源：经内联 helper
+ *  获取的资源不归因给入口（nginx 回调式生命周期：open 在 helper 链内、
+ *  close 在回调里，直接调用序列看不到），提供后仅在获取调用 ∈ 直接调用
+ *  时报告 endState。未提供时保持旧行为。 */
+entryDirectCalls) {
     const allRuleNames = Array.from(rules.keys());
     const aliases = aliasIndex || new Map();
     const wildcards = wildcardAliases || new Map();
@@ -359,14 +367,15 @@ projectFunctions) {
         }
     })();
     // 本序列中"新获取"的资源状态（endState 检查只针对本序列获取、未释放的状态——
-    // 继承自命名空间初始状态的不算泄漏，与 planner 语义一致）
-    const acquiredStates = new Set();
-    const trackAcquiredStates = (before, after) => {
+    // 继承自命名空间初始状态的不算泄漏，与 planner 语义一致）。
+    // 记录获取调用名：endState 归因溯源（入口直接调用 vs 内联 helper 获取）。
+    const acquiredStates = new Map(); // `${ns}::${state}` → 获取调用名
+    const trackAcquiredStates = (before, after, acquiringCall) => {
         for (const ns of Object.keys(after)) {
             const prev = before?.[ns] || [];
             for (const s of after[ns]) {
                 if (!prev.includes(s))
-                    acquiredStates.add(`${ns}::${s}`);
+                    acquiredStates.set(`${ns}::${s}`, acquiringCall);
             }
         }
     };
@@ -413,7 +422,7 @@ projectFunctions) {
                 // Advance state
                 ctx.ledger.push(result.transition);
                 ctx.currentState = result.transition.statesAfter;
-                trackAcquiredStates(result.transition.statesBefore, result.transition.statesAfter);
+                trackAcquiredStates(result.transition.statesBefore, result.transition.statesAfter, step.api);
             }
             else {
                 violatedCalls++;
@@ -445,7 +454,7 @@ projectFunctions) {
                 // Still advance state on rejection (best-effort: apply transition anyway
                 // so subsequent calls can be validated)
                 ctx.ledger.push(result.transition);
-                trackAcquiredStates(result.transition.statesBefore, result.transition.statesAfter);
+                trackAcquiredStates(result.transition.statesBefore, result.transition.statesAfter, step.api);
             }
         }
         catch {
@@ -479,7 +488,12 @@ projectFunctions) {
         const ctx = contexts.get(hs.namespace);
         if (!ctx)
             continue;
-        if (!acquiredStates.has(`${hs.namespace}::${hs.state}`))
+        const acquiringCall = acquiredStates.get(`${hs.namespace}::${hs.state}`);
+        if (!acquiringCall)
+            continue;
+        // 资源获取溯源：经内联 helper 获取的状态不归因给入口（释放可能存在于
+        // 兄弟 helper 或回调注册中——nginx 回调式生命周期是 12/24 FP 的主源）
+        if (entryDirectCalls && !entryDirectCalls.has(acquiringCall))
             continue;
         const cur = ctx.currentState[hs.namespace] || [];
         if (!cur.includes(hs.state))
@@ -678,6 +692,32 @@ function loadProtocolRules(projectPath) {
             nsInit._global = "INIT";
         if (!nsInit.stateless)
             nsInit.stateless = "IDLE";
+        // ── Load shared C alias registry (c-aliases.json, confirmed entries only) ──
+        // 注解驱动定位的孵化器燃料：库边界别名跨项目迁移——用户项目别名回写提案、
+        // 人工确认（status=confirmed）后对全部项目生效。加载顺序在项目别名之前：
+        // 项目本地映射优先于共享表（与「项目别名不覆盖全局」同哲学，first-wins）。
+        try {
+            const cRegistryPath = [
+                projectPath ? path.join(projectPath, "c-aliases.json") : "",
+                path.join(process.cwd(), "c-aliases.json"),
+                path.join(__dirname, "..", "c-aliases.json"),
+            ].find((p) => p && fs.existsSync(p));
+            if (cRegistryPath) {
+                const reg = JSON.parse(fs.readFileSync(cRegistryPath, "utf-8"));
+                for (const entry of reg.entries || []) {
+                    if (entry.status !== "confirmed")
+                        continue;
+                    const callName = String(entry.call).toLowerCase().trim();
+                    const ruleName = String(entry.rule);
+                    if (!callName || !rules.has(ruleName))
+                        continue;
+                    if (!aliasIndex.has(callName)) {
+                        aliasIndex.set(callName, ruleName);
+                    }
+                }
+            }
+        }
+        catch { /* best-effort — 共享表缺失或损坏不影响验证 */ }
         // ── Load project-level aliases (supplemental, never override global) ──
         let projectAliases;
         let aliasWarnings;

package/dist/trust/ssg-bridge.test.js

@@ -8,8 +8,44 @@
  *   3. Detects state machine violations
  *   4. Passes valid sequences without false positives
  */
+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 ssg_bridge_1 = require("./ssg-bridge");
 // Load protocol rules once for all tests
 const protoData = (0, ssg_bridge_1.loadProtocolRules)();
@@ -272,3 +308,43 @@ function step(api, domain, description = "") {
         });
     });
 });
+(0, vitest_1.describe)("共享 C 别名表（c-aliases.json，孵化器机制）", () => {
+    (0, vitest_1.it)("confirmed 条目被加载进 aliasIndex；proposed 条目不加载（人工确认门）", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-calias-"));
+        try {
+            fs.writeFileSync(path.join(dir, "c-aliases.json"), JSON.stringify({
+                entries: [
+                    { call: "ssh_userauth_password", rule: "verify_password", status: "confirmed" },
+                    { call: "some_lib_connect", rule: "connect_db", status: "proposed" },
+                    { call: "ghost_call", rule: "no_such_rule", status: "confirmed" },
+                ],
+            }));
+            const loaded = (0, ssg_bridge_1.loadProtocolRules)(dir);
+            (0, vitest_1.expect)(loaded).not.toBeNull();
+            (0, vitest_1.expect)(loaded.aliasIndex.get("ssh_userauth_password")).toBe("verify_password");
+            (0, vitest_1.expect)(loaded.aliasIndex.has("some_lib_connect")).toBe(false); // 未确认不生效
+            (0, vitest_1.expect)(loaded.aliasIndex.has("ghost_call")).toBe(false); // 规则不存在跳过
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("共享表不覆盖全局别名与项目别名（first-wins）", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-calias2-"));
+        try {
+            // 全局 verify_hash 的别名 jsonwebtoken.verify——共享表同名条目不得覆盖
+            fs.writeFileSync(path.join(dir, "c-aliases.json"), JSON.stringify({
+                entries: [
+                    { call: "jsonwebtoken.verify", rule: "verify_password", status: "confirmed" },
+                ],
+            }));
+            const loaded = (0, ssg_bridge_1.loadProtocolRules)(dir);
+            const globalRule = loaded.rules.get("verify_token")?.aliases?.includes("jsonwebtoken.verify");
+            // jsonwebtoken.verify 若已存在全局别名，共享表不覆盖（值保持原规则）
+            (0, vitest_1.expect)(loaded.aliasIndex.get("jsonwebtoken.verify")).not.toBe("verify_password");
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

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

@@ -174,7 +174,7 @@
   本文档面向两类读者：想快速理解的初学者，与需要专业判断的投资人。</div>
   <div class="meta">
     <span>📄 版本 v1.0 · 2026-08</span>
-    <span>🧪 引擎版本 v3.7.2</span>
+    <span>🧪 引擎版本 v<span id="npmVersion">3.7.6</span></span>
     <span>📊 13/13 安全类别覆盖</span>
     <span>🔓 开源 MIT</span>
     <span>📦 npm install progmune-runtime</span>
@@ -724,5 +724,24 @@ AI 生成: create_session(...)   ← 当前状态 UNAUTHENTICATED
 </div>
 
 </div>
+
+<script>
+// ═══ 引擎版本号动态展示：registry.npmjs.org dist-tags.latest ═══
+// 发布到 npm 后自动跟随最新版本；拉取失败保留静态回退值。
+(async function loadNpmVersion() {
+  const el = document.getElementById("npmVersion");
+  if (!el) return;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 8000);
+  try {
+    const res = await fetch("https://registry.npmjs.org/progmune-runtime", { signal: ctrl.signal });
+    clearTimeout(timer);
+    if (!res.ok) throw new Error(String(res.status));
+    const pkg = await res.json();
+    const latest = pkg && pkg["dist-tags"] && pkg["dist-tags"].latest;
+    if (latest) el.textContent = latest;
+  } catch { /* 保留静态回退值 */ }
+})();
+</script>
 </body>
 </html>

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "progmune-runtime",
-  "version": "3.7.5",
+  "version": "3.7.6",
   "description": "Progmune — AI Trust Decision Engine. Verify AI-generated code before it reaches production. Outputs APPROVED / NEEDS_REVIEW / BLOCKED with evidence.",
   "files": [
     "dist/",
     "protocols.json",
+    "c-aliases.json",
     "CHANGELOG.md",
     "docs/Progmune_项目全解.html",
     "docs/Progmune_投资人白皮书_v2.0.html"