progmune-runtime 2.1.4 → 2.1.5

package/dist/memory-layer.js

@@ -37,6 +37,7 @@ exports.WorkMemory = void 0;
 exports.recordEpisode = recordEpisode;
 exports.getRecentEpisodes = getRecentEpisodes;
 exports.getSuccessfulEpisodes = getSuccessfulEpisodes;
+exports.pruneEpisodicMemory = pruneEpisodicMemory;
 exports.consolidateSemantic = consolidateSemantic;
 exports.findSemanticTemplate = findSemanticTemplate;
 const fs = __importStar(require("fs"));
@@ -100,10 +101,14 @@ function recordEpisode(episode) {
         timestamp: new Date().toISOString(),
     };
     episodes.unshift(newEpisode);
-    if (episodes.length > MAX_EPISODES) {
+    // Simple cap: trim to prevent runaway growth between GC cycles
+    if (episodes.length > MAX_EPISODES * 1.5) {
         episodes.length = MAX_EPISODES;
     }
     saveEpisodes(episodes);
+    // Run GC every 100 episodes
+    if (episodes.length % 100 === 0)
+        pruneEpisodicMemory();
 }
 /** @requires LIMIT @produces EPISODE_LIST */
 function getRecentEpisodes(limit = 10) {
@@ -112,6 +117,35 @@ function getRecentEpisodes(limit = 10) {
 function getSuccessfulEpisodes(limit = 10) {
     return loadEpisodes().filter(e => e.success).slice(0, limit);
 }
+// ── Semantic GC: prune episodic memory ──
+const MAX_EPISODE_COUNT = 1000;
+const MAX_AGE_DAYS = 30;
+/** Prune episodic memory: keep high-value, recent, diverse episodes.
+ *  Removes: old failures (>30 days), low-value duplicates, excess beyond max.
+ *  Called periodically after recording new episodes. */
+function pruneEpisodicMemory() {
+    const episodes = loadEpisodes();
+    if (episodes.length <= MAX_EPISODE_COUNT)
+        return 0;
+    const now = Date.now();
+    const scored = episodes.map((ep, i) => {
+        const ageDays = (now - new Date(ep.timestamp).getTime()) / 86400000;
+        // Score: success=+2, recent=+3, older=-1/day
+        let score = ep.success ? 2 : 0;
+        score += Math.max(0, 3 - ageDays * 0.5); // recent bonus, decays over 6 days
+        score -= Math.max(0, (ageDays - MAX_AGE_DAYS) * 0.5); // penalty for >30 days
+        return { ep, score, index: i };
+    });
+    // Keep top MAX_EPISODES by score
+    scored.sort((a, b) => b.score - a.score);
+    const kept = scored.slice(0, MAX_EPISODE_COUNT).sort((a, b) => a.index - b.index);
+    const removed = episodes.length - kept.length;
+    if (removed > 0) {
+        saveEpisodes(kept.map(s => s.ep));
+        console.error(`[Memory] Semantic GC: removed ${removed} low-value episodes, kept ${kept.length}`);
+    }
+    return removed;
+}
 const SEMANTIC_FILE = path.join(MEMORY_DIR, "semantic.json");
 const SEMANTIC_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30 天
 function loadSemantic() {
@@ -174,18 +208,28 @@ function consolidateSemantic(minOccurrences = 3) {
     saveSemantic(templates);
     console.error(`[语义记忆] 巩固完成，模板数量: ${templates.length}`);
 }
-/** @requires INTENT @produces TEMPLATE */
+/** @requires INTENT @produces TEMPLATE
+ *  Uses keyword overlap (replaces prefix matching) for semantic recall. */
 function findSemanticTemplate(intent) {
     const templates = loadSemantic();
     if (templates.length === 0)
         return undefined;
-    const prefix = intent.substring(0, 20).toLowerCase();
-    const exactMatch = templates.find(t => t.intentPattern.toLowerCase() === prefix);
-    if (exactMatch && exactMatch.successRate >= 0.7)
-        return exactMatch;
-    const fuzzyMatch = templates.find(t => {
-        const pattern = t.intentPattern.toLowerCase();
-        return (prefix.includes(pattern) || pattern.includes(prefix)) && t.successRate >= 0.8;
-    });
-    return fuzzyMatch;
+    // Extract keywords from intent
+    const words = new Set(intent.toLowerCase().split(/[\s,，]+/).filter(w => w.length > 2));
+    if (words.size === 0)
+        return undefined;
+    // Score templates by keyword overlap
+    let best;
+    let bestScore = 0;
+    for (const t of templates) {
+        const tWords = t.intentPattern.toLowerCase().split(/[\s,，]+/);
+        const shared = tWords.filter(w => words.has(w)).length;
+        const total = new Set([...words, ...new Set(tWords)]).size;
+        const score = shared / (total || 1); // Jaccard-like
+        if (score > 0.5 && t.successRate >= 0.7 && score > bestScore) {
+            bestScore = score;
+            best = t;
+        }
+    }
+    return best;
 }

package/dist/planner.js

@@ -750,6 +750,17 @@ async function plan(userIntent) {
                     score += matchCount * 0.2;
             }
         }
+        // Semantic Capability: useWhen scenario matching
+        if (f.useWhen) {
+            for (const scenario of f.useWhen) {
+                const scenarioWords = scenario.toLowerCase().split(/[\s,]+/);
+                const matchCount = scenarioWords.filter((w) => w.length > 3 && intentLower.includes(w)).length;
+                if (matchCount >= 2)
+                    score += 3.0; // strong signal: intent matches use case
+                else if (matchCount === 1)
+                    score += 1.0;
+            }
+        }
         // Capability Graph: tag match
         if (f.tags) {
             for (const tag of f.tags) {
@@ -758,7 +769,7 @@ async function plan(userIntent) {
             }
         }
         // Dynamic Credit: multiply by actual success rate (0.1-1.0)
-        const successRate = (0, feedback_1.getFunctionSuccessRate)(f.name);
+        const successRate = (0, feedback_1.getFailureAdjustedCredit)(f.name);
         const creditFactor = 0.3 + successRate * 0.7; // range: 0.3 (always fail) to 1.0 (always succeed)
         if (f.exported && !f.external)
             score *= creditFactor;

package/dist/session-utils.js

@@ -6,6 +6,7 @@ exports.formatSessionCounts = formatSessionCounts;
  * @requires SESSION_LIST @produces RESOLVED_COUNT
  * @tags session, count, statistics
  */
+/** @useWhen checking how many sessions succeeded; computing success rate */
 function countResolved(sessions) {
     const resolved = sessions.filter((s) => s.resolved).length;
     return { resolved, unresolved: sessions.length - resolved, total: sessions.length };

package/dist/stdlib.js

@@ -32,10 +32,12 @@ exports.retry = retry;
 exports.debounce = debounce;
 // ── String ──
 /** @requires STRING @produces VALIDATION_RESULT @tags string, email, validation */
+/** @useWhen validating user input; form validation; email checking */
 function isValidEmail(str) {
     return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str);
 }
 /** @requires STRING @produces TRUNCATED_STRING @tags string, format */
+/** @useWhen displaying preview text; limiting UI output; shortening strings */
 function truncate(str, maxLen, ellipsis = "...") {
     return str.length <= maxLen ? str : str.slice(0, maxLen - ellipsis.length) + ellipsis;
 }
@@ -88,6 +90,7 @@ function arrayDiff(a, b) {
 }
 // ── Math ──
 /** @requires NUMBERS @produces AVERAGE @tags math, statistics */
+/** @useWhen computing statistics; data analysis; metrics calculation */
 function average(nums) {
     return nums.length === 0 ? 0 : nums.reduce((a, b) => a + b, 0) / nums.length;
 }

package/dist/strategy-planner.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.selectCapabilityChains = selectCapabilityChains;
 exports.formatChainHint = formatChainHint;
 const utils_1 = require("./utils");
+const feedback_1 = require("./feedback");
 /** Build a capability graph from IR functions. */
 function buildCapabilityGraph(ir) {
     const graph = new Map();
@@ -55,7 +56,10 @@ function scoreNode(node, intentLower, keywords) {
         if (w.length > 2 && purposeLower.includes(w))
             score += 0.5;
     }
-    return score;
+    // Dynamic Credit: multiply by actual success rate
+    const successRate = (0, feedback_1.getFailureAdjustedCredit)(node.name);
+    const creditFactor = 0.3 + successRate * 0.7;
+    return score * creditFactor;
 }
 /** Find all capability nodes that produce a given capability label. */
 function findProducers(graph, capability) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "progmune-runtime",
-  "version": "2.1.4",
+  "version": "2.1.5",
   "description": "Progmune Runtime — Program Immunology: Constraint-Guided Program Synthesis Runtime",
   "main": "dist/mcp-server.mjs",
   "bin": {