# 传统的"进化"方式：手动修改Prompt
# 问题：不可追溯、难以复用、风险高
prompt = "You are a helpful assistant."  # 改成这样？
prompt = "You are a helpful AI assistant."  # 还是这样？
prompt = "You are a knowledgeable AI assistant."  # 到底哪个好？

// assets/gep/genes.json 中的Gene结构
{
  "id": "gene-001",
  "name": "Error-Retry-Pattern",
  "description": "检测到错误时自动重试的基因",
  "signals": ["error", "retry", "failed"],
  "mutation": {
    "type": "prompt_modification",
    "template": "When you encounter an error, wait 1 second then retry up to 3 times before giving up."
  },
  "validation": ["node test/error-retry.test.js"],
  "version": "1.2.0"
}

// assets/gep/capsules.json 中的Capsule结构
{
  "id": "capsule-001",
  "name": "Production-Hardening",
  "description": "生产环境加固套件",
  "genes": ["gene-001", "gene-015", "gene-023"],
  "order": ["gene-015", "gene-001", "gene-023"],
  "conditions": {
    "minFailureStreak": 3,
    "environment": "production"
  }
}

// assets/gep/events.jsonl 中的Event格式
{"timestamp":"2026-04-17T08:00:00Z","type":"gene_applied","geneId":"gene-001","signal":"error_retry","status":"success","duration_ms":234}
{"timestamp":"2026-04-17T08:05:00Z","type":"capsule_applied","capsuleId":"capsule-001","status":"partial","genesApplied":2,"genesSkipped":1}

// src/gep/signalExtractor.js 核心逻辑
async function extractSignals(memoryDir) {
  const logs = await readLogs(memoryDir);
  const errorPatterns = [];
  
  for (const log of logs) {
    // 检测错误模式
    if (log.includes('Error:') || log.includes('Failed:')) {
      errorPatterns.push({
        type: 'error',
        message: extractErrorMessage(log),
        stack: extractStackTrace(log),
        timestamp: log.timestamp
      });
    }
    
    // 检测重试模式（可能的修复循环）
    if (log.includes('retry') && log.includes('retry')) {
      errorPatterns.push({
        type: 'retry_loop',
        message: 'Potential retry loop detected',
        timestamp: log.timestamp
      });
    }
  }
  
  // 去重和优先级排序
  return deduplicateAndPrioritize(errorPatterns);
}

// src/gep/selector.js
async function selectGene(signals, genes) {
  const scores = [];
  
  for (const gene of genes) {
    let score = 0;
    
    for (const signal of signals) {
      // 1. 信号匹配度
      for (const geneSignal of gene.signals) {
        if (signal.type.includes(geneSignal) || signal.message.includes(geneSignal)) {
          score += 10;
        }
      }
      
      // 2. 历史成功率（从Event中计算）
      const successRate = await getGeneSuccessRate(gene.id);
      score *= successRate;
      
      // 3. 避免重复应用（去重）
      const recentEvents = await getRecentEvents(gene.id, hours=24);
      if (recentEvents.length > 0) {
        score *= 0.5;  // 降低近期已应用Gene的分数
      }
    }
    
    scores.push({ gene, score });
  }
  
  // 返回得分最高的Gene
  return scores.sort((a, b) => b.score - a.score)[0].gene;
}

// src/gep/solidify.js
async function solidify(gene) {
  // 1. 应用Mutation
  await applyMutation(gene.mutation);
  
  // 2. 执行验证命令
  for (const validationCmd of gene.validation) {
    // 安全检查
    if (!isValidationCommandAllowed(validationCmd)) {
      throw new Error(`Unsafe validation command: ${validationCmd}`);
    }
    
    // 执行（180秒超时）
    const result = await execCommand(validationCmd, { timeout: 180000 });
    
    if (result.exitCode !== 0) {
      // 验证失败，回滚
      await rollback();
      return { status: 'failed', error: result.stderr };
    }
  }
  
  // 3. 记录Event
  await recordEvent({
    type: 'gene_applied',
    geneId: gene.id,
    status: 'success',
    timestamp: new Date().toISOString()
  });
  
  return { status: 'success' };
}

# 平衡模式（默认）
EVOLVE_STRATEGY=balanced node index.js --loop

# 创新模式 - 最大化新功能
EVOLVE_STRATEGY=innovate node index.js --loop

# 加固模式 - 聚焦稳定性
EVOLVE_STRATEGY=harden node index.js --loop

# 仅修复模式 - 紧急修复
EVOLVE_STRATEGY=repair-only node index.js --loop

// src/strategy/adaptiveStrategy.js
async function getAdaptiveStrategy() {
  const recentEvents = await getRecentEvents(hours=24);
  const failureRate = calculateFailureRate(recentEvents);
  
  if (failureRate > 0.5) {
    return 'repair-only';  // 失败率 > 50% 切换到修复模式
  } else if (failureRate > 0.3) {
    return 'harden';       // 失败率 > 30% 切换到加固模式
  }
  
  return 'balanced';       // 正常使用平衡模式
}

# 单次运行
node index.js

# 审核模式（应用前等待人工确认）
node index.js --review

# 持续循环
node index.js --loop

# 在OpenClaw workspace中克隆
git clone https://github.com/EvoMap/evolver.git
cd evolver && npm install

# OpenClaw会自动解释stdout中的sessions_spawn指令
node index.js --loop

# 启动（后台运行）
node src/ops/lifecycle.js start

# 停止（优雅关闭）
node src/ops/lifecycle.js stop

# 查看状态
node src/ops/lifecycle.js status

# 健康检查（自动重启）
node src/ops/lifecycle.js check

# 推荐方式
bash -lc 'node index.js --loop'

# 配合pm2
pm2 start "bash -lc 'node index.js --loop'" \
  --name evolver \
  --cron-restart="0 */6 * * *"

# 创建.env文件
echo "A2A_HUB_URL=https://evomap.ai" >> .env
echo "A2A_NODE_ID=your_node_id_here" >> .env

# 或注册后从evomap.ai获取Node ID

WORKER_ENABLED=1 \
WORKER_DOMAINS=repair,harden \
WORKER_MAX_LOAD=3 \
node index.js --loop

// 安全检查规则
function isValidationCommandAllowed(cmd) {
  // 1. 前缀白名单：只允许node/npm/npx
  if (!cmd.match(/^(node|npm|npx)\s/)) {
    return false;
  }
  
  // 2. 禁止命令替换
  if (cmd.match(/`|\$\(/)) {
    return false;
  }
  
  // 3. 禁止shell操作符
  const unsafeOperators = /;|&&|\|\||>|</;
  const strippedCmd = cmd.replace(/"[^"]*"|'[^']*'/g, '');  // 去除引号内容
  if (strippedCmd.match(unsafeOperators)) {
    return false;
  }
  
  return true;
}

# 方式1：环境变量
EVOLVE_REPORT_TOOL=feishu-card node index.js --loop

# 方式2：自动检测
# Evolver自动检测skills/feishu-card是否存在
# 存在则自动升级报告行为

# 1. 查看memory/中的日志
cat memory/error.log
# [2026-04-17 08:00] Error: JSON parse error at position 234
# [2026-04-17 08:05] Error: JSON parse error at position 567
# [2026-04-17 08:10] Error: JSON parse error at position 890

# 2. 运行Evolver
node index.js --review

# 输出：
# Signal detected: JSON parse error
# Gene selected: gene-042 (JSON-Validation-Enhancement)
# GEP Prompt generated...
# 
# Applying mutation? [y/N]: y
# 
# Running validation: node test/json-validation.test.js
# Test passed!
# 
# EvolutionEvent recorded: gene-042 applied successfully

# 3. 验证修复
# 下次运行时不再出现JSON解析错误

# 使用加固策略
EVOLVE_STRATEGY=harden node index.js --loop

# Evolver会优先选择：
# - 基因验证增强Gene
# - 边界检查Gene
# - 错误处理Gene

# 紧急修复模式
EVOLVE_STRATEGY=repair-only node index.js --loop

# Evolver只关注：
# - 高频错误Gene
# - 快速修复Gene
# - 最小变更Gene