progmune-runtime 2.1.5 → 3.2.0

package/dist/transition-synthesizer.js

@@ -0,0 +1,286 @@
+"use strict";
+/**
+ * P3.18-20: Transition Synthesizer + Candidate Discovery 2.0
+ *
+ * P3.18: Infer missing protocol transitions from benchmark failures.
+ *   When verify_password produces PASSWORD_VERIFIED and generate_jwt
+ *   consumes PASSWORD_VERIFIED, the synthesizer detects the connection.
+ *
+ * P3.19: Gap-driven benchmark generation — each inferred transition
+ *   becomes a benchmark case that tests the Planner's ability to use it.
+ *
+ * P3.20: CandidateOrigin tracking — classify where each candidate came from
+ *   so the Error Budget can decompose missing_candidate into root causes.
+ *
+ * Target: Top-1 ≥25%, Top-3 ≥60%, Missing Candidate ≤30%.
+ */
+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.trackCandidateOrigin = trackCandidateOrigin;
+exports.synthesizeTransitions = synthesizeTransitions;
+exports.augmentRulesWithInferences = augmentRulesWithInferences;
+exports.generateGapBenchmarks = generateGapBenchmarks;
+exports.writeGapBenchmarks = writeGapBenchmarks;
+exports.computeEnhancedScores = computeEnhancedScores;
+exports.printSynthesizerReport = printSynthesizerReport;
+exports.printCandidateOriginStats = printCandidateOriginStats;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const protocol_coverage_1 = require("./protocol-coverage");
+function trackCandidateOrigin(candidates, expectedRepair) {
+    const stats = new Map();
+    for (const c of candidates) {
+        const origin = c.metadata?.source || "protocol_bfs";
+        const existing = stats.get(origin) || { count: 0, successCount: 0 };
+        existing.count++;
+        if (expectedRepair) {
+            const actions = c.fixPath || c.actions?.map((a) => a.function) || [];
+            const match = expectedRepair.every(fn => actions.includes(fn));
+            if (match)
+                existing.successCount++;
+        }
+        stats.set(origin, existing);
+    }
+    return [...stats.entries()].map(([origin, s]) => ({
+        origin,
+        count: s.count,
+        successCount: s.successCount,
+        successRate: s.count > 0 ? s.successCount / s.count : 0,
+    })).sort((a, b) => b.count - a.count);
+}
+/**
+ * Analyze benchmark failures to infer missing protocol transitions.
+ *
+ * For each expected repair chain, checks whether consecutive function
+ * pairs have a valid state transition in the protocol rules. If not,
+ * the pair is recorded as an inferred transition.
+ *
+ * Confidence = evidenceCount / maxEvidence across all inferences.
+ */
+function synthesizeTransitions(failures, protocols) {
+    const defs = protocols || (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+    const ruleMap = new Map();
+    for (const p of defs)
+        ruleMap.set(p.name, p.rules);
+    const inferred = new Map();
+    for (const f of failures) {
+        const chain = f.expectedRepair;
+        for (let i = 0; i < chain.length - 1; i++) {
+            const fnA = chain[i];
+            const fnB = chain[i + 1];
+            // Find which protocol these functions belong to
+            for (const [protoName, rules] of ruleMap) {
+                const ruleA = rules.get(fnA);
+                const ruleB = rules.get(fnB);
+                if (!ruleA || !ruleB)
+                    continue;
+                // Check if transition exists: post_states of A → pre_states of B
+                const postA = ruleA.post_states;
+                const preB = ruleB.pre_states;
+                const connected = postA.some(s => preB.includes(s));
+                if (connected)
+                    continue; // transition already exists
+                const key = `${protoName}:${fnA}→${fnB}`;
+                const existing = inferred.get(key);
+                if (existing) {
+                    existing.evidenceCount++;
+                    if (!existing.examples.includes(f.goal))
+                        existing.examples.push(f.goal);
+                }
+                else {
+                    // Use the first post_state of A as the from-state
+                    const fromState = postA[0] || "?";
+                    const toState = preB[0] || "?";
+                    inferred.set(key, {
+                        action: `${fnA} → ${fnB}`,
+                        protocol: protoName,
+                        evidenceCount: 1,
+                        examples: [f.goal],
+                    });
+                }
+            }
+        }
+    }
+    const maxEvidence = Math.max(1, ...[...inferred.values()].map(v => v.evidenceCount));
+    const results = [];
+    for (const [key, entry] of inferred) {
+        const parts = key.split(":");
+        const protoAndPair = parts.slice(1).join(":");
+        const [fnA, fnB] = entry.action.split(" → ");
+        const protoName = entry.protocol;
+        const rules = ruleMap.get(protoName);
+        const ruleA = rules?.get(fnA);
+        const ruleB = rules?.get(fnB);
+        const fromState = ruleA?.post_states[0] || "?";
+        const toState = ruleB?.pre_states[0] || "?";
+        results.push({
+            from: fromState,
+            to: toState,
+            action: entry.action,
+            protocol: protoName,
+            confidence: entry.evidenceCount / maxEvidence,
+            evidenceCount: entry.evidenceCount,
+            examples: entry.examples.slice(0, 3),
+        });
+    }
+    return results.sort((a, b) => b.confidence - a.confidence);
+}
+/**
+ * Apply inferred transitions to augment protocol rules.
+ * Returns augmented rules with inferred edges added as virtual rules.
+ */
+function augmentRulesWithInferences(rules, inferences, minConfidence = 0.5) {
+    const augmented = new Map(rules);
+    for (const inf of inferences) {
+        if (inf.confidence < minConfidence)
+            continue;
+        const [fnA, fnB] = inf.action.split(" → ");
+        // Add a virtual bridge rule: fnA_inferred → produces the state fnB needs
+        const bridgeName = `_inferred_${fnA}_to_${fnB}`;
+        if (!augmented.has(bridgeName)) {
+            augmented.set(bridgeName, {
+                pre_states: [inf.from],
+                post_states: [inf.to],
+                namespace: "inferred",
+            });
+        }
+    }
+    return augmented;
+}
+/**
+ * Generate benchmark cases from inferred transitions.
+ * Each inferred transition becomes a test case that validates
+ * the Planner can use the newly discovered edge.
+ */
+function generateGapBenchmarks(inferences, minConfidence = 0.3) {
+    const cases = [];
+    for (const inf of inferences) {
+        if (inf.confidence < minConfidence)
+            continue;
+        const [fnA, fnB] = inf.action.split(" → ");
+        // Broken: just fnA (missing the connecting edge)
+        cases.push({
+            goal: `verify transition: ${inf.action}`,
+            protocol: "_global",
+            broken: [fnA],
+            expected: [fnA, fnB],
+            violationType: "missing_prerequisite",
+            targetsGap: inf.action,
+            confidence: inf.confidence,
+        });
+        // Also generate the resource-cleanup variant if fnB invalidates something
+        if (inf.to === "∅" || inf.from === inf.to) {
+            cases.push({
+                goal: `verify cleanup after: ${inf.action}`,
+                protocol: "_global",
+                broken: [fnA, fnB],
+                expected: [fnA, fnB],
+                violationType: "resource_leak",
+                targetsGap: `cleanup:${inf.action}`,
+                confidence: inf.confidence,
+            });
+        }
+    }
+    return cases.sort((a, b) => b.confidence - a.confidence);
+}
+/** Write generated gap benchmarks to disk. */
+function writeGapBenchmarks(cases, outputDir) {
+    const outDir = outputDir || path.resolve(__dirname, "..", "benchmarks", "synthesized");
+    if (!fs.existsSync(outDir))
+        fs.mkdirSync(outDir, { recursive: true });
+    const filepath = path.join(outDir, `transition_gaps_${new Date().toISOString().slice(0, 10)}.json`);
+    fs.writeFileSync(filepath, JSON.stringify({
+        generatedAt: new Date().toISOString(),
+        source: "transition-synthesizer",
+        count: cases.length,
+        cases,
+    }, null, 2));
+    return filepath;
+}
+/**
+ * Enhanced knowledge score including candidate discovery rate.
+ *
+ *   score = 0.30*coverage + 0.25*success + 0.20*benchmark
+ *         + 0.10*corpus + 0.15*discoveryRate
+ */
+function computeEnhancedScores(protocolNames, coverageReport, benchmarkStats, candidateStats = {}) {
+    return protocolNames.map(name => {
+        const cov = coverageReport.find(c => c.protocol === name);
+        const bench = benchmarkStats[name] || { total: 0, passed: 0 };
+        const cand = candidateStats[name] || { total: 0, found: 0 };
+        const coverage = cov ? (cov.stateCoverage + cov.transitionCoverage) / 2 : 0;
+        const successRate = bench.total > 0 ? bench.passed / bench.total : 0;
+        const benchmarkPassRate = bench.total > 0 ? bench.passed / bench.total : 0;
+        const corpusSupport = Math.min(1, bench.total / 50);
+        const discoveryRate = cand.total > 0 ? cand.found / cand.total : 0;
+        const score = 0.30 * coverage +
+            0.25 * successRate +
+            0.20 * benchmarkPassRate +
+            0.10 * corpusSupport +
+            0.15 * discoveryRate;
+        return { protocol: name, coverage, successRate, benchmarkPassRate, corpusSupport, discoveryRate, score };
+    }).sort((a, b) => b.score - a.score);
+}
+// ═══════════════════════════════════════════════════════════════
+// Dashboard
+// ═══════════════════════════════════════════════════════════════
+function printSynthesizerReport(inferences) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   Transition Synthesizer Report                    ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Inferred Transitions: ${inferences.length}\n`);
+    if (inferences.length === 0) {
+        console.log("  All transitions covered. No gaps to infer.\n");
+        return;
+    }
+    console.log("─── Top Inferred Transitions ───");
+    console.log("Conf    Evidence  Transition");
+    console.log("────────────────────────────────────────────────");
+    for (const inf of inferences.slice(0, 15)) {
+        const conf = (inf.confidence * 100).toFixed(0).padStart(4);
+        console.log(`  ${conf}%     ${String(inf.evidenceCount).padStart(2)}       ${inf.protocol}: ${inf.action}  (${inf.from} → ${inf.to})`);
+    }
+    console.log();
+}
+function printCandidateOriginStats(stats) {
+    console.log("\n─── Candidate Origin Contribution ───");
+    console.log("Origin              Count   SuccessRate");
+    console.log("────────────────────────────────────────");
+    for (const s of stats) {
+        const rate = (s.successRate * 100).toFixed(0).padStart(4);
+        console.log(`  ${s.origin.padEnd(18)} ${String(s.count).padStart(5)}  ${rate}%`);
+    }
+    console.log();
+}

package/dist/transition-synthesizer.test.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * P3.18-20: Transition Synthesizer Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const transition_synthesizer_1 = require("./transition-synthesizer");
+function makeProtocols() {
+    const rules = new Map();
+    rules.set("verify_password", { pre_states: ["UNAUTHENTICATED"], post_states: ["PASSWORD_VERIFIED"] });
+    rules.set("generate_jwt", { pre_states: ["PASSWORD_VERIFIED"], post_states: ["TOKEN_ISSUED"], invalidate: ["PASSWORD_VERIFIED"] });
+    rules.set("create_session", { pre_states: ["TOKEN_ISSUED"], post_states: ["SESSION_ACTIVE"], invalidate: ["TOKEN_ISSUED"] });
+    rules.set("logout", { pre_states: ["SESSION_ACTIVE"], post_states: ["UNAUTHENTICATED"], invalidate: ["SESSION_ACTIVE"] });
+    rules.set("open_file", { pre_states: [], post_states: ["FILE_OPEN"] });
+    rules.set("write_file", { pre_states: ["FILE_OPEN"], post_states: ["FILE_DIRTY"] });
+    rules.set("flush_file", { pre_states: ["FILE_DIRTY"], post_states: ["FILE_FLUSHED"] });
+    rules.set("close_file", { pre_states: ["FILE_OPEN", "FILE_DIRTY", "FILE_FLUSHED"], post_states: [], invalidate: ["FILE_OPEN", "FILE_DIRTY", "FILE_FLUSHED"] });
+    rules.set("connect_db", { pre_states: [], post_states: ["DB_CONNECTED"] });
+    rules.set("query_db", { pre_states: ["DB_CONNECTED"], post_states: [] });
+    rules.set("disconnect_db", { pre_states: ["DB_CONNECTED"], post_states: [], invalidate: ["DB_CONNECTED"] });
+    return [{
+            name: "AuthProtocol", states: ["UNAUTHENTICATED", "PASSWORD_VERIFIED", "TOKEN_ISSUED", "SESSION_ACTIVE"],
+            initialState: "UNAUTHENTICATED",
+            transitions: [], rules: new Map([...rules].filter(([k]) => ["verify_password", "generate_jwt", "create_session", "logout"].includes(k))),
+        }, {
+            name: "FileProtocol", states: ["FILE_OPEN", "FILE_DIRTY", "FILE_FLUSHED"],
+            initialState: "INIT",
+            transitions: [], rules: new Map([...rules].filter(([k]) => ["open_file", "write_file", "flush_file", "close_file"].includes(k))),
+        }, {
+            name: "DBProtocol", states: ["DB_CONNECTED"],
+            initialState: "INIT",
+            transitions: [], rules: new Map([...rules].filter(([k]) => ["connect_db", "query_db", "disconnect_db"].includes(k))),
+        }];
+}
+(0, vitest_1.describe)("Transition Synthesizer", () => {
+    (0, vitest_1.it)("infers transitions from benchmark failures", () => {
+        // open_file→flush_file: FILE_OPEN ≠ FILE_DIRTY → genuinely missing transition
+        // write_file→close_file: FILE_DIRTY → close_file needs FILE_OPEN/FILE_DIRTY/FILE_FLUSHED → connected
+        // But open_file→flush_file is NOT connected (FILE_OPEN vs FILE_DIRTY)
+        const failures = [
+            { goal: "flush after open without write", protocol: "FileProtocol", expectedRepair: ["open_file", "flush_file"] },
+            { goal: "flush after open v2", protocol: "FileProtocol", expectedRepair: ["open_file", "flush_file"] },
+        ];
+        const inferences = (0, transition_synthesizer_1.synthesizeTransitions)(failures, makeProtocols());
+        (0, vitest_1.expect)(inferences.length).toBeGreaterThan(0);
+        // open_file→flush_file should be inferred (FILE_OPEN → FILE_DIRTY gap)
+        const hasOpenFlush = inferences.some(i => i.action.includes("open_file → flush_file"));
+        (0, vitest_1.expect)(hasOpenFlush).toBe(true);
+        // Confidence: appears 2x
+        const top = inferences[0];
+        (0, vitest_1.expect)(top.confidence).toBeGreaterThan(0.5);
+        (0, transition_synthesizer_1.printSynthesizerReport)(inferences);
+    });
+    (0, vitest_1.it)("augments rules with inferred transitions", () => {
+        const failures = [
+            { goal: "flush after open", protocol: "FileProtocol", expectedRepair: ["open_file", "flush_file"] },
+        ];
+        const inferences = (0, transition_synthesizer_1.synthesizeTransitions)(failures, makeProtocols());
+        const fileProto = makeProtocols().find(p => p.name === "FileProtocol");
+        const augmented = (0, transition_synthesizer_1.augmentRulesWithInferences)(fileProto.rules, inferences);
+        // Should have the original rules plus inferred bridges
+        (0, vitest_1.expect)(augmented.size).toBeGreaterThan(fileProto.rules.size);
+        // Should contain an inferred bridge
+        const hasBridge = [...augmented.keys()].some(k => k.startsWith("_inferred_"));
+        (0, vitest_1.expect)(hasBridge).toBe(true);
+    });
+    (0, vitest_1.it)("generates gap-driven benchmarks", () => {
+        const failures = [
+            { goal: "flush after open", protocol: "FileProtocol", expectedRepair: ["open_file", "flush_file"] },
+        ];
+        const inferences = (0, transition_synthesizer_1.synthesizeTransitions)(failures, makeProtocols());
+        const cases = (0, transition_synthesizer_1.generateGapBenchmarks)(inferences);
+        (0, vitest_1.expect)(cases.length).toBeGreaterThan(0);
+        // Each case targets a specific gap
+        for (const c of cases) {
+            (0, vitest_1.expect)(c.targetsGap.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(c.broken.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(c.expected.length).toBeGreaterThan(0);
+        }
+        // Write to disk
+        const fp = (0, transition_synthesizer_1.writeGapBenchmarks)(cases);
+        (0, vitest_1.expect)(fp).toContain("transition_gaps_");
+    });
+});
+(0, vitest_1.describe)("Candidate Origin Tracking", () => {
+    (0, vitest_1.it)("tracks origin stats", () => {
+        const candidates = [
+            { metadata: { source: "frontier" }, fixPath: ["close_file"] },
+            { metadata: { source: "goal_template" }, fixPath: ["verify_password", "generate_jwt"] },
+            { metadata: { source: "frontier" }, fixPath: ["open_file", "close_file"] },
+            { metadata: { source: "corpus" }, fixPath: ["connect_db", "query_db", "disconnect_db"] },
+        ];
+        const stats = (0, transition_synthesizer_1.trackCandidateOrigin)(candidates);
+        (0, vitest_1.expect)(stats.length).toBe(3); // frontier, goal_template, corpus
+        const frontier = stats.find(s => s.origin === "frontier");
+        (0, vitest_1.expect)(frontier.count).toBe(2);
+        (0, transition_synthesizer_1.printCandidateOriginStats)(stats);
+    });
+});
+(0, vitest_1.describe)("Enhanced Knowledge Score", () => {
+    (0, vitest_1.it)("includes discoveryRate", () => {
+        const scores = (0, transition_synthesizer_1.computeEnhancedScores)(["FileProtocol", "AuthProtocol", "DBProtocol"], [
+            { protocol: "FileProtocol", stateCoverage: 0.6, transitionCoverage: 0.5 },
+            { protocol: "AuthProtocol", stateCoverage: 0.8, transitionCoverage: 0.7 },
+            { protocol: "DBProtocol", stateCoverage: 0.3, transitionCoverage: 0.2 },
+        ], {
+            FileProtocol: { total: 20, passed: 10 },
+            AuthProtocol: { total: 15, passed: 8 },
+            DBProtocol: { total: 10, passed: 2 },
+        }, {
+            FileProtocol: { total: 20, found: 15 },
+            AuthProtocol: { total: 15, found: 12 },
+            DBProtocol: { total: 10, found: 3 },
+        });
+        (0, vitest_1.expect)(scores.length).toBe(3);
+        // AuthProtocol should have highest score (better coverage + success)
+        (0, vitest_1.expect)(scores[0].protocol).toBe("AuthProtocol");
+        (0, vitest_1.expect)(scores[0].discoveryRate).toBeGreaterThan(0.5);
+        // DBProtocol should have lowest discovery rate
+        const db = scores.find(s => s.protocol === "DBProtocol");
+        (0, vitest_1.expect)(db.discoveryRate).toBe(0.3);
+    });
+});