progmune-runtime 2.1.2 → 2.1.4

package/dist/emitter.js

@@ -143,33 +143,73 @@ 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 AND empty-default params
         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);
                 }
-                // Also detect empty defaults: these should become function params
-                const isDefault = v === "" || v === 0 || v === false || v === null
-                    || (Array.isArray(v) && v.length === 0);
-                if (isDefault && typeof arg === "object" && arg.name) {
-                    referenced.add(arg.name);
+                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) {
@@ -177,42 +217,59 @@ function emitCode(actions, meta) {
                 const v = typeof arg === "object" ? arg?.value : arg;
                 const n = typeof arg === "object" ? arg?.name : undefined;
                 const t = typeof arg === "object" ? arg?.type : "string";
-                // Variable reference: value matches input name
-                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: param name matches input name
-                const isDefault = v === "" || v === 0 || v === false || v === null
-                    || (Array.isArray(v) && v.length === 0);
-                if (isDefault && n && inputs.includes(n)) {
+                // 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(/\[\]$/, "");
-                    if (!inputTypes.has(n))
+                    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);
+                    }
                 }
             }
         }
     }
-    // If no inputs detected but functions have params with empty defaults,
-    // create parameters from function signatures
-    if (inputs.length === 0) {
-        for (const action of actions) {
-            if (action.kind === "call" && action.args && action.args.length > 0) {
-                for (const arg of action.args) {
-                    const name = typeof arg === "object" ? arg.name : "param";
-                    const type = typeof arg === "object" ? (arg.type || "string") : "string";
-                    const val = typeof arg === "object" ? arg.value : arg;
-                    // Only add if value is empty default (not a real value)
-                    if (val === "" || val === 0 || val === false || val === null || (Array.isArray(val) && val.length === 0)) {
-                        if (!inputTypes.has(name)) {
-                            inputs.push(name);
-                            inputTypes.set(name, type.replace(/\[\]$/, ""));
-                        }
-                    }
+    // 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",
+                    });
                 }
             }
         }
     }
-    const paramList = inputs.map(v => `${v}: ${inputTypes.get(v) || "string"}`).join(", ");
+    // 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)
@@ -233,11 +290,21 @@ function emitCode(actions, meta) {
                     return val;
                 }
                 // Empty default value → use function's parameter name (input parameter)
-                const isDefault = val === "" || val === 0 || val === false || val === null
-                    || (Array.isArray(val) && val.length === 0);
-                if (isDefault && a?.name && inputs.includes(a.name)) {
-                    declared.add(a.name);
-                    return a.name;
+                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)) {
@@ -328,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/planner.js

@@ -39,12 +39,15 @@ 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");
 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 => {
@@ -104,10 +107,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 +120,40 @@ function buildCompactFuncList(funcs, allFuncs) {
         return line;
     }).join("\n");
 }
+/** Semantic matching: check if two capability labels are related.
+ *  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;
+    return false;
+}
 /** 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 || "?"}`);
             }
         }
     }
@@ -528,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) => ({
@@ -688,17 +721,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
@@ -708,11 +757,32 @@ async function plan(userIntent) {
                     score += 0.8;
             }
         }
+        // Dynamic Credit: multiply by actual success rate (0.1-1.0)
+        const successRate = (0, feedback_1.getFunctionSuccessRate)(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);
     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 +804,7 @@ async function plan(userIntent) {
     }
     const protocolChainHint = buildProtocolChainHint(protocols);
     const userPrompt = `可用函数：
-${compactFuncList}${protocolChainHint}${chainHints}${typeHints}
+${compactFuncList}${protocolChainHint}${chainHints}${typeHints}${strategyHint}
 
 需求：${userIntent}${antibodyHint}
 
@@ -874,20 +944,55 @@ ${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(" → ") || "?"}`);
+                }
+            }
+        }
+        // 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) {
-            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 +1023,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 +1175,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/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/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.2",
+  "version": "2.1.4",
   "description": "Progmune Runtime — Program Immunology: Constraint-Guided Program Synthesis Runtime",
   "main": "dist/mcp-server.mjs",
   "bin": {