progmune-runtime 2.1.6 → 3.2.0

package/dist/pairwise-preference.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * P3.11-13: Pairwise Preference System
+ *
+ * Upgrades from pointwise (accepted/rejected) to pairwise (A > B)
+ * preference data — the primitive format for RLHF.
+ *
+ * P3.11: RepairPreference data structure + collection
+ * P3.12: Enhanced benchmark with acceptableTop3 + unacceptableRepairs
+ * P3.13: PreferenceRanker using pairwise win rates
+ *
+ * Key insight: Top-3 (37%) vs Top-1 (12%) gap = 25%.
+ * Correct answers are in the candidate pool but ranked wrong.
+ * Pairwise preference is how we fix this.
+ */
+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.PAIRWISE_BENCHMARK_CASES = exports.PreferenceRanker = void 0;
+exports.createPreferenceStore = createPreferenceStore;
+exports.recordPreference = recordPreference;
+exports.getWinRate = getWinRate;
+exports.savePreferences = savePreferences;
+exports.runRankerStressTest = runRankerStressTest;
+exports.printRankerStressReport = printRankerStressReport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const planner_telemetry_1 = require("./planner-telemetry");
+const repair_ranker_1 = require("./repair-ranker");
+function createPreferenceStore() {
+    return {
+        preferences: [],
+        winCounts: new Map(),
+        comparisonCounts: new Map(),
+    };
+}
+/** Record a pairwise preference: winner > loser. */
+function recordPreference(store, winner, loser, goal, protocol) {
+    const pref = { winner, loser, goal, protocol, timestamp: Date.now() };
+    store.preferences.push(pref);
+    store.winCounts.set(winner, (store.winCounts.get(winner) || 0) + 1);
+    store.comparisonCounts.set(winner, (store.comparisonCounts.get(winner) || 0) + 1);
+    store.comparisonCounts.set(loser, (store.comparisonCounts.get(loser) || 0) + 1);
+}
+/** Win rate: wins / total comparisons. Default 0.5 for unknowns. */
+function getWinRate(store, fingerprint, minComparisons = 3) {
+    const wins = store.winCounts.get(fingerprint) || 0;
+    const total = store.comparisonCounts.get(fingerprint) || 0;
+    if (total < minComparisons)
+        return 0.5;
+    return wins / total;
+}
+/** Persist preferences to disk. */
+function savePreferences(store, dir) {
+    const outDir = dir || path.resolve(process.cwd(), ".progmune_corpus", "preferences");
+    if (!fs.existsSync(outDir))
+        fs.mkdirSync(outDir, { recursive: true });
+    fs.writeFileSync(path.join(outDir, `prefs-${new Date().toISOString().slice(0, 10)}.json`), JSON.stringify(store.preferences, null, 2));
+}
+/**
+ * Run a stress test: how well does the ranker distinguish
+ * acceptable repairs from unacceptable ones?
+ */
+function runRankerStressTest(cases, candidateGenerator, ranker) {
+    const results = [];
+    for (const tc of cases) {
+        const candidates = candidateGenerator(tc.goal, tc.protocol);
+        let ranked = candidates;
+        if (ranker) {
+            const ctx = { protocol: tc.protocol, currentState: [], targetState: [], violationType: tc.violationType, constraints: [], rules: new Map() };
+            const features = candidates.map(c => (0, repair_ranker_1.extractFeatures)(c, ctx));
+            ranked = ranker(candidates, features);
+        }
+        const top1 = ranked[0];
+        const top3 = ranked.slice(0, 3);
+        const top1Correct = top1
+            ? tc.expectedTop1.every(fn => top1.actions.some(a => a.kind === "call" && a.function === fn))
+            : false;
+        // Count acceptable patterns in top 3
+        let acceptableFound = 0;
+        for (const pattern of tc.acceptableTop3) {
+            const found = top3.some(c => pattern.every(fn => c.actions.some(a => a.kind === "call" && a.function === fn)));
+            if (found)
+                acceptableFound++;
+        }
+        const top3Coverage = tc.acceptableTop3.length > 0 ? acceptableFound / tc.acceptableTop3.length : 0;
+        // Check for unacceptable repairs
+        const unacceptableFound = tc.unacceptableRepairs.some(pattern => ranked.some(c => pattern.every(fn => c.actions.some(a => a.kind === "call" && a.function === fn))));
+        results.push({
+            goal: tc.goal,
+            top1Correct,
+            top3Coverage,
+            unacceptableFound,
+            totalCandidates: candidates.length,
+            preferenceRankerWinRate: 0,
+        });
+    }
+    return {
+        cases: cases.length,
+        top1Accuracy: results.filter(r => r.top1Correct).length / Math.max(1, cases.length),
+        top3Acceptability: results.reduce((s, r) => s + r.top3Coverage, 0) / Math.max(1, cases.length),
+        unacceptableFiltered: results.filter(r => !r.unacceptableFound).length / Math.max(1, cases.length),
+        avgCandidates: results.reduce((s, r) => s + r.totalCandidates, 0) / Math.max(1, cases.length),
+    };
+}
+function printRankerStressReport(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   Ranker Stress Test Report                        ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Cases:                 ${report.cases}`);
+    console.log(`Top-1 Accuracy:        ${(report.top1Accuracy * 100).toFixed(0)}%`);
+    console.log(`Top-3 Acceptability:   ${(report.top3Acceptability * 100).toFixed(0)}%`);
+    console.log(`Unacceptable Filtered: ${(report.unacceptableFiltered * 100).toFixed(0)}%`);
+    console.log(`Avg Candidates:        ${report.avgCandidates.toFixed(1)}`);
+    const top3Top1Gap = report.top3Acceptability - report.top1Accuracy;
+    console.log(`\n  Top-3/Top-1 Gap:    ${(top3Top1Gap * 100).toFixed(0)}%`);
+    if (top3Top1Gap > 0.2) {
+        console.log("  ⚠️  Large gap: candidates found but ranked wrong. Priority = ranking.");
+    }
+    else {
+        console.log("  ✅ Small gap: ranking is working well.");
+    }
+    console.log();
+}
+// ═══════════════════════════════════════════════════════════════
+// P3.13: Preference Ranker
+// ═══════════════════════════════════════════════════════════════
+/**
+ * PreferenceRanker: ranks candidates by pairwise win rate.
+ *
+ * Given historical preference data (A > B, B > C, ...),
+ * computes Elo-like scores from pairwise comparisons.
+ *
+ *   score = winRate * 0.6 + heuristicScore * 0.4
+ *
+ * Where winRate comes from the preference store and
+ * heuristicScore comes from the base LinearRanker.
+ */
+class PreferenceRanker {
+    constructor(store, minComparisons = 3) {
+        this.store = store || createPreferenceStore();
+        this.minComparisons = minComparisons;
+    }
+    /** Get the pairwise win rate for a candidate's fingerprint. */
+    winRate(candidate, protocol, violationType) {
+        const actions = candidate.actions
+            .filter(a => a.kind === "call")
+            .map(a => a.function);
+        const fp = (0, planner_telemetry_1.candidateFingerprint)(protocol, actions, violationType);
+        return getWinRate(this.store, fp, this.minComparisons);
+    }
+    /**
+     * Rank candidates by combining pairwise win rate with heuristic score.
+     *
+     *   score = winRate * 0.6 + heuristicScore * 0.4
+     *
+     * Where heuristicScore comes from LinearRanker (protocolSafety, performance, etc.)
+     * and winRate comes from historical pairwise preferences.
+     */
+    rank(candidates, features, protocol, violationType) {
+        const baseRanker = (0, repair_ranker_1.createLinearRanker)();
+        const heuristicScores = features.map(f => baseRanker.score(f));
+        const scored = candidates.map((c, i) => ({
+            candidate: c,
+            score: this.winRate(c, protocol, violationType) * 0.6 +
+                heuristicScores[i] * 0.4,
+        }));
+        scored.sort((a, b) => b.score - a.score);
+        return scored.map(s => s.candidate);
+    }
+    get preferences() {
+        return this.store.preferences;
+    }
+}
+exports.PreferenceRanker = PreferenceRanker;
+// ═══════════════════════════════════════════════════════════════
+// Pairwise Preference Benchmarks
+// ═══════════════════════════════════════════════════════════════
+/** Pre-built pairwise benchmark cases for ranker stress testing. */
+exports.PAIRWISE_BENCHMARK_CASES = [
+    {
+        goal: "safely write config file",
+        protocol: "FileProtocol",
+        expectedTop1: ["open_file", "write_file", "close_file"],
+        acceptableTop3: [
+            ["open_file", "write_file", "close_file"],
+            ["open_file", "write_file", "flush", "close_file"],
+        ],
+        unacceptableRepairs: [
+            ["write_file"], // skip open
+            ["open_file", "write_file"], // missing close
+        ],
+        violationType: "resource_leak",
+    },
+    {
+        goal: "authenticate user",
+        protocol: "AuthProtocol",
+        expectedTop1: ["verify_password", "generate_jwt", "create_session"],
+        acceptableTop3: [
+            ["verify_password", "generate_jwt", "create_session"],
+            ["verify_password", "generate_jwt"],
+        ],
+        unacceptableRepairs: [
+            ["generate_jwt"], // skip verify
+            ["create_session"], // skip verify+jwt
+            ["logout"], // wrong direction
+        ],
+        violationType: "missing_prerequisite",
+    },
+    {
+        goal: "logout user",
+        protocol: "AuthProtocol",
+        expectedTop1: ["verify_password", "generate_jwt", "create_session", "logout"],
+        acceptableTop3: [
+            ["verify_password", "generate_jwt", "create_session", "logout"],
+        ],
+        unacceptableRepairs: [
+            ["logout"], // skip prerequisites entirely
+        ],
+        violationType: "illegal_state_transition",
+    },
+    {
+        goal: "query database safely",
+        protocol: "DBProtocol",
+        expectedTop1: ["connect_db", "query_db", "disconnect_db"],
+        acceptableTop3: [
+            ["connect_db", "query_db", "disconnect_db"],
+        ],
+        unacceptableRepairs: [
+            ["query_db"], // no connection
+            ["connect_db", "query_db"], // missing disconnect
+        ],
+        violationType: "missing_prerequisite",
+    },
+    {
+        goal: "extract IR and validate",
+        protocol: "IRProtocol",
+        expectedTop1: ["extractIR", "validateAction"],
+        acceptableTop3: [
+            ["extractIR", "validateAction"],
+            ["extractIR", "validateAction", "validateActionSequence"],
+        ],
+        unacceptableRepairs: [
+            ["validateAction"], // skip extract
+            ["emitCode"], // skip entire pipeline
+        ],
+        violationType: "missing_prerequisite",
+    },
+    {
+        goal: "full IR pipeline",
+        protocol: "IRProtocol",
+        expectedTop1: ["extractIR", "validateAction", "validateActionSequence", "emitCode", "recordSession"],
+        acceptableTop3: [
+            ["extractIR", "validateAction", "validateActionSequence", "emitCode", "recordSession"],
+            ["extractIR", "validateAction", "validateActionSequence", "emitCode"],
+        ],
+        unacceptableRepairs: [
+            ["extractIR", "emitCode"], // skip validation
+            ["recordSession"], // skip everything
+        ],
+        violationType: "missing_prerequisite",
+    },
+];

package/dist/pairwise-preference.test.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * P3.11-13: Pairwise Preference Tests
+ *
+ * Verifying:
+ *   1. Pairwise preference recording and win rate computation
+ *   2. Ranker stress test with acceptable/unacceptable patterns
+ *   3. PreferenceRanker using pairwise win rates
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const pairwise_preference_1 = require("./pairwise-preference");
+const planner_telemetry_1 = require("./planner-telemetry");
+// ═══════════════════════════════════════════════════════════════
+// P3.11: Pairwise Preference
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("Pairwise Preference", () => {
+    (0, vitest_1.it)("records and queries win rates", () => {
+        const store = (0, pairwise_preference_1.createPreferenceStore)();
+        const fpA = (0, planner_telemetry_1.candidateFingerprint)("FileProtocol", ["open_file", "write_file", "close_file"], "resource_leak");
+        const fpB = (0, planner_telemetry_1.candidateFingerprint)("FileProtocol", ["open_file", "write_file"], "resource_leak");
+        const fpC = (0, planner_telemetry_1.candidateFingerprint)("FileProtocol", ["atomic_write"], "resource_leak");
+        // A beats B 8 times
+        for (let i = 0; i < 8; i++) {
+            (0, pairwise_preference_1.recordPreference)(store, fpA, fpB, "safely write config file", "FileProtocol");
+        }
+        // B beats A 2 times
+        for (let i = 0; i < 2; i++) {
+            (0, pairwise_preference_1.recordPreference)(store, fpB, fpA, "safely write config file", "FileProtocol");
+        }
+        // A beats C 5 times
+        for (let i = 0; i < 5; i++) {
+            (0, pairwise_preference_1.recordPreference)(store, fpA, fpC, "safely write config file", "FileProtocol");
+        }
+        (0, vitest_1.expect)(store.preferences.length).toBe(15);
+        // A: 8+5=13 wins / 10+5=15 comparisons = 86.7%
+        const aRate = (0, pairwise_preference_1.getWinRate)(store, fpA, 3);
+        (0, vitest_1.expect)(aRate).toBeCloseTo(13 / 15, 2);
+        // B: 2 wins / 10 comparisons = 20%
+        const bRate = (0, pairwise_preference_1.getWinRate)(store, fpB, 3);
+        (0, vitest_1.expect)(bRate).toBe(0.2);
+        // C: 0 wins / 5 comparisons = 0%
+        const cRate = (0, pairwise_preference_1.getWinRate)(store, fpC, 3);
+        (0, vitest_1.expect)(cRate).toBe(0);
+        // Unknown fingerprint: default 0.5
+        const unknown = (0, pairwise_preference_1.getWinRate)(store, "unknown-fp", 3);
+        (0, vitest_1.expect)(unknown).toBe(0.5);
+    });
+    (0, vitest_1.it)("defaults to 0.5 for fingerprints with insufficient comparisons", () => {
+        const store = (0, pairwise_preference_1.createPreferenceStore)();
+        const fp = (0, planner_telemetry_1.candidateFingerprint)("FileProtocol", ["close_file"], "resource_leak");
+        (0, pairwise_preference_1.recordPreference)(store, fp, "other", "test", "FileProtocol");
+        // 1 win, 1 comparison → need 3 minimum
+        (0, vitest_1.expect)((0, pairwise_preference_1.getWinRate)(store, fp, 3)).toBe(0.5);
+        // 1 win, 1 comparison → enough for min 1
+        (0, vitest_1.expect)((0, pairwise_preference_1.getWinRate)(store, fp, 1)).toBe(1.0);
+    });
+});
+// ═══════════════════════════════════════════════════════════════
+// P3.12: Ranker Stress Test
+// ═══════════════════════════════════════════════════════════════
+function fakeCandidateGenerator(goal, _protocol) {
+    if (goal.includes("safely write")) {
+        return [
+            { id: "safe", source: "protocol", actions: fnActions(["open_file", "write_file", "close_file"]), explanation: "safe" },
+            { id: "flush", source: "corpus", actions: fnActions(["open_file", "write_file", "flush", "close_file"]), explanation: "safe+flush" },
+            { id: "leak", source: "corpus", actions: fnActions(["open_file", "write_file"]), explanation: "leaky" },
+            { id: "bare", source: "antibody", actions: fnActions(["write_file"]), explanation: "bare" },
+        ];
+    }
+    if (goal.includes("authenticate")) {
+        return [
+            { id: "full", source: "protocol", actions: fnActions(["verify_password", "generate_jwt", "create_session"]), explanation: "full" },
+            { id: "partial", source: "protocol", actions: fnActions(["verify_password", "generate_jwt"]), explanation: "partial" },
+            { id: "skip", source: "antibody", actions: fnActions(["generate_jwt"]), explanation: "skip-verify" },
+            { id: "wrong", source: "corpus", actions: fnActions(["logout"]), explanation: "wrong" },
+        ];
+    }
+    return [];
+}
+function fnActions(fns) {
+    return fns.map(fn => ({ kind: "call", function: fn, args: [] }));
+}
+(0, vitest_1.describe)("Ranker Stress Test", () => {
+    (0, vitest_1.it)("measures top-1 accuracy and top-3 acceptability", () => {
+        const testCases = pairwise_preference_1.PAIRWISE_BENCHMARK_CASES.slice(0, 2); // first 2
+        const report = (0, pairwise_preference_1.runRankerStressTest)(testCases, fakeCandidateGenerator);
+        (0, vitest_1.expect)(report.cases).toBe(2);
+        (0, vitest_1.expect)(report.top1Accuracy).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(report.top3Acceptability).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(report.unacceptableFiltered).toBeGreaterThanOrEqual(0);
+        // With our fake generator: safe+flush both in top 3 for file case, full+partial for auth
+        (0, vitest_1.expect)(report.top3Acceptability).toBeGreaterThan(0.5);
+        (0, pairwise_preference_1.printRankerStressReport)(report);
+    });
+    (0, vitest_1.it)("all benchmark cases have expectedTop1, acceptableTop3, unacceptableRepairs", () => {
+        for (const c of pairwise_preference_1.PAIRWISE_BENCHMARK_CASES) {
+            (0, vitest_1.expect)(c.expectedTop1.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(c.acceptableTop3.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(c.unacceptableRepairs.length).toBeGreaterThan(0);
+        }
+    });
+});
+// ═══════════════════════════════════════════════════════════════
+// P3.13: PreferenceRanker
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("PreferenceRanker", () => {
+    (0, vitest_1.it)("ranks candidates by pairwise win rate", () => {
+        const store = (0, pairwise_preference_1.createPreferenceStore)();
+        const safeFp = (0, planner_telemetry_1.candidateFingerprint)("FileProtocol", ["open_file", "write_file", "close_file"], "resource_leak");
+        const leakFp = (0, planner_telemetry_1.candidateFingerprint)("FileProtocol", ["open_file", "write_file"], "resource_leak");
+        // Safe beats leak 9 times, leak beats safe 1 time
+        for (let i = 0; i < 9; i++)
+            (0, pairwise_preference_1.recordPreference)(store, safeFp, leakFp, "write file", "FileProtocol");
+        for (let i = 0; i < 1; i++)
+            (0, pairwise_preference_1.recordPreference)(store, leakFp, safeFp, "write file", "FileProtocol");
+        const ranker = new pairwise_preference_1.PreferenceRanker(store);
+        const safe = { id: "safe", source: "protocol", actions: fnActions(["open_file", "write_file", "close_file"]), explanation: "safe" };
+        const leak = { id: "leak", source: "corpus", actions: fnActions(["open_file", "write_file"]), explanation: "leaky" };
+        const features = [
+            { protocolSafety: 1.0, historicalSuccessRate: 0.5, actionCount: 3, latencyCost: 0.6, auditability: 0.8, corpusEvidence: 0, source: "protocol" },
+            { protocolSafety: 0.3, historicalSuccessRate: 0.5, actionCount: 2, latencyCost: 0.4, auditability: 0.5, corpusEvidence: 0, source: "corpus" },
+        ];
+        const ranked = ranker.rank([leak, safe], features, "FileProtocol", "resource_leak");
+        // Safe should rank higher (90% win rate vs 10%)
+        (0, vitest_1.expect)(ranked[0].id).toBe("safe");
+        (0, vitest_1.expect)(ranked[1].id).toBe("leak");
+    });
+    (0, vitest_1.it)("defaults to heuristic when no preference data", () => {
+        const ranker = new pairwise_preference_1.PreferenceRanker();
+        const safe = { id: "safe", source: "protocol", actions: fnActions(["open_file", "write_file", "close_file"]), explanation: "safe" };
+        const leak = { id: "leak", source: "antibody", actions: fnActions(["open_file", "write_file"]), explanation: "missing close" };
+        // Safe has higher protocolSafety, leak has lower (missing close = unsafe)
+        const safeFeatures = { protocolSafety: 1.0, historicalSuccessRate: 0.5, actionCount: 3, latencyCost: 0.6, auditability: 0.8, corpusEvidence: 0, source: "protocol" };
+        const leakFeatures = { protocolSafety: 0.2, historicalSuccessRate: 0.3, actionCount: 2, latencyCost: 0.4, auditability: 0.4, corpusEvidence: 0, source: "antibody" };
+        // Without preference data, falls back to heuristic
+        const ranked = ranker.rank([leak, safe], [leakFeatures, safeFeatures], "FileProtocol");
+        (0, vitest_1.expect)(ranked[0].id).toBe("safe");
+    });
+});

package/dist/planner-constraints.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Planner Constraints — mined rules injected into the search space.
+ *
+ * Bridges Rule Miner → Planner: MinedRule patterns directly influence
+ * function scoring, filtering, and prioritization in the capability graph.
+ *
+ * Three levels of constraint:
+ *   L1 (soft): Adjust function scores based on rule confidence
+ *   L2 (medium): Deprioritize functions matching high-risk patterns
+ *   L3 (hard): Blacklist functions that consistently cause violations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveConstraints = deriveConstraints;
+exports.applyConstraints = applyConstraints;
+exports.formatConstraints = formatConstraints;
+exports.getConstraints = getConstraints;
+exports.clearConstraintsCache = clearConstraintsCache;
+const rule_miner_1 = require("./rule-miner");
+/**
+ * Derive planner constraints from mined rules.
+ * Each mined rule becomes a scoring constraint that modifies
+ * how functions are weighted during capability graph construction.
+ */
+function deriveConstraints() {
+    const rules = (0, rule_miner_1.mineRules)();
+    const constraints = [];
+    for (const rule of rules) {
+        // High-confidence rules → stronger penalties
+        const normalizedConf = Math.min(1, rule.confidence / 50); // 50+ occurrences = max confidence
+        // Pattern-based constraints
+        if (rule.function === "symbol_existence") {
+            constraints.push({
+                pattern: "symbol_existence",
+                penalty: Math.max(0.3, 1 - normalizedConf * 0.5), // 0.3-1.0
+                reason: rule.reason,
+                confidence: rule.confidence,
+            });
+        }
+        if (rule.function === "protocol") {
+            constraints.push({
+                pattern: "protocol",
+                penalty: Math.max(0.4, 1 - normalizedConf * 0.4),
+                reason: rule.reason,
+                confidence: rule.confidence,
+            });
+        }
+        if (rule.function === "type_mismatch") {
+            constraints.push({
+                pattern: "type_mismatch",
+                penalty: Math.max(0.5, 1 - normalizedConf * 0.3),
+                reason: rule.reason,
+                confidence: rule.confidence,
+            });
+        }
+        if (rule.function === "dataflow") {
+            constraints.push({
+                pattern: "dataflow",
+                penalty: Math.max(0.5, 1 - normalizedConf * 0.3),
+                reason: rule.reason,
+                confidence: rule.confidence,
+            });
+        }
+    }
+    return constraints;
+}
+/**
+ * Apply constraints to adjust a function's score.
+ * Returns a multiplier in [0, 1] — multiply the raw score by this.
+ */
+function applyConstraints(funcName, funcPurpose, constraints) {
+    let multiplier = 1.0;
+    const matched = [];
+    const searchText = (funcName + " " + funcPurpose).toLowerCase();
+    for (const c of constraints) {
+        // Match: function name/purpose contains the pattern
+        if (searchText.includes(c.pattern.toLowerCase())) {
+            multiplier *= c.penalty;
+            matched.push(`${c.pattern}(${(c.confidence)}x)`);
+        }
+    }
+    return { multiplier: Math.max(0.2, multiplier), matchedRules: matched };
+}
+/**
+ * Get a human-readable summary of active constraints.
+ */
+function formatConstraints(constraints) {
+    if (constraints.length === 0)
+        return "";
+    const lines = ["\n📋 规则约束 (Rule → Planner):"];
+    for (const c of constraints.slice(0, 5)) {
+        const level = c.penalty < 0.4 ? "🔴" : c.penalty < 0.7 ? "🟡" : "🟢";
+        lines.push(`  ${level} ${c.pattern}: ×${c.penalty.toFixed(2)} (${c.reason.slice(0, 40)})`);
+    }
+    return lines.join("\n");
+}
+// Cache constraints (derived once per session)
+let _constraints = null;
+function getConstraints() {
+    if (!_constraints)
+        _constraints = deriveConstraints();
+    return _constraints;
+}
+function clearConstraintsCache() { _constraints = null; }