progmune-runtime 3.3.8 → 3.4.1

package/dist/agent-supervision.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Phase 12: Agent 自监督层 (P3)
+ *
+ * 运行项目测试并提取失败信息 —— 失败注入下一次尝试的 prompt（失败→prompt 回路）。
+ * 设计文档 P3：编译/测试失败反馈注入重试。
+ *
+ * 自动探测顺序：
+ *   1. package.json 有 "test" script → npm test --silent
+ *   2. 存在 .py 文件 → python3 -m pytest -q
+ *   3. 都没有 → { ran: false }（调用方跳过该门）
+ */
+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.runProjectTests = runProjectTests;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+// ── Helpers ──
+const FAILURE_PATTERN = /(FAIL|✕|×|failed|Error:|error TS|AssertionError|FAILED)/i;
+function extractFailures(output) {
+    return output
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0 && FAILURE_PATTERN.test(l))
+        .slice(0, 10);
+}
+function runCommand(cwd, command, timeoutMs) {
+    try {
+        const output = (0, child_process_1.execSync)(command, {
+            cwd,
+            timeout: timeoutMs,
+            encoding: "utf-8",
+            stdio: "pipe",
+        });
+        return { pass: true, output };
+    }
+    catch (e) {
+        // 非零退出或超时 → 捕获输出
+        const output = `${e.stdout || ""}\n${e.stderr || ""}`;
+        return { pass: false, output, error: e?.message || String(e) };
+    }
+}
+// ── Main ──
+/**
+ * 自动探测并运行项目测试。
+ *
+ * @requires PROJECT_PATH @produces TEST_RESULT
+ */
+function runProjectTests(projectPath, timeoutMs = 60000) {
+    // 1) npm test
+    const pkgPath = path.join(projectPath, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            if (pkg.scripts?.test) {
+                const command = "npm test --silent";
+                const r = runCommand(projectPath, command, timeoutMs);
+                return {
+                    ran: true,
+                    pass: r.pass,
+                    failures: extractFailures(r.output),
+                    command,
+                    error: r.error,
+                };
+            }
+        }
+        catch { /* package.json 解析失败 → 继续探测 */ }
+    }
+    // 2) pytest
+    const hasPy = listQuickly(projectPath, (e) => e.endsWith(".py"));
+    if (hasPy) {
+        const command = "python3 -m pytest -q";
+        const r = runCommand(projectPath, command, timeoutMs);
+        if (r.error && /no module named pytest/i.test(r.error + r.output)) {
+            return { ran: false, pass: true, failures: [], command, error: "pytest 未安装" };
+        }
+        return {
+            ran: true,
+            pass: r.pass,
+            failures: extractFailures(r.output),
+            command,
+            error: r.error,
+        };
+    }
+    return { ran: false, pass: true, failures: [], command: "(无测试脚本)" };
+}
+/** 浅层探测是否存在匹配文件（不递归依赖目录）。 */
+function listQuickly(projectPath, match) {
+    const SKIP = new Set(["node_modules", "dist", "build", ".git", "__pycache__", "venv", ".venv"]);
+    const stack = [projectPath];
+    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) {
+            if (e.isFile() && match(e.name))
+                return true;
+            if (e.isDirectory() && !SKIP.has(e.name) && !e.name.startsWith("."))
+                stack.push(path.join(dir, e.name));
+        }
+    }
+    return false;
+}

package/dist/agent-supervision.test.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Phase 12: 自监督层测试 (P3)
+ *
+ * runProjectTests 的探测逻辑与失败提取。全部 mock，不跑真实测试。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const child_process_1 = require("child_process");
+const agent_supervision_1 = require("./agent-supervision");
+vitest_1.vi.mock("child_process", () => ({
+    execSync: vitest_1.vi.fn(),
+}));
+const mockExecSync = vitest_1.vi.mocked(child_process_1.execSync);
+(0, vitest_1.beforeEach)(() => {
+    vitest_1.vi.clearAllMocks();
+});
+(0, vitest_1.describe)("agent-supervision", () => {
+    (0, vitest_1.it)("package.json 有 test script → npm test，失败时提取失败行", () => {
+        mockExecSync.mockImplementation(() => {
+            const err = new Error("Command failed");
+            err.stdout = "FAIL src/auth.test.ts\nAssertionError: token 无效\n  12 passing\n  1 failing\n";
+            err.stderr = "";
+            throw err;
+        });
+        // 真实 npm 项目路径下才能探测到 package.json —— 用临时脚本验证探测逻辑
+        const fs = require("fs");
+        const os = require("os");
+        const path = require("path");
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-test-"));
+        fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ scripts: { test: "vitest run" } }));
+        const r = (0, agent_supervision_1.runProjectTests)(dir, 5000);
+        (0, vitest_1.expect)(r.ran).toBe(true);
+        (0, vitest_1.expect)(r.pass).toBe(false);
+        (0, vitest_1.expect)(r.failures.length).toBeGreaterThan(0);
+        (0, vitest_1.expect)(r.failures.join(" ")).toContain("token 无效");
+        (0, vitest_1.expect)(r.command).toBe("npm test --silent");
+    });
+    (0, vitest_1.it)("测试通过时 pass=true 且 failures 为空", () => {
+        mockExecSync.mockReturnValue(" 12 passing (3s)");
+        const fs = require("fs");
+        const os = require("os");
+        const path = require("path");
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-test2-"));
+        fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ scripts: { test: "vitest run" } }));
+        const r = (0, agent_supervision_1.runProjectTests)(dir, 5000);
+        (0, vitest_1.expect)(r.ran).toBe(true);
+        (0, vitest_1.expect)(r.pass).toBe(true);
+        (0, vitest_1.expect)(r.failures).toHaveLength(0);
+    });
+    (0, vitest_1.it)("无测试脚本且无 python 文件 → ran=false（调用方跳过该门）", () => {
+        const fs = require("fs");
+        const os = require("os");
+        const path = require("path");
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-test3-"));
+        const r = (0, agent_supervision_1.runProjectTests)(dir, 5000);
+        (0, vitest_1.expect)(r.ran).toBe(false);
+        (0, vitest_1.expect)(mockExecSync).not.toHaveBeenCalled();
+    });
+});

package/dist/audit.js

@@ -66,7 +66,11 @@ function auditDirectory(dir, threshold = DEFAULT_THRESHOLD) {
     if (!stat.isDirectory()) {
         return result;
     }
-    scanDir(dir, dir, result);
+    // Allowlist（.progmune_allowlist）：豁免名单中的文件不参与覆盖率分母——
+    // 祖父条款：存量手写代码一次入册，新文件仍受覆盖要求约束。
+    // 匹配相对 allowlist 所在目录（通常为项目根），而非被扫描目录。
+    const allowlist = loadAllowlist(dir);
+    scanDir(dir, dir, result, allowlist);
     result.coverage = result.totalFiles > 0
         ? result.progmuneFiles / result.totalFiles
         : 0;
@@ -84,7 +88,46 @@ function auditDirectory(dir, threshold = DEFAULT_THRESHOLD) {
 }
 const MARKER_REGEX = /@progmune-generated\s+session=(\S+)(?:\s+timestamp=(\S+))?(?:\s+ruleHash=(\S+))?/;
 const EXCLUDED_DIRS = new Set(["node_modules", ".git", "dist", ".progmune_corpus", ".progmune_memory"]);
-function scanDir(rootDir, currentDir, result) {
+/** 读取 .progmune_allowlist：从被扫描目录向上查找，返回匹配函数（相对 allowlist 所在目录）。 */
+function loadAllowlist(dir) {
+    let root = dir;
+    let allowlistPath = "";
+    for (let i = 0; i < 4; i++) {
+        const p = path.join(root, ".progmune_allowlist");
+        if (fs.existsSync(p)) {
+            allowlistPath = p;
+            break;
+        }
+        const parent = path.dirname(root);
+        if (parent === root)
+            break;
+        root = parent;
+    }
+    if (!allowlistPath)
+        return { root: dir, match: () => false };
+    try {
+        const patterns = fs.readFileSync(allowlistPath, "utf-8")
+            .split("\n")
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0 && !l.startsWith("#"));
+        return {
+            root: path.dirname(allowlistPath),
+            match: (relPath) => {
+                const normalized = relPath.replace(/\\/g, "/");
+                return patterns.some((p) => {
+                    const pat = p.replace(/^\.\//, ""); // 兼容 "./foo.ts" 写法
+                    if (pat.endsWith("*"))
+                        return normalized.startsWith(pat.slice(0, -1));
+                    return normalized === pat || normalized.startsWith(pat.replace(/\/$/, "") + "/");
+                });
+            },
+        };
+    }
+    catch {
+        return { root: dir, match: () => false };
+    }
+}
+function scanDir(rootDir, currentDir, result, allowlist) {
     let entries;
     try {
         entries = fs.readdirSync(currentDir, { withFileTypes: true });
@@ -96,7 +139,7 @@ function scanDir(rootDir, currentDir, result) {
         const fullPath = path.join(currentDir, entry.name);
         if (entry.isDirectory()) {
             if (!EXCLUDED_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
-                scanDir(rootDir, fullPath, result);
+                scanDir(rootDir, fullPath, result, allowlist);
             }
             continue;
         }
@@ -104,6 +147,10 @@ function scanDir(rootDir, currentDir, result) {
         if (!entry.name.endsWith(".ts") && !entry.name.endsWith(".tsx") && !entry.name.endsWith(".mjs")) {
             continue;
         }
+        // 豁免名单（祖父条款）：不在覆盖率分母内——相对 allowlist 根匹配
+        const rel = path.relative(allowlist.root, fullPath);
+        if (allowlist.match(rel))
+            continue;
         result.totalFiles++;
         try {
             const content = fs.readFileSync(fullPath, "utf-8");

package/dist/check.js

@@ -117,10 +117,16 @@ if (cliArg === "--ledger") {
     const rebuilt = (0, ssg_validator_1.rebuildState)(allTransitions, nsInit);
     const lastTransition = allTransitions[allTransitions.length - 1];
     const recorded = lastTransition.statesAfter;
-    const allNs = new Set([...Object.keys(rebuilt), ...Object.keys(recorded)]);
+    // 与 checkLedgerConsistency 同规则：只比较 recorded 中有过非空快照的 ns——
+    // 早期 session 对 file/db 等记录空数组（无信息），不参与比较。
+    const informativeNs = new Set();
+    for (const [ns, s] of Object.entries(recorded)) {
+        if ((s || []).length > 0)
+            informativeNs.add(ns);
+    }
     const norm = (snap) => {
         const out = {};
-        for (const ns of [...allNs].sort())
+        for (const ns of [...informativeNs].sort())
             out[ns] = [...(snap[ns] || [])].sort();
         return out;
     };
@@ -307,6 +313,35 @@ else {
     }
 }
 // ── 4. Ledger 不变量检查 (Phase 3) ──
+/**
+ * 历史约定兼容：早期 session 以 "INIT" 作为 _global 初始状态
+ * （当前约定 UNAUTHENTICATED；当前 148 条协议规则已不含 INIT 状态）。
+ * 返回规范化视图（仅比较用，不改盘）与受影响转移数。
+ */
+function normalizeLegacyInit(transitions, nsInit) {
+    let migrated = 0;
+    const view = transitions.map((t) => {
+        const normSnap = (snap) => {
+            const out = {};
+            let changed = false;
+            for (const [ns, states] of Object.entries(snap)) {
+                const currentInit = nsInit.get(ns);
+                if (currentInit && currentInit !== "INIT" && states.length === 1 && states[0] === "INIT") {
+                    out[ns] = [currentInit];
+                    changed = true;
+                }
+                else {
+                    out[ns] = [...states];
+                }
+            }
+            if (changed)
+                migrated++;
+            return out;
+        };
+        return { ...t, statesBefore: normSnap(t.statesBefore), statesAfter: normSnap(t.statesAfter) };
+    });
+    return { view, migrated };
+}
 step("4/6 Ledger 不变量");
 {
     // Load namespace initial states from protocols.json for correct replay
@@ -314,6 +349,7 @@ step("4/6 Ledger 不变量");
     let checked = 0;
     let consistent = 0;
     let stateMatch = 0;
+    let legacyInitMigrations = 0;
     const allLedgers = [];
     const violationsDetail = [];
     const replayMismatchDetail = [];
@@ -335,9 +371,15 @@ step("4/6 Ledger 不变量");
                     const transitions = attempt.transitions || [];
                     if (transitions.length === 0)
                         continue;
-                    allLedgers.push(...transitions);
+                    // 历史约定兼容：早期 session 以 "INIT" 作为 _global 初始状态
+                    // （当前约定 UNAUTHENTICATED；当前协议规则已不含 INIT）。
+                    // 规范化视图只用于比较，不改盘。
+                    const { view, migrated } = normalizeLegacyInit(transitions, nsInit);
+                    if (migrated > 0)
+                        legacyInitMigrations++;
+                    allLedgers.push(...view);
                     // Invariant check
-                    const result = (0, ssg_validator_1.checkLedgerConsistency)(transitions, nsInit);
+                    const result = (0, ssg_validator_1.checkLedgerConsistency)(view, nsInit);
                     checked++;
                     if (result.consistent) {
                         consistent++;
@@ -348,10 +390,16 @@ step("4/6 Ledger 不变量");
                         }
                     }
                     // Replay check: rebuildState === recorded statesAfter
-                    const rebuilt = (0, ssg_validator_1.rebuildState)(transitions, nsInit);
-                    const recorded = transitions[transitions.length - 1].statesAfter;
-                    const allNs = new Set([...Object.keys(rebuilt), ...Object.keys(recorded)]);
-                    if (JSON.stringify(norm(rebuilt, allNs)) === JSON.stringify(norm(recorded, allNs))) {
+                    // 只比较 recorded 中有过非空快照的 ns（早期 session 对部分 ns
+                    // 记录空数组，不携带可比较的状态信息）
+                    const rebuilt = (0, ssg_validator_1.rebuildState)(view, nsInit);
+                    const recorded = view[view.length - 1].statesAfter;
+                    const informativeNs = new Set();
+                    for (const [ns, s] of Object.entries(recorded)) {
+                        if ((s || []).length > 0)
+                            informativeNs.add(ns);
+                    }
+                    if (JSON.stringify(norm(rebuilt, informativeNs)) === JSON.stringify(norm(recorded, informativeNs))) {
                         stateMatch++;
                     }
                     else {
@@ -368,6 +416,9 @@ step("4/6 Ledger 不变量");
     else if (consistent === checked && stateMatch === checked) {
         const combinedHash = (0, ssg_validator_1.hashLedger)(allLedgers);
         pass(`全部 ${checked} 个 Ledger 通过 (Invariant-0 + Invariant-1 + Replay) | 完整性指纹: ${combinedHash}`);
+        if (legacyInitMigrations > 0) {
+            warn(`历史约定兼容：${legacyInitMigrations} 条转移的初始状态 INIT 已按当前约定（${nsInit.get("_global")}）规范化比较（不改盘）`);
+        }
     }
     else {
         if (consistent < checked) {
@@ -404,7 +455,9 @@ step("4/6 Ledger 不变量");
                     if (transitions.length === 0)
                         continue;
                     try {
-                        (0, runtime_invariants_1.assertLedgerInvariants)(transitions, nsInit);
+                        // 历史约定兼容：与主检查一致，先规范化旧 INIT 初值
+                        const { view } = normalizeLegacyInit(transitions, nsInit);
+                        (0, runtime_invariants_1.assertLedgerInvariants)(view, nsInit);
                     }
                     catch (e) {
                         if (e instanceof runtime_invariants_1.InvariantViolationError) {

package/dist/execute.js

@@ -225,6 +225,10 @@ async function execute(intent, projectPath, filePath) {
 /** @requires FILE_PATH @produces COMPILE_RESULT */
 /** @requires FILE_PATH @produces COMPILE_RESULT */
 function verifyCompiles(filePath) {
+    // tsc 报错行以「相对 tsconfig 的文件路径」开头（如 `login_flow.ts(7,13):`），
+    // 而调用方可能传绝对路径——两种形态都要匹配，否则编译门会静默漏报。
+    const base = path.basename(filePath);
+    const isMatch = (l) => l.includes(filePath) || l.startsWith(base + "(") || l.startsWith(base + ":");
     try {
         const { execSync } = require("child_process");
         const result = execSync(`npx tsc --noEmit --project tsconfig.json --pretty false 2>&1`, {
@@ -233,13 +237,13 @@ function verifyCompiles(filePath) {
             stdio: "pipe",
         });
         // tsc exits 0, check if our file is mentioned in output anyway (unlikely but safe)
-        const lines = result.split("\n").filter((l) => l.includes(filePath));
+        const lines = result.split("\n").filter(isMatch);
         return { pass: lines.length === 0, errors: lines };
     }
     catch (e) {
         // tsc exits non-zero — parse stderr/stdout for our file's errors
         const output = (e.stdout || "") + (e.stderr || "");
-        const lines = output.split("\n").filter((l) => l.includes(filePath));
+        const lines = output.split("\n").filter(isMatch);
         return { pass: lines.length === 0, errors: lines };
     }
 }

package/dist/extract-ir.js

@@ -121,8 +121,10 @@ function parseProtocolFromJSDoc(node) {
                 const preMatch = text.match(/pre_states\s*=\s*\[([^\]]*)\]/);
                 const postMatch = text.match(/post_states\s*=\s*\[([^\]]*)\]/);
                 const invMatch = text.match(/invalidate\s*=\s*\[([^\]]*)\]/);
+                // 非规则注解（如文件头文档正文中的 "@protocol" 字样被 ts-morph 解析为 tag）
+                // → 跳过继续找下一个 @protocol tag，而不是直接放弃
                 if (!preMatch || !postMatch)
-                    return undefined;
+                    continue;
                 const namespace = nsMatch ? nsMatch[1] : undefined;
                 const pre_states = preMatch[1].split(',').map((s) => s.trim().replace(/["']/g, '')).filter(Boolean);
                 const post_states = postMatch[1].split(',').map((s) => s.trim().replace(/["']/g, '')).filter(Boolean);

package/dist/patrol-cli.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Phase 12: Progmune 免疫巡逻 CLI — `progmune patrol`（形态 B 第一版）
+ *
+ * 扫描项目 → trust_check → 违规报告 + 建议补丁（绝不自动合并）。
+ * 支持 --watch 持续监听（文件变更 → 防抖 → 重新巡逻 → 刷新报告）。
+ *
+ * Usage:
+ *   npx ts-node src/patrol-cli.ts --project <dir> [options]
+ *   npm run patrol -- --project <dir> [options]
+ *
+ * Options:
+ *   --project <dir>   目标项目目录（默认 CWD）
+ *   --watch           持续监听模式（文件变更后自动重扫）
+ *   --json            JSON 输出（单次扫描）
+ *   --help, -h
+ */
+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 path = __importStar(require("path"));
+const agent_patrol_1 = require("./agent-patrol");
+const agent_perception_1 = require("./agent-perception");
+const agent_permissions_1 = require("./agent-permissions");
+// 在 chdir 到项目目录之前按启动 CWD 加载 .env——
+// trust 引擎内部的 lazy require（语义映射 LLM 回退）发生在 chdir 之后，
+// 若不预载，LLM_API_KEY 不可用，映射降级会导致漏报。
+try {
+    require("dotenv/config");
+}
+catch { /* dotenv 可选 */ }
+const args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Progmune 免疫巡逻 (P4) — 监听/扫描 → trust_check → 报告 + 建议补丁（永不自动合并）
+
+Usage:
+  npx ts-node src/patrol-cli.ts --project <dir> [options]
+  npm run patrol -- --project <dir> [options]
+
+Options:
+  --project <dir>   目标项目目录（默认当前目录）
+  --watch           持续监听模式（源文件变更后自动重扫并刷新报告）
+  --json            JSON 输出（单次扫描）
+  --help, -h        显示帮助
+
+Example:
+  npm run patrol -- --project demo-patrol
+  npm run patrol -- --project demo-patrol --watch
+`);
+    process.exit(0);
+}
+const getFlag = (name) => {
+    const idx = args.indexOf(`--${name}`);
+    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : undefined;
+};
+const projectPath = path.resolve(getFlag("project") || process.cwd());
+const watch = args.includes("--watch");
+const json = args.includes("--json");
+async function scanOnce(label) {
+    try {
+        const report = await (0, agent_patrol_1.runPatrol)(projectPath);
+        // ── P5 安全层：报告写入经 FsSandbox（巡逻预设：写=沙箱白名单） ──
+        const writeDecision = (0, agent_permissions_1.decidePermission)("patrol", {
+            level: "write",
+            target: path.join(projectPath, ".progmune_patrol_report.md"),
+            projectPath,
+        });
+        let reportFile = "";
+        if (writeDecision.allowed) {
+            reportFile = (0, agent_patrol_1.writePatrolReport)(report, projectPath);
+        }
+        if (json && !watch) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`[${label}] ` + (0, agent_patrol_1.formatPatrolTerminal)(report).replace(/\n/g, "\n  "));
+            console.log(writeDecision.allowed
+                ? `   报告: ${reportFile}`
+                : `   ⚠️ 报告写入被沙箱拒绝: ${writeDecision.detail}`);
+        }
+    }
+    catch (e) {
+        console.error(`❌ 巡逻失败: ${e?.message || e}`);
+    }
+}
+async function main() {
+    process.chdir(projectPath);
+    console.log(`🛡️  Progmune 免疫巡逻 (P4) — 项目: ${projectPath}${watch ? "（持续监听）" : ""}`);
+    if (!watch) {
+        await scanOnce("扫描");
+        process.exit(0);
+    }
+    // 持续监听：RepoWatcher 防抖触发重扫
+    await scanOnce("首次");
+    let scanning = false;
+    const watcher = new agent_perception_1.RepoWatcher(projectPath, async (file) => {
+        if (scanning)
+            return; // 扫描期间的新变更合并进下一轮
+        scanning = true;
+        console.log(`🔍 检测到变更: ${file}`);
+        await scanOnce("重扫");
+        scanning = false;
+    }, 1500);
+    watcher.start();
+    console.log("👂 监听中（Ctrl+C 退出）…");
+}
+main().catch((e) => {
+    console.error(`❌ 巡逻 CLI 异常: ${e?.message || e}`);
+    process.exit(1);
+});

package/dist/planner-prompts.js

@@ -40,6 +40,9 @@ exports.RETRY_HINT = `输出格式：紧凑 JSON 数组 [{"f":"函数名","to":"
 // ── Formatters ──
 /** Build a compact function list with parameter examples for LLM precision. */
 function buildCompactFuncList(funcs, allFuncs) {
+    // 语义 marker（__progmune_*，提取器注入供规则消费）不是真实可调用函数——
+    // 不出现在 LLM 可见函数列表中，防止被生成成真实调用导致编译失败
+    funcs = funcs.filter((f) => !String(f.name || "").startsWith("__progmune_"));
     // Example values for each type — helps LLM fill meaningful args
     function exampleValue(type, paramName) {
         const t = (type || "any").replace(/\[\]$/, "").toLowerCase();

package/dist/planner.js

@@ -900,6 +900,8 @@ ${planner_prompts_1.RETRY_HINT}
                 : await (0, llm_1.generate)(`你是程序合成助手。\n\n${currentPrompt}`);
         }
         catch (e) {
+            // 铁律：失败原因必须可见（不许静默绕过）——LLM 异常记录后继续重试/降级
+            console.error(`⚠️ LLM 调用失败 (attempt ${r + 1}/${maxRetries}): ${e?.message || e}`);
             continue;
         }
         if (!text)

package/dist/protocol-registry.js

@@ -68,9 +68,22 @@ function getProtocolConfig() {
     let rules = [];
     let version = "1.0";
     const protoPath = path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd(), "protocols.json");
-    if (fs.existsSync(protoPath)) {
+    // 解析顺序与 loadIR 一致：显式目录 → CWD → 包目录回退。
+    // 修复：在无 protocols.json 的项目目录里运行时（如 agent CLI chdir 到
+    // demo-project），此前 nsInit 退化为仅 _global —— session 只记录 1 个
+    // 命名空间，而 check 在仓库根跑用全量 27 个 ns 重建 → before-consistency
+    // 全量误报（1308/1308）。包目录回退保证任何 cwd 下世界一致。
+    const candidates = [protoPath];
+    try {
+        candidates.push(path.resolve(__dirname, "../protocols.json"));
+    }
+    catch { /* __dirname 不可用时跳过 */ }
+    let loaded = false;
+    for (const p of candidates) {
+        if (!fs.existsSync(p))
+            continue;
         try {
-            const proto = JSON.parse(fs.readFileSync(protoPath, "utf-8"));
+            const proto = JSON.parse(fs.readFileSync(p, "utf-8"));
             version = proto.$schema || proto.version || "1.0";
             // Load namespace initial states
             nsInit.set("_global", "UNAUTHENTICATED");
@@ -81,11 +94,13 @@ function getProtocolConfig() {
             }
             // Parse rules
             rules = (0, ssg_validator_1.parseProtocolsFromJSON)(proto);
+            loaded = true;
+            break;
         }
-        catch { /* protocol load — optional */ }
+        catch { /* 下一个候选 */ }
     }
-    else {
-        // Fallback: minimal defaults (no protocols.json found)
+    if (!loaded) {
+        // Fallback: minimal defaults (no protocols.json anywhere)
         nsInit.set("_global", "UNAUTHENTICATED");
     }
     // Compute rule hash