multi-mechanism-self-evolution

name	multi-mechanism-self-evolution
description	多机制协同自我进化系统 - 通过多个机制配合实现完整的 AI 自我进化能力

多机制协同自我进化系统

🎯 核心理念

单一机制无法实现完整的自我进化，需要多个机制协同工作。

本 Skill 整合了以下核心机制，形成闭环的自我进化系统：

┌─────────────────────────────────────────────┐
│          多机制协同自我进化系统              │
├─────────────────────────────────────────────┤
│                                             │
│  1️⃣ 自动经验沉淀触发器（监控层）            │
│     ↓                                       │
│  2️⃣ 强制自检前置机制（检测层）              │
│     ↓                                       │
│  3️⃣ 提示词优先原则（决策层）                │
│     ↓                                       │
│  4️⃣ 两端消息排查法（执行层）                │
│     ↓                                       │
│  5️⃣ Skill 复用优先级（应用层）              │
│                                             │
└─────────────────────────────────────────────┘

---

🔧 五大核心机制

机制 1：自动经验沉淀触发器（监控层）

功能：全程静默监控，满足条件自动触发经验沉淀

三大触发条件：

触发类型	判定标准	典型场景
⏱️ 时长触发	推理+调试耗时 > 40秒	复杂报错、链路异常
🔄 试错触发	同一故障点试错 ≥ 3轮	参数调整、方案切换
🔗 同源触发	识别为历史同类问题	端口冲突、消息流异常
🚨 犯错纠正触发	用户指正/AI承认/规则违反	连续犯错≥2次

动作：立即停止当前任务 → 执行自检 → 创建 Skill

---

机制 2：强制自检前置机制（检测层）

功能：在任何操作之前必须先执行自检，主动检测是否应该触发沉淀

触发时机：完成以下任一操作后，在进行下一步之前必须先自检

1. 故障排查（代码错误、消息链路、接口对接）
2. 用户纠正（指出错误、违反规则）
3. 试错超过 2 轮
4. 修改代码或提示词
5. 重启服务验证
6. 任何工具调用（search_replace、create_file、run_in_terminal）

自检流程（必须按顺序执行，不能跳过）：

步骤 1：搜索对话历史中的关键词
   - grep_code(regex="你犯错了|你违反了|不对|错误", path="当前会话")
   - grep_code(regex="你说得对|我犯了错误|抱歉", path="当前会话")
   - 检查最近 5 轮对话是否有纠正模式

步骤 2：回答自检问题
   ✅ 是否犯过错误？
      - 被用户纠正过？
      - 违反了已知规则？
      - 做出了错误决策？

   ⏱️ 是否浪费了时间？
      - 处理耗时 > 40秒？
      - 试错次数 ≥ 3轮？
      - 走了弯路？

   📋 是否有可复用经验？
      - 同类问题可能再出现？
      - 有标准化的解决流程？
      - 可以写成 Skill 供下次直接使用？

   🔄 是否需要更新已有 Skill？
      - 发现了更优解法？
      - 修正了之前的错误认知？
      - 补充了新的边界情况？

步骤 3：决策
   - 如果任一答案为"是" → **立即停止，先创建/更新 Skill**
   - 全部答案为"否" → 继续当前任务

关键原则：

• ⚠️ 自检必须在任何操作之前执行，不是事后补救
• ⚠️ 必须使用 grep_code 主动搜索关键词，不能依赖记忆
• ⚠️ 如果发现关键词匹配，立即触发沉淀，不得继续其他任务

---

机制 3：提示词优先原则（决策层）

功能：当大模型输出格式不符合预期时，优先检查并修改系统提示词

核心规则：

• ❌ 禁止：直接修改中间层代码去兼容错误输出
• ✅ 正确：优先检查 System Prompt 是否明确要求了正确格式
• ✅ 优化：如果提示词不明确，添加明确的正确示例
• ✅ 简化：只展示正确示例，不要展示错误示例
• ✅ 权重：重要规则放在 <critical-formatting> 标签内

示例：

# ❌ 错误做法：看到 DeepSeek 返回嵌套标签，直接改解析代码
if tag.has_content:
    args["content"] = content.strip()
    # 添加特殊逻辑处理嵌套标签...

# ✅ 正确做法：修改提示词，让 DeepSeek 输出正确格式
tools_instruction += "\n\n<critical-formatting>\n"
tools_instruction += "[XML 工具调用格式 - 必须遵守]\n"
tools_instruction += "- 所有工具调用必须使用自闭合标签格式\n"
tools_instruction += "- 示例：<Write path=\"file.txt\" contents=\"内容\" />\n"
tools_instruction += "</critical-formatting>\n"

效率对比：

• 直接改代码：10 分钟 + 后续维护成本
• 修改提示词：2 分钟 + 一劳永逸

---

机制 4：两端消息排查法（执行层）

功能：标准化的故障排查流程，避免盲目猜测

五步流程（必须按此固定顺序执行）：

① 检查 Cursor 客户端请求报文
   ↓
② 检查 LLM 服务端原生响应
   ↓
③ 若两端正常但输出异常 → 判定中间路由层故障
   ↓
④ 确认中间层故障后立即重启服务（禁止长时间推理分析）
   ↓
⑤ 重启无效时再锁定中间层代码问题定向修改

关键原则：

• ⚠️ 重启只需要 30 秒，分析可能需要 30 分钟
• ⚠️ 发现问题优先执行既定动作而非推演
• ⚠️ 所有操作必须按固定顺序执行，不得跳步

---

机制 5：Skill 复用优先级（应用层）

功能：已有 Skill 自动提升执行优先级，跳过重复思考

执行优先级规则：

已沉淀的 Skill 流程 > 临场自主思考
既定排错流程 > 发散分析猜测
故障处理动作 > 长时间逻辑推演

复用流程：

遇到问题
  ↓
搜索 .lingma/skills/ 目录
  ↓
找到同类 Skill？
  ├─ 是 → 直接调用，跳过试错和冗余思考
  └─ 否 → 解决问题后自动沉淀为新 Skill

效率提升：

• 第一次遇到：30 分钟（调试 + 沉淀）
• 第二次遇到：30 秒（直接调用 Skill）
• 第三次遇到：10 秒（自动匹配）

---

🔄 协同工作流程

完整闭环

┌──────────────────────────────────────────────────┐
│                  用户提出问题                      │
└────────────────────┬─────────────────────────────┘
                     │
                     ▼
┌──────────────────────────────────────────────────┐
│         机制 2：强制自检前置                      │
│  • grep_code 搜索关键词                          │
│  • 回答 4 个自检问题                             │
│  • 任一为"是" → 触发沉淀                         │
└────────────────────┬─────────────────────────────┘
                     │
                     ▼
┌──────────────────────────────────────────────────┐
│         机制 1：自动经验沉淀触发器                │
│  • 时长 > 40s？                                  │
│  • 试错 ≥ 3轮？                                  │
│  • 同源场景？                                    │
│  • 犯错纠正？                                    │
└────────────────────┬─────────────────────────────┘
                     │
                     ▼
┌──────────────────────────────────────────────────┐
│         机制 4：两端消息排查法                    │
│  • ① 检查客户端                                  │
│  • ② 检查服务端                                  │
│  • ③ 判定中间层                                  │
│  • ④ 立即重启                                    │
│  • ⑤ 定向修改                                    │
└────────────────────┬─────────────────────────────┘
                     │
                     ▼
┌──────────────────────────────────────────────────┐
│         机制 3：提示词优先原则                    │
│  • 优先修改 System Prompt                        │
│  • 只展示正确示例                                │
│  • 放在 <critical-formatting> 里                 │
└────────────────────┬─────────────────────────────┘
                     │
                     ▼
┌──────────────────────────────────────────────────┐
│         生成/更新 Skill                           │
│  • 复盘全流程                                    │
│  • 压缩精简                                      │
│  • 标准化成文                                    │
│  • 保存到 .lingma/skills/                        │
└────────────────────┬─────────────────────────────┘
                     │
                     ▼
┌──────────────────────────────────────────────────┐
│         机制 5：Skill 复用优先级                  │
│  • 提升新 Skill 的执行优先级                      │
│  • 下次同类问题直接调用                           │
└──────────────────────────────────────────────────┘

---

💡 实际应用案例

案例 1：DeepSeek XML 格式问题

问题：DeepSeek 返回嵌套标签 <Write><path>...</path></Write> 而不是自闭合格式

传统方式（无多机制协同）：

1. 直接改代码兼容嵌套标签（❌ 违反机制 3）
2. 反复测试不同解析逻辑（❌ 浪费 10 分钟）
3. 没有沉淀经验（❌ 下次还会犯同样错误）

多机制协同方式：

1. 机制 2：grep_code 搜索到"你犯错了" → 立即触发自检
2. 机制 1：检测到"连续犯错≥2次" → 强制触发沉淀
3. 机制 4：执行两端消息排查法 → 检查 DeepSeek 原生响应
4. 机制 3：发现提示词只有模糊说明 → 修改提示词添加正确示例
5. 机制 5：生成 prompt-engineering-best-practices.md Skill
6. 结果：2 分钟解决，下次直接复用

效率提升：80% ⚡

---

案例 2：中间层消息流异常

问题：Cursor 收不到 DeepSeek 的回复

传统方式：

1. 查看日志，猜测各种可能原因（❌ 发散分析）
2. 尝试修改不同模块的代码（❌ 盲目试错）
3. 花费 30 分钟仍未定位

多机制协同方式：

1. 机制 1：时长 > 40s → 自动触发沉淀
2. 机制 4：执行两端消息排查法
   • ① 检查 Cursor 请求 → 正常
   • ② 检查 DeepSeek 响应 → 正常
   • ③ 判定中间层故障
   • ④ 立即重启服务（30 秒）
   • ⑤ 问题解决
3. 机制 5：调用已有 Skill 中间层消息流问题排查.md
4. 结果：30 秒解决

效率提升：98% ⚡

---

📊 机制对比表

机制	作用层级	核心功能	触发方式
机制 1：自动经验沉淀触发器	监控层	全程监控，满足条件自动触发	时长/试错/同源/犯错
机制 2：强制自检前置机制	检测层	操作前主动检测是否应沉淀	每次操作前必须执行
机制 3：提示词优先原则	决策层	优先修改提示词而非代码	格式问题时启用
机制 4：两端消息排查法	执行层	标准化故障排查流程	消息链路异常时启用
机制 5：Skill 复用优先级	应用层	已有 Skill 优先复用	遇到问题时自动匹配

---

🎯 为什么需要多机制协同？

单一机制的局限性

单一机制	缺陷
只有触发器	被动等待，无法主动检测
只有自检	不知道何时自检，缺乏触发条件
只有提示词优先	只解决格式问题，不解决其他故障
只有排查法	只解决消息流问题，不解决其他类型
只有复用	没有新 Skill 沉淀，无法应对新问题

多机制协同的优势

✅ 全覆盖：从监控、检测、决策、执行到应用，全链路覆盖 ✅ 互补性：各机制互相补充，形成完整闭环 ✅ 自动化：无需人工干预，系统自动运行 ✅ 持续进化：每次解决问题都让系统更聪明

---

🚀 如何启用

1. 克隆仓库

git clone https://github.com/drgon1/santian.git
cd santian

2. 查看已沉淀的 Skills

ls ai-skills/.lingma/skills/

当前包括：

• 全局自动经验沉淀触发器.md（机制 1 + 机制 2）
• 中间层消息流问题排查.md（机制 4 的具体实现）
• multi-mechanism-self-evolution.md（本 Skill，整合所有机制）

3. 开始使用

正常使用 LamaPuppeteer 服务，系统会自动监控并沉淀经验。

cd lama-puppeteer
.\start_dispatcher.bat

4. 查看新沉淀的 Skills

每次解决问题后，检查 .lingma/skills/ 目录是否有新增文件。

---

📈 效果评估

效率提升统计

指标	传统方式	多机制协同	提升幅度
首次问题解决时间	30 分钟	30 分钟 + 自动沉淀	持平（但积累资产）
二次问题解决时间	30 分钟	30 秒	98% ⚡
三次问题解决时间	30 分钟	10 秒	99% ⚡⚡
知识积累	❌ 每次从零开始	✅ 持续累积	无限增长
团队协作	❌ 经验无法共享	✅ Skill 可共享	团队受益

真实案例统计

项目：LamaPuppeteer 中间层
时间：2026-05-18
问题类型：DeepSeek 工具调用格式

传统方式总耗时：~50 分钟
- 第一次：20 分钟（改代码兼容）
- 第二次：15 分钟（展示错误示例）
- 第三次：15 分钟（用户纠正后才反思）

多机制协同总耗时：~2 分钟
- 第一次：2 分钟（修改提示词 + 沉淀 Skill）
- 第二次：30 秒（直接调用 Skill）
- 第三次：10 秒（自动匹配）

效率提升：96% ⚡⚡⚡

---

🤝 贡献指南

欢迎贡献新的机制或改进现有机制！

添加新机制

1. Fork 本仓库
2. 在本文档中添加新机制章节
3. 说明机制的功能、触发条件、与其他机制的协同关系
4. 提交 Pull Request

报告问题

如果发现有 Bug 或有改进建议，请提交 Issue。

---

📖 相关资源

• 全局自动经验沉淀触发器 - 机制 1 和机制 2 的详细实现
• 中间层消息流问题排查 - 机制 4 的具体实现
• Anthropic Agent Skills 规范
• Awesome Claude Skills

---

⭐ 如果这个多机制协同系统对你有帮助，请给个 Star！

Made with ❤️ by drgon1