progmune-runtime 2.1.1 → 2.1.3

package/dist/emitter.js

@@ -143,40 +143,133 @@ function emitCode(actions, meta) {
     // Pre-scan: find input variables (referenced but never assigned via call/assign)
     const declared = new Set();
     const referenced = new Set();
+    // Track param name → type for conflict detection
+    const paramTypes = new Map();
     let counter = 0;
-    // First pass: collect declared and referenced variables
-    for (const action of actions) {
+    // Recursive scan: collect variables from actions including nested if/for
+    const scanAction = (action) => {
         if (action.kind === "call" && action.assignTo) {
             declared.add(action.assignTo);
         }
         else if (action.kind === "assign" && action.target) {
             declared.add(action.target);
         }
-        // Collect arg value references
         if (action.kind === "call" && action.args) {
             for (const arg of action.args) {
                 const v = typeof arg === "object" ? arg?.value : arg;
+                const n = typeof arg === "object" ? arg?.name : undefined;
+                const t = typeof arg === "object" ? arg?.type : "string";
                 if (typeof v === "string" && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(v) && v !== "") {
                     referenced.add(v);
                 }
+                const isEmptyV = (val) => val === "" || val === 0 || val === false || val === null || (Array.isArray(val) && val.length === 0);
+                const isDefault = isEmptyV(v);
+                if (isDefault && n) {
+                    // Track type for conflict detection
+                    if (!paramTypes.has(n))
+                        paramTypes.set(n, []);
+                    if (!paramTypes.get(n).includes(t))
+                        paramTypes.get(n).push(t);
+                    referenced.add(n);
+                }
             }
         }
-    }
+        // Recursive: scan nested actions in if/for
+        if (action.kind === "if") {
+            (action.thenActions || []).forEach(scanAction);
+            (action.elseActions || []).forEach(scanAction);
+        }
+        else if (action.kind === "for") {
+            if (action.variable)
+                declared.add(action.variable);
+            (action.bodyActions || []).forEach(scanAction);
+        }
+    };
+    for (const action of actions)
+        scanAction(action);
     // Inputs = referenced but not declared — add as typed parameters
-    const inputs = [...referenced].filter(v => !declared.has(v) && v !== "");
+    const rawInputs = [...referenced].filter(v => !declared.has(v) && v !== "");
+    // Resolve type conflicts: rename duplicate params with different types
+    const conflictNames = [...paramTypes.entries()]
+        .filter(([_, types]) => new Set(types).size > 1)
+        .map(([name]) => name);
+    const _resolved = [];
+    const renamed = new Map(); // oldName → newName
+    for (const name of rawInputs) {
+        if (conflictNames.includes(name) && paramTypes.get(name).length > 1) {
+            const types = [...new Set(paramTypes.get(name))]; // unique types
+            for (const t of types) {
+                const suffix = t.replace(/\[\]$/, "").toLowerCase();
+                const newName = `${name}_${suffix}`;
+                _resolved.push(newName);
+                renamed.set(name + ":" + t, newName);
+            }
+        }
+        else {
+            _resolved.push(name);
+        }
+    }
+    const uniqueInputs = [...new Set(_resolved)];
     const inputTypes = new Map();
     for (const action of actions) {
         if (action.kind === "call" && action.args) {
             for (const arg of action.args) {
                 const v = typeof arg === "object" ? arg?.value : arg;
+                const n = typeof arg === "object" ? arg?.name : undefined;
                 const t = typeof arg === "object" ? arg?.type : "string";
-                if (typeof v === "string" && inputs.includes(v) && t && t !== "any") {
+                // Check for renamed param (type conflict resolution)
+                const renameKey = n + ":" + t;
+                const resolvedName = renamed.get(renameKey) || n || "";
+                // Variable reference
+                if (typeof v === "string" && uniqueInputs.includes(v) && t && t !== "any") {
                     inputTypes.set(v, t);
                 }
+                // Empty default: use resolved name for type-conflicted params
+                const isEmptyV = (val) => val === "" || val === 0 || val === false || val === null || (Array.isArray(val) && val.length === 0);
+                const isDefault = isEmptyV(v);
+                if (isDefault && n) {
+                    const cleanType = (t || "string").replace(/\[\]$/, "");
+                    const targetName = (resolvedName !== n) ? resolvedName : n;
+                    if (uniqueInputs.includes(targetName) && !inputTypes.has(targetName)) {
+                        inputTypes.set(targetName, cleanType);
+                    }
+                    else if (uniqueInputs.includes(n) && !inputTypes.has(n)) {
+                        inputTypes.set(n, cleanType);
+                    }
+                }
             }
         }
     }
-    const paramList = inputs.map(v => `${v}: ${inputTypes.get(v) || "string"}`).join(", ");
+    // Parameter bloat threshold: refuse if too many params
+    const MAX_PARAMS = 10;
+    if (uniqueInputs.length > MAX_PARAMS) {
+        return `// REFINEMENT_NEEDED: ${uniqueInputs.length} params detected (max ${MAX_PARAMS}). Split into smaller functions or use an options object.`;
+    }
+    // Refinement: collect empty defaults for Planner feedback
+    const emptyDefaults = [];
+    for (let i = 0; i < actions.length; i++) {
+        const action = actions[i];
+        if (action.kind === "call" && action.args) {
+            for (const arg of action.args) {
+                const v = typeof arg === "object" ? arg?.value : arg;
+                const isEmptyV = (val) => val === "" || val === 0 || val === false || val === null || (Array.isArray(val) && val.length === 0);
+                const isDefault = isEmptyV(v);
+                if (isDefault && typeof arg === "object" && arg.name) {
+                    emptyDefaults.push({
+                        actionIndex: i,
+                        function: action.function || "unknown",
+                        param: arg.name,
+                        type: (typeof arg === "object" ? arg.type : "string") || "string",
+                    });
+                }
+            }
+        }
+    }
+    // Store for Planner feedback (accessible via global)
+    if (emptyDefaults.length > 0) {
+        globalThis.__progmune_empty_defaults = emptyDefaults;
+    }
+    const paramList = uniqueInputs.map(v => `${v}: ${inputTypes.get(v) || "string"}`).join(", ");
     code += `\nexport function main(${paramList}) {\n`;
     const convert = (action, indent = "  ") => {
         if (!action || !action.kind)
@@ -192,11 +285,27 @@ function emitCode(actions, meta) {
                 const val = a?.value;
                 if (typeof val === "string" && declared.has(val))
                     return val;
-                // If value looks like a variable name (valid JS identifier), pass it through
                 if (typeof val === "string" && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(val) && val !== "") {
                     declared.add(val);
                     return val;
                 }
+                // Empty default value → use function's parameter name (input parameter)
+                const isEmptyVal = (v) => v === "" || v === 0 || v === false || v === null || (Array.isArray(v) && v.length === 0);
+                const isDefault = isEmptyVal(val);
+                if (isDefault && a?.name) {
+                    // Check for renamed param (type conflict resolution)
+                    const paramType = meta?.params?.[i]?.type || "string";
+                    const renameKey = a.name + ":" + paramType;
+                    const resolvedName = renamed.get(renameKey) || a.name;
+                    if (uniqueInputs.includes(resolvedName)) {
+                        declared.add(resolvedName);
+                        return resolvedName;
+                    }
+                    else if (uniqueInputs.includes(a.name)) {
+                        declared.add(a.name);
+                        return a.name;
+                    }
+                }
                 const paramType = meta?.params?.[i]?.type || "any";
                 if (BASIC_TYPES.has(paramType)) {
                     if (paramType === "string" || paramType === "str")
@@ -286,7 +395,7 @@ function emitCode(actions, meta) {
     }
     code += "}\n";
     // Call main with params if it has inputs, otherwise no-arg call
-    if (inputs.length > 0) {
+    if (uniqueInputs.length > 0) {
         // Don't call — the user provides the arguments
         // Just export the function for external use
     }

package/dist/health-utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeHealthScore = computeHealthScore;
+exports.formatHealthLevel = formatHealthLevel;
+exports.countSessionLedgers = countSessionLedgers;
+/** Compute overall immune health score from failure and antibody data.
+ * @requires FAILURE_GENOME @produces HEALTH_SCORE
+ * @tags health, score, immune
+ */
+function computeHealthScore(failureGenome, antibodyStats) {
+    const totalFailures = failureGenome?.totalFailures || 0;
+    const totalHits = antibodyStats?.totalHits || 0;
+    const base = 100;
+    const failurePenalty = Math.min(totalFailures * 2, 40);
+    const antibodyBonus = Math.min(totalHits * 3, 20);
+    return Math.max(0, Math.min(100, base - failurePenalty + antibodyBonus));
+}
+/** Format a health score as a status level.
+ * @requires HEALTH_SCORE @produces HEALTH_STATUS
+ * @tags health, format
+ */
+function formatHealthLevel(score) {
+    if (score >= 90)
+        return "Excellent";
+    if (score >= 70)
+        return "Good";
+    if (score >= 50)
+        return "Fair";
+    return "Poor";
+}
+/** Validate a ledger and return pass/fail counts.
+ * @requires SESSION_LIST @produces VALIDATION_COUNTS
+ * @tags ledger, validation, audit
+ */
+function countSessionLedgers(sessions) {
+    const withLedger = sessions.filter((s) => {
+        return s.attempts?.some((a) => a.transitions?.length > 0);
+    }).length;
+    return { total: sessions.length, withLedger };
+}

package/dist/ledger-utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countTotalTransitions = countTotalTransitions;
+exports.formatTransitionCount = formatTransitionCount;
+exports.hasViolations = hasViolations;
+exports.countSessionsWithViolations = countSessionsWithViolations;
+/** Count total transitions across all session ledgers.
+ * @requires SESSION_LIST @produces TRANSITION_COUNT
+ * @tags ledger, count, statistics
+ */
+function countTotalTransitions(sessions) {
+    let count = 0;
+    for (const s of sessions) {
+        for (const a of (s.attempts || [])) {
+            count += (a.transitions || []).length;
+        }
+    }
+    return count;
+}
+/** Format a transition count as a summary string.
+ * @requires TRANSITION_COUNT @produces FORMATTED_COUNT
+ * @tags ledger, format
+ */
+function formatTransitionCount(count) {
+    return `${count} total transitions across all sessions`;
+}
+/** Check if a session has any protocol violations in its attempts.
+ * @requires SESSION_DATA @produces VIOLATION_CHECK
+ * @tags ledger, validation
+ */
+function hasViolations(session) {
+    return (session.attempts || []).some((a) => (a.violations || []).length > 0);
+}
+/** Count sessions that have violations.
+ * @requires SESSION_LIST @produces VIOLATION_COUNT
+ * @tags ledger, validation, statistics
+ */
+function countSessionsWithViolations(sessions) {
+    return sessions.filter(s => hasViolations(s)).length;
+}

package/dist/planner.js

@@ -45,6 +45,7 @@ const memory_layer_1 = require("./memory-layer");
 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 fs = __importStar(require("fs"));
 function enrichActions(actions, ir) {
     return actions.map(a => {
@@ -104,10 +105,12 @@ function buildCompactFuncList(funcs, allFuncs) {
             return def ? `${p.name}: ${def}` : `${p.name}: ${p.type}`;
         }).join(",");
         let line = `${f.name}(${params})->${f.returnType || "any"}`;
-        // Add capability metadata
+        // Add capability metadata + score
         const meta = [];
+        if (f.score && f.score > 0)
+            meta.push(`★${f.score.toFixed(1)}`);
         if (f.purpose)
-            meta.push(f.purpose.slice(0, 60));
+            meta.push(f.purpose.slice(0, 50));
         if (f.produces && f.produces.length > 0)
             meta.push(`→${f.produces.join(",")}`);
         if (meta.length > 0)
@@ -115,17 +118,37 @@ function buildCompactFuncList(funcs, allFuncs) {
         return line;
     }).join("\n");
 }
+/** Semantic matching: check if two capability labels are related.
+ *  Uses exact match, substring, and Jaccard similarity. */
+function semanticMatch(a, b) {
+    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;
+}
 /** Build capability chain hints from IR: producer→consumer relationships.
- *  e.g. "failureStats → formatFailureStats (FAILURE_STATS)" */
+ *  Uses semantic matching for fuzzy capability linking. */
 function buildChainHints(funcs) {
     const chains = [];
+    const seen = new Set();
     for (const f of funcs) {
         if (!f.produces)
             continue;
         for (const p of f.produces) {
-            const consumers = funcs.filter((x) => x.requires?.includes(p) && x.name !== f.name);
+            const consumers = funcs.filter((x) => x.name !== f.name &&
+                (x.requires || []).some((r) => semanticMatch(p, r)));
             for (const c of consumers) {
-                chains.push(`${f.name}()→${c.name}()  // ${p}`);
+                const key = `${f.name}→${c.name}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const matchedReq = (c.requires || []).find((r) => semanticMatch(p, r));
+                chains.push(`${f.name}()→${c.name}()  // ${p} ≈ ${matchedReq || "?"}`);
             }
         }
     }
@@ -688,17 +711,33 @@ async function plan(userIntent) {
                     score += 0.3;
             }
         }
-        // Capability Graph: requires/produces capability matching
+        // Capability Graph: semantic requires/produces matching
         if (f.produces) {
             for (const p of f.produces) {
-                if (intentLower.includes(p.toLowerCase().replace(/_/g, " ")))
+                const pText = p.toLowerCase().replace(/_/g, " ");
+                // Exact match
+                if (intentLower.includes(pText)) {
                     score += 1.5;
+                    continue;
+                }
+                // Semantic: word overlap
+                const pWords = pText.split(/\s+/);
+                const matchCount = pWords.filter((w) => intentLower.includes(w)).length;
+                if (matchCount > 0)
+                    score += matchCount * 0.5;
             }
         }
         if (f.requires) {
             for (const r of f.requires) {
-                if (intentLower.includes(r.toLowerCase().replace(/_/g, " ")))
+                const rText = r.toLowerCase().replace(/_/g, " ");
+                if (intentLower.includes(rText)) {
                     score += 0.5;
+                    continue;
+                }
+                const rWords = rText.split(/\s+/);
+                const matchCount = rWords.filter((w) => intentLower.includes(w)).length;
+                if (matchCount > 0)
+                    score += matchCount * 0.2;
             }
         }
         // Capability Graph: tag match
@@ -712,7 +751,23 @@ async function plan(userIntent) {
     });
     scored.sort((a, b) => b.score - a.score);
     const topFuncs = scored.slice(0, 15);
-    const compactFuncList = buildCompactFuncList(topFuncs, ir);
+    // Strategy Layer: select capability chain (local, 0 LLM calls)
+    const chains = (0, strategy_planner_1.selectCapabilityChains)(userIntent, ir, 3);
+    const strategyHint = (0, strategy_planner_1.formatChainHint)(chains);
+    // Action Layer: filter functions to those in selected chains
+    let chainFuncs = topFuncs;
+    if (chains.length > 0) {
+        const chainNames = new Set();
+        for (const c of chains.slice(0, 2)) {
+            for (const n of c.nodes)
+                chainNames.add(n.name);
+        }
+        // Prioritize chain functions: keep them first, add others as fallback
+        const inChain = topFuncs.filter((f) => chainNames.has(f.name));
+        const outChain = topFuncs.filter((f) => !chainNames.has(f.name));
+        chainFuncs = [...inChain, ...outChain].slice(0, 15);
+    }
+    const compactFuncList = buildCompactFuncList(chainFuncs, ir);
     const chainHints = buildChainHints(topFuncs);
     // Known string-enum types: tell LLM these are strings, not objects
     const STRING_ENUMS = {
@@ -734,7 +789,7 @@ async function plan(userIntent) {
     }
     const protocolChainHint = buildProtocolChainHint(protocols);
     const userPrompt = `可用函数：
-${compactFuncList}${protocolChainHint}${chainHints}${typeHints}
+${compactFuncList}${protocolChainHint}${chainHints}${typeHints}${strategyHint}
 
 需求：${userIntent}${antibodyHint}
 
@@ -874,20 +929,44 @@ ${RETRY_HINT}
         const enriched = enrichActions(rawActions, ir);
         const filtered = enriched.filter(a => !forbiddenFuncs.includes(a.kind === "call" ? a.function : ''));
         let ssgTransitions = [];
+        // 0) Hard Constraint Pre-check: local scan before full validation
+        //    Saves LLM tokens by detecting obvious violations first
+        const preCheckRules = new Map();
+        for (const p of protocols)
+            preCheckRules.set(p.function, p.protocol);
+        const preCheckErrors = [];
+        for (let ai = 0; ai < filtered.length; ai++) {
+            const a = filtered[ai];
+            if (a.kind !== "call" || !a.function)
+                continue;
+            const def = ir.find((f) => f.name === a.function);
+            if (!def) {
+                preCheckErrors.push(`${a.function}: 函数不存在于 IR`);
+                continue;
+            }
+            if (def.params && a.args && a.args.length !== def.params.length) {
+                preCheckErrors.push(`${a.function}: 参数数量错误 (期望${def.params.length}, 实际${a.args.length})`);
+            }
+            // Protocol pre-check: verify function is callable in current namespace state
+            if (def.protocol && preCheckRules.size > 0) {
+                const ctx = { ledger: [], currentState: (0, ssg_validator_1.rebuildState)([], namespaceInitialStates) };
+                const { valid, rejection } = (0, ssg_validator_1.validateTransition)(ctx, a.function, ai, preCheckRules, namespaceInitialStates);
+                if (!valid && rejection) {
+                    preCheckErrors.push(`${a.function}: 协议违规 — 需要先调用 ${rejection.fixPath?.join(" → ") || "?"}`);
+                }
+            }
+        }
         // 1) 基础序列校验
         const seqResult = (0, validator_1.validateActionSequence)(filtered);
-        if (!seqResult.valid) {
-            const errorsFlat = seqResult.errors.flat();
+        if (!seqResult.valid || preCheckErrors.length > 0) {
+            const errorsFlat = [...preCheckErrors, ...seqResult.errors.flat()];
             console.error("⚠️ 序列校验失败:", errorsFlat.join(", "));
             // Use structured violations directly from validator
             const violations = seqResult.violations.length > 0
                 ? seqResult.violations
-                : [{
-                        svl: 1,
-                        violatedConstraint: "symbol_existence",
-                        actionIndex: 0,
-                        description: errorsFlat.join("; "),
-                    }];
+                : preCheckErrors.length > 0
+                    ? [{ svl: 1, violatedConstraint: "symbol_existence", actionIndex: 0, description: preCheckErrors.join("; ") }]
+                    : [{ svl: 1, violatedConstraint: "symbol_existence", actionIndex: 0, description: errorsFlat.join("; ") }];
             const primarySvl = `SVL-${violations[0].svl}`;
             const attempt = {
                 id: (0, runtime_types_1.generateAttemptId)(),
@@ -918,7 +997,11 @@ ${RETRY_HINT}
                 plannerRetryTotal: maxRetries,
             });
             (0, memory_layer_1.recordEpisode)({ intent: userIntent, actions: filtered, success: false, svlViolated: primarySvl });
-            currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}\n\n错误：${errorsFlat.join("；")}。请修正。\n${RETRY_HINT}\n只输出 JSON。`;
+            // Build targeted retry prompt based on pre-check results
+            const specificErrors = preCheckErrors.length > 0
+                ? `精确错误:\n${preCheckErrors.map(e => `  - ${e}`).join("\n")}`
+                : `错误：${errorsFlat.join("；")}`;
+            currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}\n\n${specificErrors}\n请修正上述问题。\n${RETRY_HINT}\n只输出 JSON。`;
             useSystem = false;
             (0, failure_corpus_1.saveCheckpoint)(userIntent, { attemptIndex: r + 1, sessionAttempts: session.attempts, currentPrompt, useSystem });
             continue;
@@ -1066,6 +1149,47 @@ ${RETRY_HINT}
             (0, failure_corpus_1.saveCheckpoint)(userIntent, { attemptIndex: r + 1, sessionAttempts: session.attempts, currentPrompt, useSystem });
             continue;
         }
+        // Phase 8: Refinement — detect empty args, ask LLM to fill meaningful values
+        const emptyArgs = [];
+        for (let ai = 0; ai < filtered.length; ai++) {
+            const a = filtered[ai];
+            if (a.kind === "call" && a.args) {
+                for (const arg of a.args) {
+                    const v = typeof arg === "object" ? arg.value : arg;
+                    const isEmpty = (val) => val === "" || val === 0 || val === false || val === null || (Array.isArray(val) && val.length === 0);
+                    if (isEmpty(v)) {
+                        emptyArgs.push({ idx: ai, fn: a.function || "?", param: arg.name || "?", type: arg.type || "?" });
+                    }
+                }
+            }
+        }
+        if (emptyArgs.length > 0 && r < maxRetries - 1) {
+            const argDetails = emptyArgs.map(e => `  ${e.fn}() 参数 "${e.param}" (${e.type}) 是空值`).join("\n");
+            console.error(`🔍 检测到 ${emptyArgs.length} 个空参数，启动精炼...`);
+            currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}\n\n上一次生成的 JSON 中以下参数为空值：\n${argDetails}\n\n请为这些参数填入有意义的示例值（字符串用描述性值，数字用合理数值，对象用 {} as Type）。\n${RETRY_HINT}\n只输出 JSON。`;
+            useSystem = false;
+            continue;
+        }
+        // 4D Scoring Self-Verification: compare LLM choices against scores
+        const chosenFuncs = filtered.filter(a => a.kind === "call").map(a => a.function);
+        const scoredFuncs = new Map(topFuncs.map((f) => [f.name, f.score || 0]));
+        let scoreViolations = 0;
+        for (const fn of chosenFuncs) {
+            const actualScore = scoredFuncs.get(fn) || 0;
+            const allScores = [...scoredFuncs.values()].filter((s) => typeof s === "number" && s > 0);
+            const maxScore = allScores.length > 0 ? Math.max(...allScores) : 0;
+            if (maxScore > 0 && actualScore < maxScore * 0.3 && maxScore > 1) {
+                scoreViolations++;
+                const better = [...scoredFuncs.entries()]
+                    .filter(([_, s]) => typeof s === "number" && s > actualScore * 2)
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, 3).map(([n, s]) => `${n}(${s.toFixed(1)})`).join(", ");
+                console.error(`⚠️ 评分偏低: ${fn}(${actualScore.toFixed(1)}) 被选中, 但更高分函数可用: ${better}`);
+            }
+        }
+        if (scoreViolations > 0) {
+            console.error(`📊 评分自省: ${scoreViolations}/${chosenFuncs.length} 个函数评分偏低 (阈值: 最高分30%)`);
+        }
         // 校验通过：构建成功 Attempt
         const successAntibodyHit = antibodyHint
             ? {

package/dist/stdlib.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Progmune Standard Library — general-purpose utilities for external tasks.
+ * Each function has @requires/@produces for Capability Graph integration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidEmail = isValidEmail;
+exports.truncate = truncate;
+exports.camelToSnake = camelToSnake;
+exports.capitalizeWords = capitalizeWords;
+exports.countSubstring = countSubstring;
+exports.removeWhitespace = removeWhitespace;
+exports.mostFrequent = mostFrequent;
+exports.unique = unique;
+exports.chunk = chunk;
+exports.arrayDiff = arrayDiff;
+exports.average = average;
+exports.median = median;
+exports.roundTo = roundTo;
+exports.isPrime = isPrime;
+exports.randomInt = randomInt;
+exports.deepClone = deepClone;
+exports.pick = pick;
+exports.deepMerge = deepMerge;
+exports.hasRequiredFields = hasRequiredFields;
+exports.isPlainObject = isPlainObject;
+exports.parseSemver = parseSemver;
+exports.formatDuration = formatDuration;
+exports.formatFileSize = formatFileSize;
+exports.toQueryString = toQueryString;
+exports.retry = retry;
+exports.debounce = debounce;
+// ── String ──
+/** @requires STRING @produces VALIDATION_RESULT @tags string, email, validation */
+function isValidEmail(str) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str);
+}
+/** @requires STRING @produces TRUNCATED_STRING @tags string, format */
+function truncate(str, maxLen, ellipsis = "...") {
+    return str.length <= maxLen ? str : str.slice(0, maxLen - ellipsis.length) + ellipsis;
+}
+/** @requires STRING @produces FORMATTED_STRING @tags string, case, format */
+function camelToSnake(str) {
+    return str.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
+}
+/** @requires STRING @produces FORMATTED_STRING @tags string, case, format */
+function capitalizeWords(str) {
+    return str.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+/** @requires STRING @produces COUNT @tags string, count */
+function countSubstring(str, sub) {
+    if (!sub)
+        return 0;
+    let count = 0, pos = 0;
+    while ((pos = str.indexOf(sub, pos)) !== -1) {
+        count++;
+        pos += sub.length;
+    }
+    return count;
+}
+/** @requires STRING @produces CLEANED_STRING @tags string, format */
+function removeWhitespace(str) {
+    return str.replace(/\s+/g, "");
+}
+// ── Array ──
+/** @requires ARRAY @produces ELEMENT @tags array, statistics */
+function mostFrequent(arr) {
+    if (arr.length === 0)
+        return null;
+    const counts = new Map();
+    for (const item of arr)
+        counts.set(item, (counts.get(item) || 0) + 1);
+    return [...counts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+}
+/** @requires ARRAY @produces ARRAY @tags array, dedupe */
+function unique(arr) { return [...new Set(arr)]; }
+/** @requires ARRAY @produces ARRAY @tags array, chunk */
+function chunk(arr, size) {
+    const result = [];
+    for (let i = 0; i < arr.length; i += size)
+        result.push(arr.slice(i, i + size));
+    return result;
+}
+/** @requires ARRAY @produces ARRAY @tags array, difference */
+function arrayDiff(a, b) {
+    const setB = new Set(b);
+    return a.filter(x => !setB.has(x));
+}
+// ── Math ──
+/** @requires NUMBERS @produces AVERAGE @tags math, statistics */
+function average(nums) {
+    return nums.length === 0 ? 0 : nums.reduce((a, b) => a + b, 0) / nums.length;
+}
+/** @requires NUMBERS @produces MEDIAN @tags math, statistics */
+function median(nums) {
+    if (nums.length === 0)
+        return 0;
+    const sorted = [...nums].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+/** @requires NUMBER @produces ROUNDED_NUMBER @tags math, format */
+function roundTo(num, decimals) {
+    const factor = Math.pow(10, decimals);
+    return Math.round(num * factor) / factor;
+}
+/** @requires NUMBER @produces PRIME_CHECK @tags math, validation */
+function isPrime(n) {
+    if (n < 2)
+        return false;
+    for (let i = 2; i <= Math.sqrt(n); i++)
+        if (n % i === 0)
+            return false;
+    return true;
+}
+/** @requires NUMBERS @produces RANDOM_INT @tags math, random */
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+// ── Object ──
+/** @requires OBJECT @produces CLONED_OBJECT @tags object, clone */
+function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+/** @requires OBJECT @produces PICKED_OBJECT @tags object, filter */
+function pick(obj, keys) {
+    const result = {};
+    for (const k of keys)
+        if (k in obj)
+            result[k] = obj[k];
+    return result;
+}
+/** @requires OBJECTS @produces MERGED_OBJECT @tags object, merge */
+function deepMerge(...objects) {
+    return objects.reduce((acc, obj) => {
+        for (const key of Object.keys(obj || {})) {
+            acc[key] = typeof obj[key] === "object" && !Array.isArray(obj[key])
+                ? deepMerge(acc[key] || {}, obj[key]) : obj[key];
+        }
+        return acc;
+    }, {});
+}
+// ── Validation ──
+/** @requires OBJECT @produces VALIDATION_RESULT @tags validation, schema */
+function hasRequiredFields(obj, fields) {
+    return fields.every(f => obj && obj[f] !== undefined && obj[f] !== null);
+}
+/** @requires ANY @produces VALIDATION_RESULT @tags validation, type */
+function isPlainObject(val) {
+    return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+/** @requires STRING @produces PARSED_VERSION @tags validation, semver */
+function parseSemver(version) {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return null;
+    return { major: +match[1], minor: +match[2], patch: +match[3] };
+}
+// ── Formatting ──
+/** @requires NUMBER @produces FORMATTED_STRING @tags format, duration */
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const mins = Math.floor(ms / 60000);
+    const secs = Math.round((ms % 60000) / 1000);
+    return `${mins}m ${secs}s`;
+}
+/** @requires NUMBER @produces FORMATTED_STRING @tags format, file */
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1048576)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / 1048576).toFixed(1)}MB`;
+}
+/** @requires OBJECT @produces QUERY_STRING @tags web, format */
+function toQueryString(obj) {
+    return Object.entries(obj)
+        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+        .join("&");
+}
+// ── Async ──
+/** @requires FUNCTION @produces RETRY_RESULT @tags async, retry */
+async function retry(fn, maxRetries = 3) {
+    for (let i = 0; i < maxRetries; i++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (i === maxRetries - 1)
+                throw e;
+        }
+    }
+    throw new Error("unreachable");
+}
+/** @requires FUNCTION @produces DEBOUNCED_FUNCTION @tags async, debounce */
+function debounce(fn, delay) {
+    let timer;
+    return ((...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => fn(...args), delay);
+    });
+}

package/dist/strategy-planner.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Phase 8: Multi-Level Planning — Strategy Layer
+ *
+ * Selects capability chains from the IR graph WITHOUT calling LLM.
+ * Pure graph search: intent → capability matching → ordered chain.
+ *
+ * The Action Layer (planner.ts) then uses this chain to constrain
+ * the LLM's function selection space.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectCapabilityChains = selectCapabilityChains;
+exports.formatChainHint = formatChainHint;
+const utils_1 = require("./utils");
+/** Build a capability graph from IR functions. */
+function buildCapabilityGraph(ir) {
+    const graph = new Map();
+    for (const f of ir) {
+        if (!f.exported)
+            continue;
+        graph.set(f.name, {
+            name: f.name,
+            purpose: f.purpose || "",
+            tags: f.tags || [],
+            requires: f.requires || [],
+            produces: f.produces || [],
+            score: 0,
+        });
+    }
+    return graph;
+}
+/** Score a capability node against an intent. */
+function scoreNode(node, intentLower, keywords) {
+    let score = 0;
+    // Name match
+    for (const kw of keywords) {
+        if (node.name.toLowerCase().includes(kw))
+            score += 1;
+        score += (0, utils_1.jaccardSimilarity)(node.name.toLowerCase(), kw);
+    }
+    // Purpose match
+    const purposeLower = node.purpose.toLowerCase();
+    for (const kw of keywords) {
+        if (purposeLower.includes(kw))
+            score += 2;
+    }
+    // Tag match
+    for (const tag of node.tags) {
+        if (intentLower.includes(tag.toLowerCase()))
+            score += 1.5;
+    }
+    // Semantic word overlap in purpose
+    const intentWords = intentLower.split(/[\s,，]+/);
+    for (const w of intentWords) {
+        if (w.length > 2 && purposeLower.includes(w))
+            score += 0.5;
+    }
+    return score;
+}
+/** Find all capability nodes that produce a given capability label. */
+function findProducers(graph, capability) {
+    const producers = [];
+    for (const node of graph.values()) {
+        if (node.produces.some(p => p === capability || capability.includes(p) || p.includes(capability))) {
+            producers.push(node);
+        }
+    }
+    return producers;
+}
+/** Find all capability nodes that require a given capability label. */
+function findConsumers(graph, capability) {
+    const consumers = [];
+    for (const node of graph.values()) {
+        if (node.requires.some(r => r === capability || capability.includes(r) || r.includes(capability))) {
+            consumers.push(node);
+        }
+    }
+    return consumers;
+}
+/**
+ * Select the best capability chain for an intent.
+ *
+ * Algorithm:
+ * 1. Score all nodes against intent
+ * 2. Find top producers (nodes whose produces matches intent keywords)
+ * 3. For each producer, trace forward: producer → consumer → consumer...
+ * 4. Score each chain and return top N
+ */
+function selectCapabilityChains(intent, ir, maxChains = 5) {
+    const intentLower = intent.toLowerCase();
+    const keywords = (0, utils_1.extractKeywords)(intent);
+    const graph = buildCapabilityGraph(ir);
+    // Score all nodes
+    for (const node of graph.values()) {
+        node.score = scoreNode(node, intentLower, keywords);
+    }
+    // Find seed nodes: highest-scoring nodes that produce something
+    const seeds = [...graph.values()]
+        .filter(n => n.produces.length > 0 && n.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 10);
+    const chains = [];
+    for (const seed of seeds) {
+        // Build chain: seed → consumer → consumer...
+        const chain = [seed];
+        const visited = new Set([seed.name]);
+        let totalScore = seed.score;
+        // Forward trace: for each produce of the last node, find consumers
+        let current = seed;
+        let extended = true;
+        while (extended && chain.length < 8) {
+            extended = false;
+            for (const p of current.produces) {
+                const consumers = findConsumers(graph, p).filter(c => !visited.has(c.name));
+                if (consumers.length > 0) {
+                    // Pick best-scoring consumer
+                    const bestConsumer = consumers.sort((a, b) => b.score - a.score)[0];
+                    chain.push(bestConsumer);
+                    visited.add(bestConsumer.name);
+                    totalScore += bestConsumer.score;
+                    current = bestConsumer;
+                    extended = true;
+                    break;
+                }
+            }
+        }
+        // Backward trace: does seed need something? Find producers.
+        if (seed.requires.length > 0) {
+            const producers = findProducers(graph, seed.requires[0])
+                .filter(p => !visited.has(p.name));
+            if (producers.length > 0) {
+                const bestProducer = producers.sort((a, b) => b.score - a.score)[0];
+                chain.unshift(bestProducer);
+                totalScore += bestProducer.score;
+            }
+        }
+        if (chain.length >= 1) {
+            chains.push({
+                nodes: chain,
+                score: totalScore / chain.length, // average score
+                explanation: chain.map(n => n.name).join(" → "),
+            });
+        }
+    }
+    // Sort by score, deduplicate, return top N
+    chains.sort((a, b) => b.score - a.score);
+    const seen = new Set();
+    const unique = [];
+    for (const c of chains) {
+        const key = c.explanation;
+        if (!seen.has(key)) {
+            seen.add(key);
+            unique.push(c);
+        }
+    }
+    return unique.slice(0, maxChains);
+}
+/** Format chains as a hint for the LLM prompt. */
+function formatChainHint(chains) {
+    if (chains.length === 0)
+        return "";
+    const lines = ["\n推荐能力链 (Strategy Layer):"];
+    for (let i = 0; i < Math.min(chains.length, 3); i++) {
+        const c = chains[i];
+        lines.push(`  ${i + 1}. ${c.explanation} (★${c.score.toFixed(1)})`);
+    }
+    return lines.join("\n");
+}

package/package.json

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