progmune-runtime 2.1.3 → 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

@@ -39,6 +39,7 @@ const runtime_types_1 = require("./runtime-types");
 const action_runtime_1 = require("./action-runtime");
 const validator_1 = require("./validator");
 const semantic_validator_1 = require("./semantic-validator");
+const feedback_1 = require("./feedback");
 const utils_1 = require("./utils");
 const failure_corpus_1 = require("./failure-corpus");
 const memory_layer_1 = require("./memory-layer");
@@ -46,6 +47,7 @@ const ssg_validator_1 = require("./ssg-validator");
 const protocol_registry_1 = require("./protocol-registry");
 const semantic_snapshot_1 = require("./semantic-snapshot");
 const strategy_planner_1 = require("./strategy-planner");
+const semantic_topology_1 = require("./semantic-topology");
 const fs = __importStar(require("fs"));
 function enrichActions(actions, ir) {
     return actions.map(a => {
@@ -119,17 +121,20 @@ function buildCompactFuncList(funcs, allFuncs) {
     }).join("\n");
 }
 /** Semantic matching: check if two capability labels are related.
- *  Uses exact match, substring, and Jaccard similarity. */
+ *  Uses SemanticTopology (structural graph) instead of string matching. */
 function semanticMatch(a, b) {
+    try {
+        const topo = (0, semantic_topology_1.getTopology)();
+        if (topo.size > 0)
+            return topo.capabilityMatch(a, b);
+    }
+    catch { }
+    // Fallback: exact + substring
     if (a === b)
         return true;
     if (a.includes(b) || b.includes(a))
         return true;
-    // Fuzzy: shared word prefix (e.g. FAILURE_LIST ↔ FAILURE_DATA)
-    const aWords = a.split("_");
-    const bWords = b.split("_");
-    const shared = aWords.filter(w => bWords.some(bw => bw.includes(w) || w.includes(bw)));
-    return shared.length >= 1 && aWords.length <= 3 && bWords.length <= 3;
+    return false;
 }
 /** Build capability chain hints from IR: producer→consumer relationships.
  *  Uses semantic matching for fuzzy capability linking. */
@@ -551,6 +556,11 @@ async function plan(userIntent) {
     const irRaw = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
     // Support both old (array) and new ({typeMap, functions}) formats
     const ir = Array.isArray(irRaw) ? irRaw : (irRaw.functions || []);
+    // P1: Build Semantic Topology (once per plan call, cached)
+    try {
+        (0, semantic_topology_1.rebuildTopology)(ir);
+    }
+    catch { }
     // Helper: wrap actions into PlanResult
     let repairMetrics = { applied: false, count: 0, branchIds: [] };
     const wrapResult = (actions, repair) => ({
@@ -740,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) {
@@ -747,6 +768,11 @@ async function plan(userIntent) {
                     score += 0.8;
             }
         }
+        // Dynamic Credit: multiply by actual success rate (0.1-1.0)
+        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;
         return { ...f, score };
     });
     scored.sort((a, b) => b.score - a.score);
@@ -956,6 +982,17 @@ ${RETRY_HINT}
                 }
             }
         }
+        // P0: Strategy Enforcement — LLM must follow recommended chain
+        if (chains.length > 0 && chains[0].nodes.length >= 2) {
+            const topChain = chains[0];
+            const requiredFuncs = topChain.nodes.map(n => n.name);
+            const chosenFuncs = filtered.filter(a => a.kind === "call").map(a => a.function);
+            const missing = requiredFuncs.filter(fn => !chosenFuncs.includes(fn));
+            if (missing.length >= requiredFuncs.length * 0.5) {
+                // More than 50% of the chain is missing — LLM ignored the strategy
+                preCheckErrors.push(`策略违规: 推荐链 ${topChain.explanation}，但缺少 ${missing.join(", ")}`);
+            }
+        }
         // 1) 基础序列校验
         const seqResult = (0, validator_1.validateActionSequence)(filtered);
         if (!seqResult.valid || preCheckErrors.length > 0) {

package/dist/semantic-topology.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Phase 8: Semantic Topology (P1)
+ *
+ * Builds a similarity graph from IR structural data:
+ *   - File co-occurrence (functions in same file are related)
+ *   - Tag overlap (shared domain tags)
+ *   - Purpose word overlap (Jaccard on purpose text)
+ *   - Chain adjacency (producer→consumer links)
+ *
+ * Replaces simple string matching in capability search.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticTopology = void 0;
+exports.getTopology = getTopology;
+exports.rebuildTopology = rebuildTopology;
+class SemanticTopology {
+    constructor() {
+        this.nodes = new Map();
+        this.edges = new Map();
+        this.similarityCache = new Map();
+    }
+    /** Build topology from IR data */
+    build(ir) {
+        this.nodes.clear();
+        this.edges.clear();
+        this.similarityCache.clear();
+        // 1. Create nodes
+        for (const f of ir) {
+            if (!f.exported && !f.external)
+                continue;
+            this.nodes.set(f.name, {
+                name: f.name,
+                file: f.file || "",
+                tags: new Set((f.tags || []).map((t) => t.toLowerCase())),
+                purposeWords: new Set((f.purpose || "").toLowerCase().split(/[\s,，]+/).filter((w) => w.length > 2)),
+                produces: new Set(f.produces || []),
+                requires: new Set(f.requires || []),
+            });
+        }
+        // 2. Build edges: file co-occurrence
+        const byFile = new Map();
+        for (const [name, node] of this.nodes) {
+            if (!byFile.has(node.file))
+                byFile.set(node.file, []);
+            byFile.get(node.file).push(name);
+        }
+        for (const names of byFile.values()) {
+            for (let i = 0; i < names.length; i++) {
+                for (let j = i + 1; j < names.length; j++) {
+                    this.addEdge(names[i], names[j], 0.3, "co-file");
+                }
+            }
+        }
+        // 3. Build edges: tag overlap
+        for (const [nameA, nodeA] of this.nodes) {
+            for (const [nameB, nodeB] of this.nodes) {
+                if (nameA >= nameB)
+                    continue;
+                const tagOverlap = [...nodeA.tags].filter(t => nodeB.tags.has(t)).length;
+                if (tagOverlap > 0) {
+                    const maxTags = Math.max(nodeA.tags.size, nodeB.tags.size) || 1;
+                    this.addEdge(nameA, nameB, 0.4 * (tagOverlap / maxTags), "tag");
+                }
+            }
+        }
+        // 4. Build edges: purpose word overlap
+        for (const [nameA, nodeA] of this.nodes) {
+            for (const [nameB, nodeB] of this.nodes) {
+                if (nameA >= nameB)
+                    continue;
+                const shared = [...nodeA.purposeWords].filter(w => nodeB.purposeWords.has(w)).length;
+                const total = [...new Set([...nodeA.purposeWords, ...nodeB.purposeWords])].length || 1;
+                const jaccard = shared / total;
+                if (jaccard > 0.15) {
+                    this.addEdge(nameA, nameB, 0.5 * jaccard, "purpose");
+                }
+            }
+        }
+        // 5. Build edges: chain adjacency (producer→consumer)
+        for (const [nameA, nodeA] of this.nodes) {
+            for (const p of nodeA.produces) {
+                for (const [nameB, nodeB] of this.nodes) {
+                    if (nameA === nameB)
+                        continue;
+                    if (nodeB.requires.has(p)) {
+                        this.addEdge(nameA, nameB, 0.7, `chain:${p}`);
+                    }
+                    // Fuzzy chain: substring match
+                    for (const r of nodeB.requires) {
+                        if (p.includes(r) || r.includes(p)) {
+                            this.addEdge(nameA, nameB, 0.4, `fuzzy:${p}≈${r}`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    addEdge(a, b, weight, reason) {
+        const key = a < b ? `${a}::${b}` : `${b}::${a}`;
+        if (!this.edges.has(a))
+            this.edges.set(a, []);
+        if (!this.edges.has(b))
+            this.edges.set(b, []);
+        this.edges.get(a).push({ source: a, target: b, weight, reason });
+        this.edges.get(b).push({ source: b, target: a, weight, reason });
+        this.similarityCache.set(key, Math.max(this.similarityCache.get(key) || 0, weight));
+    }
+    /** Get similarity between two functions (0-1). */
+    similarity(funcA, funcB) {
+        if (funcA === funcB)
+            return 1.0;
+        const key = funcA < funcB ? `${funcA}::${funcB}` : `${funcB}::${funcA}`;
+        return this.similarityCache.get(key) || 0;
+    }
+    /** Find top N most similar functions to a given function. */
+    findSimilar(funcName, topN = 5) {
+        const edges = this.edges.get(funcName) || [];
+        return edges
+            .sort((a, b) => b.weight - a.weight)
+            .slice(0, topN)
+            .map(e => ({ name: e.target, similarity: e.weight }));
+    }
+    /** Semantic match: two capability labels are related via topology. */
+    capabilityMatch(produce, require) {
+        // Direct match
+        if (produce === require)
+            return true;
+        if (produce.includes(require) || require.includes(produce))
+            return true;
+        // Topology check: are there functions producing 'produce' that are connected
+        // to functions requiring 'require'?
+        const producers = [...this.nodes.values()].filter(n => n.produces.has(produce));
+        const consumers = [...this.nodes.values()].filter(n => n.requires.has(require));
+        for (const p of producers) {
+            for (const c of consumers) {
+                if (this.similarity(p.name, c.name) > 0.2)
+                    return true;
+            }
+        }
+        return false;
+    }
+    /** Get node count */
+    get size() { return this.nodes.size; }
+}
+exports.SemanticTopology = SemanticTopology;
+// Singleton
+let _topology = null;
+function getTopology(ir) {
+    if (!_topology && ir) {
+        _topology = new SemanticTopology();
+        _topology.build(ir);
+    }
+    return _topology || new SemanticTopology();
+}
+function rebuildTopology(ir) {
+    _topology = new SemanticTopology();
+    _topology.build(ir);
+    return _topology;
+}

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.3",
+  "version": "2.1.5",
   "description": "Progmune Runtime — Program Immunology: Constraint-Guided Program Synthesis Runtime",
   "main": "dist/mcp-server.mjs",
   "bin": {