progmune-runtime 3.4.1 → 3.6.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## [3.6.0] — 2026-08-23
+
+### 新增：SSG endState 检查（序列末尾资源未释放）
+
+- trust 桥接路径（`src/trust/ssg-bridge.ts`）补齐 endState 检测：函数序列末尾仍有未释放资源状态 → 违规（`endState: true`、`fixPath=[releaseFn]`、追加式修复文案、独立 rule_id `SSG_*_END_STATE_VIOLATION`）
+- 与 planner 语义对齐：共享判定 `findHeldResourceStates` + `RESOURCE_NAMESPACE_RE` 入 `ssg-validator.ts`（planner 重构换用，语义不变）
+- 边界：仅资源生命周期命名空间（auth/session 合法地以活跃会话结束不检查）；仅本序列新获取的状态（继承自初始态不算泄漏）
+- **Python 协议盲测 v1 复测：40/40 全检出（Recall/Precision 100%，0 FP）**，基线 `BASELINE_PROTOCOL_PYTHON_v1.md`
+
+### 新增：Python 协议盲测基准（v1）
+
+- `blind-benchmark/generate-projects-protocol-python.ts` + `scan-protocol-python.ts` + `expand-gold-protocol-python.ts`：6 违规类型 × 4 结构风格 = 24 项目，金标 `annotations-protocol-python-v1.json`
+- 测量生产 SSG 桥接校验器（确定性、无 LLM）；回归测试 `tests/python-protocol-benchmark.test.ts`
+
+### 文档
+
+- README 新增「社区与反馈」章节：讨论群二维码（`assets/wechat-group.png`，当前为占位图待替换真实群码）+ GitHub Issues 通道（中英双语）
+- README 删除双峰（Two-Hump）内容：科学基础章节的双峰类比段与 P0-P3 节的双峰报告链接
+- 覆盖矩阵（中英）刷新至 2026-08-23 并新增英文版 `coverage-matrix-en.md`；架构图规则数修正 140→148（与 protocols.json 实测一致）
+
+## [3.5.0] — 2026-08-22
+
+### 新增：多语言合并 IR（注册表式提取）
+
+- `src/extract-project-ir.ts`：`LanguageExtractor` 注册表（detect + extract），`extractProjectIR` 合并所有检测到语言的 FunctionInfo——混合项目中 TS 与 Python 函数共存于同一 IR
+- agent loop 感知路径（`extractIRWithDelta`）、`execute()` 的 ir.json 写盘、MCP server 统一走合并入口：Python 项目的函数协议链进入 agent 编排范围（此前 agent 侧 IR 仅 TS）
+- `extractIRPython` 默认写临时文件（可选 `outPath`），不再覆盖项目根 ir.json；单语言提取失败不中断其余语言，全部失败才抛错（保留 execute 硬失败语义）
+- 新增语言（Go/Java/Rust）：实现 detect + extract → `LANGUAGE_EXTRACTORS` 注册一条 → 调用方零改动
+
+### 修复：function-synonyms 本地超时（遗留）
+
+- `runBootstrapValidation` 无参调用结果缓存（同进程复用，语料重度测试 5 次重计算降为 1 次）
+- vitest 改用 forks 池 + 4GB 堆上限（本地语料丰富时 threads 池触 V8 自适应堆上限 OOM）；本地 7/7 通过（~24s）
+
+### 验证
+
+- 相关套件 26/26；`npm run check` 0 失败；合并冒烟：progmune-runtime 自身 4043 函数（TS 1949 + Python 2094）
+
 ## [3.4.1] — 2026-08-22
 
 ### 修复：`npm run check` 四项失败根因

package/README.md

@@ -106,6 +106,8 @@ Progmune is honest about what it can and cannot verify.
 | **C** | ⚠️ Research-only | Gold benchmark F1=16.5%. L3 cross-function experiment terminated; L4 not planned. 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.
+
 **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.
 
 ### What Progmune does NOT cover (honest boundaries)
@@ -116,7 +118,7 @@ Progmune is honest about what it can and cannot verify.
 - **Framework internals** — well-known framework dispatch/cache machinery (e.g. django-unicorn internals) can produce a small number of boundary false positives; they are documented per-corpus in the benchmark gold files.
 - **Known failure boundaries are documented** rather than hidden: if Progmune cannot verify a language (e.g. Go), Confidence is lowered instead of pretending 100%.
 
-→ [Full Coverage Matrix](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/coverage-matrix.md)
+→ [Full Coverage Matrix](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/coverage-matrix-en.md)
 
 ---
 
@@ -160,7 +162,7 @@ C analysis is **research-only**: gold benchmark F1=16.5% across 4 repos (curl, l
 - Bootstrapping deadlock broken: all 21 protocol namespaces now have rule vocabulary
 - `excludePatterns` + `languages` architecture for FP management
 
-→ [Two-Hump Report](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/two-hump-report.md) · [P0-P3 Final Report](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/p0-p3-final-report.md)
+→ [P0-P3 Final Report](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/p0-p3-final-report.md)
 
 ---
 
@@ -172,11 +174,12 @@ SDK (src/sdk.ts)           verify() → APPROVED / NEEDS_REVIEW / BLOCKED
        ├─ Policy Engine     Enterprise policy enforcement (ALLOW/WARN/BLOCK)
        ├─ SSG Validator     Protocol state machine verification
        ├─ Protocol Detector  Regex-based protocol step detection (22 detectors)
-       ├─ IR Extractors     TypeScript (ts-morph) + Python (ast module) → function IR;
-       │                    source-level markers: taint tracking, import resolution,
-       │                    qualified call chains, cross-file template analysis
+       ├─ IR Extraction      Registry-based: TS (ts-morph) + Python (ast module)
+       │                     merged into one function IR per project;
+       │                     source-level markers: taint tracking, import resolution,
+       │                     qualified call chains, cross-file template analysis
        ├─ Repair Executor   detect → plan → fix → validate → commit/rollback
-       └─ Knowledge Base    31 domains, 140 rules, evidence chains
+       └─ Knowledge Base    31 domains, 148 rules, evidence chains
 ```
 
 ### Interfaces
@@ -191,12 +194,20 @@ SDK (src/sdk.ts)           verify() → APPROVED / NEEDS_REVIEW / BLOCKED
 
 ---
 
+## Community & Feedback
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/shenlian19831109/progmune-runtime/main/assets/wechat-group.png" width="240" alt="Progmune user discussion group QR code" />
+</p>
+
+Your feedback shapes Progmune. Scan the QR code to join the user discussion group (WeChat), or open a [GitHub Issue](https://github.com/shenlian19831109/progmune-runtime/issues) for bug reports, feature requests, and suggestions.
+
+---
+
 ## Scientific Foundation
 
 Progmune is built on the premise that **LLM outputs are statistical performances, not reasoning** — a view developed by Subbarao Kambhampati et al. in the position paper ["Stop Anthropomorphizing Intermediate Tokens as Reasoning/Thinking Traces!"](https://arxiv.org/abs/2505.22285) (arXiv:2505.22285, 2025) and elaborated in his ICML 2026 talk "On the Role of Verifiers and Thinking Traces in Reasoning Models". Rather than trusting what the model says about code, Progmune verifies what the program actually does — using protocol state machines, IR extraction, and evidence-backed decision chains.
 
-Coverage-gap analysis borrows the "two-hump problem" terminology **as a cross-domain analogy** from Sergei Gukov's work in mathematical physics (the Andrews-Curtis conjecture in group theory, 2026) — it describes a bimodal coverage distribution, not a collaboration. See [Two-Hump Report](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/two-hump-report.md) for the full methodology.
-
 → [Investor Whitepaper](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/Progmune_投资人白皮书_v2.0.html) · [Trust Decision Model](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/ai-trust-decision-model-v1.md)
 
 ---

package/README.zh-CN.md

@@ -106,6 +106,8 @@ Progmune 对能验证什么、不能验证什么保持诚实。
 | **C** | ⚠️ 仅研究 | 黄金基准 F1=16.5%。L3 跨函数实验已终止；L4 无计划。见 [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……）= 注册一条提取器，调用方零改动。
+
 **框架适配器：2/13。** Express ✅ 与 tRPC ✅ 有专用检测器；Next.js 有版本感知治理；NestJS 部分支持。Django、FastAPI 及另外 8 个待适配——框架适配是 #1 产品缺口。
 
 ### Progmune 不覆盖什么（诚实边界）
@@ -160,7 +162,7 @@ C 分析**仅研究**：黄金基准 F1=16.5%，覆盖 4 个仓库（curl、libs
 - 打破引导死锁：全部 21 个协议命名空间已有规则词汇
 - `excludePatterns` + `languages` 架构管理误报
 
-→ [双峰报告](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/two-hump-report.md) · [P0-P3 终报](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/p0-p3-final-report.md)
+→ [P0-P3 终报](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/p0-p3-final-report.md)
 
 ---
 
@@ -172,10 +174,11 @@ SDK (src/sdk.ts)           verify() → APPROVED / NEEDS_REVIEW / BLOCKED
        ├─ 策略引擎           企业策略执行（ALLOW/WARN/BLOCK）
        ├─ SSG 校验器         协议状态机验证
        ├─ 协议检测器         基于正则的协议步骤检测（22 个检测器）
-       ├─ IR 提取器          TypeScript（ts-morph）+ Python（ast 模块）→ 函数 IR；
+       ├─ IR 提取            注册表式：TS（ts-morph）+ Python（ast 模块）
+       │                     合并为每项目一份函数 IR；
        │                     源码级标记：污点追踪、import 解析、限定调用链、跨文件模板分析
        ├─ 修复执行器         detect → plan → fix → validate → commit/rollback
-       └─ 知识库             31 个域、140 条规则、证据链
+       └─ 知识库             31 个域、148 条规则、证据链
 ```
 
 ### 接口
@@ -190,12 +193,20 @@ SDK (src/sdk.ts)           verify() → APPROVED / NEEDS_REVIEW / BLOCKED
 
 ---
 
+## 社区与反馈
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/shenlian19831109/progmune-runtime/main/assets/wechat-group.png" width="240" alt="Progmune 用户讨论群二维码" />
+</p>
+
+你的意见塑造 Progmune。扫码加入用户讨论群（微信），或通过 [GitHub Issue](https://github.com/shenlian19831109/progmune-runtime/issues) 提交缺陷报告、功能需求与建议。
+
+---
+
 ## 科学基础
 
 Progmune 建立在"**LLM 输出是统计表演而非推理**"这一前提上——该观点源自 Subbarao Kambhampati 等人的立场论文 ["Stop Anthropomorphizing Intermediate Tokens as Reasoning/Thinking Traces!"](https://arxiv.org/abs/2505.22285)（arXiv:2505.22285，2025），并在其 ICML 2026 演讲 "On the Role of Verifiers and Thinking Traces in Reasoning Models" 中展开。Progmune 不信任模型对代码的说法，而是用协议状态机、IR 提取与证据链验证程序实际行为。
 
-覆盖缺口分析借用"双峰问题"术语作为**跨域类比**，源自 Sergei Gukov 在数学物理领域的工作（群论中的 Andrews-Curtis 猜想，2026）——它描述的是双峰覆盖分布，而非合作关系。详见 [双峰报告](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/two-hump-report.md)。
-
 → [投资人白皮书](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/Progmune_投资人白皮书_v2.0.html) · [信任决策模型](https://github.com/shenlian19831109/progmune-runtime/blob/main/docs/ai-trust-decision-model-v1.md)
 
 ---

package/dist/agent-perception.js

@@ -49,7 +49,7 @@ exports.extractIRWithDelta = extractIRWithDelta;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
-const extract_ir_1 = require("./extract-ir");
+const extract_project_ir_1 = require("./extract-project-ir");
 // ── Git Context ──
 function git(projectPath, args) {
     return (0, child_process_1.execSync)(`git -C "${projectPath}" ${args}`, {
@@ -125,7 +125,7 @@ function listSourceFiles(projectPath) {
  * prevNames 缺省时只返回全量 IR（delta 为空）。
  */
 function extractIRWithDelta(projectPath, prevNames) {
-    const ir = (0, extract_ir_1.extractIR)(projectPath);
+    const ir = (0, extract_project_ir_1.extractProjectIR)(projectPath);
     const names = ir.map((f) => String(f.name || "")).filter(Boolean);
     if (!prevNames) {
         return { ir, delta: { added: [], removed: [], functionCount: names.length } };

package/dist/agent-perception.test.js

@@ -41,16 +41,16 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
 const child_process_1 = require("child_process");
-const extract_ir_1 = require("./extract-ir");
+const extract_project_ir_1 = require("./extract-project-ir");
 const agent_perception_1 = require("./agent-perception");
 vitest_1.vi.mock("child_process", () => ({
     execSync: vitest_1.vi.fn(),
 }));
-vitest_1.vi.mock("./extract-ir", () => ({
-    extractIR: vitest_1.vi.fn(),
+vitest_1.vi.mock("./extract-project-ir", () => ({
+    extractProjectIR: vitest_1.vi.fn(),
 }));
 const mockExecSync = vitest_1.vi.mocked(child_process_1.execSync);
-const mockExtractIR = vitest_1.vi.mocked(extract_ir_1.extractIR);
+const mockExtractProjectIR = vitest_1.vi.mocked(extract_project_ir_1.extractProjectIR);
 (0, vitest_1.beforeEach)(() => {
     vitest_1.vi.clearAllMocks();
 });
@@ -82,7 +82,7 @@ const mockExtractIR = vitest_1.vi.mocked(extract_ir_1.extractIR);
         (0, vitest_1.expect)(ctx.error).toContain("not a git repository");
     });
     (0, vitest_1.it)("extractIRWithDelta 计算新增/消失函数差集", () => {
-        mockExtractIR.mockReturnValue([
+        mockExtractProjectIR.mockReturnValue([
             { name: "verify_password" },
             { name: "main" },
         ]);

package/dist/bootstrap-validation.js

@@ -69,8 +69,23 @@ function buildPath(startFn, rules, visited) {
 }
 /**
  * Run the bootstrap validation experiment.
+ *
+ * 无参调用结果缓存（纯计算、确定性）：同进程内多次调用复用同一结果。
+ * 运行时与本地语料规模线性相关（语料丰富时可 >30s / 2GB 堆）——
+ * function-synonyms 等测试会 5 次重计算，缓存降为 1 次。
  */
+let _defaultResultCache = null;
 async function runBootstrapValidation(existingRules, extraSequences) {
+    if (!existingRules && !extraSequences) {
+        if (!_defaultResultCache) {
+            _defaultResultCache = runBootstrapValidationUncached();
+        }
+        return _defaultResultCache;
+    }
+    return runBootstrapValidationUncached(existingRules, extraSequences);
+}
+/** 原实现（无缓存）。 */
+async function runBootstrapValidationUncached(existingRules, extraSequences) {
     // 1. Ground truth
     const defs = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
     const originalRules = existingRules || new Map();

package/dist/execute.js

@@ -49,7 +49,7 @@ exports.verifyFileMarker = verifyFileMarker;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const planner_1 = require("./planner");
-const extract_ir_1 = require("./extract-ir");
+const extract_project_ir_1 = require("./extract-project-ir");
 const failure_collector_1 = require("./failure-collector");
 const emitter_1 = require("./emitter");
 const METRICS_FILE = ".progmune_corpus/metrics.json";
@@ -101,7 +101,7 @@ async function execute(intent, projectPath, filePath) {
     // 1. IR extraction
     let ir;
     try {
-        ir = (0, extract_ir_1.extractIR)(projectPath);
+        ir = (0, extract_project_ir_1.extractProjectIR)(projectPath);
     }
     catch (e) {
         return { success: false, degraded: false, code: "", sessionId: "", hash: "", ruleHash: "", irFunctionCount: 0, protocolRuleCount: 0, violations: 0, repairApplied: false, repairCount: 0, repairBranchIds: [], branchWinner: undefined, error: `IR extraction failed: ${e.message}` };

package/dist/extract-ir-python.js

@@ -50,10 +50,18 @@ exports.extractIRPython = extractIRPython;
 exports.isPythonProject = isPythonProject;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
-function extractIRPython(projectRoot) {
+/**
+ * @param projectRoot - Project root to scan
+ * @param outPath - Output path for the Python script. Defaults to a temp
+ *   file (cleaned up afterwards) so extraction never clobbers the project's
+ *   own ir.json — the merged extractProjectIR runs this on TS projects too.
+ *   Pass an explicit path when the extracted IR must be persisted.
+ */
+function extractIRPython(projectRoot, outPath) {
     const scriptPath = path.resolve(__dirname, "..", "tools", "extract_ir.py");
-    const irPath = path.resolve(projectRoot, "ir.json");
+    const irPath = outPath ?? path.join(os.tmpdir(), `progmune-py-ir-${process.pid}-${Date.now()}.json`);
     const cmd = `python3 "${scriptPath}" "${projectRoot}" "${irPath}"`;
     try {
         (0, child_process_1.execSync)(cmd, { encoding: "utf-8", stdio: "pipe" });
@@ -64,7 +72,18 @@ function extractIRPython(projectRoot) {
     }
     if (!fs.existsSync(irPath))
         return [];
-    const raw = JSON.parse(fs.readFileSync(irPath, "utf-8"));
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(irPath, "utf-8"));
+    }
+    finally {
+        if (!outPath) {
+            try {
+                fs.unlinkSync(irPath);
+            }
+            catch { /* 临时文件清理失败无害 */ }
+        }
+    }
     if (!Array.isArray(raw))
         return [];
     // Map Python IR records to FunctionInfo

package/dist/extract-project-ir.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Project IR extraction — merged multi-language entry point.
+ *
+ * Registry pattern: each supported language contributes a detector +
+ * extractor entry. extractProjectIR runs every extractor whose language
+ * is detected in the project and merges the results into one FunctionInfo
+ * list, so TS + Python coexist in a mixed project.
+ *
+ * Adding a language later (Go, Java, ...) = register one entry in
+ * LANGUAGE_EXTRACTORS. The agent loop (extractIRWithDelta), execute()'s
+ * ir.json write and the MCP server all pick it up automatically — no
+ * dispatch rewiring anywhere else.
+ */
+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 });
+exports.LANGUAGE_EXTRACTORS = void 0;
+exports.detectLanguages = detectLanguages;
+exports.extractProjectIR = extractProjectIR;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const extract_ir_1 = require("./extract-ir");
+const extract_ir_python_1 = require("./extract-ir-python");
+const SKIP_DIRS = new Set([
+    "node_modules", "dist", "build", ".git", ".progmune_corpus",
+    "__pycache__", "venv", ".venv",
+]);
+/** 有界递归扫描：项目是否含指定扩展名源文件（首个命中即返回）。 */
+function hasSourceFiles(projectRoot, exts) {
+    const stack = [projectRoot];
+    const seen = new Set();
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        if (seen.has(dir))
+            continue;
+        seen.add(dir);
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (!SKIP_DIRS.has(e.name) && !e.name.startsWith("."))
+                    stack.push(full);
+            }
+            else if (exts.has(path.extname(e.name))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/** 已注册语言提取器（新增语言在此追加一条）。 */
+exports.LANGUAGE_EXTRACTORS = [
+    {
+        language: "typescript",
+        detect: (p) => hasSourceFiles(p, new Set([".ts", ".tsx"])),
+        extract: (p) => (0, extract_ir_1.extractIR)(p),
+    },
+    {
+        language: "python",
+        detect: (p) => hasSourceFiles(p, new Set([".py"])),
+        extract: (p) => (0, extract_ir_python_1.extractIRPython)(p),
+    },
+];
+/** 项目检测到的语言列表（审计/标签用）。 */
+function detectLanguages(projectRoot) {
+    return exports.LANGUAGE_EXTRACTORS.filter((e) => e.detect(projectRoot)).map((e) => e.language);
+}
+/**
+ * Extract the merged project IR across all detected languages.
+ *
+ * 单语言提取失败不拖垮其余语言（与感知层 best-effort 原则一致）；
+ * 仅当所有检测到的语言全部失败时才抛错，保留 execute 的硬失败语义。
+ *
+ * @param projectRoot - Absolute path to project root
+ * @param extractors - Registry override (tests inject fake entries here)
+ * @returns Merged FunctionInfo list
+ */
+function extractProjectIR(projectRoot, extractors = exports.LANGUAGE_EXTRACTORS) {
+    const merged = [];
+    let anyDetected = false;
+    let anySucceeded = false;
+    for (const e of extractors) {
+        if (!e.detect(projectRoot))
+            continue;
+        anyDetected = true;
+        try {
+            merged.push(...e.extract(projectRoot));
+            anySucceeded = true;
+        }
+        catch (err) {
+            console.error(`[extractProjectIR] ${e.language} 提取失败: ${err?.message || err}`);
+        }
+    }
+    if (anyDetected && !anySucceeded) {
+        throw new Error("所有已检测语言的 IR 提取均失败");
+    }
+    return merged;
+}

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

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Project IR extraction (merged multi-language registry) — unit tests.
+ *
+ * Registry injection: tests pass fake extractor entries to extractProjectIR
+ * so no real extractor runs; the real detectors are covered by two
+ * temp-dir tests (per module convention, FS use is kept minimal).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const extract_project_ir_1 = require("./extract-project-ir");
+(0, vitest_1.describe)("extractProjectIR（注册表合并）", () => {
+    (0, vitest_1.it)("合并所有检测到语言的函数", () => {
+        const tsFns = [{ name: "getSession", file: "src/auth.ts" }];
+        const pyFns = [{ name: "verify_password", file: "auth_service.py" }];
+        const extractors = [
+            { language: "typescript", detect: () => true, extract: () => tsFns },
+            { language: "python", detect: () => true, extract: () => pyFns },
+        ];
+        const ir = (0, extract_project_ir_1.extractProjectIR)("/tmp/fake", extractors);
+        (0, vitest_1.expect)(ir).toEqual([...tsFns, ...pyFns]);
+    });
+    (0, vitest_1.it)("未检测到的语言不运行提取器", () => {
+        const ran = [];
+        const extractors = [
+            { language: "typescript", detect: () => true, extract: () => { ran.push("ts"); return []; } },
+            { language: "python", detect: () => false, extract: () => { ran.push("py"); return []; } },
+        ];
+        (0, extract_project_ir_1.extractProjectIR)("/tmp/fake", extractors);
+        (0, vitest_1.expect)(ran).toEqual(["ts"]);
+    });
+    (0, vitest_1.it)("单语言提取失败不拖垮其余语言", () => {
+        vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
+        const extractors = [
+            { language: "typescript", detect: () => true, extract: () => { throw new Error("broken tsconfig"); } },
+            { language: "python", detect: () => true, extract: () => [{ name: "f" }] },
+        ];
+        const ir = (0, extract_project_ir_1.extractProjectIR)("/tmp/fake", extractors);
+        (0, vitest_1.expect)(ir).toEqual([{ name: "f" }]);
+    });
+    (0, vitest_1.it)("所有检测到的语言都失败时抛错（保留 execute 硬失败语义）", () => {
+        vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
+        const extractors = [
+            { language: "typescript", detect: () => true, extract: () => { throw new Error("broken"); } },
+        ];
+        (0, vitest_1.expect)(() => (0, extract_project_ir_1.extractProjectIR)("/tmp/fake", extractors)).toThrow();
+    });
+    (0, vitest_1.it)("无任何检测到的语言时返回空数组，不抛错", () => {
+        const extractors = [
+            { language: "typescript", detect: () => false, extract: () => [] },
+            { language: "python", detect: () => false, extract: () => [] },
+        ];
+        (0, vitest_1.expect)((0, extract_project_ir_1.extractProjectIR)("/tmp/fake", extractors)).toEqual([]);
+    });
+});
+(0, vitest_1.describe)("detectLanguages（真实探测器）", () => {
+    (0, vitest_1.it)("TS/Python 混合项目两种语言都被检测", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-lang-"));
+        try {
+            fs.writeFileSync(path.join(dir, "main.ts"), "export function f() {}");
+            fs.mkdirSync(path.join(dir, "src"));
+            fs.writeFileSync(path.join(dir, "src", "app.py"), "def g():\n    pass\n");
+            (0, vitest_1.expect)((0, extract_project_ir_1.detectLanguages)(dir).sort()).toEqual(["python", "typescript"]);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)("依赖目录里的源文件不计入检测（node_modules/.py）", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-lang2-"));
+        try {
+            fs.mkdirSync(path.join(dir, "node_modules", "pkg"), { recursive: true });
+            fs.writeFileSync(path.join(dir, "node_modules", "pkg", "x.py"), "x = 1\n");
+            (0, vitest_1.expect)((0, extract_project_ir_1.detectLanguages)(dir)).toEqual([]);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/function-synonyms.test.js

@@ -49,12 +49,16 @@ const bootstrap_validation_1 = require("./bootstrap-validation");
     });
 });
 (0, vitest_1.describe)("Synonym Normalization Impact", () => {
+    // 注：这两个测试的重度与本地语料规模线性相关（.progmune_corpus 864+ 条时
+    // 实测 40-130s）。CI 干净检出无语料 → 秒级通过；本地语料丰富 → 需放宽超时。
+    // 显式超时 180s，不依赖 vitest 全局 30s。
+    const CORPUS_HEAVY_TIMEOUT = 180000;
     (0, vitest_1.it)("reduces unique function count via normalization", async () => {
         const report = await (0, function_synonyms_1.runSynonymNormalization)();
         (0, vitest_1.expect)(report.uniqueAfter).toBeLessThanOrEqual(report.uniqueBefore);
         (0, vitest_1.expect)(report.uniqueAfter).toBeLessThanOrEqual(report.uniqueBefore);
         (0, function_synonyms_1.printSynonymReport)(report);
-    });
+    }, CORPUS_HEAVY_TIMEOUT);
     (0, vitest_1.it)("bootstrap function overlap improves with normalization", async () => {
         // Baseline without normalization
         const baseline = await (0, bootstrap_validation_1.runBootstrapValidation)();
@@ -64,5 +68,5 @@ const bootstrap_validation_1 = require("./bootstrap-validation");
         console.log(`Function overlap: ${(after.functionOverlap * 100).toFixed(0)}%`);
         console.log(`State overlap: ${(after.stateOverlap * 100).toFixed(0)}%`);
         console.log(`Behavioral: ${after.behavioralMatch}/${after.behavioralTotal}`);
-    }, 30000);
+    }, CORPUS_HEAVY_TIMEOUT);
 });

package/dist/mcp-server.mjs

@@ -39,8 +39,7 @@ for (const envPath of [
     }
 }
 import { plan } from "./planner.js";
-import { extractIR } from "./extract-ir.js";
-import { extractIRPython, isPythonProject } from "./extract-ir-python.js";
+import { extractProjectIR, detectLanguages } from "./extract-project-ir.js";
 import { emitCode } from "./emitter.js";
 import { recordRun } from "./feedback.js";
 import { reportFingerprints } from "./immune-reporter.js";
@@ -419,10 +418,9 @@ Then restart Claude Code.`,
                 log.warn(`No .ts files found in project root, IR may be empty`);
             }
             // IR extraction — auto-detect language
-            const isPython = isPythonProject(projectPath);
             let ir;
             try {
-                ir = isPython ? extractIRPython(projectPath) : extractIR(projectPath);
+                ir = extractProjectIR(projectPath);
             }
             catch (e) {
                 return {
@@ -573,9 +571,9 @@ Then restart Claude Code.`,
             const warn = (msg) => results.push(`! ${msg}`);
             // 1. IR extraction — auto-detect language
             try {
-                const py = isPythonProject(projectPath);
-                const ir = py ? extractIRPython(projectPath) : extractIR(projectPath);
-                pass(`IR (${py ? "Python" : "TypeScript"}): ${ir.length} functions extracted`);
+                const langs = detectLanguages(projectPath);
+                const ir = extractProjectIR(projectPath);
+                pass(`IR (${langs.length > 0 ? langs.join("+") : "无已支持语言"}): ${ir.length} functions extracted`);
             }
             catch (e) {
                 fail(`IR extraction: ${e.message}`);

package/dist/planner.js

@@ -392,26 +392,10 @@ function validateProtocolWithTransitions(actions, protocols, namespaceInitialSta
         }
     }
     // End-of-sequence check: held resources must be released (resource leak).
-    // A state S is resource-holding when some rule REQUIRES S and INVALIDATES S
-    // (acquire/release semantics — e.g. FILE_OPEN set by open_file, released by
-    // close_file). Only RESOURCE-LIFECYCLE namespaces apply: session/auth flows
-    // legitimately END with an active session (SESSION_ACTIVE is not a leak).
-    const RESOURCE_NS = /^(file|db|database|connection|conn|socket|stream|resource|io)/i;
-    const heldStates = [];
-    for (const p of protocols) {
-        const ann = p.protocol;
-        if (!ann)
-            continue;
-        const ns = ann.namespace || "";
-        if (!RESOURCE_NS.test(ns))
-            continue;
-        const inv = ann.invalidate || [];
-        const pre = ann.pre_states || [];
-        for (const s of inv) {
-            if (pre.includes(s))
-                heldStates.push({ state: s, releaseFn: p.function, namespace: ns });
-        }
-    }
+    // 共享判定见 ssg-validator.findHeldResourceStates：资源生命周期命名空间 +
+    // pre/invalidate 交集（获取/释放语义）。会话/认证流合法地以活跃会话结束，
+    // 不在检查范围（SESSION_ACTIVE 不是泄漏）。
+    const heldStates = (0, ssg_validator_1.findHeldResourceStates)(rules);
     // 只检查"本序列中获取"的持有状态——继承自命名空间初始状态的
     // （如 db 初始即 DB_CONNECTED）不算泄漏。
     const acquiredStates = new Set();

package/dist/ssg-validator.js

@@ -33,7 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StateMachineValidator = exports.InvariantViolationError = void 0;
+exports.StateMachineValidator = exports.InvariantViolationError = exports.RESOURCE_NAMESPACE_RE = void 0;
+exports.findHeldResourceStates = findHeldResourceStates;
 exports.rebuildState = rebuildState;
 exports.applyTransitionDelta = applyTransitionDelta;
 exports.findFixPathStatic = findFixPathStatic;
@@ -51,6 +52,28 @@ exports.explainRejection = explainRejection;
 exports.rejectionToJSON = rejectionToJSON;
 exports.parseProtocolsFromJSON = parseProtocolsFromJSON;
 const crypto = __importStar(require("crypto"));
+/** 资源生命周期命名空间：会话/认证流合法地以活跃会话结束（SESSION_ACTIVE 不是泄漏），
+ *  只有资源类命名空间（文件/数据库/连接/流等）做序列末尾持有状态检查。 */
+exports.RESOURCE_NAMESPACE_RE = /^(file|db|database|connection|conn|socket|stream|resource|io)/i;
+/**
+ * 找出资源持有状态候选：某规则的 pre_states 与 invalidate 的交集
+ * （获取/释放语义——如 FILE_OPEN 由 open_file 设置、close_file 释放），
+ * 仅限资源生命周期命名空间。planner 与 trust 桥接共用（endState 检查）。
+ */
+function findHeldResourceStates(rules) {
+    const held = [];
+    for (const [fn, ann] of rules) {
+        const ns = ann.namespace || "";
+        if (!exports.RESOURCE_NAMESPACE_RE.test(ns))
+            continue;
+        for (const s of ann.invalidate || []) {
+            if ((ann.pre_states || []).includes(s)) {
+                held.push({ state: s, releaseFn: fn, namespace: ns });
+            }
+        }
+    }
+    return held;
+}
 const DEFAULT_NAMESPACE = "_global";
 class InvariantViolationError extends Error {
     constructor(message, detail) {

package/dist/trust/ssg-bridge.js

@@ -342,6 +342,18 @@ function validateSequenceWithSSG(steps, rules, namespaceInitialStates, file, ali
             return undefined;
         }
     })();
+    // 本序列中"新获取"的资源状态（endState 检查只针对本序列获取、未释放的状态——
+    // 继承自命名空间初始状态的不算泄漏，与 planner 语义一致）
+    const acquiredStates = new Set();
+    const trackAcquiredStates = (before, after) => {
+        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}`);
+            }
+        }
+    };
     for (let i = 0; i < steps.length; i++) {
         const step = steps[i];
         const namespace = DOMAIN_TO_NAMESPACE[step.domain] || "stateless";
@@ -385,6 +397,7 @@ function validateSequenceWithSSG(steps, rules, namespaceInitialStates, file, ali
                 // Advance state
                 ctx.ledger.push(result.transition);
                 ctx.currentState = result.transition.statesAfter;
+                trackAcquiredStates(result.transition.statesBefore, result.transition.statesAfter);
             }
             else {
                 violatedCalls++;
@@ -414,6 +427,7 @@ function validateSequenceWithSSG(steps, rules, namespaceInitialStates, file, ali
                 // 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);
             }
         }
         catch {
@@ -440,6 +454,39 @@ function validateSequenceWithSSG(steps, rules, namespaceInitialStates, file, ali
             valid: true,
         });
     }
+    // ── End-of-sequence check: held resources must be released (resource leak).
+    // 共享判定见 ssg-validator.findHeldResourceStates：仅资源生命周期命名空间 +
+    // pre/invalidate 交集；只报本序列获取且最终仍持有的状态（对齐 planner）。
+    for (const hs of (0, ssg_validator_1.findHeldResourceStates)(rules)) {
+        const ctx = contexts.get(hs.namespace);
+        if (!ctx)
+            continue;
+        if (!acquiredStates.has(`${hs.namespace}::${hs.state}`))
+            continue;
+        const cur = ctx.currentState[hs.namespace] || [];
+        if (!cur.includes(hs.state))
+            continue;
+        violatedCalls++;
+        violations.push({
+            callName: "(end-of-sequence)",
+            namespace: hs.namespace,
+            currentState: cur,
+            requiredState: [],
+            fixPath: [hs.releaseFn],
+            matchedRule: hs.releaseFn,
+            endState: true,
+            explanation: `SSG end-state violation: resource state [${hs.state}] ` +
+                `acquired in this function is still held at end of sequence ` +
+                `(namespace ${hs.namespace}, current [${cur.join(", ")}]) — ` +
+                `missing release call: ${hs.releaseFn}.`,
+        });
+        trace.push({
+            call: "(end-of-sequence)",
+            namespace: hs.namespace,
+            matchedRule: hs.releaseFn,
+            valid: false,
+        });
+    }
     return {
         passed: violations.length === 0,
         trace,
@@ -459,19 +506,30 @@ function validateSequenceWithSSG(steps, rules, namespaceInitialStates, file, ali
 function ssgViolationsToTrustViolations(ssgResult, file, funcName) {
     return ssgResult.violations.map((v) => ({
         severity: "medium",
-        rule_id: `SSG_${v.namespace.toUpperCase()}_STATE_VIOLATION`,
+        rule_id: v.endState
+            ? `SSG_${v.namespace.toUpperCase()}_END_STATE_VIOLATION`
+            : `SSG_${v.namespace.toUpperCase()}_STATE_VIOLATION`,
         file,
         function: funcName,
         message: v.explanation,
-        evidence: `Call: ${v.callName} | Rule: ${v.matchedRule || "unknown"} | ` +
-            `Required: [${v.requiredState.join(", ")}] | ` +
-            `Current: [${v.currentState.join(", ")}]`,
-        why: `Protocol state machine violation in namespace "${v.namespace}": ` +
-            `function "${v.callName}" cannot be called in current state ` +
-            `[${v.currentState.join(", ")}]. Required pre-states: [${v.requiredState.join(", ")}].`,
-        fix: v.fixPath.length > 0
-            ? `Insert before the violating call: ${v.fixPath.join(" → ")}`
-            : `Review protocol documentation for namespace "${v.namespace}" to understand required state transitions.`,
+        evidence: v.endState
+            ? `End-of-sequence: held resource state [${v.currentState.join(", ")}] | ` +
+                `Release call: ${v.fixPath.join(" → ") || "unknown"}`
+            : `Call: ${v.callName} | Rule: ${v.matchedRule || "unknown"} | ` +
+                `Required: [${v.requiredState.join(", ")}] | ` +
+                `Current: [${v.currentState.join(", ")}]`,
+        why: v.endState
+            ? `Protocol state machine violation in namespace "${v.namespace}": ` +
+                `a resource acquired in this function ([${v.currentState.join(", ")}]) ` +
+                `is still held when the function ends — resource leak.`
+            : `Protocol state machine violation in namespace "${v.namespace}": ` +
+                `function "${v.callName}" cannot be called in current state ` +
+                `[${v.currentState.join(", ")}]. Required pre-states: [${v.requiredState.join(", ")}].`,
+        fix: v.endState
+            ? `Append the release call at the end of the function: ${v.fixPath.join(" → ")}`
+            : v.fixPath.length > 0
+                ? `Insert before the violating call: ${v.fixPath.join(" → ")}`
+                : `Review protocol documentation for namespace "${v.namespace}" to understand required state transitions.`,
         policy_ref: `protocol-safety.ssg.${v.namespace}`,
     }));
 }

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

@@ -167,17 +167,22 @@ function step(api, domain, description = "") {
             }
         });
         (0, vitest_1.it)("detects missing cleanup (file opened but not closed)", () => {
-            // open_file without close_file — state machine will show FILE_OPEN still active
+            // open_file without close_file — held FILE_OPEN at end of sequence
             const steps = [
                 step("fs.openSync", "conn_mgmt", "Open file"),
                 step("fs.readFileSync", "conn_mgmt", "Read file contents"),
                 // Missing: close_file
             ];
             const result = validate(steps);
-            // The SSG state machine tracks that file is still open.
-            // While it may not report this as a violation (since close_file
-            // isn't called), the state trace should show FILE_OPEN is active.
-            (0, vitest_1.expect)(result.trace.length).toBe(steps.length);
+            // endState 检查：序列末尾资源未释放 → 违规 + 追加式修复路径
+            const endState = result.violations.filter((v) => v.endState);
+            (0, vitest_1.expect)(endState).toHaveLength(1);
+            (0, vitest_1.expect)(endState[0].namespace).toBe("file");
+            (0, vitest_1.expect)(endState[0].currentState).toContain("FILE_OPEN");
+            (0, vitest_1.expect)(endState[0].fixPath).toEqual(["close_file"]);
+            (0, vitest_1.expect)(result.passed).toBe(false);
+            // trace 含步骤节点 + 末尾 endState 节点
+            (0, vitest_1.expect)(result.trace.length).toBe(steps.length + 1);
         });
     });
     (0, vitest_1.describe)("violation → TrustViolation conversion", () => {

package/package.json

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