progmune-runtime 2.1.5 → 3.2.0

package/dist/protocol-frontier.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * P3.14-15: Protocol Frontier Explorer + Cross-Protocol Planner
+ *
+ * P3.14: BFS-based state→state search without template dependency.
+ *   Given currentState and targetState, auto-discovers paths like
+ *   SESSION_ACTIVE → logout → SESSION_CLOSED without needing
+ *   a template for every goal variant.
+ *
+ * P3.15: Cross-protocol meta-graph for multi-protocol repair chains.
+ *   Auth → File → DB → IR protocol composition.
+ *   Enables repairs like "auth then file write then db insert".
+ *
+ * Target: reduce missing_candidate from 49% to <20%.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchFrontier = searchFrontier;
+exports.searchFrontierMulti = searchFrontierMulti;
+exports.exploreFrontier = exploreFrontier;
+exports.planCrossProtocol = planCrossProtocol;
+exports.getProtocolBridges = getProtocolBridges;
+exports.expandCrossProtocolCandidates = expandCrossProtocolCandidates;
+const protocol_coverage_1 = require("./protocol-coverage");
+/**
+ * BFS from currentState to find the shortest path reaching targetState.
+ *
+ * Unlike Goal Templates (which require manual patterns), this searches
+ * the protocol state graph directly. It discovers paths like:
+ *   - SESSION_ACTIVE → logout → UNAUTHENTICATED
+ *   - FILE_OPEN → close_file → (FILE_OPEN invalidated)
+ *   - DB_CONNECTED → disconnect_db → (DB_CONNECTED invalidated)
+ *
+ * Works for any state pair defined in the protocol rules.
+ */
+function searchFrontier(rules, currentStates, targetStates, maxDepth = 8) {
+    if (currentStates.length === 0) {
+        // If no current states, start from rules with no pre_states
+        const startable = new Set();
+        for (const [fn, rule] of rules) {
+            if (rule.pre_states.length === 0) {
+                for (const post of rule.post_states)
+                    startable.add(post);
+            }
+        }
+        if (startable.size > 0) {
+            currentStates = [...startable];
+        }
+    }
+    const currentSet = new Set(currentStates);
+    const targetSet = new Set(targetStates);
+    // BFS
+    const visited = new Set();
+    const queue = [
+        { states: new Set(currentStates), actions: [], stateList: [...currentStates], cost: 0 },
+    ];
+    visited.add([...currentStates].sort().join(","));
+    while (queue.length > 0) {
+        const { states, actions, stateList, cost } = queue.shift();
+        // Target reached?
+        if (targetStates.length > 0 && targetStates.every(t => states.has(t))) {
+            return { actions, states: stateList, cost, found: true };
+        }
+        // Resource cleanup: if target is empty, found when all current states are invalidated
+        if (targetStates.length === 0 && actions.length > 0) {
+            // Check if any state was successfully invalidated
+            const remainingFileOpen = states.has("FILE_OPEN");
+            const remainingDbConnected = states.has("DB_CONNECTED");
+            if (!remainingFileOpen && !remainingDbConnected && actions.length > 0) {
+                return { actions, states: stateList, cost, found: true };
+            }
+        }
+        if (cost >= maxDepth)
+            continue;
+        for (const [fn, rule] of rules) {
+            // Can we apply this rule from current states?
+            const preStatesOk = rule.pre_states.length === 0 || rule.pre_states.every(p => states.has(p));
+            if (!preStatesOk)
+                continue;
+            const nextStates = new Set(states);
+            if (rule.invalidate)
+                rule.invalidate.forEach(s => nextStates.delete(s));
+            for (const post of rule.post_states)
+                nextStates.add(post);
+            const stateKey = [...nextStates].sort().join(",");
+            if (visited.has(stateKey))
+                continue;
+            visited.add(stateKey);
+            queue.push({
+                states: nextStates,
+                actions: [...actions, fn],
+                stateList: [...stateList, ...rule.post_states],
+                cost: cost + 1,
+            });
+        }
+    }
+    return { actions: [], states: [], cost: 0, found: false };
+}
+/**
+ * Multi-start frontier search: tries multiple initial state combinations
+ * to find the best path. Useful when currentState is ambiguous.
+ */
+function searchFrontierMulti(rules, currentStatesCandidates, targetStates, maxDepth = 8) {
+    let best = { actions: [], states: [], cost: Infinity, found: false };
+    for (const startStates of currentStatesCandidates) {
+        const result = searchFrontier(rules, startStates, targetStates, maxDepth);
+        if (result.found && result.cost < best.cost) {
+            best = result;
+        }
+    }
+    return best;
+}
+/**
+ * Generate all reachable action sequences from a given state.
+ * Used as a candidate generator for Monte-Carlo style planning (P3.16).
+ */
+function exploreFrontier(rules, currentStates, maxPaths = 20, maxDepth = 6) {
+    const paths = [];
+    const visited = new Set();
+    const queue = [
+        { states: new Set(currentStates), actions: [], cost: 0 },
+    ];
+    while (queue.length > 0 && paths.length < maxPaths) {
+        const { states, actions, cost } = queue.shift();
+        if (cost >= maxDepth)
+            continue;
+        for (const [fn, rule] of rules) {
+            const preOk = rule.pre_states.length === 0 || rule.pre_states.every(p => states.has(p));
+            if (!preOk)
+                continue;
+            const next = new Set(states);
+            if (rule.invalidate)
+                rule.invalidate.forEach(s => next.delete(s));
+            for (const post of rule.post_states)
+                next.add(post);
+            const key = [...next].sort().join(",");
+            if (visited.has(key))
+                continue;
+            visited.add(key);
+            const newActions = [...actions, fn];
+            if (newActions.length >= 1)
+                paths.push(newActions);
+            queue.push({ states: next, actions: newActions, cost: cost + 1 });
+        }
+    }
+    return paths;
+}
+/** Known bridges between protocols. */
+const PROTOCOL_BRIDGES = [
+    // Original bridges
+    { from: "AuthProtocol", to: "FileProtocol", outputState: "SESSION_ACTIVE", inputState: "INIT" },
+    { from: "AuthProtocol", to: "DBProtocol", outputState: "SESSION_ACTIVE", inputState: "INIT" },
+    { from: "FileProtocol", to: "DBProtocol", outputState: "FILE_OPEN", inputState: "INIT" },
+    { from: "DBProtocol", to: "IRProtocol", outputState: "DB_CONNECTED", inputState: "IR_STALE" },
+    { from: "IRProtocol", to: "FileProtocol", outputState: "CODE_EMITTED", inputState: "INIT" },
+    // P7.3: New protocol bridges
+    { from: "AuthProtocol", to: "TransactionProtocol", outputState: "SESSION_ACTIVE", inputState: "TX_IDLE" },
+    { from: "AuthProtocol", to: "ConditionalProtocol", outputState: "SESSION_ACTIVE", inputState: "COND_IDLE" },
+    { from: "AuthProtocol", to: "LoopProtocol", outputState: "SESSION_ACTIVE", inputState: "LOOP_IDLE" },
+    { from: "AuthProtocol", to: "CrossProtocol", outputState: "SESSION_ACTIVE", inputState: "UNAUTHENTICATED" },
+    { from: "TransactionProtocol", to: "DBProtocol", outputState: "TX_IDLE", inputState: "INIT" },
+    { from: "ConditionalProtocol", to: "FileProtocol", outputState: "COND_ACCEPTED", inputState: "INIT" },
+    { from: "ConditionalProtocol", to: "DBProtocol", outputState: "COND_ACCEPTED", inputState: "INIT" },
+    { from: "LoopProtocol", to: "FileProtocol", outputState: "LOOP_DONE", inputState: "INIT" },
+    { from: "LoopProtocol", to: "DBProtocol", outputState: "LOOP_DONE", inputState: "INIT" },
+    { from: "FileProtocol", to: "CrossProtocol", outputState: "FILE_OPEN", inputState: "AUTH_FILE_GATE" },
+    { from: "DBProtocol", to: "CrossProtocol", outputState: "DB_CONNECTED", inputState: "AUTH_DB_GATE" },
+    { from: "StatelessProtocol", to: "FileProtocol", outputState: "IDLE", inputState: "INIT" },
+    { from: "StatelessProtocol", to: "DBProtocol", outputState: "IDLE", inputState: "INIT" },
+    { from: "StatelessProtocol", to: "TransactionProtocol", outputState: "IDLE", inputState: "TX_IDLE" },
+];
+/**
+ * Find a cross-protocol action chain for a multi-protocol goal.
+ *
+ * Decomposes the goal into protocol segments, plans each segment
+ * using the frontier explorer, and stitches them together via bridges.
+ */
+function planCrossProtocol(goal, protocols, targetProtocols, initialStates = {}) {
+    const bridges = [];
+    const allActions = [];
+    const orderedProtocols = [];
+    // Order protocols by bridge connectivity
+    if (targetProtocols.length <= 1) {
+        // Single protocol: just use frontier
+        const proto = protocols.find(p => p.name === targetProtocols[0]);
+        if (proto) {
+            const path = searchFrontier(proto.rules, initialStates[proto.name] || [], [], 8);
+            return { protocols: [proto.name], bridges: [], actions: path.actions };
+        }
+    }
+    // Multi-protocol: chain through bridges
+    for (let i = 0; i < targetProtocols.length; i++) {
+        const current = targetProtocols[i];
+        orderedProtocols.push(current);
+        if (i < targetProtocols.length - 1) {
+            const next = targetProtocols[i + 1];
+            const bridge = PROTOCOL_BRIDGES.find(b => b.from === current && b.to === next);
+            if (bridge)
+                bridges.push(bridge);
+        }
+    }
+    // Plan each protocol segment
+    for (const protoName of orderedProtocols) {
+        const proto = protocols.find(p => p.name === protoName);
+        if (!proto)
+            continue;
+        const init = initialStates[protoName] || [];
+        const path = searchFrontier(proto.rules, init, [], 8);
+        if (path.found)
+            allActions.push(...path.actions);
+    }
+    return { protocols: orderedProtocols, bridges, actions: allActions };
+}
+/** Get protocol bridges for visualization. */
+function getProtocolBridges() {
+    return [...PROTOCOL_BRIDGES];
+}
+/**
+ * Generate cross-protocol candidate actions for a multi-protocol goal.
+ * Used by ProtocolStrategy to expand candidates beyond single-protocol BFS.
+ */
+function expandCrossProtocolCandidates(goal, targetProtocols) {
+    const allDefs = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+    const protoMap = new Map(allDefs.map(p => [p.name, p]));
+    const candidates = [];
+    // For each target protocol, generate frontier paths
+    for (const tp of targetProtocols) {
+        const proto = protoMap.get(tp);
+        if (!proto)
+            continue;
+        const frontierPaths = exploreFrontier(proto.rules, [], 10, 6);
+        for (const path of frontierPaths) {
+            if (path.length > 0)
+                candidates.push(path);
+        }
+    }
+    // For multi-protocol: stitch via bridges
+    if (targetProtocols.length > 1) {
+        const plan = planCrossProtocol(goal, allDefs, targetProtocols);
+        if (plan.actions.length > 0)
+            candidates.push(plan.actions);
+    }
+    return candidates;
+}

package/dist/protocol-frontier.test.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * P3.14-15: Protocol Frontier Explorer Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const protocol_frontier_1 = require("./protocol-frontier");
+function makeRules() {
+    return new Map([
+        ["verify_password", { pre_states: ["UNAUTHENTICATED"], post_states: ["PASSWORD_VERIFIED"] }],
+        ["generate_jwt", { pre_states: ["PASSWORD_VERIFIED"], post_states: ["TOKEN_ISSUED"], invalidate: ["PASSWORD_VERIFIED"] }],
+        ["create_session", { pre_states: ["TOKEN_ISSUED"], post_states: ["SESSION_ACTIVE"], invalidate: ["TOKEN_ISSUED"] }],
+        ["logout", { pre_states: ["SESSION_ACTIVE"], post_states: ["UNAUTHENTICATED"], invalidate: ["SESSION_ACTIVE"] }],
+        ["open_file", { pre_states: [], post_states: ["FILE_OPEN"] }],
+        ["close_file", { pre_states: ["FILE_OPEN"], post_states: [], invalidate: ["FILE_OPEN"] }],
+        ["connect_db", { pre_states: [], post_states: ["DB_CONNECTED"] }],
+        ["disconnect_db", { pre_states: ["DB_CONNECTED"], post_states: [], invalidate: ["DB_CONNECTED"] }],
+    ]);
+}
+(0, vitest_1.describe)("Frontier Explorer", () => {
+    (0, vitest_1.it)("finds auth path from UNAUTHENTICATED to SESSION_ACTIVE", () => {
+        const rules = makeRules();
+        const path = (0, protocol_frontier_1.searchFrontier)(rules, ["UNAUTHENTICATED"], ["SESSION_ACTIVE"]);
+        (0, vitest_1.expect)(path.found).toBe(true);
+        (0, vitest_1.expect)(path.actions).toContain("verify_password");
+        (0, vitest_1.expect)(path.actions).toContain("generate_jwt");
+        (0, vitest_1.expect)(path.actions).toContain("create_session");
+        (0, vitest_1.expect)(path.cost).toBe(3);
+    });
+    (0, vitest_1.it)("finds logout path from SESSION_ACTIVE to UNAUTHENTICATED", () => {
+        const rules = makeRules();
+        const path = (0, protocol_frontier_1.searchFrontier)(rules, ["SESSION_ACTIVE"], ["UNAUTHENTICATED"]);
+        (0, vitest_1.expect)(path.found).toBe(true);
+        (0, vitest_1.expect)(path.actions).toEqual(["logout"]);
+        (0, vitest_1.expect)(path.cost).toBe(1);
+    });
+    (0, vitest_1.it)("finds close_file cleanup from FILE_OPEN", () => {
+        const rules = makeRules();
+        const path = (0, protocol_frontier_1.searchFrontier)(rules, ["FILE_OPEN"], []);
+        (0, vitest_1.expect)(path.found).toBe(true);
+        (0, vitest_1.expect)(path.actions).toContain("close_file");
+    });
+    (0, vitest_1.it)("returns not found for unreachable target", () => {
+        const rules = makeRules();
+        const path = (0, protocol_frontier_1.searchFrontier)(rules, ["UNAUTHENTICATED"], ["NONEXISTENT"]);
+        (0, vitest_1.expect)(path.found).toBe(false);
+    });
+    (0, vitest_1.it)("explores frontier: generates multiple paths", () => {
+        const rules = makeRules();
+        const paths = (0, protocol_frontier_1.exploreFrontier)(rules, ["UNAUTHENTICATED"], 20, 6);
+        (0, vitest_1.expect)(paths.length).toBeGreaterThan(1);
+        // Should include auth chain
+        const hasAuth = paths.some(p => p.includes("verify_password") && p.includes("generate_jwt") && p.includes("create_session"));
+        (0, vitest_1.expect)(hasAuth).toBe(true);
+    });
+    (0, vitest_1.it)("multi-start finds best path among candidates", () => {
+        const rules = makeRules();
+        const path = (0, protocol_frontier_1.searchFrontierMulti)(rules, [
+            ["FILE_OPEN"],
+            ["SESSION_ACTIVE"],
+        ], ["UNAUTHENTICATED"]);
+        // SESSION_ACTIVE→logout→UNAUTHENTICATED is 1 step, better than FILE_OPEN→close→open→auth→...
+        (0, vitest_1.expect)(path.found).toBe(true);
+        (0, vitest_1.expect)(path.cost).toBe(1);
+        (0, vitest_1.expect)(path.actions).toContain("logout");
+    });
+});
+(0, vitest_1.describe)("Cross-Protocol Planner", () => {
+    (0, vitest_1.it)("has protocol bridges", () => {
+        const bridges = (0, protocol_frontier_1.getProtocolBridges)();
+        (0, vitest_1.expect)(bridges.length).toBeGreaterThanOrEqual(3);
+        (0, vitest_1.expect)(bridges.some(b => b.from === "AuthProtocol" && b.to === "FileProtocol")).toBe(true);
+        (0, vitest_1.expect)(bridges.some(b => b.from === "AuthProtocol" && b.to === "DBProtocol")).toBe(true);
+    });
+    (0, vitest_1.it)("plans single protocol", () => {
+        const rules = makeRules();
+        const plan = (0, protocol_frontier_1.planCrossProtocol)("logout", [
+            { name: "AuthProtocol", rules },
+        ], ["AuthProtocol"], { AuthProtocol: ["SESSION_ACTIVE"] });
+        (0, vitest_1.expect)(plan.actions.length).toBeGreaterThan(0);
+        (0, vitest_1.expect)(plan.actions).toContain("logout");
+    });
+    (0, vitest_1.it)("generates cross-protocol candidates", () => {
+        const candidates = (0, protocol_frontier_1.expandCrossProtocolCandidates)("multi-step repair", ["FileProtocol", "DBProtocol"]);
+        // Should find paths for both protocols
+        (0, vitest_1.expect)(candidates.length).toBeGreaterThan(1);
+        // At least one file path and one db path
+        const hasFile = candidates.some(p => p.includes("open_file") || p.includes("close_file"));
+        const hasDb = candidates.some(p => p.includes("connect_db") || p.includes("disconnect_db"));
+        (0, vitest_1.expect)(hasFile || hasDb).toBe(true);
+    });
+});

package/dist/protocol-gap-analyzer.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * P3.16-17: Protocol Gap Mining + Knowledge Acquisition Planner
+ *
+ * Decomposes the 57% missing_candidate into actionable categories:
+ *   - Missing Actions: functions in expected repair but not in any protocol rule
+ *   - Missing Transitions: state pairs not connected by any rule
+ *   - Missing Cross-Protocol Bridges: protocol pairs with no bridge definition
+ *
+ * This transforms protocol expansion from guesswork to data-driven prioritization.
+ *
+ * Fourth flywheel:
+ *   Failures → Missing Knowledge → Protocol Expansion → Better Candidates
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeProtocolGaps = analyzeProtocolGaps;
+exports.computeKnowledgeScores = computeKnowledgeScores;
+exports.printGapReport = printGapReport;
+exports.printKnowledgeScores = printKnowledgeScores;
+const protocol_coverage_1 = require("./protocol-coverage");
+const protocol_frontier_1 = require("./protocol-frontier");
+// ═══════════════════════════════════════════════════════════════
+// Gap Analyzer
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Analyze benchmark failures to identify which actions/transitions
+ * are missing from the protocol definitions.
+ */
+function analyzeProtocolGaps(attributed, rules // protocol → set of function names
+) {
+    const failures = attributed.filter(a => a.failureReason !== "success");
+    const gapMap = new Map();
+    for (const f of failures) {
+        for (const fn of f.expectedRepair) {
+            // Check if this function exists in any protocol
+            let found = false;
+            for (const [, fns] of rules) {
+                if (fns.has(fn)) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                const key = `action:${fn}`;
+                const existing = gapMap.get(key);
+                if (existing) {
+                    existing.protocols.add(f.protocol);
+                    existing.examples.push(f.goal);
+                }
+                else {
+                    gapMap.set(key, {
+                        kind: "missing_action",
+                        protocols: new Set([f.protocol]),
+                        examples: [f.goal],
+                    });
+                }
+            }
+        }
+        // Check for missing transitions: consecutive function pairs in expected
+        for (let i = 0; i < f.expectedRepair.length - 1; i++) {
+            const from = f.expectedRepair[i];
+            const to = f.expectedRepair[i + 1];
+            const key = `transition:${from}→${to}`;
+            if (!gapMap.has(key)) {
+                gapMap.set(key, {
+                    kind: "missing_transition",
+                    protocols: new Set([f.protocol]),
+                    examples: [f.goal],
+                });
+            }
+            else {
+                gapMap.get(key).examples.push(f.goal);
+            }
+        }
+    }
+    // Cross-protocol bridge gaps
+    const bridges = (0, protocol_frontier_1.getProtocolBridges)();
+    const bridgePairs = new Set(bridges.map(b => `${b.from}→${b.to}`));
+    const crossProtocolFailures = failures.filter(f => f.expectedRepair.some(fn => fn.includes("file")) &&
+        f.expectedRepair.some(fn => fn.includes("db")));
+    for (const f of crossProtocolFailures) {
+        // Check if there's a bridge connecting the protocols involved
+        const protoSet = new Set();
+        for (const fn of f.expectedRepair) {
+            for (const [proto, fns] of rules) {
+                if (fns.has(fn))
+                    protoSet.add(proto);
+            }
+        }
+        const protoList = [...protoSet];
+        for (let i = 0; i < protoList.length - 1; i++) {
+            const pair = `${protoList[i]}→${protoList[i + 1]}`;
+            if (!bridgePairs.has(pair)) {
+                const key = `bridge:${pair}`;
+                if (!gapMap.has(key)) {
+                    gapMap.set(key, {
+                        kind: "missing_bridge",
+                        protocols: new Set(protoList),
+                        examples: [f.goal],
+                    });
+                }
+                else {
+                    gapMap.get(key).examples.push(f.goal);
+                }
+            }
+        }
+    }
+    // Convert to sorted list with priority scores
+    const totalFailures = failures.length;
+    const gaps = [];
+    const byKind = {
+        missing_action: { count: 0, items: [] },
+        missing_transition: { count: 0, items: [] },
+        missing_bridge: { count: 0, items: [] },
+        missing_protocol: { count: 0, items: [] },
+    };
+    for (const [key, entry] of gapMap) {
+        const kind = entry.kind;
+        const item = key.split(":")[1] || key;
+        const frequency = entry.examples.length;
+        const priority = Math.min(1, frequency / Math.max(1, totalFailures));
+        byKind[kind].count++;
+        byKind[kind].items.push(item);
+        gaps.push({
+            kind,
+            item,
+            protocols: [...entry.protocols],
+            frequency,
+            examples: entry.examples.slice(0, 3),
+            priority,
+        });
+    }
+    gaps.sort((a, b) => b.priority - a.priority);
+    return {
+        totalFailures,
+        failuresAnalyzed: failures.length,
+        gaps,
+        byKind: byKind,
+        topMissingActions: gaps.filter(g => g.kind === "missing_action").slice(0, 10).map(g => g.item),
+        topMissingTransitions: gaps.filter(g => g.kind === "missing_transition").slice(0, 10).map(g => g.item),
+        topMissingBridges: gaps.filter(g => g.kind === "missing_bridge").slice(0, 5).map(g => g.item),
+    };
+}
+/**
+ * Compute a per-protocol knowledge score.
+ *   score = 0.4*coverage + 0.3*successRate + 0.2*benchmarkPassRate + 0.1*corpusSupport
+ */
+function computeKnowledgeScores(failures) {
+    const protocols = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+    return protocols.map(p => {
+        const relevant = failures.filter(f => f.protocol === p.name || f.expectedRepair.some(fn => p.rules.has(fn)));
+        const passed = relevant.filter(f => f.failureReason === "success").length;
+        const total = relevant.length;
+        // Coverage: states defined / total transitions
+        const coverage = p.states.length > 0 ? Math.min(1, p.states.length / 20) : 0;
+        const successRate = total > 0 ? passed / total : 0;
+        const benchmarkPassRate = total > 0 ? passed / total : 0;
+        const corpusSupport = total > 0 ? Math.min(1, total / 50) : 0;
+        const score = 0.4 * coverage + 0.3 * successRate + 0.2 * benchmarkPassRate + 0.1 * corpusSupport;
+        return {
+            protocol: p.name,
+            coverage,
+            successRate,
+            benchmarkPassRate,
+            corpusSupport,
+            score,
+            gaps: relevant.filter(f => f.failureReason !== "success").length,
+        };
+    }).sort((a, b) => b.score - a.score);
+}
+// ═══════════════════════════════════════════════════════════════
+// Dashboard
+// ═══════════════════════════════════════════════════════════════
+function printGapReport(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   Protocol Gap Mining Report                       ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Failures Analyzed: ${report.failuresAnalyzed}/${report.totalFailures}`);
+    console.log(`Gaps Found:        ${report.gaps.length}`);
+    console.log();
+    console.log("─── Gap Breakdown ───");
+    for (const [kind, info] of Object.entries(report.byKind)) {
+        if (info.count === 0)
+            continue;
+        const label = kind.replace(/_/g, " ").padEnd(22);
+        console.log(`  ${label} ${String(info.count).padStart(4)} items`);
+    }
+    console.log();
+    if (report.topMissingActions.length > 0) {
+        console.log("─── Top Missing Actions (add to protocol rules) ───");
+        const tops = report.gaps.filter(g => g.kind === "missing_action").slice(0, 10);
+        for (const g of tops) {
+            console.log(`  ${g.item.padEnd(25)} freq=${g.frequency}  pri=${(g.priority * 100).toFixed(0)}%`);
+        }
+        console.log();
+    }
+    if (report.topMissingTransitions.length > 0) {
+        console.log("─── Top Missing Transitions ───");
+        for (const t of report.topMissingTransitions.slice(0, 5)) {
+            console.log(`  ${t}`);
+        }
+        console.log();
+    }
+    if (report.topMissingBridges.length > 0) {
+        console.log("─── Top Missing Bridges ───");
+        for (const b of report.topMissingBridges) {
+            console.log(`  ${b}`);
+        }
+        console.log();
+    }
+}
+function printKnowledgeScores(scores) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   Protocol Knowledge Scoreboard                    ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log("Protocol          Covrg  Succ   Bench  Corpus  Score  Gaps");
+    console.log("──────────────────────────────────────────────────────────");
+    for (const s of scores) {
+        const cov = (s.coverage * 100).toFixed(0).padStart(4);
+        const suc = (s.successRate * 100).toFixed(0).padStart(4);
+        const ben = (s.benchmarkPassRate * 100).toFixed(0).padStart(4);
+        const cor = (s.corpusSupport * 100).toFixed(0).padStart(4);
+        const scr = (s.score * 100).toFixed(0).padStart(4);
+        const icon = s.score > 0.7 ? "🟢" : s.score > 0.4 ? "🟡" : "🔴";
+        console.log(`  ${s.protocol.padEnd(16)} ${cov}% ${suc}% ${ben}% ${cor}% ${scr}% ${String(s.gaps).padStart(4)} ${icon}`);
+    }
+    console.log();
+}

package/dist/protocol-gap-analyzer.test.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * P3.16-17: Protocol Gap Mining Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const protocol_gap_analyzer_1 = require("./protocol-gap-analyzer");
+function makeAttributedCases() {
+    return [
+        { caseId: "c1", goal: "authenticate user", protocol: "AuthProtocol", violationType: "missing_prerequisite", expectedRepair: ["verify_password", "generate_jwt", "create_session"], plannerTop1: ["logout"], candidatesReturned: 1, rank: null, failureReason: "missing_candidate" },
+        { caseId: "c2", goal: "authenticate user", protocol: "AuthProtocol", violationType: "missing_prerequisite", expectedRepair: ["verify_password", "generate_jwt", "create_session"], plannerTop1: ["logout"], candidatesReturned: 1, rank: null, failureReason: "missing_candidate" },
+        { caseId: "c3", goal: "full auth lifecycle", protocol: "AuthProtocol", violationType: "missing_prerequisite", expectedRepair: ["verify_password", "generate_jwt", "create_session", "logout"], plannerTop1: ["logout"], candidatesReturned: 1, rank: null, failureReason: "missing_candidate" },
+        { caseId: "c4", goal: "safely write file", protocol: "FileProtocol", violationType: "resource_leak", expectedRepair: ["open_file", "write_file", "flush_file", "close_file"], plannerTop1: ["close_file"], candidatesReturned: 1, rank: null, failureReason: "missing_candidate" },
+        { caseId: "c5", goal: "safely write file", protocol: "FileProtocol", violationType: "resource_leak", expectedRepair: ["open_file", "write_file", "flush_file", "close_file"], plannerTop1: ["close_file"], candidatesReturned: 1, rank: null, failureReason: "missing_candidate" },
+        { caseId: "c6", goal: "query db safely", protocol: "DBProtocol", violationType: "missing_prerequisite", expectedRepair: ["connect_db", "query_db", "disconnect_db"], plannerTop1: ["disconnect_db"], candidatesReturned: 1, rank: null, failureReason: "missing_candidate" },
+        { caseId: "c7", goal: "auth then file then db", protocol: "FileProtocol", violationType: "resource_leak", expectedRepair: ["verify_password", "open_file", "write_file", "close_file", "connect_db", "query_db", "disconnect_db"], plannerTop1: ["close_file"], candidatesReturned: 1, rank: null, failureReason: "missing_candidate" },
+        { caseId: "c8", goal: "success case", protocol: "FileProtocol", violationType: "resource_leak", expectedRepair: ["open_file", "write_file", "close_file"], plannerTop1: ["open_file", "write_file", "close_file"], candidatesReturned: 3, rank: 1, failureReason: "success" },
+    ];
+}
+(0, vitest_1.describe)("Protocol Gap Analyzer", () => {
+    (0, vitest_1.it)("identifies missing actions from failures", () => {
+        const cases = makeAttributedCases();
+        // Build rules map: only existing protocol functions
+        const rules = new Map();
+        rules.set("AuthProtocol", new Set(["verify_password", "generate_jwt", "create_session", "logout", "revoke_token"]));
+        rules.set("FileProtocol", new Set(["open_file", "read_file", "write_file", "close_file"]));
+        rules.set("DBProtocol", new Set(["connect_db", "query_db", "disconnect_db"]));
+        rules.set("IRProtocol", new Set(["extractIR", "validateAction", "validateActionSequence", "emitCode", "recordSession"]));
+        const report = (0, protocol_gap_analyzer_1.analyzeProtocolGaps)(cases, rules);
+        (0, vitest_1.expect)(report.failuresAnalyzed).toBe(7); // 8 total, 1 success
+        (0, vitest_1.expect)(report.gaps.length).toBeGreaterThan(0);
+        // flush_file should appear as a missing action
+        const missingActions = report.gaps.filter(g => g.kind === "missing_action");
+        (0, vitest_1.expect)(missingActions.some(g => g.item === "flush_file")).toBe(true);
+        // flush_file appears in 2 cases (c4, c5)
+        const flushGap = missingActions.find(g => g.item === "flush_file");
+        (0, vitest_1.expect)(flushGap?.frequency).toBe(2);
+        (0, protocol_gap_analyzer_1.printGapReport)(report);
+    });
+    (0, vitest_1.it)("computes knowledge scores per protocol", () => {
+        const cases = makeAttributedCases();
+        const scores = (0, protocol_gap_analyzer_1.computeKnowledgeScores)(cases);
+        (0, vitest_1.expect)(scores.length).toBeGreaterThanOrEqual(4); // P7.3: 9 protocol groups
+        // FileProtocol has success case → higher score
+        const file = scores.find(s => s.protocol === "FileProtocol");
+        (0, vitest_1.expect)(file.successRate).toBeGreaterThan(0);
+        (0, protocol_gap_analyzer_1.printKnowledgeScores)(scores);
+    });
+});