progmune-runtime 3.3.0 → 3.3.2

package/dist/check.js

@@ -193,10 +193,14 @@ if (cliArg === "--verify") {
     }
 }
 // ── 1. IR 提取 ──
+// 目标项目：PROGMUNE_PROJECT_DIR > CWD。使用编译产物提取器
+// （安装态下包内没有 src/ 也没有 ts-node）。
 step("1/6 IR 提取");
 try {
-    (0, child_process_1.execSync)("npx ts-node src/extract-ir.ts .", { stdio: "pipe", cwd: path.resolve(__dirname, "..") });
-    const irRaw = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../ir.json"), "utf-8"));
+    const projectDir = path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd());
+    const extractor = path.resolve(__dirname, "extract-ir.js");
+    (0, child_process_1.execSync)(`node "${extractor}" "${projectDir}"`, { stdio: "pipe" });
+    const irRaw = JSON.parse(fs.readFileSync(path.resolve(projectDir, "ir.json"), "utf-8"));
     const ir = Array.isArray(irRaw) ? irRaw : (irRaw.functions || []);
     const externalCount = ir.filter((f) => f.external).length;
     pass(`IR 提取完成: ${ir.length} 个函数 (${externalCount} 外部)`);
@@ -207,8 +211,17 @@ catch (e) {
 // ── 2. TypeScript 编译 ──
 step("2/6 TypeScript 类型检查");
 try {
-    (0, child_process_1.execSync)("npx tsc --noEmit", { stdio: "pipe", cwd: path.resolve(__dirname, "..") });
-    pass("零类型错误");
+    const projectDir = path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd());
+    const tsconfig = path.resolve(projectDir, "tsconfig.json");
+    if (!fs.existsSync(tsconfig)) {
+        warn("跳过（项目无 tsconfig.json）");
+    }
+    else {
+        // 用包内 typescript 依赖的 tsc（安装态可用），而非全局 npx
+        const tscBin = path.resolve(__dirname, "..", "node_modules", "typescript", "bin", "tsc");
+        (0, child_process_1.execSync)(`node "${tscBin}" --noEmit -p "${tsconfig}"`, { stdio: "pipe" });
+        pass("零类型错误");
+    }
 }
 catch (e) {
     const stderr = e.stderr?.toString() || e.stdout?.toString() || "";

package/dist/ir-utils.js

@@ -46,11 +46,25 @@ const path = __importStar(require("path"));
  * is a bare array or an object with a `functions` key.
  */
 function loadIR(filePath) {
-    const irPath = filePath || path.resolve(__dirname, "../ir.json");
-    if (!fs.existsSync(irPath))
-        return [];
-    const raw = JSON.parse(fs.readFileSync(irPath, "utf-8"));
-    return Array.isArray(raw) ? raw : (raw.functions || []);
+    // Resolution order: explicit path → PROGMUNE_PROJECT_DIR → CWD →
+    // package directory (legacy fallback). The package dir must be LAST —
+    // in an installed-package setup the project's ir.json lives in the
+    // consuming project, not inside node_modules/progmune-runtime.
+    const candidates = [];
+    if (filePath)
+        candidates.push(filePath);
+    const projectDir = process.env.PROGMUNE_PROJECT_DIR;
+    if (projectDir)
+        candidates.push(path.resolve(projectDir, "ir.json"));
+    candidates.push(path.resolve(process.cwd(), "ir.json"));
+    candidates.push(path.resolve(__dirname, "../ir.json"));
+    for (const irPath of candidates) {
+        if (fs.existsSync(irPath)) {
+            const raw = JSON.parse(fs.readFileSync(irPath, "utf-8"));
+            return Array.isArray(raw) ? raw : (raw.functions || []);
+        }
+    }
+    return [];
 }
 /** Count exported functions in an IR function list.
  * @requires IR_FUNCTIONS @produces EXPORT_COUNT

package/dist/mcp-server.mjs

@@ -9,10 +9,17 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import * as fs from "fs";
 import * as path from "path";
-import { createLogger } from "./logger";
-// ── Load .env (in compiled ESM output, use import.meta.url; here we use __dirname) ──
-const envPath = path.resolve(__dirname, "..", ".env");
-if (fs.existsSync(envPath)) {
+import { fileURLToPath } from "url";
+import { createLogger } from "./logger.js";
+// ── ESM-compatible __dirname (the compiled output is an .mjs module) ──
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// ── Load .env（包目录 + 项目目录，后者优先） ──
+for (const envPath of [
+    path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd(), ".env"),
+    path.resolve(__dirname, "..", ".env"),
+]) {
+    if (!fs.existsSync(envPath))
+        continue;
     const envContent = fs.readFileSync(envPath, "utf-8");
     for (const line of envContent.split("\n")) {
         const trimmed = line.trim();
@@ -27,12 +34,12 @@ if (fs.existsSync(envPath)) {
             process.env[key] = value;
     }
 }
-import { plan } from "./planner";
-import { extractIR } from "./extract-ir";
-import { extractIRPython, isPythonProject } from "./extract-ir-python";
-import { emitCode } from "./emitter";
-import { recordRun } from "./feedback";
-import { reportFingerprints } from "./immune-reporter";
+import { plan } from "./planner.js";
+import { extractIR } from "./extract-ir.js";
+import { extractIRPython, isPythonProject } from "./extract-ir-python.js";
+import { emitCode } from "./emitter.js";
+import { recordRun } from "./feedback.js";
+import { reportFingerprints } from "./immune-reporter.js";
 const OPT_IN_FILE = path.resolve(__dirname, "..", ".progmune_memory", "opt_in.json");
 // ── Structured logging (stderr, not stdout JSON-RPC) ──
 const log = createLogger("progmune");
@@ -332,7 +339,7 @@ async function main() {
 
 Progmune needs an LLM API key to generate code. Configure via:
 
-  【.env file】Add to ${envPath}:
+  【.env file】Add to ${path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd(), ".env")}:
     LLM_API_KEY=your-key
     LLM_BASE_URL=https://api.deepseek.com/v1
     LLM_MODEL=deepseek-chat

package/dist/planner.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProtocolWithTransitions = validateProtocolWithTransitions;
 exports.plan = plan;
 const llm_1 = require("./llm");
 const runtime_types_1 = require("./runtime-types");
@@ -49,6 +50,7 @@ const semantic_snapshot_1 = require("./semantic-snapshot");
 const strategy_planner_1 = require("./strategy-planner");
 const semantic_topology_1 = require("./semantic-topology");
 const planner_prompts_1 = require("./planner-prompts");
+const ir_utils_1 = require("./ir-utils");
 const fs = __importStar(require("fs"));
 function enrichActions(actions, ir) {
     return actions.map(a => {
@@ -389,6 +391,68 @@ function validateProtocolWithTransitions(actions, protocols, namespaceInitialSta
             ctx.currentState = transition.statesAfter;
         }
     }
+    // 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 });
+        }
+    }
+    // 只检查"本序列中获取"的持有状态——继承自命名空间初始状态的
+    // （如 db 初始即 DB_CONNECTED）不算泄漏。
+    const acquiredStates = new Set();
+    for (const t of transitions) {
+        for (const ns of Object.keys(t.statesAfter || {})) {
+            const after = t.statesAfter[ns] || [];
+            const before = t.statesBefore?.[ns] || [];
+            for (const s of after) {
+                if (!before.includes(s))
+                    acquiredStates.add(`${ns}::${s}`);
+            }
+        }
+    }
+    for (const hs of heldStates) {
+        const cur = ctx.currentState[hs.namespace] || [];
+        if (!acquiredStates.has(`${hs.namespace}::${hs.state}`))
+            continue;
+        if (cur.includes(hs.state)) {
+            const trace = transitions.map(t => ({
+                function: t.function,
+                statesBefore: t.statesBefore,
+                statesAfter: t.statesAfter,
+            }));
+            return {
+                valid: false,
+                rejection: {
+                    blocked: "(end-of-sequence)",
+                    currentState: cur,
+                    requiredState: [],
+                    missingFunctions: [hs.releaseFn],
+                    fixPath: [hs.releaseFn],
+                    namespace: hs.namespace,
+                    endState: true,
+                },
+                index: actions.length,
+                trace,
+                transitions,
+                ruleHash,
+            };
+        }
+    }
     // Invariant check on full ledger
     const consistency = (0, ssg_validator_1.checkLedgerConsistency)(transitions, namespaceInitialStates);
     if (!consistency.consistent) {
@@ -400,37 +464,54 @@ function validateProtocolWithTransitions(actions, protocols, namespaceInitialSta
     return { valid: true, transitions, ledgerConsistent: consistency.consistent, ruleHash };
 }
 /** SSG 确定性修复：当协议违规有已知修复路径时，自动插入缺失函数 */
-function attemptSSGRepair(actions, rejection, ir, protocols, namespaceInitialStates) {
-    if (!rejection.fixPath || rejection.fixPath.length === 0)
+function attemptSSGRepair(actions, rejection, ir, protocols, namespaceInitialStates, depth = 0) {
+    if (depth > 5) {
+        console.error(`[修复] 递归深度超限 (${depth})，放弃确定性修复`);
         return null;
-    // 找到被拦截函数在序列中的位置
-    const blockedIdx = actions.findIndex(a => a.kind === "call" && a.function === rejection.blocked);
-    if (blockedIdx === -1)
+    }
+    if (!rejection.fixPath || rejection.fixPath.length === 0)
         return null;
+    // 名称归一化：内置规则可能是下划线风格（generate_jwt），项目 IR 是
+    // camelCase（generateJwt）——修复动作必须使用 IR 中的真实函数名。
+    const normalizeName = (n) => n.replace(/[_-]/g, "").toLowerCase();
+    const resolveIR = (fnName) => ir.find((f) => f.name === fnName)
+        || ir.find((f) => normalizeName(f.name) === normalizeName(fnName));
     // 为修复路径中的每个函数创建合成 Action
     const repairActions = [];
     for (const fnName of rejection.fixPath) {
-        const def = ir.find((f) => f.name === fnName);
+        const def = resolveIR(fnName);
         if (!def)
             return null;
+        const realName = def.name;
         const args = (def.params || []).map((p, i) => ({
             name: p.name || `p${i}`,
             type: p.type || 'any',
             value: "",
         }));
         const assignTo = def.returnType && def.returnType !== 'void' && def.returnType !== 'undefined'
-            ? `${fnName}_result` : undefined;
-        const action = { kind: 'call', function: fnName, args };
+            ? `${realName}_result` : undefined;
+        const action = { kind: 'call', function: realName, args };
         if (assignTo)
             action.assignTo = assignTo;
         repairActions.push(action);
     }
-    // 在被拦截函数前插入修复函数
-    const repaired = [
-        ...actions.slice(0, blockedIdx),
-        ...repairActions,
-        ...actions.slice(blockedIdx),
-    ];
+    let repaired;
+    if (rejection.endState) {
+        // 末尾状态违规（资源未释放）：释放函数追加到序列末尾
+        repaired = [...actions, ...repairActions];
+    }
+    else {
+        // 找到被拦截函数在序列中的位置
+        const blockedIdx = actions.findIndex(a => a.kind === "call" && a.function === rejection.blocked);
+        if (blockedIdx === -1)
+            return null;
+        // 在被拦截函数前插入修复函数
+        repaired = [
+            ...actions.slice(0, blockedIdx),
+            ...repairActions,
+            ...actions.slice(blockedIdx),
+        ];
+    }
     // 重新验证
     const recheck = validateProtocolWithTransitions(repaired, protocols, namespaceInitialStates);
     if (recheck.valid) {
@@ -439,7 +520,8 @@ function attemptSSGRepair(actions, rejection, ir, protocols, namespaceInitialSta
     }
     // 单步修复不够，尝试递归修复
     if (recheck.rejection && recheck.rejection.fixPath && recheck.rejection.fixPath.length > 0) {
-        const nested = attemptSSGRepair(repaired, recheck.rejection, ir, protocols, namespaceInitialStates);
+        console.error(`[修复] 重验仍失败 (blocked=${recheck.rejection.blocked}, fixPath=${recheck.rejection.fixPath.join(" → ")})，递归深度 ${depth + 1}`);
+        const nested = attemptSSGRepair(repaired, recheck.rejection, ir, protocols, namespaceInitialStates, depth + 1);
         if (nested)
             return nested;
     }
@@ -448,9 +530,8 @@ function attemptSSGRepair(actions, rejection, ir, protocols, namespaceInitialSta
 /** @requires INTENT @produces ACTION_PLAN */
 async function plan(userIntent, llmSeeds) {
     (0, llm_1.resetCallCount)();
-    const irRaw = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
-    // Support both old (array) and new ({typeMap, functions}) formats
-    const ir = Array.isArray(irRaw) ? irRaw : (irRaw.functions || []);
+    // IR 读取走 loadIR 的解析顺序（显式路径 → PROGMUNE_PROJECT_DIR → CWD → 包目录回退）
+    const ir = (0, ir_utils_1.loadIR)();
     // P1: Build Semantic Topology (once per plan call, cached)
     try {
         (0, semantic_topology_1.rebuildTopology)(ir);
@@ -458,7 +539,7 @@ async function plan(userIntent, llmSeeds) {
     catch { /* topology rebuild — optional */ }
     // Helper: wrap actions into PlanResult
     let repairMetrics = { applied: false, count: 0, branchIds: [] };
-    const wrapResult = (actions, repair, degraded = false) => ({
+    const wrapResult = (actions, repair, degraded = false, blocked, blockedReason) => ({
         actions,
         sessionId: session?.sessionId || "",
         ruleHash: session?.ruleHash,
@@ -466,6 +547,8 @@ async function plan(userIntent, llmSeeds) {
         repairApplied: repair?.applied ?? repairMetrics.applied,
         repairCount: repair?.count ?? repairMetrics.count,
         repairBranchIds: repair?.branchIds ?? repairMetrics.branchIds,
+        blocked,
+        blockedReason,
     });
     // 初始化执行会话和快照（需在抗体快速通道前创建，以便记录 antibody hits）
     const sessionId = (0, runtime_types_1.generateSessionId)();
@@ -963,15 +1046,19 @@ ${planner_prompts_1.RETRY_HINT}
             }
         }
         // 1) 基础序列校验
+        // 预检查的协议违规（"需要先调用 X"）不属于符号/类型错误——
+        // 它们由下方 SSG 块以 SVL-4 处理（含确定性修复）。
+        // 只有符号/类型类错误走本回退分支，避免把 SVL-4 误标为 SVL-1。
+        const preCheckSymbolErrors = preCheckErrors.filter(e => e.includes("函数不存在") || e.includes("参数数量"));
         const seqResult = (0, validator_1.validateActionSequence)(filtered);
-        if (!seqResult.valid || preCheckErrors.length > 0) {
-            const errorsFlat = [...preCheckErrors, ...seqResult.errors.flat()];
+        if (!seqResult.valid || preCheckSymbolErrors.length > 0) {
+            const errorsFlat = [...preCheckSymbolErrors, ...seqResult.errors.flat()];
             console.error("⚠️ 序列校验失败:", errorsFlat.join(", "));
             // Use structured violations directly from validator
             const violations = seqResult.violations.length > 0
                 ? seqResult.violations
-                : preCheckErrors.length > 0
-                    ? [{ svl: 1, violatedConstraint: "symbol_existence", actionIndex: 0, description: preCheckErrors.join("; ") }]
+                : preCheckSymbolErrors.length > 0
+                    ? [{ svl: 1, violatedConstraint: "symbol_existence", actionIndex: 0, description: preCheckSymbolErrors.join("; ") }]
                     : [{ svl: 1, violatedConstraint: "symbol_existence", actionIndex: 0, description: errorsFlat.join("; ") }];
             const primarySvl = `SVL-${violations[0].svl}`;
             const attempt = {
@@ -1004,8 +1091,8 @@ ${planner_prompts_1.RETRY_HINT}
             });
             (0, memory_layer_1.recordEpisode)({ intent: userIntent, actions: filtered, success: false, svlViolated: primarySvl });
             // Build targeted retry prompt based on pre-check results
-            const specificErrors = preCheckErrors.length > 0
-                ? `精确错误:\n${preCheckErrors.map(e => `  - ${e}`).join("\n")}`
+            const specificErrors = preCheckSymbolErrors.length > 0
+                ? `精确错误:\n${preCheckSymbolErrors.map(e => `  - ${e}`).join("\n")}`
                 : `错误：${errorsFlat.join("；")}`;
             currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}${antibodyHint}\n\n${specificErrors}\n请修正上述问题。\n${planner_prompts_1.RETRY_HINT}\n只输出 JSON。`;
             useSystem = false;
@@ -1017,6 +1104,13 @@ ${planner_prompts_1.RETRY_HINT}
             const protoResult = validateProtocolWithTransitions(filtered, protocols, namespaceInitialStates);
             if (!protoResult.valid && protoResult.rejection) {
                 const rej = protoResult.rejection;
+                // P3：fixPath / missingFunctions 归一化到 IR 真实函数名——
+                // 内置规则是下划线风格（generate_jwt），项目 IR 是 camelCase
+                // （generateJwt）。提示与记录使用项目里真实存在的名字。
+                const normIRName = (n) => ir.find((f) => f.name === n)
+                    || ir.find((f) => f.name.replace(/[_-]/g, "").toLowerCase() === n.replace(/[_-]/g, "").toLowerCase());
+                rej.fixPath = (rej.fixPath || []).map(n => normIRName(n)?.name || n);
+                rej.missingFunctions = (rej.missingFunctions || []).map(n => normIRName(n)?.name || n);
                 const explain = (0, ssg_validator_1.explainRejection)(rej);
                 console.error(explain);
                 const violation = {
@@ -1290,6 +1384,16 @@ ${planner_prompts_1.RETRY_HINT}
         session.endedAt = Date.now();
         (0, failure_corpus_1.recordSession)(session);
         (0, failure_corpus_1.clearCheckpoint)(userIntent);
+        // 显式失败信号：所有尝试（含本地回退）都被约束拦截——
+        // 调用方必须能区分"无事可做"与"被拦截"。
+        const lastViolation = session.attempts.length > 0
+            ? session.attempts[session.attempts.length - 1].violations[0]
+            : undefined;
+        const reason = lastViolation
+            ? `所有生成尝试均被 SVL-${lastViolation.svl} 拦截: ${lastViolation.violatedConstraint}${lastViolation.fixPath?.length ? `（修复路径: ${lastViolation.fixPath.join(" → ")}）` : ""}`
+            : "所有生成尝试均被约束拦截，本地回退亦失败";
+        console.error(`[拦截] ${reason}`);
+        return wrapResult([], undefined, true, true, reason);
     }
     return wrapResult(finalActions);
 }

package/dist/validator.js

@@ -86,7 +86,17 @@ function checkVariableFlow(actions) {
     };
     const processAction = (action) => {
         if (action.kind === "call") {
-            // call 动作的参数值来自结构化 {name, type, value}，都是字面量，不做变量引用检查
+            // call 参数值若是变量引用（$ 前缀，或 planner 剥离 $ 后的裸标识符），
+            // 必须已声明——白皮书 SVL-3："变量先声明后使用"。
+            for (const arg of action.args || []) {
+                const val = arg?.value;
+                if (typeof val !== "string")
+                    continue;
+                const bare = val.startsWith("$") ? val.slice(1) : val;
+                if (bare && !isLiteral(bare) && /^[a-zA-Z_]\w*$/.test(bare) && !declared.has(bare)) {
+                    errors.push(`变量 '${bare}' 在使用前未声明 (call 参数 '${arg.name || "?"}')`);
+                }
+            }
             if (action.assignTo) {
                 declared.set(action.assignTo, "any");
             }

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

@@ -465,6 +465,8 @@ AI 生成: create_session(...)   ← 当前状态 UNAUTHENTICATED
   <ul>
     <li><strong>22 个协议检测器</strong>：TLS 握手、SSH 连接、HTTP 请求、支付处理、会话管理、文件上传、注册流程等</li>
     <li><strong>26 条防护规则（safeguard）</strong>：触发式检查——"如果出现了 X，就必须有 Y"。例：注册函数必须调用安全哈希（bcrypt/argon2）；管理操作必须检查角色；tRPC mutation 必须有 <code>.input()</code> 校验 schema</li>
+    <li><strong>15 条源码级检测规则（Python，2026-08 上线）</strong>：SQL 注入（f-string/%/.format/拼接，参数化写法正确放行）、SSRF（限定接收者的 HTTP 抓取 + request 污点追踪）、路径穿越（文件 sink + 污点）、XSS（跨文件：模板 <code>{{ var|safe }}</code> × 污点上下文绑定）、SSTI、XXE（解析器配置 + 污点双信号）、命令注入（仅动态命令参数）、反序列化、CSRF 双形态（<code>@csrf_exempt</code> / GET 状态变更）、eval 代码执行、硬编码 JWT 密钥（含跨模块常量）、cookie 授权、可预测重置令牌</li>
+    <li><strong>提取器标记架构</strong>：IR 提取器做源码级分析（污点追踪、import 解析、限定调用链、模板扫描、跨模块常量表）→ 合成标记 → 规则消费。零管道改动、完全可审计，已同步移植到 TS（ts-morph）提取器</li>
   </ul>
 
   <h3>5.4 API 语义映射：让检查认识"陌生函数"</h3>
@@ -501,12 +503,15 @@ AI 生成: create_session(...)   ← 当前状态 UNAUTHENTICATED
   <h3>5.7 基准测试：用数据证明能力</h3>
   <table>
     <tr><th>基准</th><th>方法</th><th>结果</th></tr>
-    <tr><td><strong>盲测基准</strong>（TypeScript）</td><td>10 个真实项目、432 个序列、gold 标注</td><td>精确率 <strong>86.8%</strong> · 召回率 <strong>83.6%</strong> · F1 <strong>85.2%</strong></td></tr>
+    <tr><td><strong>盲测基准</strong>（TypeScript，100 项目）</td><td>90 个合成风格变体 + 10 个模型变体项目、795 条 gold finding、严格定位匹配</td><td>精确率 <strong>100%</strong> · 召回率 <strong>98.5%</strong>（有效口径 100%）· 事实性误报 <strong>0</strong></td></tr>
+    <tr><td><strong>盲测基准</strong>（Python，90 项目）</td><td>90 个合成风格变体、729 条 gold finding</td><td>精确率 <strong>100%</strong> · 召回率 <strong>100%</strong> · 事实性误报 <strong>0</strong></td></tr>
+    <tr><td><strong>真实应用验证</strong>（PyGoat）</td><td>OWASP 故意脆弱 Django 应用、232 条检测逐条人工核实</td><td>标记精确率 <strong>100%</strong>（67 真阳性 / 0 误报）；覆盖 14 个漏洞类别</td></tr>
+    <tr><td><strong>良构应用</strong>（django/fastapi realworld、django-unicorn）</td><td>176 条检测</td><td>0 条误报真阳性；3 条框架内部边界 FP（已定性归档）</td></tr>
     <tr><td><strong>黄金基准</strong>（C 语言）</td><td>curl/libssh/nginx/openssl 等真实 CVE 案例</td><td>F1 16.5% —— <strong>研究阶段</strong>，诚实披露</td></tr>
     <tr><td><strong>PLSB v1.0</strong></td><td>13 类协议安全弱点、39 个手工验证缺陷案例</td><td>覆盖 <strong>13/13 全类别</strong>（业界唯一）</td></tr>
   </table>
   <div class="plain">
-    <strong>为什么披露 C 语言的低分？</strong>因为"诚实"是产品原则。一个只报告好消息的基准没有参考价值。TS 已生产可用、Python 规则开发中、C 为研究课题——能力边界清清楚楚。
+    <strong>为什么披露 C 语言的低分？</strong>因为"诚实"是产品原则。一个只报告好消息的基准没有参考价值。TS 与 Python 已生产可用、C 为研究课题——能力边界清清楚楚。所有基准均有 gold 标注文件入库，可复现。
   </div>
 </section>
 
@@ -528,21 +533,21 @@ AI 生成: create_session(...)   ← 当前状态 UNAUTHENTICATED
   <h3>6.2 语言与框架覆盖（诚实版）</h3>
   <table>
     <tr><th>能力</th><th>状态</th><th>说明</th></tr>
-    <tr><td>TypeScript / JavaScript</td><td><span style="color:var(--green);font-weight:700">✅ 生产</span></td><td>F1 85.2%，主战场</td></tr>
-    <tr><td>Python</td><td><span style="color:var(--amber);font-weight:700">⚠️ IR 就绪</span></td><td>代码提取可用，协议规则开发中（下一阶段优先）</td></tr>
+    <tr><td>TypeScript / JavaScript</td><td><span style="color:var(--green);font-weight:700">✅ 生产</span></td><td>盲测 100 项目：精确率 100%、召回率 98.5%</td></tr>
+    <tr><td>Python</td><td><span style="color:var(--green);font-weight:700">✅ 生产</span></td><td>盲测 90 项目：精确率/召回率双 100%；15 条源码级检测规则；PyGoat 真实验证 67 TP / 0 FP</td></tr>
     <tr><td>C</td><td><span style="color:var(--amber);font-weight:700">⚠️ 研究</span></td><td>F1 16.5%，瓶颈已定位（规则覆盖），L3 实验已终止</td></tr>
     <tr><td>Go / Java</td><td><span style="color:var(--ink-3)">❌ 未支持</span></td><td>路线图内</td></tr>
-    <tr><td>框架适配</td><td><span style="color:var(--amber);font-weight:700">2/13</span></td><td>Express ✅、tRPC ✅、NestJS 部分；Next.js 版本感知已实现</td></tr>
+    <tr><td>框架适配</td><td><span style="color:var(--amber);font-weight:700">2/13</span></td><td>Express ✅、tRPC ✅、NestJS 部分；Next.js 版本感知已实现；Django/FastAPI 经 Python 源码级检测间接覆盖</td></tr>
   </table>
 
   <h3>6.3 知识库规模</h3>
   <div class="stats">
     <div class="stat"><div class="n">148</div><div class="l">协议规则</div></div>
     <div class="stat"><div class="n">21</div><div class="l">协议命名空间全覆盖</div></div>
-    <div class="stat"><div class="n">22+26</div><div class="l">检测器 + 防护规则</div></div>
+    <div class="stat"><div class="n">22+26+15</div><div class="l">检测器 + 防护 + 源码级规则</div></div>
     <div class="stat"><div class="n">39</div><div class="l">黄金缺陷案例（人工验证）</div></div>
-    <div class="stat"><div class="n">19</div><div class="l">MCP 工具</div></div>
-    <div class="stat"><div class="n">71</div><div class="l">单元测试全部通过</div></div>
+    <div class="stat"><div class="n">190</div><div class="l">盲测项目（TS 100 + Python 90）</div></div>
+    <div class="stat"><div class="n">4</div><div class="l">真实应用验证仓库</div></div>
   </div>
 </section>
 
@@ -655,7 +660,7 @@ AI 生成: create_session(...)   ← 当前状态 UNAUTHENTICATED
     <tr><th>风险</th><th>等级</th><th>内容</th><th>缓解措施</th></tr>
     <tr><td><strong>市场教育成本</strong></td><td><span style="color:var(--red);font-weight:700">高</span></td><td>多数企业尚未意识到"AI 代码需要验证"这个问题本身</td><td>公开缺陷基准库、从受监管行业切入、开源社区自然教育</td></tr>
     <tr><td><strong>大厂竞争</strong></td><td><span style="color:var(--amber);font-weight:700">中</span></td><td>GitHub/Microsoft 可能内置类似功能</td><td>聚焦"验证层"差异化；大厂内置方案通常浅层；开源先发</td></tr>
-    <tr><td><strong>验证的边界性</strong></td><td><span style="color:var(--amber);font-weight:700">中</span></td><td>当前仅 TS 生产可用；协议规则不可能覆盖所有场景——存在漏检的可能</td><td>诚实披露置信度；数据飞轮持续补规则；规则来自真实 CVE 案例</td></tr>
+    <tr><td><strong>验证的边界性</strong></td><td><span style="color:var(--amber);font-weight:700">中</span></td><td>TS 与 Python 已生产可用；协议规则不可能覆盖所有场景——存在漏检的可能</td><td>诚实披露置信度；数据飞轮持续补规则；规则来自真实 CVE 案例</td></tr>
     <tr><td><strong>LLM 依赖</strong></td><td><span style="color:var(--green);font-weight:700">低</span></td><td>代码生成环节依赖底层模型能力</td><td>架构上模型无关；验证器本身不依赖任何 LLM；模型越强产品越有价值</td></tr>
     <tr><td><strong>商业化节奏</strong></td><td><span style="color:var(--amber);font-weight:700">中</span></td><td>开源到付费的转化路径需要时间验证；尚无企业 PoC</td><td>GitLab/Databricks 模式已成熟；优先做 2-3 个企业 PoC 验证 PMF</td></tr>
     <tr><td><strong>核心假说未验证</strong></td><td><span style="color:var(--amber);font-weight:700">中</span></td><td>"每个新代码库让所有验证更强"的知识网络假说尚无实证</td><td>以 Phase 2 的 PoC 数据为准；假说不成立也不影响单点验证的产品价值</td></tr>
@@ -672,9 +677,9 @@ AI 生成: create_session(...)   ← 当前状态 UNAUTHENTICATED
 
   <table>
     <tr><th>阶段</th><th>时间</th><th>目标</th><th>关键交付</th></tr>
-    <tr><td><strong>当前</strong></td><td>2026-08</td><td>Trust Foundation 完成</td><td>信任引擎 ✅、策略引擎 ✅、PLSB 13/13 ✅、tRPC/Express 适配 ✅、PrintLab 案例 ✅</td></tr>
+    <tr><td><strong>当前</strong></td><td>2026-08</td><td>Trust Foundation + 语言扩展完成</td><td>信任引擎 ✅、策略引擎 ✅、PLSB 13/13 ✅、tRPC/Express 适配 ✅、PrintLab 案例 ✅、<strong>Python 生产级 ✅（盲测双 100%、PyGoat 真实验证 0 误报）✅、15 条源码级检测规则 ✅、TS/Python 盲测 precision 100% ✅</strong></td></tr>
     <tr><td><strong>Phase 1 收官</strong></td><td>2026 Q3</td><td>可信度校准</td><td>已知风险项目上的 Score 校准、真实项目验收、Trust Report PDF</td></tr>
-    <tr><td><strong>Phase 2</strong></td><td>2026 Q4</td><td>语言扩展 + 企业验证</td><td>Python 完整支持、企业 PoC × 2-3、Evolution 追踪、CI/CD 门禁集成</td></tr>
+    <tr><td><strong>Phase 2</strong></td><td>2026 Q4</td><td>企业验证</td><td>企业 PoC × 2-3、Evolution 追踪、CI/CD 门禁集成、良构应用框架内部 FP 收尾（类属性建模）</td></tr>
     <tr><td><strong>Phase 3</strong></td><td>2027+</td><td>平台化</td><td>Go/Java、SaaS 仪表盘、公开基准排行榜、全球免疫网络、协议模板市场</td></tr>
   </table>
 </section>
@@ -694,7 +699,7 @@ AI 生成: create_session(...)   ← 当前状态 UNAUTHENTICATED
   <h3>为什么需要谨慎</h3>
   <ol>
     <li>企业 PoC 为零——PMF 未验证，商业化路径尚需数据</li>
-    <li>语言覆盖有限（当前仅 TS 生产可用）</li>
+    <li>语言覆盖有限（TS/Python 生产可用，Go/Java 未支持）</li>
     <li>"信任"类产品教育成本高，销售周期长</li>
     <li>大厂随时可能跟进（但架构先发 + 数据积累构成时间壁垒）</li>
   </ol>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "progmune-runtime",
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "Progmune — AI Trust Decision Engine. Verify AI-generated code before it reaches production. Outputs APPROVED / NEEDS_REVIEW / BLOCKED with evidence.",
   "files": [
     "dist/",
@@ -16,15 +16,15 @@
     "prepare": "npm run build",
     "build": "tsc -p tsconfig.json && tsc -p tsconfig.mcp.json && mv dist-mcp/mcp-server.js dist/mcp-server.mjs && rm -rf dist-mcp",
     "start": "node dist/mcp-server.mjs",
-    "test": "node dist/mcp-server.mjs test",
+    "test": "node dist/check.js",
     "test:unit": "vitest run --exclude '**/stress/**' --exclude '**/soak/**' --exclude '**/chaos/**'",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "ir": "npx ts-node src/extract-ir.ts .",
+    "ir": "node dist/extract-ir.js .",
     "guard": "node -e \"require('./dist/validator.js'); console.log('✅ 校验器已加载')\"",
     "obs": "npx ts-node src/semantic-trace.ts",
     "obs-web": "npx ts-node src/obs-web.ts",
-    "check": "npx ts-node src/check.ts",
+    "check": "node dist/check.js",
     "audit": "npx ts-node src/audit.ts",
     "governance": "npx ts-node src/audit/cli.ts --all",
     "governance:json": "npx ts-node src/audit/cli.ts --all --json",