progmune-runtime 2.1.5 → 3.2.0

package/dist/proof-provenance.js

@@ -0,0 +1,315 @@
+"use strict";
+/**
+ * Progmune V7 — Proof Provenance System
+ * ======================================
+ * 把每一个不变量变成可追溯的证明对象。
+ *
+ * 核心原则:
+ *   Proof ≠ Belief — 两者永远分离。
+ *
+ *   Proof:  形式逻辑对象。回答"这个结论能否从前提推导出来？"
+ *           没有概率，只有有效/无效。每一层推导都精确记录来源。
+ *
+ *   Belief: 工程决策对象。回答"我们有多相信这个结论？"
+ *           融合运行时数据、Git 历史、业务文档、人工确认。
+ *           这是 V8 的事。
+ *
+ * 三层架构:
+ *   L1 Recovery:  Code → AST → State Machine → Protocol
+ *   L2 Reasoning: Protocol → Proof Tree → Counterexample → Retain/Discard
+ *   L3 Belief:    Proof + Runtime + Docs + Human → Belief Score (V8)
+ *
+ * V7 完成 L1+L2。Proof 层不出现任何概率数字。
+ */
+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.buildProofProvenance = buildProofProvenance;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ══════════════════════════════════════════════
+// L1: RECOVERY — Build derivation from code artifacts
+// ══════════════════════════════════════════════
+/**
+ * Build a derivation node for an OBSERVATION — something directly read from code.
+ * This is the leaf of every proof tree. No inference. Just extraction.
+ */
+function observationNode(id, conclusion, sourceFile, sourceLine, extractionMethod) {
+    return {
+        id,
+        conclusion,
+        rule: "OBSERVATION",
+        children: [],
+        provenance: {
+            sourceFile,
+            sourceLine,
+            sourceArtifact: conclusion,
+            extractionMethod,
+            transformationChain: [extractionMethod],
+        },
+        depth: 0,
+    };
+}
+/**
+ * Extend an observation through a transformation.
+ * e.g. OBSERVATION("status: ['pending','paid','shipped']")
+ *   → STATE_MACHINE("order_suppliers: pending → paid → shipped → completed")
+ */
+function transformNode(id, conclusion, childId, rule, transformStep) {
+    return {
+        id,
+        conclusion,
+        rule,
+        children: [childId],
+        provenance: {
+            sourceFile: "", // Filled by combining child provenances
+            sourceLine: 0,
+            sourceArtifact: conclusion,
+            extractionMethod: transformStep,
+            transformationChain: [transformStep],
+        },
+        depth: 1,
+    };
+}
+// ══════════════════════════════════════════════
+// L2: REASONING — Build the full proof provenance graph
+// ══════════════════════════════════════════════
+/**
+ * Build a complete Provenance Report from the pipeline outputs.
+ *
+ * Every invariant gets:
+ *   1. A full derivation tree tracing back to OBSERVATION leaves
+ *   2. A refutation record if V6 found a counterexample
+ *   3. No probability — only provenance
+ */
+function buildProvenance(protocols, stateMachines, proofEngine) {
+    const invariants = [];
+    const refutations = [];
+    let nodeCounter = 1000;
+    // ── Build derivation trees from protocol invariants ──
+    for (const proto of protocols) {
+        for (const inv of proto.invariants || []) {
+            const id = inv.id;
+            const predicate = inv.predicate || inv.rawPredicate || "";
+            const sources = inv.sources || [];
+            const domain = inv.domain || proto.domain || "unknown";
+            // Determine logic type from the predicate
+            let logicType = "REQUIRES";
+            if (predicate.includes("¬(") && predicate.includes("→"))
+                logicType = "FORBIDS";
+            else if (predicate.includes("¬∃"))
+                logicType = "TERMINAL";
+            else if (predicate.includes("≤ 1") || predicate.includes("unique"))
+                logicType = "UNIQUE";
+            else if (predicate.includes("initial_state"))
+                logicType = "INITIAL";
+            // Find the corresponding state machine
+            const machine = stateMachines.find((m) => m.entity === domain || domain.includes(m.entity) || m.entity.includes(domain));
+            // Build the OBSERVATION leaf
+            const sourceFile = sources[0] || "unknown";
+            const obsNode = observationNode(`OBS-${nodeCounter++}`, sources[0] || predicate, sourceFile.includes("State transition") ? "state-miner output" : sourceFile, 0, sourceFile.includes("Domain:") ? "domain_template" : "state_transition_recovery");
+            // Build the STATE_MACHINE intermediate node (if machine exists)
+            let derivation;
+            if (machine) {
+                const smNode = transformNode(`SM-${nodeCounter++}`, `${machine.entity}: ${(machine.states || []).join(" → ")}`, obsNode.id, "STATE_MACHINE", "state_transition_recovery → state_machine");
+                smNode.depth = 1;
+                // Build the top-level PROTOCOL node
+                derivation = {
+                    id: `PR-${nodeCounter++}`,
+                    conclusion: predicate,
+                    rule: inv.id.startsWith("INV-TMPL") ? "PROTOCOL_TEMPLATE" : "STATE_MACHINE",
+                    children: [smNode.id],
+                    provenance: {
+                        sourceFile: sourceFile,
+                        sourceLine: 0,
+                        sourceArtifact: predicate,
+                        extractionMethod: smNode.provenance.extractionMethod,
+                        transformationChain: [...smNode.provenance.transformationChain, "state_machine → protocol_invariant"],
+                    },
+                    depth: 2,
+                };
+                // Attach all nodes for serialization
+                derivation._obsNode = obsNode;
+                derivation._smNode = smNode;
+            }
+            else {
+                // No state machine — direct OBSERVATION → invariant
+                derivation = {
+                    id: `PR-${nodeCounter++}`,
+                    conclusion: predicate,
+                    rule: "PROTOCOL_TEMPLATE",
+                    children: [obsNode.id],
+                    provenance: {
+                        sourceFile: sourceFile,
+                        sourceLine: 0,
+                        sourceArtifact: predicate,
+                        extractionMethod: obsNode.provenance.extractionMethod,
+                        transformationChain: [...obsNode.provenance.transformationChain, "template → invariant"],
+                    },
+                    depth: 1,
+                };
+                derivation._obsNode = obsNode;
+            }
+            // Check refutation from V6 — match by PREDICATE TEXT, not ID
+            // (IDs collide across protocols: each has its own INV-3)
+            const v6Counterexamples = proofEngine?.counterexamples || [];
+            const ce = v6Counterexamples.find((c) => c.invariantStatement === predicate);
+            const isRefuted = !!ce;
+            if (ce) {
+                refutations.push({
+                    invariantId: id,
+                    invariantPredicate: predicate,
+                    counterexamplePath: ce.path || [],
+                    explanation: ce.explanation || "",
+                    refutationRule: "BFS_SHORTCUT",
+                });
+            }
+            invariants.push({
+                id,
+                predicate,
+                domain,
+                logicType,
+                derivation,
+                derivationDepth: derivation.depth,
+                isRefuted,
+                counterexamplePath: ce?.path,
+                counterexampleExplanation: ce?.explanation,
+            });
+        }
+    }
+    // ── Check inferred invariants from V6 ──
+    for (const inf of proofEngine?.inferred || []) {
+        const pred = inf.deducedPredicate;
+        const premises = inf.premises || [];
+        const proofTree = inf.proofTree;
+        // Build TRANSITIVITY node with premises as children
+        const derivation = {
+            id: `INF-${nodeCounter++}`,
+            conclusion: pred,
+            rule: "TRANSITIVITY",
+            children: premises.map((p) => p.id),
+            provenance: {
+                sourceFile: "",
+                sourceLine: 0,
+                sourceArtifact: pred,
+                extractionMethod: "transitive_closure",
+                transformationChain: ["premise_a ⇒ premise_b", "premise_b ⇒ premise_c", "transitivity ⇒ conclusion"],
+            },
+            depth: 2,
+        };
+        invariants.push({
+            id: proofTree?.id || `INF-${nodeCounter}`,
+            predicate: pred,
+            domain: "inferred",
+            logicType: "REQUIRES",
+            derivation,
+            derivationDepth: 2,
+            isRefuted: false,
+        });
+    }
+    // Compute summary
+    const observations = invariants.filter(i => i.derivationDepth === 0 || i.derivation.rule === "OBSERVATION");
+    const derived = invariants.filter(i => !i.isRefuted && i.derivationDepth > 0);
+    const refuted = invariants.filter(i => i.isRefuted);
+    const retained = invariants.filter(i => !i.isRefuted);
+    const depths = invariants.map(i => i.derivationDepth);
+    const report = {
+        timestamp: new Date().toISOString(),
+        invariants,
+        refutations,
+        summary: {
+            totalInvariants: invariants.length,
+            observations: observations.length,
+            derived: derived.length,
+            refuted: refuted.length,
+            retained: retained.length,
+            proofDepth: {
+                min: depths.length > 0 ? Math.min(...depths) : 0,
+                max: depths.length > 0 ? Math.max(...depths) : 0,
+                avg: depths.length > 0 ? Math.round(depths.reduce((a, b) => a + b, 0) / depths.length) : 0,
+            },
+        },
+    };
+    return report;
+}
+// ══════════════════════════════════════════════
+// MAIN
+// ══════════════════════════════════════════════
+function buildProofProvenance(projectPath) {
+    console.log("🔬 Progmune Proof Provenance System — V7");
+    const protoPath = path.join(projectPath, ".progmune_protocols.json");
+    const statePath = path.join(projectPath, ".progmune_state_machines.json");
+    const proofPath = path.join(projectPath, ".progmune_proofs.json");
+    const protocols = fs.existsSync(protoPath) ? JSON.parse(fs.readFileSync(protoPath, "utf-8")).protocols || [] : [];
+    const stateMachines = fs.existsSync(statePath) ? JSON.parse(fs.readFileSync(statePath, "utf-8")).machines || [] : [];
+    const proofEngine = fs.existsSync(proofPath) ? JSON.parse(fs.readFileSync(proofPath, "utf-8")) : {};
+    console.log(`   Input: ${protocols.length} protocols, ${stateMachines.length} state machines`);
+    console.log(`   V6 data: ${proofEngine.summary?.totalInvariants || 0} invariants, ${proofEngine.summary?.counterexamples || 0} counterexamples`);
+    const report = buildProvenance(protocols, stateMachines, proofEngine);
+    // Print the proof provenance for refuted invariants
+    console.log(`\n   ${report.summary.totalInvariants} invariants with full provenance`);
+    console.log(`   ${report.summary.refuted} refuted (counterexample found)`);
+    console.log(`   ${report.summary.retained} retained`);
+    if (report.refutations.length > 0) {
+        console.log("\n   ── Refutations ──");
+        for (const ref of report.refutations) {
+            console.log(`   ❌ ${ref.invariantPredicate}`);
+            console.log(`      Rule: ${ref.refutationRule}`);
+            console.log(`      Path: ${ref.counterexamplePath.join(" → ")}`);
+        }
+    }
+    return report;
+}
+// ══════════════════════════════════════════════
+// CLI
+// ══════════════════════════════════════════════
+if (require.main === module) {
+    const targetProject = process.argv[2];
+    if (!targetProject) {
+        console.error("Usage: npx ts-node src/proof-provenance.ts <project-path>");
+        process.exit(1);
+    }
+    const report = buildProofProvenance(targetProject);
+    const outputPath = path.join(targetProject, ".progmune_provenance.json");
+    fs.writeFileSync(outputPath, JSON.stringify(report, null, 2));
+    console.log(`\n✅ Provenance report saved to: ${outputPath}`);
+    console.log("\n═══ Proof Provenance Summary ═══");
+    console.log(`  Total:          ${report.summary.totalInvariants}`);
+    console.log(`  Observations:   ${report.summary.observations}`);
+    console.log(`  Derived:        ${report.summary.derived}`);
+    console.log(`  Refuted:        ${report.summary.refuted}`);
+    console.log(`  Retained:       ${report.summary.retained}`);
+    console.log(`  Proof Depth:    min=${report.summary.proofDepth.min} max=${report.summary.proofDepth.max} avg=${report.summary.proofDepth.avg}`);
+    console.log();
+}

package/dist/protocol-coverage.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * P3.6: Protocol Coverage Engine
+ *
+ * Analyzes Trajectory Corpus against Protocol Definitions to determine
+ * which states and transitions have been observed in real execution data.
+ *
+ * Core question: "What does the system NOT know yet?"
+ *
+ * Coverage gaps drive:
+ *   1. Benchmark generation (targeted test cases)
+ *   2. Data acquisition priorities (where to collect more feedback)
+ *   3. Risk assessment (which protocols are under-observed)
+ *
+ * Architecture:
+ *   Protocol definitions → All possible states + transitions
+ *   Trajectory records    → Observed states + transitions
+ *   Coverage engine       → Gap analysis + risk ranking
+ */
+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.parseProtocolDefinition = parseProtocolDefinition;
+exports.analyzeCoverage = analyzeCoverage;
+exports.analyzeAllCoverage = analyzeAllCoverage;
+exports.loadDefaultProtocolDefinitions = loadDefaultProtocolDefinitions;
+// ═══════════════════════════════════════════════════════════════
+// Protocol Parser
+// ═══════════════════════════════════════════════════════════════
+function parseTransitions(rules) {
+    const transitions = [];
+    for (const [fn, rule] of rules) {
+        // Acquire transitions: pre_states (or INIT) → post_states
+        const pres = rule.pre_states.length > 0 ? rule.pre_states : ["INIT"];
+        for (const pre of pres) {
+            for (const post of rule.post_states) {
+                transitions.push({ from: pre, to: post, rule: fn, type: "acquire" });
+            }
+        }
+        // Invalidation transitions: state → ∅
+        if (rule.invalidate) {
+            for (const inv of rule.invalidate) {
+                transitions.push({ from: inv, to: "∅", rule: fn, type: "invalidate" });
+            }
+        }
+    }
+    return transitions;
+}
+function allStatesFromRules(rules, initialState) {
+    const states = new Set();
+    states.add(initialState);
+    states.add("INIT");
+    for (const rule of rules.values()) {
+        for (const s of rule.pre_states)
+            states.add(s);
+        for (const s of rule.post_states)
+            states.add(s);
+        if (rule.invalidate)
+            for (const s of rule.invalidate)
+                states.add(s);
+    }
+    return [...states].sort();
+}
+/** Parse a protocol definition from its rules. */
+function parseProtocolDefinition(name, rules, initialState) {
+    return {
+        name,
+        states: allStatesFromRules(rules, initialState),
+        initialState,
+        transitions: parseTransitions(rules),
+        rules,
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// Coverage Analyzer
+// ═══════════════════════════════════════════════════════════════
+/** Extract observed states from a trajectory. */
+function extractVisitedStates(trajectory, rules, initial) {
+    const visited = new Set();
+    if (initial)
+        visited.add(initial);
+    let current = new Set();
+    if (initial)
+        current.add(initial);
+    for (const fn of trajectory) {
+        const rule = rules.get(fn);
+        if (!rule)
+            continue;
+        for (const pre of rule.pre_states)
+            visited.add(pre);
+        for (const post of rule.post_states) {
+            visited.add(post);
+            current.add(post);
+        }
+        if (rule.invalidate)
+            rule.invalidate.forEach(s => { visited.add(s); current.delete(s); });
+    }
+    return visited;
+}
+/** Extract observed transitions from a trajectory. */
+function extractVisitedTransitions(trajectory, rules, initial) {
+    const visited = new Set();
+    let current = new Set();
+    if (initial)
+        current.add(initial);
+    for (const fn of trajectory) {
+        const rule = rules.get(fn);
+        if (!rule)
+            continue;
+        for (const pre of rule.pre_states) {
+            for (const post of rule.post_states) {
+                visited.add(`${pre}→${post}`);
+            }
+        }
+        if (rule.invalidate) {
+            for (const inv of rule.invalidate) {
+                visited.add(`${inv}→∅`);
+            }
+        }
+        // Advance state
+        if (rule.invalidate)
+            rule.invalidate.forEach(s => current.delete(s));
+        for (const post of rule.post_states)
+            current.add(post);
+    }
+    return visited;
+}
+/**
+ * Compute coverage for a single protocol from trajectory data.
+ */
+function analyzeCoverage(protocol, trajectories) {
+    // Filter trajectories relevant to this protocol
+    const relevant = trajectories.filter(t => t.protocol === protocol.name || t.protocol === "_global");
+    // Aggregate visited states + transitions
+    const visitedStates = new Set();
+    const visitedTransitions = new Set();
+    for (const t of relevant) {
+        const initialState = t.initialState?.length > 0 ? t.initialState[0] : undefined;
+        for (const s of extractVisitedStates(t.trajectory, protocol.rules, initialState))
+            visitedStates.add(s);
+        for (const tr of extractVisitedTransitions(t.trajectory, protocol.rules, initialState))
+            visitedTransitions.add(tr);
+    }
+    const totalStates = protocol.states.length;
+    const visitedStateCount = [...visitedStates].filter(s => protocol.states.includes(s)).length;
+    const totalTransitions = protocol.transitions.length;
+    const visitedTransitionKeys = new Set(protocol.transitions.filter(t => visitedTransitions.has(`${t.from}→${t.to}`)).map(t => `${t.from}→${t.to}`));
+    const missingStates = protocol.states.filter(s => !visitedStates.has(s));
+    const missingTransitions = protocol.transitions
+        .filter(t => !visitedTransitions.has(`${t.from}→${t.to}`))
+        .map(t => ({ from: t.from, to: t.to, rule: t.rule }));
+    return {
+        protocol: protocol.name,
+        stateCoverage: {
+            protocol: protocol.name,
+            totalStates,
+            visitedStates: visitedStateCount,
+            stateCoverage: totalStates > 0 ? visitedStateCount / totalStates : 0,
+            missingStates,
+        },
+        transitionCoverage: {
+            protocol: protocol.name,
+            totalTransitions,
+            visitedTransitions: visitedTransitionKeys.size,
+            transitionCoverage: totalTransitions > 0 ? visitedTransitionKeys.size / totalTransitions : 0,
+            missingTransitions,
+        },
+        trajectoryCount: relevant.length,
+    };
+}
+/**
+ * Analyze coverage across all protocols.
+ */
+function analyzeAllCoverage(protocols, trajectories) {
+    return protocols.map(p => analyzeCoverage(p, trajectories));
+}
+// ═══════════════════════════════════════════════════════════════
+// Default protocol definitions (from protocols.json)
+// ═══════════════════════════════════════════════════════════════
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ssg_validator_1 = require("./ssg-validator");
+let _cachedProtocols = null;
+function loadDefaultProtocolDefinitions() {
+    if (_cachedProtocols)
+        return _cachedProtocols;
+    const protoDef = JSON.parse(fs.readFileSync(path.resolve(__dirname, "..", "protocols.json"), "utf-8"));
+    const fns = (0, ssg_validator_1.parseProtocolsFromJSON)(protoDef);
+    const rules = new Map();
+    for (const p of fns)
+        rules.set(p.function, p.protocol);
+    // Split rules into logical protocol groups by state namespace
+    const protocolGroups = [
+        {
+            name: "FileProtocol",
+            ruleFilter: (_fn, rule) => rule.pre_states.some(s => s.includes("FILE")) || rule.post_states.some(s => s.includes("FILE")) || (rule.invalidate || []).some(s => s.includes("FILE")),
+            initialState: "INIT",
+        },
+        {
+            name: "AuthProtocol",
+            ruleFilter: (_fn, rule) => rule.pre_states.some(s => ["UNAUTHENTICATED", "PASSWORD_VERIFIED", "TOKEN_ISSUED", "SESSION_ACTIVE"].includes(s)) ||
+                rule.post_states.some(s => ["UNAUTHENTICATED", "PASSWORD_VERIFIED", "TOKEN_ISSUED", "SESSION_ACTIVE"].includes(s)),
+            initialState: "UNAUTHENTICATED",
+        },
+        {
+            name: "DBProtocol",
+            ruleFilter: (_fn, rule) => rule.pre_states.some(s => s.includes("DB")) || rule.post_states.some(s => s.includes("DB")) || (rule.invalidate || []).some(s => s.includes("DB")),
+            initialState: "INIT",
+        },
+        {
+            name: "IRProtocol",
+            ruleFilter: (_fn, rule) => rule.pre_states.some(s => s.includes("IR_") || s.includes("ACTION_") || s.includes("SEQUENCE_") || s.includes("CODE_") || s.includes("SESSION_")) ||
+                rule.post_states.some(s => s.includes("IR_") || s.includes("ACTION_") || s.includes("SEQUENCE_") || s.includes("CODE_") || s.includes("SESSION_")),
+            initialState: "IR_STALE",
+        },
+        {
+            name: "StatelessProtocol",
+            ruleFilter: (_fn, rule) => rule.namespace === "stateless" ||
+                (rule.pre_states.length === 0 && rule.post_states.length === 0),
+            initialState: "IDLE",
+        },
+        {
+            name: "TransactionProtocol",
+            ruleFilter: (_fn, rule) => rule.namespace === "transaction" ||
+                rule.pre_states.some(s => s.startsWith("TX_") || s === "SAVEPOINT_HELD") ||
+                rule.post_states.some(s => s.startsWith("TX_") || s === "SAVEPOINT_HELD") ||
+                (rule.invalidate || []).some(s => s.startsWith("TX_") || s === "SAVEPOINT_HELD"),
+            initialState: "TX_IDLE",
+        },
+        {
+            name: "ConditionalProtocol",
+            ruleFilter: (_fn, rule) => rule.namespace === "conditional" ||
+                rule.pre_states.some(s => s.startsWith("COND_")) ||
+                rule.post_states.some(s => s.startsWith("COND_")) ||
+                (rule.invalidate || []).some(s => s.startsWith("COND_")),
+            initialState: "COND_IDLE",
+        },
+        {
+            name: "LoopProtocol",
+            ruleFilter: (_fn, rule) => rule.namespace === "loop" ||
+                rule.pre_states.some(s => s.startsWith("LOOP_") || s === "FETCHING" || s === "BATCH_READY" || s === "ITERATING") ||
+                rule.post_states.some(s => s.startsWith("LOOP_") || s === "FETCHING" || s === "BATCH_READY" || s === "ITERATING") ||
+                (rule.invalidate || []).some(s => s.startsWith("LOOP_") || s === "FETCHING" || s === "BATCH_READY" || s === "ITERATING"),
+            initialState: "LOOP_IDLE",
+        },
+        {
+            name: "CrossProtocol",
+            ruleFilter: (_fn, rule) => rule.namespace === "cross" ||
+                rule.pre_states.some(s => s.includes("AUTH_FILE_GATE") || s.includes("AUTH_DB_GATE")) ||
+                rule.post_states.some(s => s.includes("AUTH_FILE_GATE") || s.includes("AUTH_DB_GATE")),
+            initialState: "UNAUTHENTICATED",
+        },
+    ];
+    _cachedProtocols = protocolGroups.map(g => {
+        const groupRules = new Map();
+        for (const [fn, rule] of rules) {
+            if (g.ruleFilter(fn, rule))
+                groupRules.set(fn, rule);
+        }
+        return parseProtocolDefinition(g.name, groupRules, g.initialState);
+    });
+    return _cachedProtocols;
+}