progmune-runtime 2.1.5 → 3.2.0

package/dist/strategy-planner.js

@@ -13,73 +13,178 @@ exports.selectCapabilityChains = selectCapabilityChains;
 exports.formatChainHint = formatChainHint;
 const utils_1 = require("./utils");
 const feedback_1 = require("./feedback");
+const semantic_topology_1 = require("./semantic-topology");
+const planner_constraints_1 = require("./planner-constraints");
+const failure_corpus_1 = require("./failure-corpus");
 /** Build a capability graph from IR functions. */
 function buildCapabilityGraph(ir) {
+    const SKIP_FILES = new Set(["src/strategy-planner.ts", "src/planner.ts"]);
+    const SKIP_TAGS = new Set(); // P8.3: Python IR now supported
     const graph = new Map();
     for (const f of ir) {
         if (!f.exported)
             continue;
+        if (SKIP_FILES.has(f.file))
+            continue;
+        if ((f.tags || []).some(t => SKIP_TAGS.has(t)))
+            continue; // skip language-specific
         graph.set(f.name, {
             name: f.name,
             purpose: f.purpose || "",
             tags: f.tags || [],
             requires: f.requires || [],
             produces: f.produces || [],
+            useWhen: f.useWhen || [],
             score: 0,
+            hasExplicitMeta: !f._requiresDerived && !f._producesDerived
+                && (f.requires || []).length > 0 && (f.produces || []).length > 0,
         });
     }
     return graph;
 }
-/** Score a capability node against an intent. */
+/** Score a capability node against an intent.
+ *  Returns 0 for irrelevant nodes (no keyword match at all). */
 function scoreNode(node, intentLower, keywords) {
     let score = 0;
+    let hasMatch = false;
+    // ── Primary verb detection: first keyword is the main action ──
+    const primaryVerb = keywords.length > 0 ? keywords[0] : "";
+    const nameWords = node.name.replace(/([A-Z])/g, " $1").toLowerCase().split(/[\s_]+/).filter(w => w.length > 1);
+    const nameLower = node.name.toLowerCase();
     // Name match
     for (const kw of keywords) {
-        if (node.name.toLowerCase().includes(kw))
+        // Substring match
+        if (nameLower.includes(kw)) {
             score += 1;
-        score += (0, utils_1.jaccardSimilarity)(node.name.toLowerCase(), kw);
+            hasMatch = true;
+            // Exact word match
+            if (nameWords.includes(kw)) {
+                // Primary verb (first keyword) that STARTS the function name → decisive bonus
+                // e.g., "extract" matches "extractIR" → +5, beats generic "validate" matches
+                if (kw === primaryVerb && nameLower.startsWith(kw))
+                    score += 5;
+                else
+                    score += 2;
+            }
+        }
+        const js = (0, utils_1.jaccardSimilarity)(nameLower, kw);
+        if (js > 0.2) {
+            score += js;
+            hasMatch = true;
+        }
     }
-    // Purpose match
+    // Purpose match — semantic bridge when function names differ from intent
     const purposeLower = node.purpose.toLowerCase();
+    const intentWords = intentLower.split(/[\s,，]+/).filter(w => w.length > 2);
     for (const kw of keywords) {
-        if (purposeLower.includes(kw))
+        if (purposeLower.includes(kw)) {
             score += 2;
+            hasMatch = true;
+        }
+    }
+    // Jaccard purpose similarity: "send receipt" ↔ "dispatch a message to recipient"
+    if (purposeLower.length > 0) {
+        const purposeWords = purposeLower.split(/[\s,，]+/).filter(w => w.length > 2);
+        if (purposeWords.length > 0 && intentWords.length > 0) {
+            const shared = intentWords.filter(w => purposeWords.includes(w)).length;
+            const union = new Set([...intentWords, ...purposeWords]).size;
+            const purposeJaccard = shared / union;
+            if (purposeJaccard > 0.1) {
+                score += purposeJaccard * 5;
+                hasMatch = true;
+            }
+        }
     }
     // Tag match
     for (const tag of node.tags) {
-        if (intentLower.includes(tag.toLowerCase()))
+        if (intentLower.includes(tag.toLowerCase())) {
             score += 1.5;
+            hasMatch = true;
+        }
     }
     // Semantic word overlap in purpose
-    const intentWords = intentLower.split(/[\s,，]+/);
     for (const w of intentWords) {
-        if (w.length > 2 && purposeLower.includes(w))
+        if (w.length > 2 && purposeLower.includes(w)) {
             score += 0.5;
+            hasMatch = true;
+        }
     }
-    // Dynamic Credit: multiply by actual success rate
+    // useWhen scenario match
+    if (node.useWhen) {
+        for (const scenario of node.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;
+                hasMatch = true;
+            }
+            else if (matchCount === 1) {
+                score += 1.0;
+                hasMatch = true;
+            }
+        }
+    }
+    // Require at least one match to be relevant
+    if (!hasMatch)
+        return 0;
+    // Bonus: explicit annotations are more reliable than derived ones
+    if (node.hasExplicitMeta)
+        score *= 1.3;
+    // L3: 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;
+    score *= creditFactor;
+    // Rule → Planner: apply mined rule constraints
+    const constraints = (0, planner_constraints_1.getConstraints)();
+    const { multiplier } = (0, planner_constraints_1.applyConstraints)(node.name, node.purpose, constraints);
+    return score * multiplier;
 }
-/** Find all capability nodes that produce a given capability label. */
-function findProducers(graph, capability) {
-    const producers = [];
+/** Pick the highest-scoring node from a list. */
+function topByScore(nodes) {
+    return nodes.sort((a, b) => b.score - a.score)[0];
+}
+/** Shared logic for finding nodes that produce or consume a capability label.
+ *  Falls back to topology similarity if no direct data-flow match.
+ *
+ *  @param field - which side of the data-flow edge to match on
+ *  @param isProducer - when true the field value acts as the "produce" side
+ *    of capabilityMatch; when false it acts as the "require" side. */
+function findRelated(graph, capability, allNodes, field, isProducer) {
+    const results = [];
     for (const node of graph.values()) {
-        if (node.produces.some(p => p === capability || capability.includes(p) || p.includes(capability))) {
-            producers.push(node);
+        if (node[field].some(v => v === capability || capability.includes(v) || v.includes(capability))) {
+            results.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);
+    // Topology fallback: find semantically related nodes via capabilityMatch
+    if (results.length === 0) {
+        try {
+            const topo = (0, semantic_topology_1.getTopology)();
+            for (const node of allNodes) {
+                if (node[field].length > 0) {
+                    for (const v of node[field]) {
+                        const matched = isProducer
+                            ? topo.capabilityMatch(v, capability)
+                            : topo.capabilityMatch(capability, v);
+                        if (matched && !results.includes(node)) {
+                            results.push(node);
+                            break;
+                        }
+                    }
+                }
+            }
         }
+        catch { /* topology fallback unavailable — non-critical */ }
     }
-    return consumers;
+    return results;
+}
+/** Find all capability nodes that produce a given capability label. */
+function findProducers(graph, capability, allNodes) {
+    return findRelated(graph, capability, allNodes, "produces", true);
+}
+/** Find all capability nodes that require a given capability label. */
+function findConsumers(graph, capability, allNodes) {
+    return findRelated(graph, capability, allNodes, "requires", false);
 }
 /**
  * Select the best capability chain for an intent.
@@ -90,58 +195,202 @@ function findConsumers(graph, capability) {
  * 3. For each producer, trace forward: producer → consumer → consumer...
  * 4. Score each chain and return top N
  */
-function selectCapabilityChains(intent, ir, maxChains = 5) {
+function selectCapabilityChains(intent, ir, maxChains = 5, llmSeeds) {
+    // Guard: null/undefined/empty intent
+    if (!intent || typeof intent !== "string" || !intent.trim())
+        return { chains: [], needsLLM: false };
+    // Ensure semantic topology is built (cached after first build)
+    const startTopo = Date.now();
+    (0, semantic_topology_1.getTopology)(ir);
+    const topoMs = Date.now() - startTopo;
     const intentLower = intent.toLowerCase();
     const keywords = (0, utils_1.extractKeywords)(intent);
     const graph = buildCapabilityGraph(ir);
     // Score all nodes
+    const startScore = Date.now();
     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);
+    // Dynamic threshold: tighten for large IR to prevent score dilution
+    let dynamicThreshold = graph.size > 500 ? 2.0 : graph.size > 200 ? 1.5 : 1.0;
+    // Fallback: if no seeds found, halve threshold
+    let seeds = [...graph.values()]
+        .filter(n => n.score > dynamicThreshold && (n.produces.length > 0 || n.score > dynamicThreshold + 2))
+        .sort((a, b) => b.score - a.score);
+    if (seeds.length === 0 && dynamicThreshold > 0.3) {
+        dynamicThreshold *= 0.5;
+        seeds = [...graph.values()]
+            .filter(n => n.score > dynamicThreshold && (n.produces.length > 0 || n.score > dynamicThreshold + 1))
+            .sort((a, b) => b.score - a.score);
+    }
+    // Best-effort fallback: prefer nodes with edges AND some score
+    if (seeds.length === 0) {
+        seeds = [...graph.values()]
+            .filter(n => n.score > 0 && (n.produces.length > 0 || n.requires.length > 0))
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 5);
+    }
+    // Ultimate fallback: just take any exported nodes with score > 0
+    if (seeds.length === 0) {
+        seeds = [...graph.values()].filter(n => n.score > 0).slice(0, 3);
+    }
+    seeds = seeds.slice(0, graph.size > 1000 ? 10 : graph.size > 500 ? 20 : 15);
+    // ── Capability Ranking: preload edge confidence from session history ──
+    const edgeConfMap = new Map();
+    for (const ec of (0, failure_corpus_1.getEdgeConfidence)()) {
+        edgeConfMap.set(`${ec.producer}→${ec.consumer}`, ec.confidence);
+    }
+    // ── LLM seed injection: bridge the semantic gap ──
+    if (llmSeeds && llmSeeds.length > 0) {
+        const seedNames = new Set(seeds.map(n => n.name));
+        const maxScore = seeds.length > 0 ? Math.max(...seeds.map(n => n.score)) : 1;
+        for (const fnName of llmSeeds) {
+            if (seedNames.has(fnName))
+                continue;
+            const node = graph.get(fnName);
+            if (node) {
+                node.score = Math.max(node.score, maxScore);
+                seeds.unshift(node);
+                seedNames.add(fnName); // keep seedNames in sync for edge expansion
+            }
+        }
+        // Edge Confidence expansion: high-conf downstream from seeds
+        let edgeAdded = 0;
+        for (const [edgeKey, conf] of edgeConfMap) {
+            if (conf < 0.9)
+                continue;
+            const [prod, cons] = edgeKey.split("→");
+            if (!seedNames.has(prod))
+                continue;
+            if (seedNames.has(cons))
+                continue;
+            const consumerNode = graph.get(cons);
+            if (consumerNode) {
+                consumerNode.score = Math.max(consumerNode.score, maxScore * 0.8);
+                seeds.push(consumerNode);
+                edgeAdded++;
+            }
+        }
+        if (edgeAdded > 0)
+            console.error(`[EdgeExp] ${edgeAdded}高置信边扩展种子 (+${edgeAdded} nodes)`);
+    }
+    const allNodes = [...graph.values()];
     const chains = [];
+    const BEAM_WIDTH = graph.size > 500 ? 3 : 5;
+    const MAX_CHAIN_LEN = parseInt(process.env.PROGMUNE_MAX_CHAIN_LEN || "5", 10);
+    const SCORE_FLOOR = graph.size > 1000 ? 0.2 : 0.1; // always filter noise
     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;
+        let beam = [{
+                chain: [seed],
+                visited: new Set([seed.name]),
+                totalScore: seed.score,
+                leapDecay: 1.0,
+                deadEnd: false,
+            }];
+        let bestEntry = null;
+        for (let depth = 0; depth < MAX_CHAIN_LEN && beam.length > 0; depth++) {
+            const nextBeam = [];
+            for (const entry of beam) {
+                if (entry.deadEnd || entry.chain.length >= MAX_CHAIN_LEN) {
+                    // Dead-end or max length: finalize this branch
+                    if (!bestEntry || (entry.totalScore / entry.chain.length) > (bestEntry.totalScore / bestEntry.chain.length)) {
+                        bestEntry = entry;
+                    }
+                    continue;
+                }
+                const current = entry.chain[entry.chain.length - 1];
+                let expanded = false;
+                // Strategy 1: direct data flow (produces → requires)
+                for (const p of current.produces) {
+                    const consumers = findConsumers(graph, p, allNodes)
+                        .filter(c => !entry.visited.has(c.name) && c.score >= SCORE_FLOOR);
+                    for (const consumer of consumers) {
+                        const newVisited = new Set(entry.visited);
+                        newVisited.add(consumer.name);
+                        // Capability Ranking: edge confidence × consumer score
+                        const edgeKey = `${current.name}→${consumer.name}`;
+                        const edgeConf = edgeConfMap.get(edgeKey) ?? 0.5; // Laplace prior for unseen edges
+                        const rankedScore = consumer.score * (0.5 + edgeConf * 0.5);
+                        nextBeam.push({
+                            chain: [...entry.chain, consumer],
+                            visited: newVisited,
+                            totalScore: entry.totalScore + rankedScore,
+                            leapDecay: 1.0,
+                            deadEnd: consumer.score === 0 && consumer.produces.length === 0,
+                        });
+                        expanded = true;
+                    }
+                }
+                // Strategy 2: semantic leap — topology similarity
+                if (!expanded) {
+                    try {
+                        const topo = (0, semantic_topology_1.getTopology)();
+                        const similar = topo.findSimilar(current.name, 10)
+                            .filter(s => !entry.visited.has(s.name) && s.similarity > 0.25);
+                        for (const s of similar.slice(0, 3)) {
+                            const bestMatch = graph.get(s.name);
+                            if (bestMatch && bestMatch.score >= SCORE_FLOOR) {
+                                const newVisited = new Set(entry.visited);
+                                newVisited.add(bestMatch.name);
+                                nextBeam.push({
+                                    chain: [...entry.chain, bestMatch],
+                                    visited: newVisited,
+                                    totalScore: entry.totalScore + bestMatch.score * entry.leapDecay,
+                                    leapDecay: entry.leapDecay * 0.7, // decay 30% per leap
+                                    deadEnd: false,
+                                });
+                                expanded = true;
+                            }
+                        }
+                    }
+                    catch { /* semantic leap unavailable — non-critical */ }
+                }
+                // Dead-end: no consumers found → finalize this branch
+                if (!expanded) {
+                    if (!bestEntry || (entry.totalScore / entry.chain.length) > (bestEntry.totalScore / bestEntry.chain.length)) {
+                        bestEntry = entry;
+                    }
                 }
             }
+            // Beam pruning: keep top BEAM_WIDTH by average score
+            nextBeam.sort((a, b) => (b.totalScore / b.chain.length) - (a.totalScore / a.chain.length));
+            beam = nextBeam.slice(0, BEAM_WIDTH);
         }
+        // Any remaining beam entries compete for best
+        for (const entry of beam) {
+            if (!bestEntry || (entry.totalScore / entry.chain.length) > (bestEntry.totalScore / bestEntry.chain.length)) {
+                bestEntry = entry;
+            }
+        }
+        if (!bestEntry || bestEntry.chain.length < 1)
+            continue;
+        const chain = bestEntry.chain;
+        let totalScore = bestEntry.totalScore;
+        const visited = bestEntry.visited;
         // Backward trace: does seed need something? Find producers.
         if (seed.requires.length > 0) {
-            const producers = findProducers(graph, seed.requires[0])
+            const producers = findProducers(graph, seed.requires[0], allNodes)
                 .filter(p => !visited.has(p.name));
             if (producers.length > 0) {
-                const bestProducer = producers.sort((a, b) => b.score - a.score)[0];
+                const bestProducer = topByScore(producers);
                 chain.unshift(bestProducer);
                 totalScore += bestProducer.score;
             }
         }
+        // Hybrid: supplement graph chain with high-score keyword matches the graph missed
+        const missed = allNodes
+            .filter(n => !visited.has(n.name) && n.score >= SCORE_FLOOR)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 2); // at most 2 supplements
+        for (const m of missed) {
+            chain.push(m);
+            visited.add(m.name);
+            totalScore += m.score * 0.5; // half weight — graph-discovered nodes are preferred
+        }
         if (chain.length >= 1) {
             chains.push({
                 nodes: chain,
-                score: totalScore / chain.length, // average score
+                score: totalScore / chain.length,
                 explanation: chain.map(n => n.name).join(" → "),
             });
         }
@@ -157,16 +406,34 @@ function selectCapabilityChains(intent, ir, maxChains = 5) {
             unique.push(c);
         }
     }
-    return unique.slice(0, maxChains);
+    const scoreMs = Date.now() - startScore;
+    // Detect semantic gap: very few seeds passed threshold → LLM could help
+    const needsLLM = seeds.length === 0 || (seeds.length <= 2 && graph.size > 50);
+    if (graph.size > 200) {
+        console.error(`[Strategy] ${graph.size} nodes | topo=${topoMs}ms score=${scoreMs}ms | ${unique.length} chains | needsLLM=${needsLLM}`);
+    }
+    return { chains: unique.slice(0, maxChains), needsLLM };
 }
-/** Format chains as a hint for the LLM prompt. */
+/** Format chains as a routing hint (not full path).
+ *  Only shows top 2 high-confidence next steps per entry,
+ *  so the LLM gets guidance without being forced into long chains. */
 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)})`);
+    const lines = ["\n建议的下一步调用 (已从历史成功链中验证):"];
+    const shown = new Set();
+    for (const c of chains.slice(0, 3)) {
+        const pairs = [];
+        for (let i = 0; i < c.nodes.length - 1 && pairs.length < 2; i++) {
+            const key = `${c.nodes[i].name}→${c.nodes[i + 1].name}`;
+            if (!shown.has(key)) {
+                shown.add(key);
+                pairs.push(`${c.nodes[i].name} → ${c.nodes[i + 1].name}`);
+            }
+        }
+        if (pairs.length > 0) {
+            lines.push(`  ${pairs.join("  |  ")} (★${c.score.toFixed(1)})`);
+        }
     }
     return lines.join("\n");
 }

package/dist/strategy-planner.test.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Unit tests for strategy-planner pure functions.
+ * Tests the graph-building and chain-selection logic in isolation.
+ */
+const vitest_1 = require("vitest");
+const strategy_planner_1 = require("./strategy-planner");
+// Minimal mock IR with functions covering auth and data domains
+const mockIR = [
+    {
+        name: "validatePassword",
+        purpose: "Validate a user's password against stored hash",
+        tags: ["auth", "security"],
+        requires: ["password", "hash"],
+        produces: ["validation_result"],
+        useWhen: ["user login", "password reset"],
+        file: "src/auth.ts",
+        exported: true,
+        params: [
+            { name: "password", type: "string" },
+            { name: "hash", type: "string" },
+        ],
+        returnType: "boolean",
+    },
+    {
+        name: "generateJWT",
+        purpose: "Generate a JWT token for authenticated user",
+        tags: ["auth", "token"],
+        requires: ["validation_result"],
+        produces: ["jwt_token"],
+        useWhen: ["after successful login"],
+        file: "src/auth.ts",
+        exported: true,
+        params: [{ name: "userId", type: "string" }],
+        returnType: "string",
+    },
+    {
+        name: "fetchUser",
+        purpose: "Fetch user data from the database",
+        tags: ["data", "user"],
+        requires: ["userId"],
+        produces: ["user_data"],
+        useWhen: ["user profile", "dashboard"],
+        file: "src/data.ts",
+        exported: true,
+        params: [{ name: "userId", type: "string" }],
+        returnType: "object",
+    },
+    {
+        name: "saveToDatabase",
+        purpose: "Save record to persistent storage",
+        tags: ["data", "storage"],
+        requires: ["record"],
+        produces: ["saved_id"],
+        useWhen: ["data persistence"],
+        file: "src/data.ts",
+        exported: true,
+        params: [{ name: "record", type: "object" }],
+        returnType: "string",
+    },
+    // Non-exported function — should be skipped
+    {
+        name: "internalHelper",
+        purpose: "Internal helper — not exported",
+        tags: [],
+        requires: [],
+        produces: [],
+        file: "src/internal.ts",
+        exported: false,
+        params: [],
+        returnType: "void",
+    },
+];
+(0, vitest_1.describe)("selectCapabilityChains", () => {
+    (0, vitest_1.it)("returns chains for an auth intent", () => {
+        const { chains } = (0, strategy_planner_1.selectCapabilityChains)("authenticate user", mockIR, 3);
+        (0, vitest_1.expect)(chains.length).toBeGreaterThan(0);
+        // Should find at least validatePassword or generateJWT
+        const names = chains.flatMap(c => c.nodes.map(n => n.name));
+        (0, vitest_1.expect)(names.some(n => n.includes("validate") || n.includes("JWT"))).toBe(true);
+    });
+    (0, vitest_1.it)("returns chains for a data intent", () => {
+        const { chains } = (0, strategy_planner_1.selectCapabilityChains)("fetch user data", mockIR, 3);
+        (0, vitest_1.expect)(chains.length).toBeGreaterThan(0);
+        const names = chains.flatMap(c => c.nodes.map(n => n.name));
+        (0, vitest_1.expect)(names.some(n => n.includes("fetchUser"))).toBe(true);
+    });
+    (0, vitest_1.it)("respects maxChains limit", () => {
+        const { chains } = (0, strategy_planner_1.selectCapabilityChains)("data", mockIR, 1);
+        (0, vitest_1.expect)(chains.length).toBeLessThanOrEqual(1);
+    });
+    (0, vitest_1.it)("skips planner internals (self-referential guard)", () => {
+        const selfIR = [{
+                name: "selectCapabilityChains",
+                purpose: "planner logic",
+                tags: [],
+                requires: [],
+                produces: [],
+                file: "src/strategy-planner.ts",
+                exported: true,
+                params: [],
+                returnType: "any",
+            }];
+        const { chains } = (0, strategy_planner_1.selectCapabilityChains)("planning", selfIR, 3);
+        // strategy-planner.ts and planner.ts should be filtered out
+        const names = chains.flatMap(c => c.nodes.map(n => n.name));
+        (0, vitest_1.expect)(names).not.toContain("selectCapabilityChains");
+    });
+});
+(0, vitest_1.describe)("selectCapabilityChains — edge cases", () => {
+    (0, vitest_1.it)("returns empty array for null intent", () => {
+        (0, vitest_1.expect)((0, strategy_planner_1.selectCapabilityChains)(null, mockIR)).toEqual({ chains: [], needsLLM: false });
+    });
+    (0, vitest_1.it)("returns empty array for undefined intent", () => {
+        (0, vitest_1.expect)((0, strategy_planner_1.selectCapabilityChains)(undefined, mockIR)).toEqual({ chains: [], needsLLM: false });
+    });
+    (0, vitest_1.it)("returns empty array for empty string intent", () => {
+        (0, vitest_1.expect)((0, strategy_planner_1.selectCapabilityChains)("", mockIR)).toEqual({ chains: [], needsLLM: false });
+    });
+    (0, vitest_1.it)("returns empty array for whitespace-only intent", () => {
+        (0, vitest_1.expect)((0, strategy_planner_1.selectCapabilityChains)("   ", mockIR)).toEqual({ chains: [], needsLLM: false });
+    });
+});
+(0, vitest_1.describe)("formatChainHint", () => {
+    (0, vitest_1.it)("returns empty string for empty chains", () => {
+        (0, vitest_1.expect)((0, strategy_planner_1.formatChainHint)([])).toBe("");
+    });
+    (0, vitest_1.it)("formats a single chain", () => {
+        const { chains } = (0, strategy_planner_1.selectCapabilityChains)("authenticate user", mockIR, 1);
+        const hint = (0, strategy_planner_1.formatChainHint)(chains);
+        (0, vitest_1.expect)(hint).toContain("建议的下一步调用");
+        (0, vitest_1.expect)(hint).toContain("★");
+    });
+});