progmune-runtime 3.7.5 → 3.7.7

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## [3.7.7] — 2026-08-28
+
+### C 注解采纳体验（采纳生死线工具）
+
+- **注解建议引擎**（`src/annotation-suggest.ts`）：确定性启发式（无 LLM）——按函数名词汇（3.7.6 金标 5/5 真实注解反推的词表）× 已注解状态，生成原语注解候选（verify/establish/guard/open/close 角色 + 命名空间/状态转移/注释块模板/置信度/命中理由/掩蔽风险标记）；已注解、规则名、外部函数自动排除；两遍计算 maskRisk（体内调用规则原语或本批同被建议函数）
+- **CLI 扫描模式**（`scripts/c-annotate.js --scan <dir> [--write] [--all] [--include-resource]`）：dry-run 默认；--write 自动插入函数定义上方（写入后自动刷新 ir.json 防陈旧）；保守门控（全部实测依据）：establish/掩蔽风险跳过（不提供强制开关）、open/close 跳过（--include-resource 强制）
+- **引擎加性字段**：`evaluateTrust.annotationSuggestions`（仅 C 生成；TS/Python 无该字段——零漂移）
+- **验收（REALWORLD_C_V7.md）**：无注解 uftpd 副本金标恢复率 **4/4 角色正确**（check_user_pass=verify / handle_PASS=establish / do_RETR / do_STOR=guard）；自动应用 7 条后与手写金标**等价**（真实代码 0 SSG FP、植入违规 2/2 精确定位、NEEDS_REVIEW 72 同分）
+- **三个实测安全发现（自动写入的门控依据）**：①掩蔽风险——establish 注解把手握违规的流函数变「原语」（函数内顺序不检查）后植入违规被掩蔽（实测 2 处）；②资源生命周期注解自动应用触发跨函数窗口 FP 类（实测 28 条，open/close 分处不同函数窗口）；③new_session 词汇误判守卫（实测 4 FP，模式收紧为 channel 类）
+- 回归：15 个新单元测试；引擎相关套件 98/98；Python 盲测 v1.2 零漂移（64）；C 应用级金标 F1=95.7% 不变；演示重扫 SSG 结果不变
+
+## [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/annotation-suggest.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * annotation-suggest.ts — C 注解建议引擎（确定性启发式，无 LLM）
+ *
+ * 注解驱动定位的「采纳生死线」：未注解 C 项目的 SSG 层静默（0 flags——
+ * 看不见问题，也看不见该在哪下注）。本模块按函数名词汇 + 已注解状态，
+ * 为项目生成「原语注解建议清单」——每条建议含角色（verify/establish/
+ * guard/open/close）、命名空间、状态转移与可直接粘贴的注释块模板。
+ *
+ * 设计原则：
+ *   - 纯名称启发式，诚实标注置信度（high=多证据/强动词，medium=单证据）；
+ *     不假装语义理解——建议是「填空起点」，人工确认后生效（与
+ *     c-alias-propose.js 的人工确认门同一哲学）。
+ *   - 词汇来自 3.7.6 金标 5/5 的真实注解反推（check_user_pass=verify、
+ *     handle_PASS=establish、do_RETR/do_STOR=守卫、auth_password=verify、
+ *     new_session_channel=会话守卫、open/close_data_connection=资源生命周期）。
+ *   - 已注解函数、规则名函数（按名即命中，无需注解）、外部函数不重复建议。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestAnnotations = suggestAnnotations;
+const ROLE_DEFS = [
+    {
+        // 凭证比对（密码/口令/凭证 × 比对动词）——verify_password 同款语义
+        role: "verify",
+        namespace: "auth",
+        pre: ["UNAUTHENTICATED"],
+        post: ["PASSWORD_VERIFIED"],
+        patterns: [
+            ["password", "check"],
+            ["password", "compare"],
+            ["password", "verify"],
+            ["password", "auth"],
+            ["passwd", "check"],
+            ["pass", "check"],
+            ["pass", "compare"],
+            ["credential", "check"],
+            ["credential", "compare"],
+            ["secret", "check"],
+            ["secret", "compare"],
+            ["kbdint", "get"],
+            ["otp", "check"],
+        ],
+    },
+    {
+        // 登录完成（认证循环/命令处理器的完成点）——establish 原语
+        role: "establish",
+        namespace: "auth",
+        pre: [],
+        post: ["AUTHENTICATED"],
+        patterns: [
+            ["authenticate"],
+            ["login"],
+            ["logon"],
+            ["sign_in"],
+            ["auth_success"],
+            ["auth_ok"],
+            ["handle", "pass"],
+            ["do", "login"],
+            ["do", "user"],
+        ],
+    },
+    {
+        // 权限/会话守卫（权限词 × 检查动词，或 FTP/传输类命令处理器、
+        // 通道开启回调）——check_resource_ownership 同款语义（auth 命名空间，
+        // 见 REALWORLD_C_V6.md 发现 G5：跨命名空间 pre 不可满足）
+        role: "guard",
+        namespace: "auth",
+        pre: ["AUTHENTICATED"],
+        post: ["AUTHORIZED"],
+        patterns: [
+            ["perm", "check"],
+            ["authoriz", "check"],
+            ["acl", "check"],
+            ["grant", "check"],
+            ["privilege", "check"],
+            ["do", "retr"],
+            ["do", "stor"],
+            ["handle", "retr"],
+            ["handle", "stor"],
+            ["do", "download"],
+            ["do", "upload"],
+            ["do", "transfer"],
+            ["start", "transfer"],
+            ["send", "transfer"],
+            ["open", "channel"],
+            ["accept", "channel"],
+            ["new", "channel"],
+            ["new", "session", "channel"],
+            // 注意：不带 ["new","session"]——new_session 是会话工厂（创建而非检查），
+            // 实测（V7）：守卫注解会误报其调用方（ftp_cb/tftp_cb/main 在登录前建会话）。
+        ],
+    },
+    {
+        // 资源获取（打开文件/连接/日志）——open_file 同款语义
+        role: "open",
+        namespace: "file",
+        pre: [],
+        post: ["FILE_OPEN"],
+        patterns: [
+            ["open", "file"],
+            ["open", "data"],
+            ["open", "connection"],
+            ["open", "conn"],
+            ["open", "log"],
+            ["open", "db"],
+            ["create", "connection"],
+        ],
+    },
+    {
+        // 资源释放（关闭/销毁文件/连接）——close_file 同款语义
+        role: "close",
+        namespace: "file",
+        pre: ["FILE_OPEN"],
+        post: [],
+        invalidate: ["FILE_OPEN"],
+        patterns: [
+            ["close", "file"],
+            ["close", "data"],
+            ["close", "connection"],
+            ["close", "conn"],
+            ["close", "log"],
+            ["close", "db"],
+            ["release", "connection"],
+            ["destroy", "connection"],
+        ],
+    },
+];
+/** 匹配命中数 ≥2 视为高置信（多个独立证据） */
+const HIGH_CONFIDENCE_HITS = 2;
+/**
+ * 为一组函数生成注解建议（确定性，同输入同输出）。
+ *
+ * @param functions — 项目函数列表（C IR）
+ * @param ruleNames — 已加载规则名集合（规则名函数按名即命中，无需注解建议）
+ * @param limit — 输出上限（默认 20，防大仓库刷屏；按置信度排序）
+ */
+function suggestAnnotations(functions, ruleNames, limit = 20) {
+    const suggestions = [];
+    const seen = new Set();
+    for (const fn of functions) {
+        if (!fn.name)
+            continue;
+        if (fn.protocol && (fn.protocol.pre_states?.length || fn.protocol.post_states?.length)) {
+            continue; // 已注解
+        }
+        if (ruleNames?.has(fn.name))
+            continue; // 规则名函数按名命中，无需注解
+        if (fn.external)
+            continue;
+        if (seen.has(fn.name))
+            continue;
+        seen.add(fn.name);
+        const lower = fn.name.toLowerCase();
+        for (const def of ROLE_DEFS) {
+            const hits = [];
+            for (const pattern of def.patterns) {
+                if (pattern.every((word) => lower.includes(word))) {
+                    hits.push(pattern.join("+"));
+                }
+            }
+            if (hits.length === 0)
+                continue;
+            const confidence = hits.length >= HIGH_CONFIDENCE_HITS ? "high" : "medium";
+            const invalidatePart = def.invalidate
+                ? `, invalidate=${fmtStates(def.invalidate)}`
+                : "";
+            suggestions.push({
+                function: fn.name,
+                file: fn.file || "",
+                role: def.role,
+                namespace: def.namespace,
+                pre: def.pre,
+                post: def.post,
+                invalidate: def.invalidate,
+                confidence,
+                reasons: hits,
+                template: `/* @progmune(namespace="${def.namespace}", pre=${fmtStates(def.pre)}, post=${fmtStates(def.post)}${invalidatePart}) */`,
+                maskRisk: false, // 两遍计算（见下）
+            });
+            break; // 一个函数只取最先命中的角色
+        }
+    }
+    // 第二遍：掩蔽风险——函数体调用了「已存在规则原语」或「本批同被建议的
+    // 函数」→ 注解后体内序列不再被验证，可能掩蔽其握有的违规（V7 实测：
+    // 植入流被 establish 注解变不透明后违规消失）。
+    const coSuggested = new Set(suggestions.map((s) => s.function));
+    for (const s of suggestions) {
+        const fnInfo = functions.find((f) => f.name === s.function);
+        s.maskRisk = (fnInfo?.calls || []).some((c) => (ruleNames?.has(c) ?? false) || coSuggested.has(c));
+    }
+    // 稳定性排序：置信度高优先，其次按 文件+名字（结果可复现）
+    const rank = { high: 0, medium: 1 };
+    suggestions.sort((a, b) => rank[a.confidence] - rank[b.confidence] ||
+        a.file.localeCompare(b.file) ||
+        a.function.localeCompare(b.function));
+    return suggestions.slice(0, limit);
+}
+function fmtStates(states) {
+    return `[${states.map((s) => `"${s}"`).join(", ")}]`;
+}

package/dist/annotation-suggest.test.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * annotation-suggest.test.ts — 注解建议引擎回归（纯函数，无文件系统 I/O）
+ *
+ * 词汇模式来自 3.7.6 金标 5/5 真实注解反推（REALWORLD_C_V6.md）：
+ * check_user_pass/auth_password=verify、handle_PASS=establish、
+ * do_RETR/do_STOR/new_session_channel=guard、open/close_data_connection=资源生命周期。
+ */
+const vitest_1 = require("vitest");
+const annotation_suggest_1 = require("./annotation-suggest");
+const fn = (name, extra = {}) => ({
+    name,
+    file: "src/demo.c",
+    ...extra,
+});
+(0, vitest_1.describe)("annotation-suggest", () => {
+    (0, vitest_1.it)("verify：凭证名词 × 比对动词（check_user_pass / auth_password）", () => {
+        const s = (0, annotation_suggest_1.suggestAnnotations)([fn("check_user_pass"), fn("auth_password")]);
+        (0, vitest_1.expect)(s).toHaveLength(2);
+        for (const x of s) {
+            (0, vitest_1.expect)(x.role).toBe("verify");
+            (0, vitest_1.expect)(x.namespace).toBe("auth");
+            (0, vitest_1.expect)(x.pre).toEqual(["UNAUTHENTICATED"]);
+            (0, vitest_1.expect)(x.post).toEqual(["PASSWORD_VERIFIED"]);
+        }
+    });
+    (0, vitest_1.it)("establish：登录完成原语（handle_PASS / authenticate）", () => {
+        const s = (0, annotation_suggest_1.suggestAnnotations)([fn("handle_PASS"), fn("authenticate")]);
+        (0, vitest_1.expect)(s.map((x) => [x.function, x.role])).toEqual(vitest_1.expect.arrayContaining([
+            ["handle_PASS", "establish"],
+            ["authenticate", "establish"],
+        ]));
+        (0, vitest_1.expect)(s[0].pre).toEqual([]);
+        (0, vitest_1.expect)(s[0].post).toEqual(["AUTHENTICATED"]);
+    });
+    (0, vitest_1.it)("guard：FTP 命令处理器与通道开启回调（do_RETR/do_STOR/new_session_channel）", () => {
+        const s = (0, annotation_suggest_1.suggestAnnotations)([
+            fn("do_RETR"),
+            fn("do_STOR"),
+            fn("new_session_channel"),
+        ]);
+        for (const x of s) {
+            (0, vitest_1.expect)(x.role).toBe("guard");
+            (0, vitest_1.expect)(x.pre).toEqual(["AUTHENTICATED"]);
+            (0, vitest_1.expect)(x.post).toEqual(["AUTHORIZED"]);
+        }
+    });
+    (0, vitest_1.it)("资源生命周期：open/close_data_connection", () => {
+        const s = (0, annotation_suggest_1.suggestAnnotations)([
+            fn("open_data_connection"),
+            fn("close_data_connection"),
+        ]);
+        const open = s.find((x) => x.function === "open_data_connection");
+        const close = s.find((x) => x.function === "close_data_connection");
+        (0, vitest_1.expect)(open?.role).toBe("open");
+        (0, vitest_1.expect)(open?.post).toEqual(["FILE_OPEN"]);
+        (0, vitest_1.expect)(close?.role).toBe("close");
+        (0, vitest_1.expect)(close?.pre).toEqual(["FILE_OPEN"]);
+        (0, vitest_1.expect)(close?.invalidate).toEqual(["FILE_OPEN"]);
+    });
+    (0, vitest_1.it)("已注解函数不再建议", () => {
+        const annotated = fn("check_user_pass", {
+            protocol: { pre_states: ["UNAUTHENTICATED"], post_states: ["PASSWORD_VERIFIED"], namespace: "auth" },
+        });
+        (0, vitest_1.expect)((0, annotation_suggest_1.suggestAnnotations)([annotated])).toHaveLength(0);
+    });
+    (0, vitest_1.it)("规则名函数（按名即命中）不再建议", () => {
+        const s = (0, annotation_suggest_1.suggestAnnotations)([fn("verify_password")], new Set(["verify_password"]));
+        (0, vitest_1.expect)(s).toHaveLength(0);
+    });
+    (0, vitest_1.it)("外部函数不再建议", () => {
+        (0, vitest_1.expect)((0, annotation_suggest_1.suggestAnnotations)([fn("check_password", { external: true })])).toHaveLength(0);
+    });
+    (0, vitest_1.it)("模板可直接粘贴：完整注释块文本", () => {
+        const [s] = (0, annotation_suggest_1.suggestAnnotations)([fn("check_user_pass")]);
+        (0, vitest_1.expect)(s.template).toBe('/* @progmune(namespace="auth", pre=["UNAUTHENTICATED"], post=["PASSWORD_VERIFIED"]) */');
+    });
+    (0, vitest_1.it)("确定性 + 上限：同输入同输出，超过 limit 截断（置信度优先）", () => {
+        const fns = Array.from({ length: 30 }, (_, i) => fn(`do_RETR_${i}`) // 全部 guard，单证据 medium
+        );
+        const a = (0, annotation_suggest_1.suggestAnnotations)(fns, undefined, 10);
+        const b = (0, annotation_suggest_1.suggestAnnotations)(fns, undefined, 10);
+        (0, vitest_1.expect)(a).toEqual(b);
+        (0, vitest_1.expect)(a).toHaveLength(10);
+        (0, vitest_1.expect)(a[0].function).toBe("do_RETR_0");
+    });
+    (0, vitest_1.it)("无命中词汇的函数不产生建议", () => {
+        const s = (0, annotation_suggest_1.suggestAnnotations)([fn("parse_int"), fn("strlcat"), fn("main")]);
+        (0, vitest_1.expect)(s).toHaveLength(0);
+    });
+    (0, vitest_1.it)("掩蔽风险：函数体调用已有规则原语 → maskRisk=true", () => {
+        const [s] = (0, annotation_suggest_1.suggestAnnotations)([fn("login_flow", { calls: ["verify_password"] })], new Set(["verify_password"]));
+        (0, vitest_1.expect)(s.maskRisk).toBe(true);
+    });
+    (0, vitest_1.it)("掩蔽风险：函数体调用本批同被建议的函数 → maskRisk=true（co-suggestion）", () => {
+        const s = (0, annotation_suggest_1.suggestAnnotations)([
+            fn("login_flow", { calls: ["start_file_transfer"] }),
+            fn("start_file_transfer"),
+        ]);
+        const flow = s.find((x) => x.function === "login_flow");
+        (0, vitest_1.expect)(flow?.maskRisk).toBe(true);
+    });
+    (0, vitest_1.it)("叶子函数（体内无规则原语调用）→ maskRisk=false", () => {
+        const [s] = (0, annotation_suggest_1.suggestAnnotations)([fn("check_user_pass", { calls: ["strcmp", "strlcpy"] })]);
+        (0, vitest_1.expect)(s.maskRisk).toBe(false);
+    });
+    (0, vitest_1.it)("会话工厂 new_session 不再误判为守卫", () => {
+        const s = (0, annotation_suggest_1.suggestAnnotations)([fn("new_session")]);
+        (0, vitest_1.expect)(s).toHaveLength(0);
+    });
+    (0, vitest_1.it)("通道守卫 new_session_channel 仍命中 guard", () => {
+        const s = (0, annotation_suggest_1.suggestAnnotations)([fn("new_session_channel")]);
+        (0, vitest_1.expect)(s).toHaveLength(1);
+        (0, vitest_1.expect)(s[0].role).toBe("guard");
+    });
+});

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

package/dist/trust/engine.js

@@ -60,10 +60,24 @@ const confidence_calculator_1 = require("./confidence-calculator");
 const violation_trace_1 = require("./violation-trace");
 const api_semantic_mapper_1 = require("./api-semantic-mapper");
 const protocol_domain_validator_1 = require("./protocol-domain-validator");
+const annotation_suggest_1 = require("../annotation-suggest");
 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();
@@ -74,7 +88,7 @@ async function evaluateTrust(ctx) {
     // ── Phase 5: Build call graph for cross-function propagation ──
     const callGraph = (0, call_graph_propagator_1.buildCallGraphFromIR)(path.join(ctx.projectPath, "ir.json"));
     const enterpriseViolations = collectEnterpriseViolations(ctx);
-    const { violations: protocolViolations, coverage: mappingCoverageData, ssgCoverage: ssgCov } = await collectProtocolViolations(ctx, callGraph);
+    const { violations: protocolViolations, coverage: mappingCoverageData, ssgCoverage: ssgCov, annotationSuggestions: cAnnotationSuggestions } = await collectProtocolViolations(ctx, callGraph);
     const expressResult = collectExpressViolations(ctx);
     const nestjsResult = collectNestJSViolations(ctx);
     const trpcResult = collectTRPCViolations(ctx);
@@ -161,6 +175,7 @@ async function evaluateTrust(ctx) {
         commit: ctx.commit,
         timestamp,
         engineVersion,
+        annotationSuggestions: cAnnotationSuggestions,
         overall: {
             score: effectiveScore,
             decision,
@@ -704,21 +719,39 @@ async function collectProtocolViolations(ctx, callGraph) {
     let ssgTotalCalls = 0;
     let ssgMatchedCalls = 0;
     let ssgViolationCount = 0;
+    // C 注解建议（函数级作用域——返回值在 try 外组装）
+    let annotationSuggestions;
     try {
         // ── P4.5 校准：TS/JS 项目在 ir.json 缺失时先提取 IR ──
         // 序列必须来自「函数体内真实调用」而非「文件内函数声明名单」——
         // 声明顺序 ≠ 执行顺序：正则扫描会把声明当调用（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);
@@ -772,6 +805,10 @@ async function collectProtocolViolations(ctx, callGraph) {
         // ── P4.6.1: 词段匹配门控的项目函数集合（best-effort，与注解合并共用 ir.json） ──
         // 词段匹配只对项目函数适用（改名协议原语）；外部库调用走 alias/关键词桥接。
         let projectFunctions;
+        // ── 注解建议（采纳生死线）：未注解 C 项目的原语注解候选（加性，仅 C） ──
+        // 未注解项目 SSG 层静默（0 flags）——建议清单是「看不见的问题」的入口：
+        // 按函数名词汇启发式给出现成注释块模板（角色/命名空间/状态转移预填），
+        // 人工确认后生效（与 c-alias-propose 的确认门同一哲学）。
         try {
             const fs = require("fs");
             const irPath = path.join(ctx.projectPath, "ir.json");
@@ -779,6 +816,9 @@ async function collectProtocolViolations(ctx, callGraph) {
                 const ir = JSON.parse(fs.readFileSync(irPath, "utf-8"));
                 const functions = Array.isArray(ir) ? ir : (ir.functions || []);
                 projectFunctions = (0, call_sequence_1.collectProjectFunctionNames)(functions);
+                if ((ctx.language || "typescript") === "c") {
+                    annotationSuggestions = (0, annotation_suggest_1.suggestAnnotations)(functions, protocolRulesData ? new Set(protocolRulesData.rules.keys()) : undefined);
+                }
             }
         }
         catch { /* best-effort */ }
@@ -850,7 +890,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 +913,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;
@@ -933,6 +973,7 @@ async function collectProtocolViolations(ctx, callGraph) {
             aliasWarnings: protocolRulesData.aliasWarnings?.length
                 ? protocolRulesData.aliasWarnings : undefined,
         } : undefined,
+        annotationSuggestions,
     };
 }
 function extractCallSequencesFromProject(projectPath, language, keepNames) {

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.7",
   "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"