progmune-runtime 2.1.5 → 3.2.0

package/dist/failure-corpus.js

@@ -37,6 +37,19 @@ exports.saveCheckpoint = saveCheckpoint;
 exports.loadCheckpoint = loadCheckpoint;
 exports.clearCheckpoint = clearCheckpoint;
 exports.recordFailure = recordFailure;
+exports.recordTrajectory = recordTrajectory;
+exports.recordSuccess = recordSuccess;
+exports.recordRepair = recordRepair;
+exports.recordFailureV2 = recordFailureV2;
+exports.loadFailuresV2 = loadFailuresV2;
+exports.loadTrajectories = loadTrajectories;
+exports.queryByResult = queryByResult;
+exports.queryByViolationType = queryByViolationType;
+exports.queryByProtocol = queryByProtocol;
+exports.getTopPatterns = getTopPatterns;
+exports.corpusTrajectoryStats = corpusTrajectoryStats;
+exports.getRepairStats = getRepairStats;
+exports.corpusV2Size = corpusV2Size;
 exports.recordSession = recordSession;
 exports.getAllFailures = getAllFailures;
 exports.getFailuresBySVL = getFailuresBySVL;
@@ -47,6 +60,8 @@ exports.getLearnedPatterns = getLearnedPatterns;
 exports.queryAntibodies = queryAntibodies;
 exports.getSemanticHeatmap = getSemanticHeatmap;
 exports.getAntibodyStats = getAntibodyStats;
+exports.recordEdgeRejection = recordEdgeRejection;
+exports.getEdgeConfidence = getEdgeConfidence;
 exports.generateCandidateRules = generateCandidateRules;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -91,7 +106,7 @@ function clearCheckpoint(intent) {
     try {
         fs.unlinkSync(checkpointPath(intent));
     }
-    catch { }
+    catch { /* checkpoint file may not exist */ }
 }
 /** Record a constraint violation to the failure corpus. */
 function recordFailure(record) {
@@ -105,7 +120,7 @@ function recordFailure(record) {
         try {
             seq = parseInt(fs.readFileSync(seqFile, 'utf-8'), 10);
         }
-        catch { }
+        catch { /* checkpoint file may not exist */ }
         seq++;
         fs.writeFileSync(seqFile, String(seq));
         const id = `fail_${Date.now()}_${seq}`;
@@ -121,6 +136,228 @@ function recordFailure(record) {
         console.error(`[FailureCorpus] ${record.violatedSVL} | 尝试 ${record.plannerAttempt}/${record.plannerRetryTotal} | ${id}`);
     });
 }
+const TRAJECTORY_DIR = path.join(CORPUS_DIR, "trajectories");
+function writeTrajectoryFile(record) {
+    setImmediate(() => {
+        try {
+            const date = record.timestamp.slice(0, 10);
+            const dateDir = path.join(TRAJECTORY_DIR, date);
+            ensureDir(dateDir);
+            fs.writeFileSync(path.join(dateDir, `${record.id}.json`), JSON.stringify(record, null, 2));
+        }
+        catch { /* corpus write must never crash */ }
+    });
+}
+let _trajSeq = 0;
+function nextTrajId() {
+    if (_trajSeq === 0) {
+        const seqFile = path.join(TRAJECTORY_DIR, ".seq");
+        try {
+            _trajSeq = parseInt(fs.readFileSync(seqFile, "utf-8"), 10);
+        }
+        catch { }
+    }
+    _trajSeq++;
+    setImmediate(() => {
+        try {
+            fs.writeFileSync(path.join(TRAJECTORY_DIR, ".seq"), String(_trajSeq));
+        }
+        catch { }
+    });
+    return `T-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+}
+/**
+ * Record any trajectory — success, violation, repair, or optimal.
+ * This is the single entry point for the Code World Model Dataset.
+ */
+function recordTrajectory(params) {
+    ensureDir(TRAJECTORY_DIR);
+    const defaultCtx = { nestingDepth: 0, exceptionHandled: false, insideLoop: false, branchCount: 0, asyncContext: false };
+    const defaultReward = { safety: 0.5, latency: 0.5, maintainability: 0.5, security: 0.5, auditability: 0.5, custom: {} };
+    const record = {
+        id: nextTrajId(),
+        timestamp: new Date().toISOString(),
+        protocol: params.protocol,
+        initialState: params.initialState,
+        finalState: params.finalState,
+        trajectory: params.trajectory,
+        result: params.result,
+        reward: params.result === "success" || params.result === "optimal" ? (params.reward || defaultReward) : undefined,
+        violation: params.result === "violation" || params.result === "repair" ? {
+            type: params.violationType || "other",
+            failingStepIndex: params.failingStepIndex || 0,
+            expectedStates: params.finalState,
+            actualStates: params.initialState,
+            fixPath: params.fixPath,
+            description: params.violationDesc || "",
+        } : undefined,
+        repairFrom: params.repairFrom,
+        context: params.context || defaultCtx,
+        successRate: params.successRate || 0,
+        metadata: {
+            source: params.source || "llm",
+            intent: params.intent,
+            sessionId: params.sessionId,
+        },
+        goal: params.goal,
+        feedback: params.feedback,
+        cost: params.cost,
+    };
+    writeTrajectoryFile(record);
+    console.error(`[Trajectory] ${record.result} | ${params.protocol} | ${record.id}`);
+}
+/**
+ * Record a successful trajectory — positive sample for reward learning.
+ * Call this when validation passes without violations.
+ */
+function recordSuccess(params) {
+    recordTrajectory({ ...params, result: "success", successRate: 1.0 });
+}
+/**
+ * Record a repair trajectory — shows what fix was applied and whether it worked.
+ */
+function recordRepair(params) {
+    recordTrajectory({
+        ...params,
+        result: "repair",
+        successRate: params.success ? 1.0 : 0.0,
+        failingStepIndex: 0,
+    });
+}
+// ── Backward-compatible wrappers ──
+/** @deprecated Use recordTrajectory() with result: "violation" instead. */
+function recordFailureV2(record) {
+    recordTrajectory({
+        protocol: record.protocol,
+        initialState: record.actualStateSequence,
+        finalState: record.expectedStateSequence,
+        trajectory: record.actionSequence,
+        result: "violation",
+        violationType: record.violationType,
+        violationDesc: record.violationType,
+        failingStepIndex: record.failingStepIndex,
+        fixPath: record.ssgFixPath,
+        context: record.contextFeatures,
+        successRate: record.successRate,
+        intent: record.intent,
+        sessionId: record.parentSessionId,
+    });
+}
+/** @deprecated Use loadTrajectories() instead. */
+function loadFailuresV2() {
+    return loadTrajectories()
+        .filter(t => t.result === "violation")
+        .map(t => ({
+        failureId: t.id,
+        timestamp: t.timestamp,
+        protocol: t.protocol,
+        codeSnippet: (t.trajectory || []).join("; "),
+        expectedStateSequence: t.finalState || [],
+        actualStateSequence: t.initialState || [],
+        violationType: t.violation?.type || "other",
+        failingStepIndex: t.violation?.failingStepIndex || 0,
+        contextFeatures: t.context,
+        repairAttempts: [],
+        successRate: t.successRate,
+        actionSequence: t.trajectory || [],
+        ssgStateAtViolation: t.initialState || [],
+        ssgFixPath: t.violation?.fixPath || [],
+        parentSessionId: t.metadata?.sessionId,
+        intent: t.metadata?.intent || "",
+    }));
+}
+// ═══════════════════════════════════════════════════════════════
+// P0: Trajectory query API
+// ═══════════════════════════════════════════════════════════════
+/** Load all trajectory records from the corpus. */
+function loadTrajectories() {
+    const results = [];
+    if (!fs.existsSync(TRAJECTORY_DIR))
+        return results;
+    const dateDirs = fs.readdirSync(TRAJECTORY_DIR, { withFileTypes: true });
+    for (const entry of dateDirs) {
+        if (!entry.isDirectory())
+            continue;
+        const files = fs.readdirSync(path.join(TRAJECTORY_DIR, entry.name));
+        for (const file of files) {
+            if (!file.endsWith(".json"))
+                continue;
+            try {
+                const raw = fs.readFileSync(path.join(TRAJECTORY_DIR, entry.name, file), "utf-8");
+                results.push(JSON.parse(raw));
+            }
+            catch { /* skip corrupted files */ }
+        }
+    }
+    return results.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+}
+/** Query trajectories by result type. */
+function queryByResult(result) {
+    return loadTrajectories().filter(t => t.result === result);
+}
+/** Query violations by type. */
+function queryByViolationType(type) {
+    return loadTrajectories().filter(t => t.violation?.type === type);
+}
+/** Query trajectories by protocol. */
+function queryByProtocol(protocol) {
+    return loadTrajectories().filter(t => t.protocol === protocol);
+}
+/** Get top N violation patterns across all trajectories. */
+function getTopPatterns(limit = 10) {
+    const all = loadTrajectories().filter(t => t.result === "violation");
+    const buckets = {};
+    for (const t of all) {
+        const ctx = t.context;
+        const key = `${t.violation?.type || "other"}|d${ctx.nestingDepth}|${ctx.exceptionHandled ? "try" : "no-try"}|${ctx.insideLoop ? "loop" : "no-loop"}`;
+        if (!buckets[key])
+            buckets[key] = { records: [] };
+        buckets[key].records.push(t);
+    }
+    return Object.entries(buckets)
+        .sort((a, b) => b[1].records.length - a[1].records.length)
+        .slice(0, limit)
+        .map(([key, bucket]) => {
+        const [vt, ...rest] = key.split("|");
+        const avg = bucket.records.reduce((s, t) => s + t.successRate, 0) / bucket.records.length;
+        return {
+            violationType: vt,
+            contextKey: rest.join(" "),
+            count: bucket.records.length,
+            avgSuccessRate: avg,
+        };
+    });
+}
+/** Get total trajectory count and breakdown by result type. */
+function corpusTrajectoryStats() {
+    const all = loadTrajectories();
+    return {
+        total: all.length,
+        success: all.filter(t => t.result === "success").length,
+        violation: all.filter(t => t.result === "violation").length,
+        repair: all.filter(t => t.result === "repair").length,
+        optimal: all.filter(t => t.result === "optimal").length,
+    };
+}
+/** Get repair acceptance statistics for P4 Reward Model training data. */
+function getRepairStats() {
+    const all = loadTrajectories().filter(t => t.result === "repair");
+    const accepted = all.filter(t => t.feedback?.accepted === true).length;
+    const rejected = all.filter(t => t.feedback?.rejected === true).length;
+    const total = all.length;
+    const acceptanceRate = total > 0 ? accepted / total : 0;
+    const costs = all
+        .map(t => t.cost?.latency)
+        .filter((l) => l !== undefined);
+    const avgLatency = costs.length > 0
+        ? costs.reduce((s, l) => s + l, 0) / costs.length
+        : 0;
+    return { acceptedRepairs: accepted, rejectedRepairs: rejected, totalRepairs: total, acceptanceRate, avgLatency };
+}
+/** @deprecated Use corpusTrajectoryStats() instead. */
+function corpusV2Size() {
+    return corpusTrajectoryStats().total;
+}
 /** 记录一个完整的意图会话（支持 ExecutionSession 和旧 IntentSession） */
 /**
  * 保存执行会话（含所有尝试、违规、状态转移）。
@@ -179,7 +416,7 @@ function getAllFailures() {
                 try {
                     records.push(JSON.parse(fs.readFileSync(path.join(dirPath, file), "utf-8")));
                 }
-                catch { }
+                catch { /* checkpoint file may not exist */ }
             }
         }
     }
@@ -287,7 +524,7 @@ function getAllSessions() {
                 const raw = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, file), "utf-8"));
                 sessions.push(normalizeSession(raw));
             }
-            catch { }
+            catch { /* checkpoint file may not exist */ }
         }
     }
     return sessions;
@@ -379,11 +616,11 @@ function getLearnedPatterns() {
             for (const v of a.violations) {
                 if (!v.fixPath || v.fixPath.length === 0)
                     continue;
-                if (v.svl !== 4)
-                    continue; // only SVL-4 has fix paths
                 const violatedLabel = `SVL-${v.svl}`;
-                const missingKey = (v.missingStates || ["unknown"]).join(",");
-                const signature = `${violatedLabel}:${missingKey}`;
+                // Use violatedConstraint if available, otherwise fall back to missingStates
+                const constraintKey = v.violatedConstraint
+                    || (v.missingStates || ["unknown"]).join(",");
+                const signature = `${violatedLabel}:${constraintKey}`;
                 const existing = agg.get(signature);
                 const ts = new Date(s.startedAt).toISOString();
                 if (existing) {
@@ -396,7 +633,7 @@ function getLearnedPatterns() {
                 }
                 else {
                     agg.set(signature, {
-                        violation: `${violatedLabel}: ${(v.missingStates || ["unknown"]).join(", ")}`,
+                        violation: `${violatedLabel}: ${constraintKey}`,
                         fixPath: v.fixPath,
                         count: 1,
                         intents: new Set([s.intent]),
@@ -566,6 +803,82 @@ function getAntibodyStats() {
         .slice(0, 10);
     return { totalHits, fastPathHits, injectedHintHits, totalLLMCallsSaved, totalTokensSaved, byLevel, topSignatures };
 }
+// ── Edge rejection tracking ──
+const MEMORY_DIR = path.join(CORPUS_DIR, "..", ".progmune_memory");
+const REJECTION_FILE = path.join(MEMORY_DIR, "edge_rejections.json");
+/** Record that the LLM rejected a recommended edge (picked a different function). */
+function recordEdgeRejection(producer, consumer) {
+    (0, file_lock_1.withLock)("edge_rejections", () => {
+        let data = {};
+        try {
+            if (fs.existsSync(REJECTION_FILE))
+                data = JSON.parse(fs.readFileSync(REJECTION_FILE, "utf-8"));
+        }
+        catch { }
+        const key = `${producer}→${consumer}`;
+        data[key] = (data[key] || 0) + 1;
+        fs.writeFileSync(REJECTION_FILE, JSON.stringify(data, null, 2));
+    });
+}
+function getEdgeRejections() {
+    try {
+        if (!fs.existsSync(REJECTION_FILE))
+            return new Map();
+        const data = JSON.parse(fs.readFileSync(REJECTION_FILE, "utf-8"));
+        return new Map(Object.entries(data));
+    }
+    catch {
+        return new Map();
+    }
+}
+function getEdgeConfidence(producer, consumer) {
+    const sessions = getAllSessions();
+    const edgeStats = new Map();
+    for (const s of sessions) {
+        for (const a of s.attempts) {
+            const calls = a.transitions
+                .filter(t => t.function)
+                .sort((x, y) => x.actionIndex - y.actionIndex);
+            const isSuccess = a.outcome === "success";
+            for (let i = 0; i < calls.length - 1; i++) {
+                const edgeKey = `${calls[i].function}→${calls[i + 1].function}`;
+                if (!edgeStats.has(edgeKey)) {
+                    edgeStats.set(edgeKey, { success: 0, failure: 0 });
+                }
+                const stats = edgeStats.get(edgeKey);
+                if (isSuccess)
+                    stats.success++;
+                else
+                    stats.failure++;
+            }
+        }
+    }
+    const rejections = getEdgeRejections();
+    const results = [];
+    for (const [key, stats] of edgeStats) {
+        const [prod, cons] = key.split("→");
+        if (producer && prod !== producer)
+            continue;
+        if (consumer && cons !== consumer)
+            continue;
+        // Factor in explicit LLM rejections as negative signal
+        const rejectionCount = rejections.get(key) || 0;
+        const effectiveSuccess = Math.max(0, stats.success - rejectionCount);
+        const effectiveTotal = stats.success + stats.failure + rejectionCount;
+        // Laplace smoothing: Beta(1,1) prior
+        const confidence = (effectiveSuccess + 1) / (effectiveTotal + 2);
+        results.push({
+            producer: prod,
+            consumer: cons,
+            successCount: stats.success,
+            failureCount: stats.failure,
+            totalCount: effectiveTotal,
+            confidence: Math.round(confidence * 100) / 100,
+        });
+    }
+    results.sort((a, b) => b.confidence * b.totalCount - a.confidence * a.totalCount);
+    return results;
+}
 /** Generate candidate immune rules from failure patterns. */
 function generateCandidateRules() {
     const genome = getFailureGenome();

package/dist/feedback.js

@@ -87,16 +87,26 @@ function getWeightedSuccessRate(funcName) {
     return totalWeight > 0 ? weightedSuccess / totalWeight : 0.5;
 }
 /** @requires FUNCTION_NAME @produces FAILURE_ADJUSTED_CREDIT
- *  Credit score adjusted by failure severity.
- *  SVL-4 (protocol) violations penalize 2x more than SVL-1.
- *  Time-weighted + severity-weighted. */
+ *  Credit score adjusted by failure severity with Laplace smoothing.
+ *
+ *  Laplace (add-1) smoothing eliminates small-sample bias:
+ *    - 1/1 success → ~0.67 (not 1.0 — still uncertain)
+ *    - 99/100 success → ~0.98 (approaches empirical rate)
+ *    - 0/1 failure → ~0.33 (not 0.0 — allows redemption)
+ *    - Cold start → 0.5 (neutral prior)
+ *
+ *  SVL-4 protocol violations are penalized 3× more than SVL-1.
+ *  Time-weighted via exponential decay (half-life = 1 day). */
 function getFailureAdjustedCredit(funcName) {
     const records = loadFeedback();
     const funcRecords = records
         .filter(r => r.functionName === funcName)
         .map(r => ({ ...r, age: (Date.now() - new Date(r.timestamp).getTime()) / 86400000 }));
+    // Laplace prior: Beta(1,1) → pseudocount of 1 success + 1 failure
+    const LAPLACE_PRIOR_SUCCESS = 1;
+    const LAPLACE_PRIOR_TOTAL = 2;
     if (funcRecords.length === 0)
-        return 0.5;
+        return LAPLACE_PRIOR_SUCCESS / LAPLACE_PRIOR_TOTAL; // 0.5
     const SVL_PENALTY = {
         "SVL-1": 1.0, // missing function — minor
         "SVL-2": 1.5, // type mismatch — moderate
@@ -116,7 +126,8 @@ function getFailureAdjustedCredit(funcName) {
             // weightedSuccess stays 0 for failures
         }
     }
-    return totalWeight > 0 ? weightedSuccess / totalWeight : 0.5;
+    // Laplace smoothing: (success + 1) / (total + 2)
+    return (weightedSuccess + LAPLACE_PRIOR_SUCCESS) / (totalWeight + LAPLACE_PRIOR_TOTAL);
 }
 /** @requires EXECUTION_DATA @produces RUN_ID */
 function recordRun(intent, actions, success, error) {

package/dist/feedback.test.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Unit tests for feedback module — pure functions only.
+ * Does NOT hit the filesystem (file I/O functions are integration-tested separately).
+ */
+const vitest_1 = require("vitest");
+// We test the pure scoring math indirectly by reading the source patterns.
+// The key behaviors to verify:
+//   1. Cold start returns neutral (no penalty)
+//   2. Consistent success returns high credit
+//   3. SVL-severity affects penalty proportionally
+// Since these functions read from feedback.json on disk,
+// we verify the module exports and type contracts.
+const feedback_1 = require("./feedback");
+(0, vitest_1.describe)("feedback module", () => {
+    (0, vitest_1.it)("loadFeedback returns an array", () => {
+        const records = (0, feedback_1.loadFeedback)();
+        (0, vitest_1.expect)(Array.isArray(records)).toBe(true);
+    });
+    (0, vitest_1.it)("getFunctionSuccessRate returns 0.5 for unknown function (no history)", () => {
+        const rate = (0, feedback_1.getFunctionSuccessRate)("__nonexistent_func_xyz__");
+        (0, vitest_1.expect)(rate).toBe(0.5);
+    });
+    (0, vitest_1.it)("getWeightedSuccessRate returns 0.5 for unknown function", () => {
+        const rate = (0, feedback_1.getWeightedSuccessRate)("__nonexistent_func_xyz__");
+        (0, vitest_1.expect)(rate).toBe(0.5);
+    });
+    (0, vitest_1.it)("getFailureAdjustedCredit returns 0.5 for unknown function (Laplace prior: neutral)", () => {
+        const credit = (0, feedback_1.getFailureAdjustedCredit)("__nonexistent_func_xyz__");
+        (0, vitest_1.expect)(credit).toBe(0.5);
+    });
+    (0, vitest_1.it)("getFailureAdjustedCredit returns a number between 0 and 1", () => {
+        const credit = (0, feedback_1.getFailureAdjustedCredit)("generateJWT");
+        (0, vitest_1.expect)(credit).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(credit).toBeLessThanOrEqual(1);
+    });
+    (0, vitest_1.it)("Laplace smoothing: cold start = 0.5 (neutral prior)", () => {
+        // No records → prior Beta(1,1) → 1/(1+1) = 0.5
+        (0, vitest_1.expect)((0, feedback_1.getFailureAdjustedCredit)("__unknown_fn__")).toBe(0.5);
+    });
+    (0, vitest_1.it)("Laplace smoothing: 0/1 record is not zero (allows redemption)", () => {
+        // Laplace: (0+1)/(1+2) ≈ 0.33, not 0.0
+        // This is only true if there are real records (not cold start).
+        // Cold start with no records returns 0.5 by definition.
+        const credit = (0, feedback_1.getFailureAdjustedCredit)("svl1_test_1780509556916");
+        (0, vitest_1.expect)(credit).toBeGreaterThan(0);
+    });
+});

package/dist/file-lock.js

@@ -64,7 +64,7 @@ function withLock(name, fn) {
                 try {
                     fs.rmdirSync(lock);
                 }
-                catch { }
+                catch { /* best-effort cleanup */ }
             }
         }
         catch (err) {