@metago-ai/engine 1.0.7 → 2.0.0

package/RUNTIME/dist/evolution-engine.js

@@ -5,84 +5,185 @@
  *
  * 对应专利：AI 能力边界自动检测与进化方法
  * 对应协议：PROTOCOL_META_EVOLUTION_V1
+ * 对应技能：metago-meta-evolve
  *
  * 五阶段循环：1.边界感知 2.差距分析 3.自生成 4.验证 5.递归
  *
+ * 工程化实现要点：
+ * - 阶段一（边界感知）：<10ms
+ * - 阶段二（差距分析）：<50ms 简单 / <500ms 复杂
+ * - 阶段三（自生成）  ：<100ms 简单 / <2s 复杂，耦生度≥0.95
+ * - 阶段四（验证）    ：<50ms
+ * - 接入 KMWI 记忆，进化结果可溯源、可反哺
+ * - 自生成阶段调用 SkillGenerator 实现真正的内生生长
+ *
  * @author 易霄 / MetaGO Lightyear
- * @version 1.0.0
+ * @version 2.0.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvolutionEngine = void 0;
 const perception_1 = require("./perception");
+const kmwi_memory_1 = require("./kmwi-memory");
+const skill_generator_1 = require("./skill-generator");
+// ============================================================================
+// 进化引擎
+// ============================================================================
 /**
  * 进化引擎
- * Evolution Engine - 实现五阶段元进化循环
+ *
+ * 实现五阶段元进化循环，每个阶段都有时间约束和耦生度约束。
+ * 接入 KMWI 记忆系统，进化结果可溯源、可反哺。
+ * 自生成阶段调用 SkillGenerator 实现真正的内生生长（非模板字符串）。
  */
 class EvolutionEngine {
-    constructor(version = '1.0.0') {
+    constructor(version = '1.0.0', kmwi, skillGenerator) {
         this.evolutionHistory = [];
         this.maxRecursionDepth = 3;
+        this.minCouplingScore = 0.95;
+        // 时间预算（毫秒），对应 SKILL.md 施工蓝图
+        this.TIME_BUDGETS = {
+            PERCEPTION: 10,
+            GAP_ANALYSIS_SIMPLE: 50,
+            GAP_ANALYSIS_COMPLEX: 500,
+            SELF_GENERATION_SIMPLE: 100,
+            SELF_GENERATION_COMPLEX: 2000,
+            VALIDATION: 50,
+        };
         this.perception = new perception_1.Perception();
+        this.kmwi = kmwi || new kmwi_memory_1.KMWIMemory();
+        this.skillGenerator = skillGenerator || new skill_generator_1.SkillGenerator(this.kmwi);
         this.currentVersion = version;
     }
+    // ============================================================================
+    // 元进化主循环
+    // ============================================================================
     /**
      * 触发元进化
-     * Trigger meta-evolution
+     * 五阶段循环：边界感知 → 差距分析 → 自生成 → 验证 → 递归
      */
     async evolve(context) {
-        // 阶段 1：边界感知
+        const timing = [];
+        const errors = [];
+        // ========== 阶段 1：边界感知（<10ms） ==========
+        const t1Start = Date.now();
         const boundary = this.perception.detectBoundary(context);
+        const t1Duration = Date.now() - t1Start;
+        timing.push({
+            stage: 'PERCEPTION',
+            durationMs: t1Duration,
+            budgetMs: this.TIME_BUDGETS.PERCEPTION,
+            withinBudget: t1Duration <= this.TIME_BUDGETS.PERCEPTION,
+        });
         if (!boundary) {
-            return {
+            return this.buildResult({
                 success: true,
                 stage: 'PERCEPTION',
                 errors: ['No boundary detected, no evolution needed'],
-                timestamp: new Date().toISOString(),
-            };
+                timing,
+                couplingScore: 1.0,
+                kmwiRecorded: false,
+            });
         }
-        // 阶段 2：差距分析
+        // ========== 阶段 2：差距分析（<50ms 简单 / <500ms 复杂） ==========
+        const t2Start = Date.now();
         const gaps = this.analyzeGap(boundary);
-        // 阶段 3：自生成
-        const solutions = this.selfGenerate(gaps);
-        // 阶段 4：验证
+        const isComplex = gaps.length > 2 || gaps.some(g => g.severity === 'critical');
+        const t2Duration = Date.now() - t2Start;
+        const t2Budget = isComplex ? this.TIME_BUDGETS.GAP_ANALYSIS_COMPLEX : this.TIME_BUDGETS.GAP_ANALYSIS_SIMPLE;
+        timing.push({
+            stage: 'GAP_ANALYSIS',
+            durationMs: t2Duration,
+            budgetMs: t2Budget,
+            withinBudget: t2Duration <= t2Budget,
+        });
+        if (gaps.length === 0) {
+            return this.buildResult({
+                success: true,
+                stage: 'GAP_ANALYSIS',
+                boundary,
+                errors: ['No gaps identified despite boundary detection'],
+                timing,
+                couplingScore: 1.0,
+                kmwiRecorded: false,
+            });
+        }
+        // ========== 阶段 3：自生成（<100ms 简单 / <2s 复杂） ==========
+        const t3Start = Date.now();
+        const solutions = await this.selfGenerate(gaps);
+        const t3Duration = Date.now() - t3Start;
+        const t3Budget = isComplex ? this.TIME_BUDGETS.SELF_GENERATION_COMPLEX : this.TIME_BUDGETS.SELF_GENERATION_SIMPLE;
+        timing.push({
+            stage: 'SELF_GENERATION',
+            durationMs: t3Duration,
+            budgetMs: t3Budget,
+            withinBudget: t3Duration <= t3Budget,
+        });
+        if (solutions.length === 0) {
+            errors.push('Self-generation produced no solutions');
+            return this.buildResult({
+                success: false,
+                stage: 'SELF_GENERATION',
+                boundary,
+                gaps,
+                errors,
+                timing,
+                couplingScore: 0,
+                kmwiRecorded: false,
+            });
+        }
+        // ========== 阶段 4：验证（<50ms） ==========
+        const t4Start = Date.now();
         const validated = this.validate(solutions);
-        // 阶段 5：递归（如果有未通过的解决方案）
+        const t4Duration = Date.now() - t4Start;
+        timing.push({
+            stage: 'VALIDATION',
+            durationMs: t4Duration,
+            budgetMs: this.TIME_BUDGETS.VALIDATION,
+            withinBudget: t4Duration <= this.TIME_BUDGETS.VALIDATION,
+        });
+        // ========== 阶段 5：递归 ==========
         let finalResult;
         if (validated.failed.length > 0 && this.evolutionHistory.length < this.maxRecursionDepth) {
-            this.evolutionHistory.push({
+            // 记录当前轮次，递归调用
+            this.evolutionHistory.push(this.buildResult({
                 success: false,
                 stage: 'RECURSION',
                 boundary,
                 gaps,
                 solutions: validated.failed,
                 errors: ['Some solutions failed validation, recursing'],
-                timestamp: new Date().toISOString(),
-            });
-            // 递归调用
+                timing,
+                couplingScore: this.computeOverallCoupling(validated.failed),
+                kmwiRecorded: false,
+            }));
             finalResult = await this.evolve(context);
         }
         else {
             // 固化通过验证的解决方案
             const newVersion = this.recurse(validated.passed);
-            finalResult = {
+            const overallCoupling = this.computeOverallCoupling(validated.passed);
+            finalResult = this.buildResult({
                 success: validated.failed.length === 0,
                 stage: 'RECURSION',
                 boundary,
                 gaps,
                 solutions: validated.passed,
                 newVersion,
-                errors: validated.failed.map(f => `Validation failed: ${f.name}`),
-                timestamp: new Date().toISOString(),
-            };
+                errors: validated.failed.map(f => `Validation failed: ${f.name} (coupling=${f.couplingScore.toFixed(3)})`),
+                timing,
+                couplingScore: overallCoupling,
+                kmwiRecorded: false,
+            });
         }
         // 元元进化监控
         finalResult.metaMetaEvolution = this.metaMetaEvolution(finalResult);
+        // 记录到 KMWI 记忆
+        finalResult.kmwiRecorded = this.recordToKMWI(finalResult);
         return finalResult;
     }
-    /**
-     * 阶段 2：差距分析
-     * Stage 2: Gap Analysis
-     */
+    // ============================================================================
+    // 阶段 2：差距分析
+    // ============================================================================
     analyzeGap(boundary) {
         const gaps = [];
         switch (boundary.type) {
@@ -93,6 +194,7 @@ class EvolutionEngine {
                     missingCapability: 'Task execution capability',
                     requiredSkill: 'metago-holistic-task',
                     severity: 'high',
+                    domain: this.extractDomain(boundary.message, boundary.context?.task),
                 });
                 break;
             case perception_1.BoundaryType.CAPABILITY_GAP:
@@ -101,6 +203,7 @@ class EvolutionEngine {
                     description: `Capability gap detected: ${boundary.message}`,
                     missingCapability: 'Missing skill or tool',
                     severity: boundary.severity,
+                    domain: this.extractDomain(boundary.message),
                 });
                 break;
             case perception_1.BoundaryType.USER_FEEDBACK:
@@ -109,6 +212,7 @@ class EvolutionEngine {
                     description: `User feedback indicates gap: ${boundary.message}`,
                     missingCapability: 'User-expectation alignment',
                     severity: 'medium',
+                    domain: this.extractDomain(boundary.message, boundary.context?.feedback),
                 });
                 break;
             case perception_1.BoundaryType.VERSION_OUTDATED:
@@ -117,59 +221,153 @@ class EvolutionEngine {
                     description: `Engine version outdated: ${boundary.message}`,
                     missingCapability: 'Version upgrade',
                     severity: 'low',
+                    domain: 'version-management',
                 });
                 break;
         }
         return gaps;
     }
     /**
-     * 阶段 3：自生成
-     * Stage 3: Self-Generation
+     * 从消息中提取问题域关键词
      */
-    selfGenerate(gaps) {
-        return gaps.map(gap => {
-            let type = 'skill';
-            if (gap.requiredProtocol)
-                type = 'protocol';
-            else if (gap.requiredSkill)
-                type = 'skill';
+    extractDomain(...texts) {
+        const combined = texts.filter(Boolean).join(' ').toLowerCase();
+        // 提取关键词：去除常见停用词，取前 3 个有意义的词
+        const stopwords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'to', 'of', 'in', 'on', 'at', 'for', 'with', 'and', 'or', 'not', 'failed', 'error', 'task']);
+        const words = combined.split(/[^a-z\u4e00-\u9fa5]+/).filter(w => w.length > 2 && !stopwords.has(w));
+        return words.slice(0, 3).join('-') || 'general';
+    }
+    // ============================================================================
+    // 阶段 3：自生成（真正的内生生长，非模板字符串）
+    // ============================================================================
+    async selfGenerate(gaps) {
+        const solutions = [];
+        for (const gap of gaps) {
+            // 优先尝试通过 SkillGenerator 生成（真正的内生生长）
+            const skillSolution = await this.generateViaSkillGenerator(gap);
+            if (skillSolution) {
+                solutions.push(skillSolution);
+                continue;
+            }
+            // 降级：通过 KMWI 模式匹配生成
+            const patternSolution = this.generateViaKMWIPattern(gap);
+            if (patternSolution) {
+                solutions.push(patternSolution);
+                continue;
+            }
+            // 最终降级：模板生成（带耦生度约束）
+            solutions.push(this.generateViaTemplate(gap));
+        }
+        return solutions;
+    }
+    /**
+     * 通过 SkillGenerator 生成（A5 内生公理：从内部生长）
+     */
+    async generateViaSkillGenerator(gap) {
+        try {
+            const creationResult = await this.skillGenerator.create(gap.domain, {
+                failure: gap.description,
+            });
+            if (!creationResult.success) {
+                return null;
+            }
             return {
                 id: `SOL-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`,
-                type,
-                name: gap.requiredSkill || `Generated-${gap.id}`,
-                description: gap.description,
-                draft: this.generateDraft(gap, type),
+                type: 'skill',
+                name: creationResult.skillName,
+                description: `Generated by SkillGenerator for: ${gap.description}`,
+                draft: creationResult.skillContent,
                 validated: false,
+                couplingScore: creationResult.couplingScore,
+                source: 'skill_generator',
+                provenance: creationResult.provenance,
             };
-        });
+        }
+        catch {
+            // SkillGenerator 失败不阻塞，降级到其他方式
+            return null;
+        }
+    }
+    /**
+     * 通过 KMWI 模式匹配生成
+     */
+    generateViaKMWIPattern(gap) {
+        const { wisdom, intuitions } = this.kmwi.extractPatternsForEvolution(gap.domain, 3);
+        if (wisdom.length === 0 && intuitions.length === 0) {
+            return null;
+        }
+        // 基于现有智慧模式构建解决方案
+        const patterns = wisdom.map(w => `- ${w.pattern}: ${w.description} (success=${(w.successRate * 100).toFixed(0)}%)`);
+        const insights = intuitions.map(i => `- ${i.insight} (accuracy=${(i.accuracy * 100).toFixed(0)}%)`);
+        const draft = `# Solution for: ${gap.description}\n\n## Patterns from KMWI\n${patterns.join('\n')}\n\n## Intuitions\n${insights.join('\n')}\n\n## Applied Strategy\nCombine above patterns to address: ${gap.missingCapability}`;
+        // 耦生度：基于模式成功率
+        const avgSuccess = wisdom.length > 0
+            ? wisdom.reduce((sum, w) => sum + w.successRate, 0) / wisdom.length
+            : 0.85;
+        const avgAccuracy = intuitions.length > 0
+            ? intuitions.reduce((sum, i) => sum + i.accuracy, 0) / intuitions.length
+            : 0.85;
+        const couplingScore = Math.min(1, avgSuccess * 0.6 + avgAccuracy * 0.4);
+        return {
+            id: `SOL-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`,
+            type: 'protocol',
+            name: `kmwi-pattern-${gap.domain}`,
+            description: `Synthesized from ${wisdom.length} wisdom patterns and ${intuitions.length} intuitions`,
+            draft,
+            validated: false,
+            couplingScore,
+            source: 'kmwi_pattern',
+            provenance: [
+                `[KMWI] Extracted ${wisdom.length} patterns from W layer`,
+                `[KMWI] Extracted ${intuitions.length} insights from I layer`,
+                `[SYNTHESIS] Combined with coupling=${couplingScore.toFixed(3)}`,
+            ],
+        };
     }
     /**
-     * 生成解决方案草稿
+     * 模板生成（最终降级，仍带耦生度约束）
      */
-    generateDraft(gap, type) {
+    generateViaTemplate(gap) {
+        const type = gap.requiredProtocol ? 'protocol' : 'skill';
         const templates = {
             skill: `# Skill: ${gap.requiredSkill || 'New Skill'}\n\n## Description\n${gap.description}\n\n## Triggers\n- When ${gap.missingCapability} is needed\n\n## Steps\n1. Detect gap\n2. Analyze\n3. Generate\n4. Validate\n5. Apply`,
             protocol: `# Protocol: ${gap.requiredProtocol || 'New Protocol'}\n\n## Purpose\n${gap.description}\n\n## Triggers\n- When ${gap.missingCapability} is needed\n\n## Rules\n1. Detect\n2. Analyze\n3. Execute\n4. Verify`,
             validator: `// Validator for ${gap.missingCapability}\nexport function validate(output: string): boolean {\n  // TODO: Implement validation logic\n  return true;\n}`,
             engine: `// Engine: ${gap.missingCapability}\nexport class GeneratedEngine {\n  // TODO: Implement engine logic\n}`,
         };
-        return templates[type] || templates.skill;
+        // 模板生成的耦生度较低（0.85），需要通过后续验证
+        return {
+            id: `SOL-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`,
+            type,
+            name: gap.requiredSkill || `Generated-${gap.id}`,
+            description: gap.description,
+            draft: templates[type] || templates.skill,
+            validated: false,
+            couplingScore: 0.85,
+            source: 'template',
+            provenance: [`[TEMPLATE] Generated from template (fallback mode)`],
+        };
     }
-    /**
-     * 阶段 4：验证
-     * Stage 4: Validation
-     */
+    // ============================================================================
+    // 阶段 4：验证（强化版，不只是关键词检查）
+    // ============================================================================
     validate(solutions) {
         const passed = [];
         const failed = [];
         for (const solution of solutions) {
-            // 检查是否违反现有公理
-            const violatesAxioms = this.checkAxiomViolation(solution);
-            // 检查是否有安全漏洞
-            const hasSecurityIssue = this.checkSecurity(solution);
-            // 检查格式是否正确
-            const hasValidFormat = this.checkFormat(solution);
-            if (!violatesAxioms && !hasSecurityIssue && hasValidFormat) {
+            const checks = {
+                axiomCompliance: this.checkAxiomViolation(solution),
+                security: this.checkSecurity(solution),
+                format: this.checkFormat(solution),
+                coupling: solution.couplingScore >= this.minCouplingScore,
+                completeness: this.checkCompleteness(solution),
+            };
+            const allPassed = checks.axiomCompliance === false
+                && checks.security === false
+                && checks.format === true
+                && checks.coupling === true
+                && checks.completeness === true;
+            if (allPassed) {
                 solution.validated = true;
                 passed.push(solution);
             }
@@ -180,75 +378,189 @@ class EvolutionEngine {
         return { passed, failed };
     }
     /**
-     * 阶段 5：递归
-     * Stage 5: Recursion
-     */
-    recurse(passedSolutions) {
-        if (passedSolutions.length === 0)
-            return undefined;
-        // 版本升级规则
-        const [major, minor, patch] = this.currentVersion.split('.').map(Number);
-        const newVersion = `${major}.${minor + 1}.${patch}`;
-        this.currentVersion = newVersion;
-        return newVersion;
-    }
-    /**
-     * 检查是否违反公理
+     * 检查是否违反公理（强化版）
      */
     checkAxiomViolation(solution) {
-        // 检查草稿是否包含违反公理的内容
-        const violationPatterns = ['绕过', 'bypass', '忽略公理', 'ignore axiom', '跳过验证', 'skip validation'];
-        return violationPatterns.some(p => solution.draft.toLowerCase().includes(p.toLowerCase()));
+        const content = solution.draft.toLowerCase();
+        const violationPatterns = [
+            '绕过', 'bypass', '忽略公理', 'ignore axiom',
+            '跳过验证', 'skip validation', 'skip verify',
+            'disable check', '禁用检查',
+        ];
+        return violationPatterns.some(p => content.includes(p.toLowerCase()));
     }
     /**
-     * 检查安全问题
+     * 检查安全问题（强化版）
      */
     checkSecurity(solution) {
-        const securityIssues = ['eval(', 'exec(', 'system(', 'rm -rf', 'del /f', 'format ', 'shutdown'];
-        return securityIssues.some(s => solution.draft.toLowerCase().includes(s.toLowerCase()));
+        const content = solution.draft.toLowerCase();
+        const securityIssues = [
+            'eval(', 'exec(', 'system(', 'rm -rf', 'del /f', 'format ', 'shutdown',
+            'child_process', 'fs.unlink', 'fs.rmdir',
+        ];
+        return securityIssues.some(s => content.includes(s.toLowerCase()));
     }
     /**
-     * 检查格式
+     * 检查格式（强化版）
      */
     checkFormat(solution) {
-        return solution.draft.length > 50 && solution.name.length > 0;
+        return solution.draft.length > 50
+            && solution.name.length > 0
+            && solution.description.length > 10;
     }
     /**
-     * 元元进化：监控进化本身
-     * Meta-meta-evolution: Monitor the evolution itself
+     * 检查完整性（新增）
      */
+    checkCompleteness(solution) {
+        // 必须包含溯源链
+        if (solution.provenance.length === 0)
+            return false;
+        // 必须有明确的来源
+        if (!['template', 'skill_generator', 'kmwi_pattern'].includes(solution.source))
+            return false;
+        // SkillGenerator 生成的必须有 SKILL.md 格式
+        if (solution.source === 'skill_generator' && !solution.draft.includes('---'))
+            return false;
+        return true;
+    }
+    // ============================================================================
+    // 阶段 5：递归
+    // ============================================================================
+    recurse(passedSolutions) {
+        if (passedSolutions.length === 0)
+            return undefined;
+        // 版本升级规则：基于通过验证的解决方案数量决定升级幅度
+        const [major, minor, patch] = this.currentVersion.split('.').map(Number);
+        const bumpLevel = passedSolutions.length >= 3 ? 'minor' : 'patch';
+        const newVersion = bumpLevel === 'minor'
+            ? `${major}.${minor + 1}.${patch}`
+            : `${major}.${minor}.${patch + 1}`;
+        this.currentVersion = newVersion;
+        return newVersion;
+    }
+    // ============================================================================
+    // 耦生度计算
+    // ============================================================================
+    computeOverallCoupling(solutions) {
+        if (solutions.length === 0)
+            return 0;
+        const sum = solutions.reduce((acc, s) => acc + s.couplingScore, 0);
+        return sum / solutions.length;
+    }
+    // ============================================================================
+    // 元元进化：监控进化本身
+    // ============================================================================
     metaMetaEvolution(result) {
         const concerns = [];
-        // 检查进化方向是否正确
-        if (result.solutions && result.solutions.some(s => s.type === 'skill' && s.name.includes('delete'))) {
+        const recommendations = [];
+        // 检查进化方向是否正确（A35 创造进化律）
+        if (result.solutions && result.solutions.some(s => s.name.toLowerCase().includes('delete') || s.name.toLowerCase().includes('remove'))) {
             concerns.push('Evolution may be in wrong direction (deleting instead of creating)');
+            recommendations.push('Redirect evolution toward creation, not deletion');
         }
         // 检查是否有递归死循环
         if (this.evolutionHistory.length >= this.maxRecursionDepth) {
             concerns.push('Max recursion depth reached, possible infinite loop');
+            recommendations.push('Increase maxRecursionDepth or fix the root cause of repeated failures');
         }
         // 检查新能力是否违反现有公理
         if (result.errors && result.errors.length > 3) {
             concerns.push('High error count, evolution may be unstable');
+            recommendations.push('Review the errors and refine the self-generation algorithm');
+        }
+        // 检查时间预算
+        const budgetViolations = result.timing.filter(t => !t.withinBudget);
+        if (budgetViolations.length > 0) {
+            concerns.push(`Time budget exceeded in stages: ${budgetViolations.map(t => t.stage).join(', ')}`);
+            recommendations.push('Optimize the slow stages or relax the time budgets');
+        }
+        // 检查耦生度
+        if (result.couplingScore < this.minCouplingScore && result.solutions && result.solutions.length > 0) {
+            concerns.push(`Overall coupling score ${result.couplingScore.toFixed(3)} below threshold ${this.minCouplingScore}`);
+            recommendations.push('Enhance the KMWI memory to provide better patterns for self-generation');
+        }
+        // 检查 KMWI 记忆健康度
+        const kmwiHealth = this.kmwi.getHealth();
+        if (kmwiHealth.H < 60) {
+            concerns.push(`KMWI memory health low (H=${kmwiHealth.H}), may affect evolution quality`);
+            recommendations.push('Strengthen KMWI memory: ' + this.kmwi.getStrengthenSuggestions().map(s => s.action).join('; '));
         }
         return {
             monitored: true,
             evolutionValid: concerns.length === 0,
             concerns,
+            recommendations,
         };
     }
-    /**
-     * 获取进化历史
-     */
+    // ============================================================================
+    // KMWI 记录
+    // ============================================================================
+    recordToKMWI(result) {
+        try {
+            // 记录进化事件到 M 层
+            this.kmwi.addMemory(`Evolution ${result.success ? 'succeeded' : 'failed'} at ${result.stage}: ${result.boundary?.message || 'no boundary'}`, `Version ${result.currentVersion || ''}, ${result.solutions?.length || 0} solutions, coupling=${result.couplingScore.toFixed(3)}`, ['evolution', result.stage.toLowerCase()], `evolution-engine:${result.timestamp}`);
+            // 成功的解决方案记录到 W 层（成为可复用的智慧模式）
+            if (result.solutions) {
+                for (const sol of result.solutions) {
+                    if (sol.validated) {
+                        this.kmwi.addWisdom(`Evolution solution: ${sol.name}`, sol.description, `Source: ${sol.source}, coupling=${sol.couplingScore.toFixed(3)}`, ['evolution', sol.type, sol.source], `evolution:${sol.id}`);
+                    }
+                }
+            }
+            // 如果进化成功，更新基线
+            if (result.success) {
+                this.kmwi.refreshBaseline();
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ============================================================================
+    // 辅助方法
+    // ============================================================================
+    buildResult(partial) {
+        return {
+            ...partial,
+            currentVersion: this.currentVersion,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    // ============================================================================
+    // 导出与统计
+    // ============================================================================
     getHistory() {
         return this.evolutionHistory;
     }
-    /**
-     * 获取当前版本
-     */
     getVersion() {
         return this.currentVersion;
     }
+    getKMWI() {
+        return this.kmwi;
+    }
+    getSkillGenerator() {
+        return this.skillGenerator;
+    }
+    getSummary() {
+        const lines = [
+            '【元进化引擎报告】',
+            `■ 当前版本：${this.currentVersion}`,
+            `■ 进化历史：${this.evolutionHistory.length} 轮`,
+            `■ 最大递归深度：${this.maxRecursionDepth}`,
+            `■ 耦生度阈值：${this.minCouplingScore}`,
+            `■ KMWI 综合健康度：${this.kmwi.getHealth().H}`,
+            `■ 已生成技能数：${this.skillGenerator.getExistingSkills().length}`,
+        ];
+        const recentHistory = this.evolutionHistory.slice(-3);
+        if (recentHistory.length > 0) {
+            lines.push(`■ 最近 ${recentHistory.length} 轮进化：`);
+            for (const h of recentHistory) {
+                lines.push(`  - ${h.stage}: ${h.success ? '✅' : '❌'} coupling=${h.couplingScore.toFixed(3)} solutions=${h.solutions?.length || 0}`);
+            }
+        }
+        return lines.join('\n');
+    }
 }
 exports.EvolutionEngine = EvolutionEngine;
 exports.default = EvolutionEngine;