progmune-runtime 2.1.6 → 3.2.0

package/dist/auto-benchmark-generator.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Auto-benchmark Generator
+ *
+ * Generates benchmark cases from synthesized protocols + real-world defects.
+ * Expands the benchmark suite from 3 to 20+ cases, enabling meaningful
+ * behavioral equivalence measurement.
+ *
+ * Sources:
+ *   1. Synthesized protocols → typical lifecycle paths
+ *   2. Real-world defects → broken → expected pairs
+ *   3. Cross-repo sequences → protocol-specific test cases
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateExpandedBenchmarks = generateExpandedBenchmarks;
+exports.printExpandedBenchmarkReport = printExpandedBenchmarkReport;
+const auto_protocol_synthesizer_1 = require("./auto-protocol-synthesizer");
+const realworld_benchmark_1 = require("./realworld-benchmark");
+const scale_trajectory_collector_1 = require("./scale-trajectory-collector");
+const function_synonyms_1 = require("./function-synonyms");
+/**
+ * Generate benchmarks from synthesized protocols.
+ * For each protocol, create a "missing the last step" test case.
+ */
+function generateFromProtocols(protocols) {
+    const cases = [];
+    for (const sp of protocols) {
+        if (sp.prototype.length < 2)
+            continue;
+        // Normalize the prototype
+        const norm = sp.prototype.map(function_synonyms_1.normalizeFunctionName);
+        // Case: broken = remove the last action (resource leak)
+        cases.push({
+            goal: `cover protocol: ${sp.prototype.join(" → ")}`,
+            protocol: "_global",
+            broken: norm.slice(0, -1),
+            expected: norm,
+            violationType: "resource_leak",
+            source: `synthesized:${sp.clusterId}`,
+        });
+        // Case: broken = remove the first action (missing prerequisite)
+        if (norm.length >= 3) {
+            cases.push({
+                goal: `cover prerrequisite: ${sp.prototype.join(" → ")}`,
+                protocol: "_global",
+                broken: norm.slice(1),
+                expected: norm,
+                violationType: "missing_prerequisite",
+                source: `synthesized:${sp.clusterId}`,
+            });
+        }
+    }
+    return cases;
+}
+/**
+ * Convert real-world defects to benchmark cases.
+ */
+function convertDefects() {
+    return realworld_benchmark_1.REAL_WORLD_DEFECTS.map(d => ({
+        goal: d.title,
+        protocol: d.protocol,
+        broken: d.broken.map(function_synonyms_1.normalizeFunctionName),
+        expected: d.expected.map(function_synonyms_1.normalizeFunctionName),
+        violationType: d.violationType,
+        source: `realworld:${d.id}`,
+    }));
+}
+/**
+ * Generate benchmarks from the expanded corpus.
+ * Take representative sequences and create test cases.
+ */
+function generateFromCorpus(sequences) {
+    const cases = [];
+    const seen = new Set();
+    for (const seq of sequences) {
+        if (seq.length < 3)
+            continue;
+        const norm = seq.map(function_synonyms_1.normalizeFunctionName);
+        const key = norm.join("→");
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        // Take every 5th unique sequence as a benchmark case
+        if (seen.size % 5 === 0) {
+            cases.push({
+                goal: `corpus pattern: ${key}`,
+                protocol: "_global",
+                broken: norm.slice(0, -1),
+                expected: norm,
+                violationType: "resource_leak",
+                source: "corpus",
+            });
+        }
+    }
+    return cases;
+}
+/**
+ * Generate an expanded benchmark suite from all available sources.
+ * Target: 20+ cases covering synthesized protocols, real defects, and corpus patterns.
+ */
+function generateExpandedBenchmarks() {
+    const protocols = (0, auto_protocol_synthesizer_1.synthesizeAllKnownProtocols)();
+    const { sequences } = (0, scale_trajectory_collector_1.collectTrajectoriesAtScale)();
+    const protocolCases = generateFromProtocols(protocols);
+    const defectCases = convertDefects();
+    const corpusCases = generateFromCorpus(sequences);
+    const allCases = [...protocolCases, ...defectCases, ...corpusCases];
+    // Deduplicate by expected sequence
+    const seen = new Set();
+    const unique = [];
+    for (const c of allCases) {
+        const key = c.expected.join("→");
+        if (!seen.has(key)) {
+            seen.add(key);
+            unique.push(c);
+        }
+    }
+    const bySource = {};
+    for (const c of unique) {
+        const src = c.source.split(":")[0];
+        bySource[src] = (bySource[src] || 0) + 1;
+    }
+    return {
+        cases: unique,
+        bySource,
+        totalCases: unique.length,
+    };
+}
+function printExpandedBenchmarkReport(suite) {
+    console.log("\n─── Expanded Benchmark Suite ───");
+    console.log(`  Total Cases: ${suite.totalCases}`);
+    console.log("  By Source:");
+    for (const [src, count] of Object.entries(suite.bySource)) {
+        console.log(`    ${src.padEnd(14)} ${count}`);
+    }
+    console.log();
+}

package/dist/auto-benchmark-generator.test.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Auto-benchmark Generator + Expanded Bootstrap Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const auto_benchmark_generator_1 = require("./auto-benchmark-generator");
+const bootstrap_validation_1 = require("./bootstrap-validation");
+const scale_trajectory_collector_1 = require("./scale-trajectory-collector");
+(0, vitest_1.describe)("Auto-benchmark Generator", () => {
+    (0, vitest_1.it)("generates 20+ benchmark cases from all sources", () => {
+        const suite = (0, auto_benchmark_generator_1.generateExpandedBenchmarks)();
+        (0, vitest_1.expect)(suite.totalCases).toBeGreaterThanOrEqual(20);
+        (0, vitest_1.expect)(suite.bySource["synthesized"]).toBeGreaterThan(0);
+        (0, vitest_1.expect)(suite.bySource["realworld"]).toBeGreaterThan(0);
+        (0, auto_benchmark_generator_1.printExpandedBenchmarkReport)(suite);
+    });
+    (0, vitest_1.it)("each benchmark case has valid structure", () => {
+        const suite = (0, auto_benchmark_generator_1.generateExpandedBenchmarks)();
+        for (const c of suite.cases) {
+            (0, vitest_1.expect)(c.broken.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(c.expected.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(c.expected.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(c.broken.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(["resource_leak", "missing_prerequisite", "illegal_state_transition"]).toContain(c.violationType);
+        }
+    });
+});
+(0, vitest_1.describe)("Expanded Bootstrap Validation", () => {
+    (0, vitest_1.it)("with expanded corpus + expanded benchmarks", async () => {
+        const { sequences } = (0, scale_trajectory_collector_1.collectTrajectoriesAtScale)();
+        const suite = (0, auto_benchmark_generator_1.generateExpandedBenchmarks)();
+        // Run bootstrap with expanded corpus
+        const result = await (0, bootstrap_validation_1.runBootstrapValidation)(undefined, sequences);
+        console.log(`\nExpanded Benchmark Suite: ${suite.totalCases} cases`);
+        console.log(`Corpus Size: ${sequences.length} sequences`);
+        console.log(`Regenerated Rules: ${result.regeneratedRuleCount}`);
+        console.log(`Function Overlap: ${(result.functionOverlap * 100).toFixed(0)}%`);
+        console.log(`State Overlap: ${(result.stateOverlap * 100).toFixed(0)}%`);
+        console.log(`Behavioral: ${result.behavioralMatch}/${result.behavioralTotal}`);
+        // With expanded benchmarks, regenerated rules should be substantial
+        (0, vitest_1.expect)(result.regeneratedRuleCount).toBeGreaterThanOrEqual(5);
+        (0, vitest_1.expect)(result.functionOverlap).toBeGreaterThan(0.1);
+    }, 30000);
+});

package/dist/auto-protocol-synthesizer.js

@@ -0,0 +1,362 @@
+"use strict";
+/**
+ * P6.4: Auto Protocol Synthesizer
+ *
+ * Converts unsupervised protocol clusters into executable Protocol VM rules.
+ * Zero human intervention: trajectories → clusters → state machines → patches.
+ *
+ * Pipeline:
+ *   1. Take DiscoveredClusters from P6.3
+ *   2. Extract prototype sequence per cluster (centroid by edit distance)
+ *   3. Generate state machine: S0→a1→S1→a2→S2...→Sn→∅
+ *   4. Infer pre/post/invalidation from state transitions
+ *   5. Output as KnowledgePatch (compatible with KnowledgePatchStore)
+ *   6. Conflict detection with existing protocol rules
+ *
+ * This is the bridge from "pattern discovery" to "self-extending knowledge."
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPrototype = findPrototype;
+exports.synthesizeProtocols = synthesizeProtocols;
+exports.synthesizeAllKnownProtocols = synthesizeAllKnownProtocols;
+exports.detectConflicts = detectConflicts;
+exports.runAutoSynthesis = runAutoSynthesis;
+exports.printSynthesisReport = printSynthesisReport;
+const unsupervised_physics_1 = require("./experimental/unsupervised-physics");
+const protocol_coverage_1 = require("./protocol-coverage");
+const protocol_foundation_1 = require("./protocol-foundation");
+const function_synonyms_1 = require("./function-synonyms");
+// ═══════════════════════════════════════════════════════════════
+// Prototype Selection
+// ═══════════════════════════════════════════════════════════════
+/** Levenshtein edit distance between two string arrays. */
+function editDistance(a, b) {
+    const m = a.length, n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+/**
+ * Find the prototype (centroid) sequence in a cluster.
+ * The prototype is the sequence with minimum average edit distance to all others.
+ */
+function findPrototype(sequences) {
+    if (sequences.length <= 1)
+        return sequences[0] || [];
+    let bestSeq = sequences[0];
+    let bestDist = Infinity;
+    for (const seq of sequences) {
+        const totalDist = sequences.reduce((s, other) => s + editDistance(seq, other), 0);
+        const avgDist = totalDist / sequences.length;
+        if (avgDist < bestDist) {
+            bestDist = avgDist;
+            bestSeq = seq;
+        }
+    }
+    return bestSeq;
+}
+/**
+ * Generate a state machine from a prototype action sequence.
+ *
+ * For a sequence [A, B, C]:
+ *   S0 → A → S1 → B → S2 → C → S3
+ *
+ * Rules:
+ *   A: pre=[S0], post=[S1]
+ *   B: pre=[S1], post=[S2]
+ *   C: pre=[S2], post=[S3], invalidate=[S0,S1,S2,S3] (cleanup)
+ */
+function generateStateMachine(prototype, clusterId) {
+    if (prototype.length === 0)
+        return [];
+    const rules = [];
+    const statePrefix = clusterId.replace(/[^a-zA-Z0-9]/g, "_");
+    // Generate semantic state names from action functions
+    const stateNames = [];
+    for (let i = 0; i < prototype.length; i++) {
+        const fn = prototype[i];
+        // Use domain-aware naming: "open"→FILE_OPEN, "close"→FILE_CLOSED
+        const role = i === 0 ? "post" : i === prototype.length - 1 ? "invalidate" : "post";
+        const semanticName = (0, protocol_foundation_1.inferStateName)(fn, role);
+        // Deduplicate: if same semantic name appears, add index
+        let finalName = semanticName;
+        let suffix = 1;
+        while (stateNames.includes(finalName)) {
+            finalName = `${semanticName}_${suffix++}`;
+        }
+        stateNames.push(finalName);
+    }
+    for (let i = 0; i < prototype.length; i++) {
+        const fn = prototype[i];
+        const preState = i === 0 ? "INIT" : stateNames[i - 1];
+        const postState = i < prototype.length - 1 ? stateNames[i] : `${statePrefix}_DONE`;
+        const rule = {
+            function: fn,
+            pre_states: [preState],
+            post_states: [postState],
+        };
+        // Last action: invalidate all intermediate states (cleanup / release)
+        if (i === prototype.length - 1) {
+            rule.invalidate = [...stateNames, postState];
+        }
+        rules.push(rule);
+    }
+    return rules;
+}
+// ═══════════════════════════════════════════════════════════════
+// Protocol Synthesis
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Synthesize protocol rules from unsupervised clusters.
+ *
+ * For each cluster with inferred pattern, generates a state machine
+ * and exportable rule set.
+ */
+function synthesizeProtocols(sequences) {
+    // P6.9: Normalize function names before clustering (DB_Open→open, createClient→create_client)
+    const normalized = sequences.map(seq => seq.map(function_synonyms_1.normalizeFunctionName));
+    const clusters = (0, unsupervised_physics_1.clusterByStructure)(normalized);
+    const results = [];
+    for (const c of clusters) {
+        if (!c.inferredPattern || c.sequences.length < 2)
+            continue;
+        const prototype = findPrototype(c.sequences);
+        // P9.2p: Use V2 state machine generation for richer rules
+        const rules = generateStateMachineV2(c.sequences, c.id);
+        results.push({
+            clusterId: c.id,
+            prototype,
+            rules,
+            stateCount: prototype.length + 1,
+            inferredPattern: c.inferredPattern,
+            confidence: c.closedLoopRate,
+        });
+    }
+    return results;
+}
+// ═══════════════════════════════════════════════════════════════
+// P9.2p: State Machine V2 — frequency-based, multi-path rules
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Generate richer protocol rules using ALL sequences in a cluster,
+ * not just the centroid prototype.
+ *
+ * Improvements over V1 (linear chain only):
+ *   1. Frequency-based pre_states: each function can have multiple
+ *      valid pre_states based on what actually precedes it in the data.
+ *   2. Self-transitions: functions that appear consecutively with
+ *      themselves (e.g., process→process) get self-loops.
+ *   3. Multiple exit paths: any function that appears as the last
+ *      call in a sequence is allowed to invalidate states.
+ *   4. Entry points: functions that appear as first call in sequences
+ *      get empty pre_states (always callable).
+ */
+function generateStateMachineV2(sequences, clusterId) {
+    if (sequences.length === 0)
+        return [];
+    // Collect frequency data
+    const fnPositions = new Map();
+    const transitions = new Map(); // from → {to → count}
+    for (const seq of sequences) {
+        if (seq.length === 0)
+            continue;
+        for (let i = 0; i < seq.length; i++) {
+            const fn = seq[i];
+            if (!fnPositions.has(fn))
+                fnPositions.set(fn, { first: 0, last: 0, mid: 0, total: 0 });
+            const pos = fnPositions.get(fn);
+            pos.total++;
+            if (i === 0)
+                pos.first++;
+            if (i === seq.length - 1)
+                pos.last++;
+            if (i > 0 && i < seq.length - 1)
+                pos.mid++;
+            // Track transitions
+            if (i < seq.length - 1) {
+                const from = fn;
+                const to = seq[i + 1];
+                if (!transitions.has(from))
+                    transitions.set(from, new Map());
+                const toMap = transitions.get(from);
+                toMap.set(to, (toMap.get(to) || 0) + 1);
+            }
+        }
+    }
+    const totalSeqs = sequences.length;
+    const rules = [];
+    const statePrefix = clusterId.replace(/[^a-zA-Z0-9]/g, "_");
+    let stateCounter = 0;
+    const fnToState = new Map();
+    // Assign states to functions
+    for (const [fn, pos] of fnPositions) {
+        const stateName = pos.first / pos.total > 0.5 ? "INIT"
+            : pos.last / pos.total > 0.5 ? `${statePrefix}_EXIT`
+                : `${statePrefix}_S${stateCounter++}`;
+        fnToState.set(fn, stateName);
+    }
+    // Generate rules
+    for (const [fn, pos] of fnPositions) {
+        const preStates = new Set();
+        const postStates = new Set();
+        const invalidateStates = new Set();
+        // PRE_STATES: collect all unique predecessors
+        for (const seq of sequences) {
+            for (let i = 0; i < seq.length; i++) {
+                if (seq[i] === fn) {
+                    if (i === 0) {
+                        preStates.add("INIT");
+                    }
+                    else {
+                        const predState = fnToState.get(seq[i - 1]);
+                        if (predState)
+                            preStates.add(predState);
+                    }
+                }
+            }
+        }
+        // POST_STATES: from fnToState, and from successors
+        postStates.add(fnToState.get(fn) || `${statePrefix}_S${stateCounter++}`);
+        const toMap = transitions.get(fn);
+        if (toMap) {
+            for (const [toFn] of toMap) {
+                const toState = fnToState.get(toFn);
+                if (toState && toState !== fnToState.get(fn))
+                    postStates.add(toState);
+            }
+        }
+        // INVALIDATE: functions that frequently end sequences
+        if (pos.last / Math.max(1, pos.total) > 0.3) {
+            // This function often ends sequences — it should invalidate accumulated states
+            for (const pred of findPredecessors(fn, sequences)) {
+                const predState = fnToState.get(pred);
+                if (predState && predState !== "INIT")
+                    invalidateStates.add(predState);
+            }
+        }
+        // ENTRY POINTS: functions that frequently start sequences
+        const preStatesArr = pos.first / Math.max(1, pos.total) > 0.5 ? [] : [...preStates];
+        rules.push({
+            function: fn,
+            pre_states: preStatesArr,
+            post_states: [...postStates],
+            invalidate: invalidateStates.size > 0 ? [...invalidateStates] : undefined,
+        });
+    }
+    return rules;
+}
+function findPredecessors(fn, sequences) {
+    const preds = new Set();
+    for (const seq of sequences) {
+        for (let i = 1; i < seq.length; i++) {
+            if (seq[i] === fn)
+                preds.add(seq[i - 1]);
+        }
+    }
+    return [...preds];
+}
+/**
+ * Synthesize protocols from all known cross-repo sequences.
+ */
+function synthesizeAllKnownProtocols() {
+    const allSeqs = [];
+    for (const seqs of Object.values(unsupervised_physics_1.CROSS_REPO_SEQUENCES)) {
+        allSeqs.push(...seqs);
+    }
+    return synthesizeProtocols(allSeqs);
+}
+/**
+ * Detect conflicts between synthesized rules and existing protocol rules.
+ *
+ * A conflict = same function name but different pre/post states.
+ */
+function detectConflicts(synthesized, existingRules) {
+    const reports = [];
+    for (const sp of synthesized) {
+        const conflicts = [];
+        for (const sr of sp.rules) {
+            const existing = existingRules.get(sr.function);
+            if (existing) {
+                // Check if rules are consistent
+                const preMatch = sr.pre_states.length === existing.pre_states.length &&
+                    sr.pre_states.every(s => existing.pre_states.includes(s));
+                const postMatch = sr.post_states.length === existing.post_states.length &&
+                    sr.post_states.every(s => existing.post_states.includes(s));
+                if (!preMatch || !postMatch) {
+                    conflicts.push({ fn: sr.function, existingRule: existing, synthesizedRule: sr });
+                }
+            }
+        }
+        reports.push({
+            synthesized: sp,
+            conflicts,
+            hasConflicts: conflicts.length > 0,
+        });
+    }
+    return reports;
+}
+/**
+ * Full auto-synthesis pipeline:
+ *   Sequences → Clusters → State Machines → Conflict Detection → Governance-ready
+ */
+function runAutoSynthesis(existingRules) {
+    const protocols = synthesizeAllKnownProtocols();
+    const defs = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+    const rules = existingRules || new Map();
+    for (const p of defs)
+        for (const [fn, rule] of p.rules)
+            rules.set(fn, rule);
+    const conflicts = detectConflicts(protocols, rules);
+    const totalRules = protocols.reduce((s, p) => s + p.rules.length, 0);
+    const newFunctions = protocols.reduce((s, p) => {
+        const newFns = p.rules.filter(r => !rules.has(r.function));
+        return s + newFns.length;
+    }, 0);
+    const conflictCount = conflicts.filter(c => c.hasConflicts).length;
+    return {
+        protocols,
+        conflicts,
+        totalRules,
+        newFunctions,
+        conflictCount,
+        readyForGovernance: conflictCount === 0 && newFunctions > 0,
+    };
+}
+function printSynthesisReport(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   P6.4 Auto Protocol Synthesizer                   ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Protocols Synthesized: ${report.protocols.length}`);
+    console.log(`Total Rules:           ${report.totalRules}`);
+    console.log(`New Functions:         ${report.newFunctions}`);
+    console.log(`Conflicts:             ${report.conflictCount}`);
+    console.log(`Ready for Governance:  ${report.readyForGovernance ? "✅ YES" : "❌ NO"}`);
+    console.log();
+    for (const p of report.protocols) {
+        console.log(`  ${p.clusterId}: ${p.prototype.join(" → ")}`);
+        console.log(`    Pattern: ${p.inferredPattern}, States: ${p.stateCount}, Rules: ${p.rules.length}`);
+        for (const r of p.rules) {
+            const inv = r.invalidate ? ` [inv: ${r.invalidate.join(",")}]` : "";
+            console.log(`    ${r.function}: [${r.pre_states.join(",")}] → [${r.post_states.join(",")}]${inv}`);
+        }
+    }
+    console.log();
+    if (report.conflictCount > 0) {
+        console.log("─── Conflicts ───");
+        for (const c of report.conflicts.filter(c => c.hasConflicts)) {
+            console.log(`  ${c.synthesized.clusterId}:`);
+            for (const cf of c.conflicts) {
+                console.log(`    ${cf.fn}: existing≠synthesized — needs governance review`);
+            }
+        }
+        console.log();
+    }
+}

package/dist/auto-protocol-synthesizer.test.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * P6.4: Auto Protocol Synthesizer Tests
+ *
+ * Validates the full zero-intervention pipeline:
+ *   Trajectories → Clusters → State Machines → Governance-Ready Rules
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const auto_protocol_synthesizer_1 = require("./auto-protocol-synthesizer");
+const protocol_coverage_1 = require("./protocol-coverage");
+(0, vitest_1.describe)("Prototype Selection", () => {
+    (0, vitest_1.it)("finds centroid by minimum average edit distance", () => {
+        const seqs = [
+            ["open", "read", "close"],
+            ["open", "write", "close"],
+            ["open", "read", "write", "close"],
+        ];
+        const proto = (0, auto_protocol_synthesizer_1.findPrototype)(seqs);
+        (0, vitest_1.expect)(proto.length).toBeGreaterThanOrEqual(2);
+        // The prototype should be one of the 3-step sequences (more central)
+        (0, vitest_1.expect)(proto.length).toBeLessThanOrEqual(3);
+    });
+});
+(0, vitest_1.describe)("Protocol Synthesis", () => {
+    (0, vitest_1.it)("generates state machine from prototype sequence", () => {
+        const seqs = [
+            ["fopen", "fread", "fclose"],
+            ["sqlite3_open", "sqlite3_exec", "sqlite3_close"],
+            ["DB_Open", "DB_Get", "DB_Close"],
+        ];
+        const protocols = (0, auto_protocol_synthesizer_1.synthesizeProtocols)(seqs);
+        (0, vitest_1.expect)(protocols.length).toBeGreaterThan(0);
+        // The main cluster should have Acquire-Use-Release structure
+        const mainProto = protocols[0];
+        (0, vitest_1.expect)(mainProto.inferredPattern).toBe("RESOURCE_ACQUIRE");
+        // V2 generates frequency-based multi-path rules (≥3, typically 5 for this dataset)
+        (0, vitest_1.expect)(mainProto.rules.length).toBeGreaterThanOrEqual(3);
+        (0, vitest_1.expect)(mainProto.stateCount).toBeGreaterThanOrEqual(3);
+        // Last rule should have invalidation
+        const lastRule = mainProto.rules[mainProto.rules.length - 1];
+        (0, vitest_1.expect)(lastRule.invalidate).toBeDefined();
+        (0, vitest_1.expect)(lastRule.invalidate.length).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("synthesizes from all known cross-repo sequences", () => {
+        const protocols = (0, auto_protocol_synthesizer_1.synthesizeAllKnownProtocols)();
+        (0, vitest_1.expect)(protocols.length).toBeGreaterThan(0);
+        // Should have at least Acquire-Release (len=3 closed) and Lock-Unlock (len=2 closed)
+        (0, vitest_1.expect)(protocols.some(p => p.inferredPattern === "RESOURCE_ACQUIRE")).toBe(true);
+        (0, vitest_1.expect)(protocols.some(p => p.prototype.length === 2)).toBe(true);
+    });
+});
+(0, vitest_1.describe)("Conflict Detection", () => {
+    (0, vitest_1.it)("detects conflicts with existing protocol rules", () => {
+        const seqs = [
+            ["open_file", "read_file", "close_file"],
+            ["open_file", "write_file", "close_file"],
+        ];
+        const protocols = (0, auto_protocol_synthesizer_1.synthesizeProtocols)(seqs);
+        const defs = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+        const existingRules = new Map();
+        for (const p of defs)
+            for (const [fn, rule] of p.rules)
+                existingRules.set(fn, rule);
+        const conflicts = (0, auto_protocol_synthesizer_1.detectConflicts)(protocols, existingRules);
+        // Synthesized open_file may conflict with existing open_file definition
+        // That's expected and correctly flagged
+        (0, vitest_1.expect)(conflicts.length).toBeGreaterThan(0);
+    });
+});
+(0, vitest_1.describe)("Full Synthesis Pipeline", () => {
+    (0, vitest_1.it)("runs auto-synthesis and produces governance-ready report", () => {
+        const report = (0, auto_protocol_synthesizer_1.runAutoSynthesis)();
+        (0, vitest_1.expect)(report.protocols.length).toBeGreaterThan(0);
+        (0, vitest_1.expect)(report.totalRules).toBeGreaterThan(0);
+        (0, vitest_1.expect)(report.newFunctions).toBeGreaterThan(0);
+        // Some conflicts expected (synthesized rules may differ from hand-written)
+        // The system correctly flags these for governance review
+        (0, vitest_1.expect)(report.conflictCount).toBeGreaterThanOrEqual(0);
+        (0, auto_protocol_synthesizer_1.printSynthesisReport)(report);
+    });
+});