progmune-runtime 2.1.6 → 3.2.1

package/dist/planner.js

@@ -48,6 +48,7 @@ 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 planner_prompts_1 = require("./planner-prompts");
 const fs = __importStar(require("fs"));
 function enrichActions(actions, ir) {
     return actions.map(a => {
@@ -93,98 +94,6 @@ function determineConstraintType(svl) {
         case "SVL-4": return "protocol";
     }
 }
-/** 构建紧凑函数列表 — 包含能力元数据帮助 LLM 理解函数语义 */
-function buildCompactFuncList(funcs, allFuncs) {
-    // Known string enums with example values
-    const ENUM_DEFAULTS = {
-        "SVL": '"SVL-4"', "RootCause": '"F01"', "BranchReason": '"repair_attempt"',
-        "RepairStrategy": '"insert"', "ConstraintType": '"protocol"',
-    };
-    return funcs.map((f) => {
-        const params = (f.params || []).map((p) => {
-            const t = (p.type || "any").replace(/\[\]$/, "");
-            const def = ENUM_DEFAULTS[t];
-            return def ? `${p.name}: ${def}` : `${p.name}: ${p.type}`;
-        }).join(",");
-        let line = `${f.name}(${params})->${f.returnType || "any"}`;
-        // 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, 50));
-        if (f.produces && f.produces.length > 0)
-            meta.push(`→${f.produces.join(",")}`);
-        if (meta.length > 0)
-            line += `  // ${meta.join(" | ")}`;
-        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.
- *  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.name !== f.name &&
-                (x.requires || []).some((r) => semanticMatch(p, r)));
-            for (const c of consumers) {
-                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 || "?"}`);
-            }
-        }
-    }
-    if (chains.length === 0)
-        return "";
-    return "\n推荐调用链（先调生产者，用 $变量名 传给消费者）:\n" + chains.map(c => `  ${c}`).join("\n");
-}
-const SYSTEM_PROMPT = `你是程序合成助手。只输出 JSON 数组，不输出解释。
-
-格式：[{"f":"函数名","to":"变量名","a":[{"n":"参数名","t":"类型","v":值}]},{"r":"变量名"}]
-
-规则：
-- 函数名从可用列表中选择，优先选注释中 purpose 匹配需求的函数
-- 0参数函数直接用 "a":[]：{"f":"getAllSessions","to":"s","a":[]}
-- 参数值规则（重要！）：
-  - 字符串: "v":""（空串）或 "v":"SVL-4"（已知枚举值）
-  - 数字: "v":0 或 "v":1
-  - 布尔: "v":false
-  - 对象/数组: "v":{} as Type
-  - 上一个函数返回值: "v":"$变量名"（$前缀引用）
-- 返回值: {"r":"变量名"} — 必须返回，不能只调用不返回
-- 链式调用：看到推荐调用链时，用 $变量名 把生产者输出传给消费者
-
-铁律：
-- 函数签名中带引号的参数（如 "SVL-4"）是字符串值，直接 v 中
-- 字符串枚举（SVL等）用带引号的值，禁止 {} as Type
-- 每个call的返回值用"to"命名变量，下一个call通过"$变量名"引用
-- 最后一个action必须是{"r":"变量名"}，不能以call结尾
-- 如果你调了函数，必须return它的结果
-- 只输出JSON`;
-const RETRY_HINT = `输出格式：紧凑 JSON 数组 [{"f":"函数名","to":"变量名","a":[...]}]`;
 /** 构建重试 prompt：精简但包含必要的 IR 语法提示 */
 /** 解析 LLM 输出的紧凑 JSON 为 Action[]。
  *  格式: [{"f":"fn","to":"var","a":[{"n":"p","t":"str","v":"x"}]}, {"r":"var"}, ...]
@@ -273,6 +182,15 @@ function correctFunctionNames(actions, ir) {
 /** 参数签名预检：确保 call action 的参数数量与 IR 函数签名一致 */
 function fixParameterCounts(actions, ir) {
     const fixes = [];
+    // Find the most recent preceding call with assignTo for chain defaults
+    function findPrevVar(idx) {
+        for (let k = idx - 1; k >= 0; k--) {
+            const prev = actions[k];
+            if (prev.kind === "call" && prev.assignTo)
+                return prev.assignTo;
+        }
+        return undefined;
+    }
     const corrected = actions.map((a, i) => {
         if (a.kind !== "call" || !a.function)
             return a;
@@ -284,16 +202,17 @@ function fixParameterCounts(actions, ir) {
         if (actual === expected)
             return a;
         if (actual < expected) {
-            // 参数太少：填充缺失参数
             const padded = [...(a.args || [])];
+            const prevVar = findPrevVar(i);
             for (let j = actual; j < expected; j++) {
-                padded.push({ name: def.params[j].name, type: def.params[j].type || "any", value: "" });
+                // Smart default: chain from previous call if available
+                const defaultValue = prevVar ? `$${prevVar}` : "";
+                padded.push({ name: def.params[j].name, type: def.params[j].type || "any", value: defaultValue });
             }
-            fixes.push(`action[${i}] ${a.function}: 参数 ${actual}→${expected} (填充 ${expected - actual} 个缺失参数)`);
+            fixes.push(`action[${i}] ${a.function}: 参数 ${actual}→${expected} (填充 ${expected - actual} 个缺失参数${prevVar ? ", 链自 $" + prevVar : ""})`);
             return { ...a, args: padded };
         }
         else {
-            // 参数太多：截断多余参数
             fixes.push(`action[${i}] ${a.function}: 参数 ${actual}→${expected} (截断 ${actual - expected} 个多余参数)`);
             return { ...a, args: a.args.slice(0, expected) };
         }
@@ -301,30 +220,6 @@ function fixParameterCounts(actions, ir) {
     return { actions: corrected, fixes };
 }
 /** 构建协议链提示：为 LLM 显示协议状态机的合法调用顺序 */
-function buildProtocolChainHint(protocols) {
-    if (protocols.length === 0)
-        return "";
-    // 按命名空间分组
-    const byNs = new Map();
-    for (const p of protocols) {
-        const ns = p.protocol.namespace || "_global";
-        if (!byNs.has(ns))
-            byNs.set(ns, []);
-        byNs.get(ns).push(p);
-    }
-    const lines = ["\n⚠️ 协议约束（必须严格遵循调用顺序）:"];
-    for (const [ns, fns] of byNs) {
-        if (ns === "_global" || fns.length <= 1)
-            continue;
-        lines.push(`  [${ns}] 合法调用链: ${fns.map(p => p.function).join(" → ")}`);
-        for (const p of fns) {
-            const pre = p.protocol.pre_states?.join(",") || "(无)";
-            const post = p.protocol.post_states?.join(",") || "(无)";
-            lines.push(`    ${p.function}: 前置状态=[${pre}] → 后置状态=[${post}]`);
-        }
-    }
-    return lines.join("\n");
-}
 /** JSON schema pre-validation: structural checks before IR-aware validation.
  *  Catches malformed actions that parseActionJSON() accepted but are semantically invalid. */
 function validateActionSchema(actions) {
@@ -451,7 +346,7 @@ function loadProtocols(ir) {
         const protoDef = JSON.parse(fs.readFileSync("protocols.json", "utf-8"));
         jsonProtocols = (0, ssg_validator_1.parseProtocolsFromJSON)(protoDef);
     }
-    catch { }
+    catch { /* topology rebuild — optional */ }
     // Merge: IR @protocol takes priority, but inherits JSON namespace
     const merged = new Map();
     for (const p of jsonProtocols)
@@ -551,7 +446,7 @@ function attemptSSGRepair(actions, rejection, ir, protocols, namespaceInitialSta
     return null;
 }
 /** @requires INTENT @produces ACTION_PLAN */
-async function plan(userIntent) {
+async function plan(userIntent, llmSeeds) {
     (0, llm_1.resetCallCount)();
     const irRaw = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
     // Support both old (array) and new ({typeMap, functions}) formats
@@ -560,13 +455,14 @@ async function plan(userIntent) {
     try {
         (0, semantic_topology_1.rebuildTopology)(ir);
     }
-    catch { }
+    catch { /* topology rebuild — optional */ }
     // Helper: wrap actions into PlanResult
     let repairMetrics = { applied: false, count: 0, branchIds: [] };
-    const wrapResult = (actions, repair) => ({
+    const wrapResult = (actions, repair, degraded = false) => ({
         actions,
         sessionId: session?.sessionId || "",
         ruleHash: session?.ruleHash,
+        degraded,
         repairApplied: repair?.applied ?? repairMetrics.applied,
         repairCount: repair?.count ?? repairMetrics.count,
         repairBranchIds: repair?.branchIds ?? repairMetrics.branchIds,
@@ -591,15 +487,45 @@ async function plan(userIntent) {
     }
     // 提前加载协议（后续多处使用）
     const { protocols, namespaceInitialStates } = loadProtocols(ir);
-    // 抗体免疫快速通道：查询高置信度抗体（ACL-3+），匹配则约束或跳过 LLM
-    const antibodies = (0, failure_corpus_1.queryAntibodies)(userIntent, "ACL-3");
+    // ── Auto Router: repo-specific tasks → Graph ON, generic tasks → OFF ──
+    const explicitMode = process.env.PROGMUNE_GRAPH_MODE;
+    let graphMode = explicitMode || "off"; // default OFF
+    if (!explicitMode) {
+        // Extract repo-specific terms from IR
+        const repoNames = new Set();
+        for (const f of ir) {
+            for (const word of f.name.replace(/([A-Z])/g, " $1").toLowerCase().split(/[\s_]+/))
+                if (word.length > 3)
+                    repoNames.add(word);
+            for (const tag of (f.tags || []))
+                repoNames.add(tag.toLowerCase());
+        }
+        const stopWords = new Set(["this", "that", "with", "from", "have", "been", "their", "will", "would", "could", "should", "about", "which", "there"]);
+        for (const w of stopWords)
+            repoNames.delete(w);
+        // Split intent words the same way as function names: split on whitespace + camelCase
+        const intentWords = userIntent
+            .replace(/([A-Z])/g, " $1") // camelCase → "camel Case" (before toLowerCase!)
+            .toLowerCase()
+            .split(/[\s,，]+/)
+            .filter((w) => w.length > 2);
+        const repoHits = intentWords.filter((w) => repoNames.has(w)).length;
+        const density = intentWords.length > 0 ? repoHits / intentWords.length : 0;
+        // 0.20 threshold — lower bound for short intents (3-5 words) still triggers correctly
+        if (density > 0.20) {
+            graphMode = "on";
+            console.error("[AutoRouter] " + Math.round(density * 100) + "% repo terms → Graph ON");
+        }
+    }
+    // ── 抗体免疫系统：查询历史失败模式，注入知识回流 ──
+    const antibodies = graphMode !== "off" ? (0, failure_corpus_1.queryAntibodies)(userIntent, "ACL-3") : [];
     let antibodyHint = "";
     if (antibodies.length > 0) {
         const top = antibodies[0];
         const aclLabel = top.antibodyLevel;
         console.error(`🛡️  命中抗体: ${aclLabel} | 模式: ${top.signature} | 相似度: ${top._score.toFixed(2)}`);
         console.error(`   修复路径: ${top.fixPath.join(" → ")}`);
-        // ACL-4: 全局稳定抗体 → 直接构建动作序列，跳过 LLM
+        // L2: ACL-4 全局稳定抗体 → 快速通道，绕过 LLM
         if (aclLabel === "ACL-4" && top.fixPath.length > 0) {
             const antibodyActions = top.fixPath.map((fnName) => {
                 const def = ir.find((f) => f.name === fnName);
@@ -621,7 +547,7 @@ async function plan(userIntent) {
                 similarityScore: top._score,
                 action: "fast_path",
                 llmCallsSaved: 1,
-                estimatedTokensSaved: Math.ceil((0, llm_1.estimateTokens)(SYSTEM_PROMPT + userIntent) * 1.2),
+                estimatedTokensSaved: Math.ceil((0, llm_1.estimateTokens)(planner_prompts_1.SYSTEM_PROMPT + userIntent) * 1.2),
             };
             // 验证抗体序列
             const antibodyRuleHash = (() => {
@@ -633,7 +559,7 @@ async function plan(userIntent) {
             if (protocols.length > 0) {
                 const validation = validateProtocolWithTransitions(antibodyActions, protocols, namespaceInitialStates);
                 if (validation.valid) {
-                    console.error(`⚡ ACL-4 抗体快速通道: 0 LLM 调用，节省 ~${Math.ceil((0, llm_1.estimateTokens)(SYSTEM_PROMPT + userIntent) * 1.2)} tokens (est.)`);
+                    console.error(`⚡ ACL-4 抗体快速通道: 0 LLM 调用，节省 ~${Math.ceil((0, llm_1.estimateTokens)(planner_prompts_1.SYSTEM_PROMPT + userIntent) * 1.2)} tokens (est.)`);
                     const antibodyAttempt = {
                         id: (0, runtime_types_1.generateAttemptId)(),
                         sessionId: session.sessionId,
@@ -664,7 +590,7 @@ async function plan(userIntent) {
             }
             else {
                 // 无协议规则，直接信任抗体
-                console.error(`⚡ ACL-4 抗体快速通道: 0 LLM 调用（无协议约束），节省 ~${Math.ceil((0, llm_1.estimateTokens)(SYSTEM_PROMPT + userIntent) * 1.2)} tokens (est.)`);
+                console.error(`⚡ ACL-4 抗体快速通道: 0 LLM 调用（无协议约束），节省 ~${Math.ceil((0, llm_1.estimateTokens)(planner_prompts_1.SYSTEM_PROMPT + userIntent) * 1.2)} tokens (est.)`);
                 const antibodyAttempt = {
                     id: (0, runtime_types_1.generateAttemptId)(),
                     sessionId: session.sessionId,
@@ -693,9 +619,24 @@ async function plan(userIntent) {
                 return wrapResult(antibodyActions);
             }
         }
-        // ACL-3: 注入修复路径作为提示约束
-        antibodyHint = `\n已知正确调用顺序: ${top.fixPath.join(" → ")}。请遵循此顺序。`;
-        console.error(`💉 ACL-3 抗体注入提示: ${top.fixPath.join(" → ")}`);
+        // L1: ACL-3 抗体注入提示 — 知识回流到 Planner
+        const hints = [];
+        for (let i = 0; i < Math.min(antibodies.length, 3); i++) {
+            const ab = antibodies[i];
+            const level = ab.antibodyLevel;
+            const sig = ab.signature;
+            const count = ab.occurrenceCount;
+            const fix = ab.fixPath.join(" → ");
+            // 为每种违规类型生成具体的避错指南
+            const avoidance = sig.includes("F07") ? "确保在调用 .map/.filter 前检查对象是否为数组，使用 (obj || [])"
+                : sig.includes("SVL-1") ? "只使用可用函数列表中的函数名，禁止编造"
+                    : sig.includes("SVL-2") ? `检查函数参数类型是否与 IR 签名一致`
+                        : sig.includes("SVL-4") ? `严格遵循 SSG 协议状态顺序：${fix}`
+                            : `避免此模式：${sig}`;
+            hints.push(`${i + 1}. [${level}] ${sig}（累计 ${count} 次）→ ${avoidance}`);
+        }
+        antibodyHint = `\n\n⚠️ 免疫系统警告（来自 ${antibodies.length} 条历史抗体记录）：\n${hints.join("\n")}\n请避免上述已知错误模式。`;
+        console.error(`💉 L1 抗体注入: ${antibodies.length} 条抗体 → ${hints.length} 条注入提示`);
     }
     const keywords = (0, utils_1.extractKeywords)(userIntent);
     const intentLower = userIntent.toLowerCase();
@@ -778,8 +719,9 @@ async function plan(userIntent) {
     scored.sort((a, b) => b.score - a.score);
     const topFuncs = scored.slice(0, 15);
     // 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);
+    const chainResult = graphMode !== "off" ? (0, strategy_planner_1.selectCapabilityChains)(userIntent, ir, 3, llmSeeds) : { chains: [], needsLLM: false };
+    const chains = chainResult.chains;
+    const strategyHint = graphMode !== "off" ? (0, strategy_planner_1.formatChainHint)(chains) : "";
     // Action Layer: filter functions to those in selected chains
     let chainFuncs = topFuncs;
     if (chains.length > 0) {
@@ -793,8 +735,10 @@ async function plan(userIntent) {
         const outChain = topFuncs.filter((f) => !chainNames.has(f.name));
         chainFuncs = [...inChain, ...outChain].slice(0, 15);
     }
-    const compactFuncList = buildCompactFuncList(chainFuncs, ir);
-    const chainHints = buildChainHints(topFuncs);
+    const compactFuncList = (0, planner_prompts_1.buildCompactFuncList)(chainFuncs, ir);
+    // Graph recommendations: only inject when explicitly enabled (default: off)
+    // Graph validation (SVL, protocol, dataflow) always runs regardless
+    const chainHints = graphMode === "on" ? (0, planner_prompts_1.buildChainHints)(topFuncs) : "";
     // Known string-enum types: tell LLM these are strings, not objects
     const STRING_ENUMS = {
         "SVL": '"SVL-1"|"SVL-2"|"SVL-3"|"SVL-4"',
@@ -813,15 +757,15 @@ async function plan(userIntent) {
             forbiddenFuncs.push(targetName);
         }
     }
-    const protocolChainHint = buildProtocolChainHint(protocols);
+    const protocolChainHint = (0, planner_prompts_1.buildProtocolChainHint)(protocols);
     const userPrompt = `可用函数：
 ${compactFuncList}${protocolChainHint}${chainHints}${typeHints}${strategyHint}
 
 需求：${userIntent}${antibodyHint}
 
-${RETRY_HINT}
+${planner_prompts_1.RETRY_HINT}
 只输出 JSON。`;
-    const estimatedTokens = (0, llm_1.estimateTokens)(SYSTEM_PROMPT + userPrompt);
+    const estimatedTokens = (0, llm_1.estimateTokens)(planner_prompts_1.SYSTEM_PROMPT + userPrompt);
     console.error(`💰 估算 prompt token: ${estimatedTokens}`);
     // ── 执行持久化：检查是否有未完成的 checkpoint ──
     const cp = (0, failure_corpus_1.loadCheckpoint)(userIntent);
@@ -862,14 +806,14 @@ ${RETRY_HINT}
         });
         if (legalFuncs.length === topFuncs.length)
             return compactFuncList;
-        return buildCompactFuncList(legalFuncs, ir);
+        return (0, planner_prompts_1.buildCompactFuncList)(legalFuncs, ir);
     }
     const maxRetries = 3;
     for (let r = startRetry; r < maxRetries; r++) {
         let text;
         try {
             text = useSystem
-                ? await (0, llm_1.chat)(SYSTEM_PROMPT, currentPrompt)
+                ? await (0, llm_1.chat)(planner_prompts_1.SYSTEM_PROMPT, currentPrompt)
                 : await (0, llm_1.generate)(`你是程序合成助手。\n\n${currentPrompt}`);
         }
         catch (e) {
@@ -878,7 +822,12 @@ ${RETRY_HINT}
         if (!text)
             continue;
         text = text.replace(/```(?:json|javascript)?\s*/gi, '').replace(/```\s*/g, '').trim();
-        console.error("📝 LLM 输出:\n", text);
+        if ((0, llm_1.isVerbose)()) {
+            console.error(`\n📝 [VERBOSE] LLM raw output (attempt ${r + 1}/${maxRetries}):\n${text.slice(0, 3000)}${text.length > 3000 ? `\n... [${text.length - 3000} more chars]` : ""}\n`);
+        }
+        else {
+            console.error("📝 LLM 输出:\n", text);
+        }
         // 优先尝试 JSON 解析，失败则回退到 DSL 执行
         let rawActions = parseActionJSON(text);
         if (!rawActions || !Array.isArray(rawActions)) {
@@ -887,7 +836,7 @@ ${RETRY_HINT}
         }
         if (!rawActions || !Array.isArray(rawActions) || rawActions.length === 0) {
             console.error("⚠️ 解析失败，重试...");
-            currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}\n\n上一次输出无效。请严格输出 JSON 数组。\n${RETRY_HINT}\n只输出 JSON。`;
+            currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}${antibodyHint}\n\n上一次输出无效。请严格输出 JSON 数组。\n${planner_prompts_1.RETRY_HINT}\n只输出 JSON。`;
             useSystem = false;
             continue;
         }
@@ -911,7 +860,7 @@ ${RETRY_HINT}
         const schemaCheck = validateActionSchema(rawActions);
         if (!schemaCheck.valid) {
             console.error("⚠️ JSON schema 校验失败:", schemaCheck.errors.join("; "));
-            currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}\n\n输出格式错误：${schemaCheck.errors.join("；")}。请修正 JSON 结构。\n${RETRY_HINT}\n只输出 JSON。`;
+            currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}${antibodyHint}\n\n输出格式错误：${schemaCheck.errors.join("；")}。请修正 JSON 结构。\n${planner_prompts_1.RETRY_HINT}\n只输出 JSON。`;
             useSystem = false;
             const schemaViolation = {
                 svl: 1,
@@ -955,11 +904,25 @@ ${RETRY_HINT}
         const enriched = enrichActions(rawActions, ir);
         const filtered = enriched.filter(a => !forbiddenFuncs.includes(a.kind === "call" ? a.function : ''));
         let ssgTransitions = [];
+        if ((0, llm_1.isVerbose)()) {
+            console.error(`🔬 [VERBOSE] Parsed ${rawActions.length} actions → ${enriched.length} enriched → ${filtered.length} after filtering`);
+            for (let ai = 0; ai < filtered.length; ai++) {
+                const a = filtered[ai];
+                if (a.kind === "call") {
+                    console.error(`  [${ai}] call ${a.function}(${(a.args || []).map((x) => `${x.name}=${JSON.stringify(x.value)}`).join(", ")})`);
+                }
+                else {
+                    console.error(`  [${ai}] ${a.kind}`);
+                }
+            }
+        }
         // 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);
+        // Protocol pre-check: state must accumulate across the sequence
+        const preCheckCtx = { ledger: [], currentState: (0, ssg_validator_1.rebuildState)([], namespaceInitialStates) };
         const preCheckErrors = [];
         for (let ai = 0; ai < filtered.length; ai++) {
             const a = filtered[ai];
@@ -973,24 +936,30 @@ ${RETRY_HINT}
             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
+            // Protocol pre-check: verify function is callable in ACCUMULATED 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);
+                const { valid, transition, rejection } = (0, ssg_validator_1.validateTransition)(preCheckCtx, a.function, ai, preCheckRules, namespaceInitialStates);
                 if (!valid && rejection) {
                     preCheckErrors.push(`${a.function}: 协议违规 — 需要先调用 ${rejection.fixPath?.join(" → ") || "?"}`);
                 }
+                // Update accumulated state: validateTransition computes statesAfter but doesn't mutate ctx
+                if (transition.valid) {
+                    preCheckCtx.currentState = transition.statesAfter;
+                }
             }
         }
-        // P0: Strategy Enforcement — LLM must follow recommended chain
+        // Strategy hint: warn if LLM missed all recommended nodes, record negative feedback
         if (chains.length > 0 && chains[0].nodes.length >= 2) {
             const topChain = chains[0];
-            const requiredFuncs = topChain.nodes.map(n => n.name);
+            const recommendedFuncs = 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(", ")}`);
+            const hasAny = recommendedFuncs.some(fn => chosenFuncs.includes(fn));
+            if (!hasAny && recommendedFuncs.length >= 3) {
+                console.error(`⚠️ 策略提示: LLM 未使用推荐链中的任何函数 (推荐: ${topChain.explanation})`);
+                // Record negative feedback on recommended edges
+                for (let i = 0; i < topChain.nodes.length - 1; i++) {
+                    (0, failure_corpus_1.recordEdgeRejection)(topChain.nodes[i].name, topChain.nodes[i + 1].name);
+                }
             }
         }
         // 1) 基础序列校验
@@ -1038,7 +1007,7 @@ ${RETRY_HINT}
             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。`;
+            currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}${antibodyHint}\n\n${specificErrors}\n请修正上述问题。\n${planner_prompts_1.RETRY_HINT}\n只输出 JSON。`;
             useSystem = false;
             (0, failure_corpus_1.saveCheckpoint)(userIntent, { attemptIndex: r + 1, sessionAttempts: session.attempts, currentPrompt, useSystem });
             continue;
@@ -1130,21 +1099,33 @@ ${RETRY_HINT}
                         };
                         fs.writeFileSync(`${repairDir}/repair_${session.sessionId}.json`, JSON.stringify(repairRecord, null, 2), "utf-8");
                     }
-                    catch { }
+                    catch { /* topology rebuild — optional */ }
                     finalActions = repaired;
                     break;
                 }
                 const maskedFuncList = getMaskedFuncList();
-                currentPrompt = `当前协议状态只允许以下函数：\n${maskedFuncList}${protocolChainHint}\n\n需求：${userIntent}\n\n协议违规：${explain.replace(/\n/g, '；')}。请修正。\n${RETRY_HINT}\n只输出 JSON。`;
+                currentPrompt = `当前协议状态只允许以下函数：\n${maskedFuncList}${protocolChainHint}\n\n需求：${userIntent}${antibodyHint}\n\n协议违规：${explain.replace(/\n/g, '；')}。请修正。\n${planner_prompts_1.RETRY_HINT}\n只输出 JSON。`;
                 useSystem = false;
                 (0, failure_corpus_1.saveCheckpoint)(userIntent, { attemptIndex: r + 1, sessionAttempts: session.attempts, currentPrompt, useSystem });
                 continue;
             }
             // SSG passed — capture transitions
             ssgTransitions = protoResult.transitions;
+            if ((0, llm_1.isVerbose)()) {
+                console.error(`✅ [VERBOSE] Protocol (SSG) validation passed — ${ssgTransitions.length} transitions recorded`);
+                for (const t of ssgTransitions.slice(0, 5)) {
+                    const ns = t.namespace || "_global";
+                    const before = t.statesBefore?.[ns] || [];
+                    const after = t.statesAfter?.[ns] || [];
+                    console.error(`  ${t.function}: [${before.join(",") || "·"}] → [${after.join(",") || "·"}] (ns=${ns})`);
+                }
+            }
         }
         // 3) 语义合约校验
         const semResult = (0, semantic_validator_1.checkSemantic)(userIntent, filtered);
+        if ((0, llm_1.isVerbose)() && semResult.valid) {
+            console.error(`✅ [VERBOSE] Semantic contract validation passed`);
+        }
         if (!semResult.valid) {
             console.error("⚠️ 语义校验失败:", semResult.errors.join(", "));
             const violation = {
@@ -1181,7 +1162,7 @@ ${RETRY_HINT}
                 plannerRetryTotal: maxRetries,
             });
             (0, memory_layer_1.recordEpisode)({ intent: userIntent, actions: filtered, success: false, svlViolated: "SVL-4" });
-            currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}\n\n语义错误：${semResult.errors.join("；")}。请修正。\n${RETRY_HINT}\n只输出 JSON。`;
+            currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}${antibodyHint}\n\n语义错误：${semResult.errors.join("；")}。请修正。\n${planner_prompts_1.RETRY_HINT}\n只输出 JSON。`;
             useSystem = false;
             (0, failure_corpus_1.saveCheckpoint)(userIntent, { attemptIndex: r + 1, sessionAttempts: session.attempts, currentPrompt, useSystem });
             continue;
@@ -1200,10 +1181,11 @@ ${RETRY_HINT}
                 }
             }
         }
-        if (emptyArgs.length > 0 && r < maxRetries - 1) {
+        // Only refine empty args if validation also failed — don't break good chains
+        if (emptyArgs.length > 0 && r < maxRetries - 1 && (!seqResult.valid || preCheckErrors.length > 0)) {
             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。`;
+            currentPrompt = `可用函数：\n${compactFuncList}${protocolChainHint}\n\n需求：${userIntent}${antibodyHint}\n\n上一次生成的 JSON 中以下参数为空值：\n${argDetails}\n\n请为这些参数填入有意义的示例值（字符串用描述性值，数字用合理数值，对象用 {} as Type）。\n${planner_prompts_1.RETRY_HINT}\n只输出 JSON。`;
             useSystem = false;
             continue;
         }
@@ -1299,7 +1281,8 @@ ${RETRY_HINT}
             session.endedAt = Date.now();
             (0, failure_corpus_1.recordSession)(session);
             (0, failure_corpus_1.clearCheckpoint)(userIntent);
-            return wrapResult(fallback);
+            console.error("[降级] 返回回退结果 — 代码质量可能不高，建议人工审核。");
+            return wrapResult(fallback, undefined, true);
         }
         (0, memory_layer_1.recordEpisode)({ intent: userIntent, actions: [], success: false });
         session.resolved = false;
@@ -1310,7 +1293,8 @@ ${RETRY_HINT}
     }
     return wrapResult(finalActions);
 }
-/** 本地规则回退：当 LLM 不可用时，根据意图关键词生成简单动作序列 */
+/** 本地规则回退：当 LLM 不可用时，根据意图关键词生成简单动作序列。
+ *  使用实际的默认值（而非占位符），确保生成的代码至少可以编译运行。 */
 function generateFallbackPlan(intent, ir) {
     const intentLower = intent.toLowerCase();
     const actions = [];
@@ -1325,19 +1309,30 @@ function generateFallbackPlan(intent, ir) {
     }
     if (matchedFuncs.length === 0)
         return [];
+    // Sensible default values per type — no placeholder strings
+    function defaultValue(typeName) {
+        const t = (typeName || "string").toLowerCase();
+        if (t === "number")
+            return 0;
+        if (t === "boolean")
+            return false;
+        if (t.includes("[]") || t.includes("array"))
+            return [];
+        return ""; // string default
+    }
     for (const fn of matchedFuncs) {
         const args = (fn.params || []).map((p, i) => ({
             name: p.name || `p${i}`,
-            type: p.type || 'any',
-            value: `{{${p.name || `p${i}`}}}`
+            type: p.type || "string",
+            value: defaultValue(p.type || "string"),
         }));
-        const assignTo = fn.returnType && fn.returnType !== 'void' && fn.returnType !== 'undefined'
+        const assignTo = fn.returnType && fn.returnType !== "void" && fn.returnType !== "undefined"
             ? `${fn.name}_result` : undefined;
         if (assignTo) {
-            actions.push({ kind: 'call', function: fn.name, args, assignTo });
+            actions.push({ kind: "call", function: fn.name, args, assignTo });
         }
         else {
-            actions.push({ kind: 'call', function: fn.name, args });
+            actions.push({ kind: "call", function: fn.name, args });
         }
     }
     return actions;