progmune-runtime 3.7.6 → 3.7.8

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## [3.7.8] — 2026-08-28
+
+### Django / DRF 框架结构适配（M2）——框架适配第 4 个
+
+- **结构提取（Python AST）**：`tools/extract_framework_django.py`（与 extract_ir.py / extract_framework_py.py 解耦）——urlpatterns 解析（url()/path()/re_path() → FBV / CBV .as_view() / include）、FBV 登录装饰器（login_required/permission_required/staff_member_required/user_passes_test + 自定义 *auth* 装饰器）、CBV 基类与方法（View/generics + LoginRequiredMixin 等混入）、DRF permission_classes（AllowAny/IsAuthenticated/其他类名）与 @api_view（methods + permission_classes kwarg）
+- **检测规则**（`src/frameworks/django-detector.ts`）：
+  - `DJANGO_VIEW_NO_AUTH`——mutation 视图无保护：FBV 按动词名门控（add/create/update/delete/transfer 等——信息页 home/robots/error 不报）；CBV 按方法含写操作（post/put/patch/delete/create/update/destroy）+ 无认证装饰器/无 LoginRequiredMixin
+  - `DRF_PERMISSION_BYPASS`——DRF 视图写方法 + 显式 AllowAny / 空权限类（非认证入口端点）
+  - 认证入口词汇豁免（login/signin/regist/token/health 等，视图名+URL 名+pattern）
+- **引擎接线**：`collectDjangoViolations`（仅 Python，best-effort）+ `overall.djangoCoverage`——加性零漂移
+- **合成金标**（`generate-projects-django.ts` + `scan-protocol-django.ts`）：FBV/CBV/DRF × clean/V1/V2/V2b/V1V2 = 8 项目——**TP 6 / FP 0 / FN 0 → Precision 100% / Recall 100%**
+- **真实应用验证**：django-realworld（15 路由结构全识别：DRF generics + permission_classes 接线、RegistrationAPIView/LoginAPIView AllowAny 正确豁免）——**0 FP**；PyGoat 133 路由结构全识别，适配器 2 条 flags 均为故意脆弱 lab（csrf_transfer_monei_api / DoItFast）——如实记录；fastapi-realworld 0 FP 保持
+- **修复（子串陷阱）**：`registration` 不含 `register` 子串、`register` 不含 `registr` 子串——认证入口词干统一为 `regist`（FastAPI/Django 两检测器同步）+ 回归测试锁定
+- **验证**：19 个新单元测试（django-detector 10 + fastapi 豁免回归）；套件 139/139；Python 盲测 v1.2 64 零漂移；C 演示 SSG 结果不变
+- **边界（如实）**：FBV 无法静态区分 HTTP 方法（动词名门控口径，非方法级）；include() 递归不展开（被 include 的应用 urls.py 单独成文件时已覆盖）；自定义 permission 类视为保护（保守）
+
+### FastAPI 框架结构适配（M1）——框架适配第 3 个
+
+- **结构提取（Python AST）**：`tools/extract_framework_py.py`（与 extract_ir.py 解耦，零风险）——路由（@app.get/@router.post/@r.api_route）、依赖注入（Depends()/Security()，含 Annotated[...] 订阅、嵌套调用解析、**装饰器级 dependencies=[...]**（realworld 风格）、认证方案声明（OAuth2PasswordBearer/HTTPBearer/APIKeyHeader 等 8 类）、全局中间件；跳过 tests/deps/venv 等非生产目录
+- **检测规则**（`src/frameworks/fastapi-detector.ts`，结构提取与规则判定解耦）：
+  - `FASTAPI_ROUTE_NO_AUTH`——写操作路由（post/put/patch/delete）无认证依赖且非认证入口端点（login/register/token/health 词汇豁免）→「每个 API 入口都有门禁」的精确形态；公开读（GET）不检查（realworld 的 tags/文章列表就是公开 GET——只盯 mutation 面把误报压到最低）
+  - `FASTAPI_DEAD_AUTH_SCHEME`——声明了认证方案但没有任何路由引用（认证设施是死的，装饰性声明）
+- **引擎接线**：`collectFastapiViolations`（仅 Python 项目跑 python3 扫描；best-effort 永不阻断评估）+ `overall.fastapiCoverage`（apps/routes/filesScanned/issuesFound）——加性零漂移
+- **合成金标**（`generate-projects-fastapi.ts` + `scan-protocol-fastapi.ts`，镜像 generate-projects-python 方法论）：3 结构风格（直连/APIRouter/认证方案）× 4 违规变体（clean/V1 无认证写路由/V2 死方案/V1V2）= 12 项目——**TP 13 / FP 0 / FN 0 → Precision 100% / Recall 100%**
+- **真实应用验证**：fastapi-realworld（19 路由全结构识别：签名 Depends 与装饰器 dependencies= 两种认证接线风格）——**0 FP**；django-realworld/django-unicorn 无 FastAPI 结构 → 适配器静默直通（结果不变）
+- **零漂移**：Python 盲测 v1.2 64 违规零漂移；C 演示 SSG 结果不变；相关套件 128/128（含 fastapi-detector 9 个新回归）
+- **边界（如实）**：全局中间件不视为认证（add_middleware 通常是 CORS；自定义认证中间件结构不可见）；Depends 目标按 auth-like 词表+方案引用判定（无数据流分析）；npm 安装态下 tools/ 不在包内 → 框架扫描与既有 Python IR 提取一样静默降级（安装态 Python 全链路为既有遗留问题，不随本版引入新差异）
+
+## [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 + 采纳案例 + 正则层噪声治理

package/README.md

@@ -108,7 +108,7 @@ Progmune is honest about what it can and cannot verify.
 
 **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.
 
-**Framework adapters: 2/13.** Express ✅ and tRPC ✅ have dedicated detectors; Next.js has version-aware governance; NestJS is partial. Django, FastAPI and 8 more remain — framework adaptation is the #1 product gap.
+**Framework adapters: 4/13.** Express ✅, tRPC ✅, FastAPI ✅ (route/auth-dependency structural analysis — every mutation route checked for auth dependencies, dead auth schemes flagged) and Django ✅ (urlconf/CBV/DRF structural analysis — unprotected mutation views and `AllowAny` write endpoints flagged) have dedicated detectors; Next.js has version-aware governance; NestJS is partial. Next.js/Fastify/Flask and 5 more remain — framework adaptation is the #1 product gap.
 
 ### What Progmune does NOT cover (honest boundaries)
 
@@ -234,7 +234,7 @@ High-impact contribution areas:
 - **Runtime Pipeline:** Detect → Explain → Repair → Validate (L1–L4)
 - **Trust Engine:** 4-dimension scoring with binary explainability gate
 - **MCP Tools:** 19 — `progmune_trust_check`, `progmune_score`, `progmune_policy_check`, `progmune_certify`, and more
-- **Framework Adapters:** Express ✅, tRPC ✅, NestJS partial (2/13)
+- **Framework Adapters:** Express ✅, tRPC ✅, FastAPI ✅, Django ✅, NestJS partial (4/13)
 - **Knowledge Base:** 31 domains, 148 protocol rules, 22 detectors, 26 safeguards, PLSB 13/13 categories — plus 15 source-level detection rules (Python)
 - **Corpus:** 2,500+ trajectories across 6+ repositories; blind benchmarks 100 (TS) + 90 (Python) projects; real-world validation on 4 application repos
 - **Current focus:** Enterprise PoC validation + remaining framework-internal boundary FPs

package/README.zh-CN.md

@@ -108,7 +108,7 @@ Progmune 对能验证什么、不能验证什么保持诚实。
 
 **多语言 IR（注册表式）。** TypeScript（ts-morph）与 Python（AST）提取器是同一注册表（`src/extract-project-ir.ts`）中的注册项；`extractProjectIR` 把检测到的所有语言合并为一份函数 IR，由 agent loop、`execute()` 与 MCP server 共享——agent 可在两种语言上编排函数协议链。新增语言（Go、Java……）= 注册一条提取器，调用方零改动。
 
-**框架适配器：2/13。** Express ✅ 与 tRPC ✅ 有专用检测器；Next.js 有版本感知治理；NestJS 部分支持。Django、FastAPI 及另外 8 个待适配——框架适配是 #1 产品缺口。
+**框架适配器：4/13。** Express ✅、tRPC ✅、FastAPI ✅（路由/认证依赖结构分析——逐条检查写操作路由的认证依赖、标记死认证方案）与 Django ✅（URL 配置/CBV/DRF 结构分析——标记无保护的写视图与 `AllowAny` 写端点）有专用检测器；Next.js 有版本感知治理；NestJS 部分支持。Next.js/Fastify/Flask 及另外 5 个待适配——框架适配是 #1 产品缺口。
 
 ### Progmune 不覆盖什么（诚实边界）
 
@@ -233,7 +233,7 @@ Progmune 建立在"**LLM 输出是统计表演而非推理**"这一前提上—
 - **运行时管线：** 检测 → 解释 → 修复 → 验证（L1–L4）
 - **信任引擎：** 四维评分 + 二元可解释性门
 - **MCP 工具：** 19 个——`progmune_trust_check`、`progmune_score`、`progmune_policy_check`、`progmune_certify` 等
-- **框架适配器：** Express ✅、tRPC ✅、NestJS 部分（2/13）
+- **框架适配器：** Express ✅、tRPC ✅、FastAPI ✅、Django ✅、NestJS 部分（4/13）
 - **知识库：** 31 个域、148 条协议规则、22 个检测器、26 条防护规则、PLSB 13/13 类别——另加 15 条源码级检测规则（Python）
 - **语料：** 6+ 仓库 2,500+ 轨迹；盲测基准 100（TS）+ 90（Python）个项目；4 个应用仓库真实验证
 - **当前重点：** 企业 PoC 验证 + 剩余框架内部边界误报

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/frameworks/django-detector.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Django Framework Adapter — Protocol Detection for Django / DRF
+ *
+ * 框架适配 M2：结构扫描由 tools/extract_framework_django.py（Python AST）
+ * 完成——urlpatterns 解析（FBV/CBV/DRF）、登录装饰器、DRF permission_classes。
+ * 本模块消费结构 JSON 做规则判定：
+ *
+ *   DJANGO_VIEW_NO_AUTH          mutation 视图（FBV 动词名门控 / CBV 方法
+ *                                含写操作）无登录装饰器、无权限类、无
+ *                                LoginRequiredMixin 等保护——路由级
+ *                                missing-auth 的精确形态
+ *   DRF_PERMISSION_BYPASS        DRF 视图 mutation 方法 + 显式 AllowAny /
+ *                                空权限类——显式绕过（非认证入口端点）
+ *
+ * 口径（如实）：
+ *   - FBV 无法静态区分 HTTP 方法——按视图名动词门控（add/create/update/
+ *     delete/transfer 等），信息页（home/robots/error）不报；@api_view
+ *     声明的 methods 按真实方法判定
+ *   - DRF 写方法 = post/put/patch/delete/create/update/destroy（generics
+ *     命名）；read-only（list/retrieve/feed）不检查——公开读是常见设计
+ *   - 认证入口端点按 视图名+URL 名 词汇豁免（login/register/signup/token/
+ *     health/auth）
+ *   - include() 递归与 admin.site.urls 等无法解析的引用跳过
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeDjangoStructure = analyzeDjangoStructure;
+// ── Rule vocabulary ──
+/** DRF 写方法（generics 命名 + HTTP 方法） */
+const DRF_MUTATION_METHODS = new Set([
+    "post", "put", "patch", "delete", "create", "update", "destroy",
+]);
+/** FBV 动词名门控（信息页不报——home/robots/error 等是公开设计） */
+const FBV_MUTATION_VERBS = [
+    "add", "create", "update", "delete", "remove", "transfer", "upload",
+    "submit", "edit", "change", "save", "write", "send", "post", "pay",
+    "checkout", "purchase", "reset", "revoke", "register_device",
+];
+const AUTH_ENTRY_WORDS = [
+    "login", "signin", "sign_in", "regist", "signup", "sign_up",
+    "token", "auth", "health", "status",
+];
+function isAuthEntry(route, viewName) {
+    const haystack = `${viewName || ""} ${route.urlname} ${route.pattern}`.toLowerCase();
+    return AUTH_ENTRY_WORDS.some((w) => haystack.includes(w));
+}
+function hasMutationMethod(view) {
+    if (view.apiViewMethods && view.apiViewMethods.length > 0) {
+        return view.apiViewMethods.some((m) => DRF_MUTATION_METHODS.has(m.toLowerCase()));
+    }
+    return (view.methods || []).some((m) => DRF_MUTATION_METHODS.has(m.toLowerCase()));
+}
+function fbvNameHasMutationVerb(name) {
+    const lower = name.toLowerCase();
+    return FBV_MUTATION_VERBS.some((v) => lower.includes(v));
+}
+// ── Analysis ──
+function analyzeDjangoStructure(data) {
+    if (!data.hasDjango || !Array.isArray(data.routes)) {
+        return { hasDjango: false, issues: [] };
+    }
+    const issues = [];
+    for (const route of data.routes) {
+        if (route.kind !== "fbv" && route.kind !== "cbv")
+            continue;
+        const viewName = route.view;
+        if (!viewName)
+            continue;
+        const view = data.views[viewName];
+        if (!view)
+            continue; // 无法解析的引用（admin.site.urls 等）跳过
+        if (isAuthEntry(route, viewName))
+            continue;
+        if (view.kind === "fbv") {
+            const hasAuthDecorator = (view.authDecorators || []).length > 0;
+            if (hasAuthDecorator)
+                continue;
+            const protectedByApiView = (view.apiViewMethods || []).length > 0
+                && (view.permissionClasses || []).length > 0
+                && !(view.permissionClasses || []).every((p) => p === "AllowAny");
+            const isMutation = view.apiViewMethods && view.apiViewMethods.length > 0
+                ? hasMutationMethod(view)
+                : fbvNameHasMutationVerb(viewName);
+            if (!isMutation)
+                continue;
+            if (protectedByApiView)
+                continue;
+            issues.push({
+                severity: "medium",
+                rule: "DJANGO_VIEW_NO_AUTH",
+                message: `View "${viewName}" (${route.pattern}) has no login decorator or ` +
+                    `permission protection — any visitor can reach it.`,
+                route: route.pattern,
+                handler: viewName,
+                file: view.file,
+            });
+            continue;
+        }
+        // CBV
+        if (view.isDrf) {
+            if (!hasMutationMethod(view))
+                continue;
+            if (view.openPermission) {
+                issues.push({
+                    severity: "medium",
+                    rule: "DRF_PERMISSION_BYPASS",
+                    message: `DRF view "${viewName}" (${route.pattern}) accepts write methods ` +
+                        `with permission_classes allowing any caller.`,
+                    route: route.pattern,
+                    handler: viewName,
+                    file: view.file,
+                });
+            }
+            continue;
+        }
+        // 非 DRF CBV：写方法 + 无 method_decorator 认证 + 无 LoginRequiredMixin
+        if (!hasMutationMethod(view))
+            continue;
+        const authDecorators = (view.authDecorators || []).length > 0;
+        if (authDecorators || view.protectedByMixin)
+            continue;
+        issues.push({
+            severity: "medium",
+            rule: "DJANGO_VIEW_NO_AUTH",
+            message: `View "${viewName}" (${route.pattern}) has write methods without ` +
+                `login decorators or auth mixins.`,
+            route: route.pattern,
+            handler: viewName,
+            file: view.file,
+        });
+    }
+    return { hasDjango: true, issues };
+}

package/dist/frameworks/django-detector.test.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * django-detector.test.ts — Django 框架适配器规则回归（纯函数，无文件 I/O）
+ *
+ * 规则判定与结构提取解耦：扫描器（tools/extract_framework_django.py）只做
+ * 结构，本模块消费结构 JSON 做 DJANGO_VIEW_NO_AUTH / DRF_PERMISSION_BYPASS。
+ */
+const vitest_1 = require("vitest");
+const django_detector_1 = require("./django-detector");
+function structure(partial) {
+    return {
+        hasDjango: true,
+        routes: [],
+        views: {},
+        filesScanned: 1,
+        ...partial,
+    };
+}
+const fbv = (name, extra = {}) => ({
+    file: "views.py", kind: "fbv", decorators: [], authDecorators: [],
+    apiViewMethods: null, permissionClasses: [],
+    ...extra,
+});
+const cbv = (name, extra = {}) => ({
+    file: "views.py", kind: "cbv", decorators: [], authDecorators: [],
+    apiViewMethods: null, permissionClasses: [], bases: [], methods: [],
+    isDrf: false, protectedByMixin: false, openPermission: false,
+    ...extra,
+});
+(0, vitest_1.describe)("django-detector", () => {
+    (0, vitest_1.it)("R1：无保护的 FBV 动词名视图 → DJANGO_VIEW_NO_AUTH", () => {
+        const { issues } = (0, django_detector_1.analyzeDjangoStructure)(structure({
+            routes: [{ pattern: "transfer", urlname: "", view: "transfer_money", kind: "fbv", file: "urls.py" }],
+            views: { transfer_money: fbv("transfer_money") },
+        }));
+        (0, vitest_1.expect)(issues.map((i) => i.rule)).toContain("DJANGO_VIEW_NO_AUTH");
+    });
+    (0, vitest_1.it)("R1 识别 @login_required 保护", () => {
+        const { issues } = (0, django_detector_1.analyzeDjangoStructure)(structure({
+            routes: [{ pattern: "transfer", urlname: "", view: "transfer_money", kind: "fbv", file: "urls.py" }],
+            views: { transfer_money: fbv("transfer_money", { authDecorators: ["login_required"] }) },
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("R1 豁免：home/robots/error 等信息页动词门控不报", () => {
+        const { issues } = (0, django_detector_1.analyzeDjangoStructure)(structure({
+            routes: [
+                { pattern: "", urlname: "", view: "home", kind: "fbv", file: "urls.py" },
+                { pattern: "robots.txt", urlname: "", view: "robots", kind: "fbv", file: "urls.py" },
+            ],
+            views: { home: fbv("home"), robots: fbv("robots") },
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("R1 豁免：registration 词干（不含 register 子串的陷阱回归）", () => {
+        const { issues } = (0, django_detector_1.analyzeDjangoStructure)(structure({
+            routes: [{ pattern: "^users/?$", urlname: "", view: "RegistrationAPIView", kind: "cbv", file: "urls.py" }],
+            views: {
+                RegistrationAPIView: cbv("RegistrationAPIView", {
+                    isDrf: true, methods: ["post"],
+                    permissionClasses: ["AllowAny"], openPermission: true,
+                }),
+            },
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("R2：DRF 写方法 + AllowAny → DRF_PERMISSION_BYPASS", () => {
+        const { issues } = (0, django_detector_1.analyzeDjangoStructure)(structure({
+            routes: [{ pattern: "send", urlname: "", view: "SendMoneyAPIView", kind: "cbv", file: "urls.py" }],
+            views: {
+                SendMoneyAPIView: cbv("SendMoneyAPIView", {
+                    isDrf: true, methods: ["post"],
+                    permissionClasses: ["AllowAny"], openPermission: true,
+                }),
+            },
+        }));
+        (0, vitest_1.expect)(issues.map((i) => i.rule)).toContain("DRF_PERMISSION_BYPASS");
+    });
+    (0, vitest_1.it)("R2：IsAuthenticated 保护不报；只读视图（list/retrieve）不报", () => {
+        const { issues } = (0, django_detector_1.analyzeDjangoStructure)(structure({
+            routes: [
+                { pattern: "send", urlname: "", view: "SendMoneyAPIView", kind: "cbv", file: "urls.py" },
+                { pattern: "tags", urlname: "", view: "TagListAPIView", kind: "cbv", file: "urls.py" },
+            ],
+            views: {
+                SendMoneyAPIView: cbv("SendMoneyAPIView", {
+                    isDrf: true, methods: ["post"],
+                    permissionClasses: ["IsAuthenticated"], openPermission: false,
+                }),
+                TagListAPIView: cbv("TagListAPIView", {
+                    isDrf: true, methods: ["list"],
+                    permissionClasses: ["AllowAny"], openPermission: true,
+                }),
+            },
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("非 DRF CBV：写方法 + LoginRequiredMixin → 不报", () => {
+        const { issues } = (0, django_detector_1.analyzeDjangoStructure)(structure({
+            routes: [{ pattern: "edit", urlname: "", view: "EditView", kind: "cbv", file: "urls.py" }],
+            views: {
+                EditView: cbv("EditView", {
+                    isDrf: false, methods: ["post"], protectedByMixin: true,
+                }),
+            },
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("@api_view 写方法 + permission_classes 保护 → 不报", () => {
+        const { issues } = (0, django_detector_1.analyzeDjangoStructure)(structure({
+            routes: [{ pattern: "api", urlname: "", view: "api_transfer", kind: "fbv", file: "urls.py" }],
+            views: {
+                api_transfer: fbv("api_transfer", {
+                    apiViewMethods: ["post"], permissionClasses: ["IsAuthenticated"],
+                }),
+            },
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("include 与无法解析的引用（admin.site.urls）不报", () => {
+        const { issues } = (0, django_detector_1.analyzeDjangoStructure)(structure({
+            routes: [
+                { pattern: "^admin/", urlname: "", view: "urls", kind: "fbv", file: "urls.py" },
+                { pattern: "^api/", urlname: "", view: null, kind: "include", file: "urls.py" },
+            ],
+            views: {},
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("非 Django 结构不产生任何问题", () => {
+        const { hasDjango, issues } = (0, django_detector_1.analyzeDjangoStructure)(structure({ hasDjango: false, routes: [] }));
+        (0, vitest_1.expect)(hasDjango).toBe(false);
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+});

package/dist/frameworks/fastapi-detector.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * FastAPI Framework Adapter — Protocol Detection for FastAPI
+ *
+ * 框架适配 M1（Python 侧结构提取 + TS 侧规则判定）：
+ * 结构扫描由 tools/extract_framework_py.py（Python AST）完成——路由
+ * （@app.get/@router.post）、依赖注入（Depends()/Security()，含
+ * Annotated[...] 与装饰器级 dependencies=[...]）、认证方案声明
+ * （OAuth2PasswordBearer/HTTPBearer/APIKeyHeader 等）、全局中间件。
+ * 本模块消费结构 JSON 做规则判定：
+ *
+ *   FASTAPI_ROUTE_NO_AUTH        写操作路由（post/put/patch/delete）无
+ *                                认证依赖，且不是认证入口端点（login/
+ *                                register/token 等）——「每个 API 入口
+ *                                都有门禁」的精确形态
+ *   FASTAPI_DEAD_AUTH_SCHEME     声明了认证方案但没有任何路由引用——
+ *                                认证设施是死的（装饰性声明，防御性价值为零）
+ *
+ * 边界（如实）：
+ *   - 读操作（GET）不检查——公开读是常见设计（realworld 的 tags/文章
+ *     列表就是公开 GET），只盯写操作把误报压到最低（实测 realworld 0 FP）
+ *   - 认证入口端点按 处理器名+路径 词汇豁免——登录/注册本身不能要求已认证
+ *   - 不做数据流分析：Depends 目标是 auth-like 名或声明的方案即视为认证
+ *   - 全局中间件不视为认证（add_middleware 通常是 CORS 等；认证中间件
+ *     是自定义 BaseHTTPMiddleware 且结构不可见——如实不认）
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeFastapiStructure = analyzeFastapiStructure;
+// ── Rule vocabulary ──
+/** 写操作方法——公开读是常见设计，只盯 mutation 面 */
+const MUTATION_METHODS = new Set(["post", "put", "patch", "delete"]);
+/** 认证入口端点豁免词（登录/注册/token 签发本身不能要求已认证） */
+const AUTH_ENTRY_WORDS = [
+    "login", "signin", "sign_in", "regist", "signup", "sign_up",
+    "token", "auth", "health", "status",
+];
+/** 认证方案类型——引用即视为认证依赖 */
+const SCHEME_TYPES = new Set([
+    "OAuth2PasswordBearer", "OAuth2AuthorizationCodeBearer", "HTTPBearer",
+    "HTTPBasic", "HTTPDigest", "APIKeyHeader", "APIKeyQuery", "APIKeyCookie",
+    "OpenIdConnect",
+]);
+function isAuthEntryRoute(route) {
+    const haystack = `${route.handler} ${route.path}`.toLowerCase();
+    return AUTH_ENTRY_WORDS.some((w) => haystack.includes(w));
+}
+/** 路由是否引用了某个认证方案（Depends(oauth2_scheme) 形态） */
+function referencesScheme(route, schemeNames) {
+    return route.dependencies.some((d) => d.name !== null && schemeNames.has(d.name));
+}
+// ── Analysis ──
+function analyzeFastapiStructure(data) {
+    if (!data.hasFastAPI || !Array.isArray(data.routes)) {
+        return { hasFastAPI: false, issues: [] };
+    }
+    const issues = [];
+    const schemeNames = new Set((data.authSchemes || []).map((s) => s.name));
+    // R1：无认证写操作路由
+    for (const route of data.routes) {
+        if (!MUTATION_METHODS.has(route.method.toLowerCase()))
+            continue;
+        const hasAuthDep = route.dependencies.some((d) => d.authLike);
+        if (hasAuthDep)
+            continue;
+        if (isAuthEntryRoute(route))
+            continue;
+        issues.push({
+            severity: "medium",
+            rule: "FASTAPI_ROUTE_NO_AUTH",
+            message: `Route ${route.method.toUpperCase()} ${route.path || "(root)"} has no ` +
+                `authentication dependency — any caller can invoke "${route.handler}" ` +
+                `without credentials.`,
+            route: `${route.method.toUpperCase()} ${route.path || "(root)"}`,
+            handler: route.handler,
+            file: route.file,
+            line: route.line,
+        });
+    }
+    // R2：声明了认证方案但没有路由引用（死设施）
+    for (const scheme of data.authSchemes || []) {
+        if (!SCHEME_TYPES.has(scheme.type))
+            continue; // 非认证方案类跳过
+        const used = data.routes.some((r) => referencesScheme(r, schemeNames));
+        if (!used) {
+            issues.push({
+                severity: "medium",
+                rule: "FASTAPI_DEAD_AUTH_SCHEME",
+                message: `Auth scheme "${scheme.name}" (${scheme.type}) is declared but no ` +
+                    `route references it — the scheme does not protect any endpoint.`,
+            });
+        }
+    }
+    return { hasFastAPI: true, issues };
+}

package/dist/frameworks/fastapi-detector.test.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * fastapi-detector.test.ts — FastAPI 框架适配器规则回归（纯函数，无文件 I/O）
+ *
+ * 规则判定与结构提取解耦：扫描器（tools/extract_framework_py.py）只做结构，
+ * 本模块消费结构 JSON 做 R1（无认证写操作路由）/ R2（死认证方案）。
+ */
+const vitest_1 = require("vitest");
+const fastapi_detector_1 = require("./fastapi-detector");
+function structure(partial) {
+    return {
+        hasFastAPI: true,
+        apps: ["app"],
+        routers: [],
+        authSchemes: [],
+        globalAuthMiddleware: [],
+        routes: [],
+        filesScanned: 1,
+        ...partial,
+    };
+}
+const route = (p) => ({
+    method: p.method,
+    path: p.path || "",
+    handler: p.handler,
+    file: "main.py",
+    line: 1,
+    dependencies: p.deps || [],
+});
+(0, vitest_1.describe)("fastapi-detector", () => {
+    (0, vitest_1.it)("R1：无认证写操作路由 → FASTAPI_ROUTE_NO_AUTH", () => {
+        const { issues } = (0, fastapi_detector_1.analyzeFastapiStructure)(structure({
+            routes: [route({ method: "post", handler: "create_article" })],
+        }));
+        (0, vitest_1.expect)(issues.map((i) => i.rule)).toContain("FASTAPI_ROUTE_NO_AUTH");
+    });
+    (0, vitest_1.it)("R1 豁免：登录/注册/token 认证入口端点不报", () => {
+        const { issues } = (0, fastapi_detector_1.analyzeFastapiStructure)(structure({
+            routes: [
+                route({ method: "post", path: "/login", handler: "login" }),
+                route({ method: "post", path: "/register", handler: "register_user" }),
+                route({ method: "post", path: "/token", handler: "issue_token" }),
+            ],
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("R1 豁免：registration 词干（不含 register 子串的陷阱回归）", () => {
+        const { issues } = (0, fastapi_detector_1.analyzeFastapiStructure)(structure({
+            routes: [
+                route({ method: "post", path: "/users", handler: "registration_api_view" }),
+            ],
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("R1 豁免：GET 读操作不报（公开读是常见设计）", () => {
+        const { issues } = (0, fastapi_detector_1.analyzeFastapiStructure)(structure({
+            routes: [route({ method: "get", path: "/articles", handler: "list_articles" })],
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("R1 识别 Security/Depends 认证依赖（authLike 名）", () => {
+        const { issues } = (0, fastapi_detector_1.analyzeFastapiStructure)(structure({
+            routes: [
+                route({
+                    method: "put", path: "/users/me", handler: "update_me",
+                    deps: [{ name: "get_current_user_authorizer", via: "Security", authLike: true }],
+                }),
+            ],
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("R1 识别声明的认证方案引用（Depends(oauth2_scheme)）", () => {
+        const { issues } = (0, fastapi_detector_1.analyzeFastapiStructure)(structure({
+            authSchemes: [{ name: "oauth2_scheme", type: "OAuth2PasswordBearer" }],
+            routes: [
+                route({
+                    method: "get", path: "/me", handler: "read_me",
+                    deps: [{ name: "oauth2_scheme", via: "Depends", authLike: true }],
+                }),
+            ],
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("R2：声明认证方案但无路由引用 → FASTAPI_DEAD_AUTH_SCHEME", () => {
+        const { issues } = (0, fastapi_detector_1.analyzeFastapiStructure)(structure({
+            authSchemes: [{ name: "oauth2_scheme", type: "OAuth2PasswordBearer" }],
+            routes: [route({ method: "get", handler: "list_things" })],
+        }));
+        (0, vitest_1.expect)(issues.map((i) => i.rule)).toContain("FASTAPI_DEAD_AUTH_SCHEME");
+    });
+    (0, vitest_1.it)("R2：方案被路由引用时不报", () => {
+        const { issues } = (0, fastapi_detector_1.analyzeFastapiStructure)(structure({
+            authSchemes: [{ name: "oauth2_scheme", type: "OAuth2PasswordBearer" }],
+            routes: [
+                route({
+                    method: "get", handler: "read_me",
+                    deps: [{ name: "oauth2_scheme", via: "Depends", authLike: true }],
+                }),
+            ],
+        }));
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("非 FastAPI 结构不产生任何问题", () => {
+        const { hasFastAPI, issues } = (0, fastapi_detector_1.analyzeFastapiStructure)(structure({ hasFastAPI: false, routes: [] }));
+        (0, vitest_1.expect)(hasFastAPI).toBe(false);
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+    (0, vitest_1.it)("realworld 快照：19 路由 0 问题（0 FP 回归锁）", () => {
+        const snapshot = {
+            hasFastAPI: true,
+            apps: ["application"],
+            routers: ["router"],
+            authSchemes: [],
+            globalAuthMiddleware: ["CORSMiddleware"],
+            routes: [
+                route({ method: "get", path: "", handler: "get_all_tags" }),
+                route({
+                    method: "get", path: "", handler: "retrieve_current_user",
+                    deps: [{ name: "get_current_user_authorizer", via: "Depends", authLike: true }],
+                }),
+                route({
+                    method: "put", path: "", handler: "update_current_user",
+                    deps: [{ name: "get_current_user_authorizer", via: "Depends", authLike: true }],
+                }),
+                route({ method: "post", path: "/login", handler: "login" }),
+                route({ method: "post", path: "", handler: "register" }),
+                route({
+                    method: "post", path: "/{slug}/comments", handler: "create_comment",
+                    deps: [{ name: "get_current_user_authorizer", via: "Security", authLike: true }],
+                }),
+                route({ method: "get", path: "/{slug}", handler: "retrieve_article_by_slug" }),
+                route({
+                    method: "put", path: "/{slug}", handler: "update_article_by_slug",
+                    deps: [{ name: "check_article_modification_permissions", via: "Depends", authLike: true }],
+                }),
+            ],
+            filesScanned: 70,
+        };
+        const { hasFastAPI, issues } = (0, fastapi_detector_1.analyzeFastapiStructure)(structure(snapshot));
+        (0, vitest_1.expect)(hasFastAPI).toBe(true);
+        (0, vitest_1.expect)(issues).toHaveLength(0);
+    });
+});

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

package/dist/trust/engine.js

@@ -60,7 +60,10 @@ 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 fastapi_detector_1 = require("../frameworks/fastapi-detector");
+const django_detector_1 = require("../frameworks/django-detector");
 const ssg_bridge_1 = require("./ssg-bridge");
 const call_sequence_1 = require("../call-sequence");
 const extract_ir_1 = require("../extract-ir");
@@ -87,10 +90,12 @@ 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);
+    const fastapiResult = collectFastapiViolations(ctx);
+    const djangoResult = collectDjangoViolations(ctx);
     const coverageData = collectVerificationCoverage(ctx);
     const governanceDefects = collectGovernanceDefects(ctx);
     // ═══════════════════════════════════════
@@ -108,6 +113,8 @@ async function evaluateTrust(ctx) {
         ...expressViolations,
         ...nestjsResult.violations,
         ...trpcResult.violations,
+        ...fastapiResult.violations,
+        ...djangoResult.violations,
     ];
     // ═══════════════════════════════════════
     //  PHASE 3: SCORE
@@ -174,6 +181,7 @@ async function evaluateTrust(ctx) {
         commit: ctx.commit,
         timestamp,
         engineVersion,
+        annotationSuggestions: cAnnotationSuggestions,
         overall: {
             score: effectiveScore,
             decision,
@@ -226,6 +234,24 @@ async function evaluateTrust(ctx) {
                     issuesFound: nestjsResult.violations.length,
                 }
                 : undefined,
+            /** FastAPI framework adapter coverage — route/auth-dependency analysis */
+            fastapiCoverage: fastapiResult.coverage.routes > 0
+                ? {
+                    appsDetected: fastapiResult.coverage.apps,
+                    totalRoutes: fastapiResult.coverage.routes,
+                    filesScanned: fastapiResult.coverage.filesScanned,
+                    issuesFound: fastapiResult.violations.length,
+                }
+                : undefined,
+            /** Django framework adapter coverage — urlconf/view/permission analysis */
+            djangoCoverage: djangoResult.coverage.routes > 0
+                ? {
+                    appsDetected: djangoResult.coverage.apps,
+                    totalRoutes: djangoResult.coverage.routes,
+                    filesScanned: djangoResult.coverage.filesScanned,
+                    issuesFound: djangoResult.violations.length,
+                }
+                : undefined,
         },
         dimensions: {
             policyCompliance: {
@@ -364,6 +390,102 @@ function mapPolicyViolation(rv, filePath, _enterprisePolicy) {
  * Collect Express-specific security violations from the framework detector.
  * Maps ExpressSecurityIssue[] → TrustViolation[].
  */
+function collectDjangoViolations(ctx) {
+    const violations = [];
+    const coverage = { apps: 0, routes: 0, filesScanned: 0 };
+    // 仅 Python 项目跑框架结构扫描
+    const lang = ctx.language || "typescript";
+    if (lang !== "python")
+        return { violations, coverage };
+    try {
+        const { execSync } = require("child_process");
+        const fs = require("fs");
+        const os = require("os");
+        // engine.js 位于 dist/trust/ → 仓库根 tools/ 需要两级向上
+        const scriptPath = path.resolve(__dirname, "..", "..", "tools", "extract_framework_django.py");
+        const outPath = path.join(os.tmpdir(), `progmune-fwdj-${process.pid}-${Date.now()}.json`);
+        execSync(`python3 "${scriptPath}" "${ctx.projectPath}" "${outPath}"`, {
+            encoding: "utf-8",
+            stdio: "pipe",
+            timeout: 60000,
+        });
+        if (!fs.existsSync(outPath))
+            return { violations, coverage };
+        const structure = JSON.parse(fs.readFileSync(outPath, "utf-8"));
+        fs.unlinkSync(outPath);
+        const analysis = (0, django_detector_1.analyzeDjangoStructure)(structure);
+        if (!analysis.hasDjango)
+            return { violations, coverage };
+        coverage.apps = 1;
+        coverage.routes = (structure.routes || []).length;
+        coverage.filesScanned = structure.filesScanned || 0;
+        for (const issue of analysis.issues) {
+            violations.push({
+                severity: issue.severity === "low" ? "low" : issue.severity,
+                rule_id: issue.rule,
+                file: issue.file || "",
+                function: issue.handler || "unknown",
+                message: issue.message,
+                evidence: issue.route || "",
+                why: `Framework structural analysis: ${issue.message}`,
+                fix: issue.rule === "DRF_PERMISSION_BYPASS"
+                    ? `Require authenticated permissions on write methods (e.g. permission_classes = (IsAuthenticated,)).`
+                    : `Add a login decorator (@login_required) or an auth mixin (LoginRequiredMixin) to the view.`,
+                policy_ref: "framework-safety.django",
+            });
+        }
+    }
+    catch { /* best-effort — framework analysis must never break evaluation */ }
+    return { violations, coverage };
+}
+function collectFastapiViolations(ctx) {
+    const violations = [];
+    const coverage = { apps: 0, routes: 0, filesScanned: 0 };
+    // 仅 Python 项目跑框架结构扫描（避免 TS 项目无谓的 python3 子进程）
+    const lang = ctx.language || "typescript";
+    if (lang !== "python")
+        return { violations, coverage };
+    try {
+        const { execSync } = require("child_process");
+        const fs = require("fs");
+        const os = require("os");
+        // engine.js 位于 dist/trust/ → 仓库根 tools/ 需要两级向上
+        const scriptPath = path.resolve(__dirname, "..", "..", "tools", "extract_framework_py.py");
+        const outPath = path.join(os.tmpdir(), `progmune-fw-${process.pid}-${Date.now()}.json`);
+        execSync(`python3 "${scriptPath}" "${ctx.projectPath}" "${outPath}"`, {
+            encoding: "utf-8",
+            stdio: "pipe",
+            timeout: 60000,
+        });
+        if (!fs.existsSync(outPath))
+            return { violations, coverage };
+        const structure = JSON.parse(fs.readFileSync(outPath, "utf-8"));
+        fs.unlinkSync(outPath);
+        const analysis = (0, fastapi_detector_1.analyzeFastapiStructure)(structure);
+        if (!analysis.hasFastAPI)
+            return { violations, coverage };
+        coverage.apps = (structure.apps || []).length + (structure.routers || []).length;
+        coverage.routes = (structure.routes || []).length;
+        coverage.filesScanned = structure.filesScanned || 0;
+        for (const issue of analysis.issues) {
+            violations.push({
+                severity: issue.severity === "low" ? "low" : issue.severity,
+                rule_id: issue.rule,
+                file: issue.file || "",
+                function: issue.handler || "unknown",
+                message: issue.message,
+                evidence: issue.route || "",
+                why: `Framework structural analysis: ${issue.message}`,
+                fix: issue.rule === "FASTAPI_ROUTE_NO_AUTH"
+                    ? `Add an auth dependency to the route (Depends/Security of an authenticator) or move it behind authenticated middleware.`
+                    : `Reference the scheme from a route dependency or remove the unused scheme.`,
+                policy_ref: "framework-safety.fastapi",
+            });
+        }
+    }
+    catch { /* best-effort — framework analysis must never break evaluation */ }
+    return { violations, coverage };
+}
 function collectExpressViolations(ctx) {
     const violations = [];
     let expressApps = 0;
@@ -717,6 +839,8 @@ 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 ──
         // 序列必须来自「函数体内真实调用」而非「文件内函数声明名单」——
@@ -801,6 +925,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");
@@ -808,6 +936,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 */ }
@@ -962,6 +1093,7 @@ async function collectProtocolViolations(ctx, callGraph) {
             aliasWarnings: protocolRulesData.aliasWarnings?.length
                 ? protocolRulesData.aliasWarnings : undefined,
         } : undefined,
+        annotationSuggestions,
     };
 }
 function extractCallSequencesFromProject(projectPath, language, keepNames) {

package/package.json

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