zsp/everything-claude-code
1
0
Fork 0
mirror of https://github.com/affaan-m/everything-claude-code.git synced 2026-03-30 13:43:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

docs(zh-CN): sync Chinese docs with latest upstream changes (#341)

Browse Source 
* docs(zh-CN): sync Chinese docs with latest upstream changes

* docs(zh-CN): update link

---------

Co-authored-by: neo <neo.dowithless@gmail.com>
This commit is contained in:
zdoc.app
2026-03-08 06:48:02 +08:00
committed by GitHub
parent da17d33ac3
commit abcf38b085
53 changed files with 2977 additions and 610 deletions
Download Patch File Download Diff File Expand all files Collapse all files

141
docs/zh-CN/AGENTS.md Normal file
View File

@@ -0,0 +1,141 @@
# Everything Claude Code (ECC) — 智能体指令
这是一个**生产就绪的 AI 编码插件**，提供 13 个专业智能体、50+ 项技能、33 条命令以及用于软件开发的自动化钩子工作流。
## 核心原则
1. **智能体优先** — 将领域任务委托给专业智能体
2. **测试驱动** — 先写测试再实现，要求 80%+ 覆盖率
3. **安全第一** — 绝不妥协安全；验证所有输入
4. **不可变性** — 总是创建新对象，永不修改现有对象
5. **先规划后执行** — 在编写代码前规划复杂功能
## 可用智能体
| 智能体 | 目的 | 何时使用 |
|-------|---------|-------------|
| planner | 实施规划 | 复杂功能、重构 |
| architect | 系统设计与可扩展性 | 架构决策 |
| tdd-guide | 测试驱动开发 | 新功能、错误修复 |
| code-reviewer | 代码质量与可维护性 | 编写/修改代码后 |
| security-reviewer | 漏洞检测 | 提交前、敏感代码 |
| build-error-resolver | 修复构建/类型错误 | 构建失败时 |
| e2e-runner | 端到端 Playwright 测试 | 关键用户流程 |
| refactor-cleaner | 清理无用代码 | 代码维护 |
| doc-updater | 文档和代码地图更新 | 更新文档 |
| go-reviewer | Go 代码审查 | Go 项目 |
| go-build-resolver | Go 构建错误 | Go 构建失败 |
| database-reviewer | PostgreSQL/Supabase 专家 | 模式设计、查询优化 |
| python-reviewer | Python 代码审查 | Python 项目 |
## 智能体编排
主动使用智能体，无需用户提示：
* 复杂功能请求 → **planner**
* 刚编写/修改的代码 → **code-reviewer**
* 错误修复或新功能 → **tdd-guide**
* 架构决策 → **architect**
* 安全敏感代码 → **security-reviewer**
对于独立操作使用并行执行 — 同时启动多个智能体。
## 安全指南
**在任何提交之前：**
* 没有硬编码的密钥（API 密钥、密码、令牌）
* 所有用户输入都经过验证
* 防止 SQL 注入（参数化查询）
* 防止 XSS（已清理的 HTML）
* 启用 CSRF 保护
* 已验证身份验证/授权
* 所有端点都有限速
* 错误消息不泄露敏感数据
**密钥管理：** 绝不硬编码密钥。使用环境变量或密钥管理器。在启动时验证所需的密钥。立即轮换任何暴露的密钥。
**如果发现安全问题：** 停止 → 使用 security-reviewer 智能体 → 修复 CRITICAL 问题 → 轮换暴露的密钥 → 审查代码库中的类似问题。
## 编码风格
**不可变性（关键）：** 总是创建新对象，永不修改。返回带有更改的新副本。
**文件组织：** 许多小文件优于少数大文件。通常 200-400 行，最多 800 行。按功能/领域组织，而不是按类型组织。高内聚，低耦合。
**错误处理：** 在每个层级处理错误。在 UI 代码中提供用户友好的消息。在服务器端记录详细的上下文。绝不静默地忽略错误。
**输入验证：** 在系统边界验证所有用户输入。使用基于模式的验证。快速失败并给出清晰的消息。绝不信任外部数据。
**代码质量检查清单：**
* 函数小巧（<50 行），文件专注（<800 行）
* 没有深层嵌套（>4 层）
* 适当的错误处理，没有硬编码的值
* 可读性强、命名良好的标识符
## 测试要求
**最低覆盖率：80%**
测试类型（全部必需）：
1. **单元测试** — 单个函数、工具、组件
2. **集成测试** — API 端点、数据库操作
3. **端到端测试** — 关键用户流程
**TDD 工作流（强制）：**
1. 先写测试（RED） — 测试应该失败
2. 编写最小实现（GREEN） — 测试应该通过
3. 重构（IMPROVE） — 验证覆盖率 80%+
故障排除：检查测试隔离 → 验证模拟 → 修复实现（而不是测试，除非测试是错误的）。
## 开发工作流
1. **规划** — 使用 planner 智能体，识别依赖项和风险，分解为阶段
2. **TDD** — 使用 tdd-guide 智能体，先写测试，实现，重构
3. **审查** — 立即使用 code-reviewer 智能体，解决 CRITICAL/HIGH 问题
4. **提交** — 约定式提交格式，全面的 PR 摘要
## Git 工作流
**提交格式：** `<type>: <description>` — 类型：feat, fix, refactor, docs, test, chore, perf, ci
**PR 工作流：** 分析完整的提交历史 → 起草全面的摘要 → 包含测试计划 → 使用 `-u` 标志推送。
## 架构模式
**API 响应格式：** 具有成功指示器、数据负载、错误消息和分页元数据的一致信封。
**仓储模式：** 将数据访问封装在标准接口（findAll, findById, create, update, delete）后面。业务逻辑依赖于抽象接口，而不是存储机制。
**骨架项目：** 搜索经过实战检验的模板，使用并行智能体（安全性、可扩展性、相关性）进行评估，克隆最佳匹配，在已验证的结构内迭代。
## 性能
**上下文管理：** 对于大型重构和多文件功能，避免使用上下文窗口的最后 20%。敏感性较低的任务（单次编辑、文档、简单修复）可以容忍较高的利用率。
**构建故障排除：** 使用 build-error-resolver 智能体 → 分析错误 → 增量修复 → 每次修复后验证。
## 项目结构
```
agents/ — 13 specialized subagents
skills/ — 50+ workflow skills and domain knowledge
commands/ — 33 slash commands
hooks/ — Trigger-based automations
rules/ — Always-follow guidelines (common + per-language)
scripts/ — Cross-platform Node.js utilities
mcp-configs/ — 14 MCP server configurations
tests/ — Test suite
```
## 成功指标
* 所有测试通过且覆盖率 80%+
* 没有安全漏洞
* 代码可读且可维护
* 性能可接受
* 满足用户需求

46
docs/zh-CN/CHANGELOG.md Normal file
View File

@@ -0,0 +1,46 @@
# 更新日志
## 1.8.0 - 2026-03-04
### 亮点
* 首次发布以可靠性、评估规程和自主循环操作为核心的版本。
* Hook 运行时现在支持基于配置文件的控制和针对性的 Hook 禁用。
* NanoClaw v2 增加了模型路由、技能热加载、分支、搜索、压缩、导出和指标功能。
### 核心
* 新增命令：`/harness-audit`, `/loop-start`, `/loop-status`, `/quality-gate`, `/model-route`。
* 新增技能：
* `agent-harness-construction`
* `agentic-engineering`
* `ralphinho-rfc-pipeline`
* `ai-first-engineering`
* `enterprise-agent-ops`
* `nanoclaw-repl`
* `continuous-agent-loop`
* 新增代理：
* `harness-optimizer`
* `loop-operator`
### Hook 可靠性
* 修复了 SessionStart 的根路径解析，增加了健壮的回退搜索。
* 将会话摘要持久化移至 `Stop`，此处可获得转录负载。
* 增加了质量门和成本追踪钩子。
* 用专门的脚本文件替换了脆弱的单行内联钩子。
* 增加了 `ECC_HOOK_PROFILE` 和 `ECC_DISABLED_HOOKS` 控制。
### 跨平台
* 改进了文档警告逻辑中 Windows 安全路径的处理。
* 强化了观察者循环行为，以避免非交互式挂起。
### 备注
* `autonomous-loops` 作为一个兼容性别名保留一个版本；`continuous-agent-loop` 是规范名称。
### 鸣谢
* 灵感来自 [zarazhangrui](https://github.com/zarazhangrui)
* homunculus 灵感来自 [humanplane](https://github.com/humanplane)

61
docs/zh-CN/CLAUDE.md Normal file
View File

@@ -0,0 +1,61 @@
# CLAUDE.md
本文件为 Claude Code (claude.ai/code) 处理此仓库代码时提供指导。
## 项目概述
这是一个 **Claude Code 插件** - 一个包含生产就绪的代理、技能、钩子、命令、规则和 MCP 配置的集合。该项目提供了使用 Claude Code 进行软件开发的经验证的工作流。
## 运行测试
```bash
# Run all tests
node tests/run-all.js
# Run individual test files
node tests/lib/utils.test.js
node tests/lib/package-manager.test.js
node tests/hooks/hooks.test.js
```
## 架构
项目组织为以下几个核心组件：
* **agents/** - 用于委派的专业化子代理（规划器、代码审查员、TDD 指南等）
* **skills/** - 工作流定义和领域知识（编码标准、模式、测试）
* **commands/** - 由用户调用的斜杠命令（/tdd, /plan, /e2e 等）
* **hooks/** - 基于触发的自动化（会话持久化、工具前后钩子）
* **rules/** - 始终遵循的指南（安全、编码风格、测试要求）
* **mcp-configs/** - 用于外部集成的 MCP 服务器配置
* **scripts/** - 用于钩子和设置的跨平台 Node.js 工具
* **tests/** - 脚本和工具的测试套件
## 关键命令
* `/tdd` - 测试驱动开发工作流
* `/plan` - 实施规划
* `/e2e` - 生成并运行端到端测试
* `/code-review` - 质量审查
* `/build-fix` - 修复构建错误
* `/learn` - 从会话中提取模式
* `/skill-create` - 从 git 历史记录生成技能
## 开发说明
* 包管理器检测：npm、pnpm、yarn、bun（可通过 `CLAUDE_PACKAGE_MANAGER` 环境变量或项目配置设置）
* 跨平台：通过 Node.js 脚本支持 Windows、macOS、Linux
* 代理格式：带有 YAML 前言的 Markdown（名称、描述、工具、模型）
* 技能格式：带有清晰章节的 Markdown（何时使用、如何工作、示例）
* 钩子格式：带有匹配器条件和命令/通知钩子的 JSON
## 贡献
遵循 CONTRIBUTING.md 中的格式：
* 代理：带有前言的 Markdown（名称、描述、工具、模型）
* 技能：清晰的章节（何时使用、如何工作、示例）
* 命令：带有描述前言的 Markdown
* 钩子：带有匹配器和钩子数组的 JSON
文件命名：小写字母并用连字符连接（例如 `python-reviewer.md`, `tdd-workflow.md`）

84
docs/zh-CN/CODE_OF_CONDUCT.md Normal file
View File

@@ -0,0 +1,84 @@
# 贡献者公约行为准则
## 我们的承诺
作为成员、贡献者和领导者，我们承诺，无论年龄、体型、显性或隐性残疾、民族、性征、性别认同与表达、经验水平、教育程度、社会经济地位、国籍、外貌、种族、宗教或性取向如何，都努力使参与我们社区成为对每个人而言免受骚扰的体验。
我们承诺以有助于建立一个开放、友好、多元、包容和健康的社区的方式行事和互动。
## 我们的标准
有助于为我们社区营造积极环境的行为示例包括：
* 对他人表现出同理心和善意
* 尊重不同的意见、观点和经验
* 给予并优雅地接受建设性反馈
* 承担责任，向受我们错误影响的人道歉，并从经验中学习
* 关注不仅对我们个人而言是最好的，而且对整个社区而言是最好的事情
不可接受的行为示例包括：
* 使用性暗示的语言或图像，以及任何形式的性关注或性接近
* 挑衅、侮辱或贬损性评论，以及个人或政治攻击
* 公开或私下骚扰
* 未经他人明确许可，发布他人的私人信息，例如物理地址或电子邮件地址
* 其他在专业环境中可能被合理认为不当的行为
## 执行责任
社区领导者有责任澄清和执行我们可接受行为的标准，并将对他们认为不当、威胁、冒犯或有害的任何行为采取适当和公平的纠正措施。
社区领导者有权也有责任删除、编辑或拒绝与《行为准则》不符的评论、提交、代码、wiki 编辑、问题和其他贡献，并将在适当时沟通审核决定的原因。
## 适用范围
本《行为准则》适用于所有社区空间，也适用于个人在公共空间正式代表社区时。代表我们社区的示例包括使用官方电子邮件地址、通过官方社交媒体帐户发帖，或在在线或线下活动中担任指定代表。
## 执行
辱骂、骚扰或其他不可接受行为的实例可以向负责执行的社区领导者报告，邮箱为。
所有投诉都将得到及时和公正的审查和调查。
所有社区领导者都有义务尊重任何事件报告者的隐私和安全。
## 执行指南
社区领导者在确定他们认为违反本《行为准则》的任何行为的后果时，将遵循以下社区影响指南：
### 1. 纠正
**社区影响**：使用不当语言或社区认为不专业或不受欢迎的其他行为。
**后果**：来自社区领导者的私人书面警告，阐明违规行为的性质并解释该行为为何不当。可能会要求进行公开道歉。
### 2. 警告
**社区影响**：通过单一事件或一系列行为造成的违规。
**后果**：带有持续行为后果的警告。在规定时间内，不得与相关人员互动，包括未经请求与执行《行为准则》的人员互动。这包括避免在社区空间以及社交媒体等外部渠道进行互动。违反这些条款可能导致暂时或永久封禁。
### 3. 暂时封禁
**社区影响**：严重违反社区标准，包括持续的不当行为。
**后果**：在规定时间内，禁止与社区进行任何形式的互动或公开交流。在此期间，不允许与相关人员进行公开或私下互动，包括未经请求与执行《行为准则》的人员互动。违反这些条款可能导致永久封禁。
### 4. 永久封禁
**社区影响**：表现出违反社区标准的模式，包括持续的不当行为、骚扰个人，或对特定人群表现出攻击性或贬损。
**后果**：永久禁止在社区内进行任何形式的公开互动。
## 归属
本《行为准则》改编自 \[Contributor Covenant]\[homepage]，
版本 2.0，可在
https://www.contributor-covenant.org/version/2/0/code\_of\_conduct.html 获取。
社区影响指南的灵感来源于 [Mozilla 的行为准则执行阶梯](https://github.com/mozilla/diversity)。
[homepage]: https://www.contributor-covenant.org
有关本行为准则常见问题的解答，请参阅常见问题解答：
https://www.contributor-covenant.org/faq。翻译版本可在
https://www.contributor-covenant.org/translations 获取。

2
docs/zh-CN/CONTRIBUTING.md
View File

@@ -70,7 +70,7 @@ cp -r skills/my-skill ~/.claude/skills/ # for skills
# Then test with Claude Code # Then test with Claude Code
# 5. Submit PR # 5. Submit PR
git add . && git commit -m "feat: add my-skill" && git push git add . && git commit -m "feat: add my-skill" && git push -u origin feat/my-contribution
``` ```
*** ***

355
docs/zh-CN/README.md
View File

@@ -1,10 +1,13 @@
**语言：** 英语 | [繁體中文](../zh-TW/README.md) | [简体中文](../../README.md) **语言：** [English](../../README.md) | [繁體中文](../zh-TW/README.md) | [简体中文](README.md)
# Everything Claude Code # Everything Claude Code
[![Stars](https://img.shields.io/github/stars/affaan-m/everything-claude-code?style=flat)](https://github.com/affaan-m/everything-claude-code/stargazers) [![Stars](https://img.shields.io/github/stars/affaan-m/everything-claude-code?style=flat)](https://github.com/affaan-m/everything-claude-code/stargazers)
[![Forks](https://img.shields.io/github/forks/affaan-m/everything-claude-code?style=flat)](https://github.com/affaan-m/everything-claude-code/network/members) [![Forks](https://img.shields.io/github/forks/affaan-m/everything-claude-code?style=flat)](https://github.com/affaan-m/everything-claude-code/network/members)
[![Contributors](https://img.shields.io/github/contributors/affaan-m/everything-claude-code?style=flat)](https://github.com/affaan-m/everything-claude-code/graphs/contributors) [![Contributors](https://img.shields.io/github/contributors/affaan-m/everything-claude-code?style=flat)](https://github.com/affaan-m/everything-claude-code/graphs/contributors)
[![npm ecc-universal](https://img.shields.io/npm/dw/ecc-universal?label=ecc-universal%20weekly%20downloads\&logo=npm)](https://www.npmjs.com/package/ecc-universal)
[![npm ecc-agentshield](https://img.shields.io/npm/dw/ecc-agentshield?label=ecc-agentshield%20weekly%20downloads\&logo=npm)](https://www.npmjs.com/package/ecc-agentshield)
[![GitHub App Install](https://img.shields.io/badge/GitHub%20App-150%20installs-2ea44f?logo=github)](https://github.com/marketplace/ecc-tools)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE) [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
![Shell](https://img.shields.io/badge/-Shell-4EAA25?logo=gnu-bash\&logoColor=white) ![Shell](https://img.shields.io/badge/-Shell-4EAA25?logo=gnu-bash\&logoColor=white)
![TypeScript](https://img.shields.io/badge/-TypeScript-3178C6?logo=typescript\&logoColor=white) ![TypeScript](https://img.shields.io/badge/-TypeScript-3178C6?logo=typescript\&logoColor=white)
@@ -27,9 +30,29 @@
*** ***
**Anthropic 黑客马拉松获胜者提供的完整 Claude Code 配置集合。** **适用于 AI 智能体平台的性能优化系统。来自 Anthropic 黑客马拉松的获奖作品。**
经过 10 多个月的密集日常使用，在构建真实产品的过程中演化出的生产就绪的智能体、技能、钩子、命令、规则和 MCP 配置。 不仅仅是配置。一个完整的系统：技能、本能、内存优化、持续学习、安全扫描以及研究优先的开发。经过 10 多个月的密集日常使用和构建真实产品的经验，演进出生产就绪的智能体、钩子、命令、规则和 MCP 配置。
适用于 **Claude Code**、**Codex**、**Cowork** 以及其他 AI 智能体平台。
***
## 采用与分发
向赞助商、平台或生态系统合作伙伴展示 ECC 时，请使用这些实时信号：
* **主包安装量：** npm 上的 [`ecc-universal`](https://www.npmjs.com/package/ecc-universal)
* **安全伴侣安装量：** npm 上的 [`ecc-agentshield`](https://www.npmjs.com/package/ecc-agentshield)
* **GitHub 应用分发：** [ECC 工具市场列表](https://github.com/marketplace/ecc-tools)
* **自动化月度指标问题：** 由 `.github/workflows/monthly-metrics.yml` 驱动
* **仓库采用信号：** 本 README 顶部的 stars/forks/contributors 徽章
Claude Code 插件安装的下载计数目前尚未作为公共 API 公开。对于合作伙伴报告，请将 npm 指标与 GitHub 应用安装量以及仓库流量/分支增长相结合。
有关赞助商通话的指标清单和命令片段，请参阅 [`docs/business/metrics-and-sponsorship.md`](../business/metrics-and-sponsorship.md)。
[**赞助 ECC**](https://github.com/sponsors/affaan-m) | [赞助层级](SPONSORS.md) | [赞助计划](SPONSORING.md)
*** ***
@@ -69,6 +92,16 @@
## 最新动态 ## 最新动态
### v1.8.0 — 平台性能系统（2026 年 3 月）
* **平台优先发布** — ECC 现在被明确构建为一个智能体平台性能系统，而不仅仅是一个配置包。
* **钩子可靠性大修** — SessionStart 根回退、Stop 阶段会话摘要，以及用基于脚本的钩子替换脆弱的单行内联钩子。
* **钩子运行时控制** — `ECC_HOOK_PROFILE=minimal|standard|strict` 和 `ECC_DISABLED_HOOKS=...` 用于运行时门控，无需编辑钩子文件。
* **新平台命令** — `/harness-audit`、`/loop-start`、`/loop-status`、`/quality-gate`、`/model-route`。
* **NanoClaw v2** — 模型路由、技能热加载、会话分支/搜索/导出/压缩/指标。
* **跨平台一致性** — 在 Claude Code、Cursor、OpenCode 和 Codex 应用/CLI 中行为更加统一。
* **997 项内部测试通过** — 钩子/运行时重构和兼容性更新后，完整套件全部通过。
### v1.7.0 — 跨平台扩展与演示文稿生成器（2026年2月） ### v1.7.0 — 跨平台扩展与演示文稿生成器（2026年2月）
* **Codex 应用 + CLI 支持** — 基于 `AGENTS.md` 的直接 Codex 支持、安装器目标定位以及 Codex 文档 * **Codex 应用 + CLI 支持** — 基于 `AGENTS.md` 的直接 Codex 支持、安装器目标定位以及 Codex 文档
@@ -145,6 +178,8 @@ cd everything-claude-code
# ./install.sh typescript python golang # ./install.sh typescript python golang
# or target cursor: # or target cursor:
# ./install.sh --target cursor typescript # ./install.sh --target cursor typescript
# or target antigravity:
# ./install.sh --target antigravity typescript
``` ```
手动安装说明请参阅 `rules/` 文件夹中的 README。 手动安装说明请参阅 `rules/` 文件夹中的 README。
@@ -162,13 +197,13 @@ cd everything-claude-code
/plugin list everything-claude-code@everything-claude-code /plugin list everything-claude-code@everything-claude-code
``` ```
✨ **就是这样！** 你现在可以访问 13 个代理、56 个技能和 32 个命令。 ✨ **搞定！** 您现在可以访问 16 个智能体、65 项技能和 40 条命令。
*** ***
## 🌐 跨平台支持 ## 🌐 跨平台支持
此插件现已完全支持 **Windows、macOS 和 Linux**。所有钩子和脚本都已用 Node.js 重写，以实现最大的兼容性。 此插件现已完全支持 **Windows、macOS 和 Linux**，并与主流 IDE（Cursor、OpenCode、Antigravity）和 CLI 平台紧密集成。所有钩子和脚本都已用 Node.js 重写，以实现最大兼容性。
### 包管理器检测 ### 包管理器检测
@@ -199,6 +234,18 @@ node scripts/setup-package-manager.js --detect
或者在 Claude Code 中使用 `/setup-pm` 命令。 或者在 Claude Code 中使用 `/setup-pm` 命令。
### 钩子运行时控制
使用运行时标志来调整严格性或临时禁用特定钩子：
```bash
# Hook strictness profile (default: standard)
export ECC_HOOK_PROFILE=standard
# Comma-separated hook IDs to disable
export ECC_DISABLED_HOOKS="pre:bash:tmux-reminder,post:edit:typecheck"
```
*** ***
## 📦 包含内容 ## 📦 包含内容
@@ -211,135 +258,137 @@ everything-claude-code/
| |-- plugin.json # 插件元数据和组件路径 | |-- plugin.json # 插件元数据和组件路径
| |-- marketplace.json # 用于 /plugin marketplace add 的市场目录 | |-- marketplace.json # 用于 /plugin marketplace add 的市场目录
| |
|-- agents/ # 用于委派的专用子代理 |-- agents/ # 用于委派任务的专用子代理
| |-- planner.md # 功能实现规划 | |-- planner.md # 功能实现规划
| |-- architect.md # 系统设计决策 | |-- architect.md # 系统设计决策
| |-- tdd-guide.md # 测试驱动开发 | |-- tdd-guide.md # 测试驱动开发
| |-- code-reviewer.md # 质量与安全审查 | |-- code-reviewer.md # 质量和安全审查
| |-- security-reviewer.md # 漏洞分析 | |-- security-reviewer.md # 漏洞分析
| |-- build-error-resolver.md | |-- build-error-resolver.md
| |-- e2e-runner.md # Playwright 端到端测试 | |-- e2e-runner.md # Playwright E2E 测试
| |-- refactor-cleaner.md # 无用代码清理 | |-- refactor-cleaner.md # 无用代码清理
| |-- doc-updater.md # 文档同步 | |-- doc-updater.md # 文档同步
| |-- go-reviewer.md # Go 代码审查 | |-- go-reviewer.md # Go 代码审查
| |-- go-build-resolver.md # Go 构建错误修复 | |-- go-build-resolver.md # Go 构建错误修复
| |-- python-reviewer.md # Python 代码审查（新增） | |-- python-reviewer.md # Python 代码审查 (新增)
| |-- database-reviewer.md # 数据库/Supabase 审查（新增） | |-- database-reviewer.md # 数据库 / Supabase 审查 (新增)
| |
|-- skills/ # 工作流定义与领域知识 |-- skills/ # 工作流定义和领域知识
| |-- coding-standards/ # 语言最佳实践 | |-- coding-standards/ # 各语言最佳实践
| |-- clickhouse-io/ # ClickHouse 分析、查询与数据工程 | |-- clickhouse-io/ # ClickHouse 分析、查询和数据工程
| |-- backend-patterns/ # API、数据库、缓存模式 | |-- backend-patterns/ # API、数据库、缓存模式
| |-- frontend-patterns/ # React、Next.js 模式 | |-- frontend-patterns/ # React、Next.js 模式
| |-- frontend-slides/ # HTML 幻灯片与 PPTX 转 Web 演示流程（新增） | |-- frontend-slides/ # HTML 幻灯片和 PPTX 转 Web 演示流程 (新增)
| |-- article-writing/ # 使用指定风格进行长文写作（避免通用 AI 语气）（新增） | |-- article-writing/ # 使用指定风格进行长文写作，避免通用 AI 语气 (新增)
| |-- content-engine/ # 多平台内容创作与再利用工作流（新增） | |-- content-engine/ # 多平台内容生成与复用工作流 (新增)
| |-- market-research/ # 带来源标注的市场、竞品与投资人研究（新增） | |-- market-research/ # 带来源引用的市场、竞品和投资研究 (新增)
| |-- investor-materials/ # 融资路演材料、单页纸、备忘录与财务模型（新增） | |-- investor-materials/ # 融资演示文稿、单页、备忘录和财务模型 (新增)
| |-- investor-outreach/ # 个性化融资外联与跟进（新增） | |-- investor-outreach/ # 个性化融资外联与跟进 (新增)
| |-- continuous-learning/ # 从会话中自动提取模式（长文指南） | |-- continuous-learning/ # 从会话中自动提取模式 (Longform Guide)
| |-- continuous-learning-v2/ # 基于直觉的学习与置信度评分 | |-- continuous-learning-v2/ # 基于直觉的学习与置信度评分
| |-- iterative-retrieval/ # 子代理渐进式上下文优化 | |-- iterative-retrieval/ # 子代理的渐进式上下文优化
| |-- strategic-compact/ # 手动压缩建议（长文指南） | |-- strategic-compact/ # 手动压缩建议 (Longform Guide)
| |-- tdd-workflow/ # TDD 方法论 | |-- tdd-workflow/ # TDD 方法论
| |-- security-review/ # 安全检查清单 | |-- security-review/ # 安全检查清单
| |-- eval-harness/ # 验证循环评估（长文指南） | |-- eval-harness/ # 验证循环评估 (Longform Guide)
| |-- verification-loop/ # 持续验证（长文指南） | |-- verification-loop/ # 持续验证 (Longform Guide)
| |-- golang-patterns/ # Go 惯用法与最佳实践 | |-- golang-patterns/ # Go 语言惯用法和最佳实践
| |-- golang-testing/ # Go 测试模式、TDD 与基准测试 | |-- golang-testing/ # Go 测试模式、TDD、基准测试
| |-- cpp-coding-standards/ # 来自 C++ Core Guidelines 的 C++ 编码规范（新增） | |-- cpp-coding-standards/ # 来自 C++ Core Guidelines 的 C++ 编码规范 (新增)
| |-- cpp-testing/ # 使用 GoogleTest 与 CMake/CTest 的 C++ 测试（新增） | |-- cpp-testing/ # 使用 GoogleTest、CMake/CTest 的 C++ 测试 (新增)
| |-- django-patterns/ # Django 模式、模型与视图（新增） | |-- django-patterns/ # Django 模式、模型和视图 (新增)
| |-- django-security/ # Django 安全最佳实践（新增） | |-- django-security/ # Django 安全最佳实践 (新增)
| |-- django-tdd/ # Django TDD 工作流（新增） | |-- django-tdd/ # Django TDD 工作流 (新增)
| |-- django-verification/ # Django 验证循环（新增） | |-- django-verification/ # Django 验证循环 (新增)
| |-- python-patterns/ # Python 惯用法与最佳实践（新增） | |-- python-patterns/ # Python 惯用法和最佳实践 (新增)
| |-- python-testing/ # 使用 pytest 的 Python 测试（新增） | |-- python-testing/ # 使用 pytest 的 Python 测试 (新增)
| |-- springboot-patterns/ # Java Spring Boot 模式（新增） | |-- springboot-patterns/ # Java Spring Boot 模式 (新增)
| |-- springboot-security/ # Spring Boot 安全（新增） | |-- springboot-security/ # Spring Boot 安全 (新增)
| |-- springboot-tdd/ # Spring Boot TDD（新增） | |-- springboot-tdd/ # Spring Boot TDD (新增)
| |-- springboot-verification/ # Spring Boot 验证（新增） | |-- springboot-verification/ # Spring Boot 验证流程 (新增)
| |-- configure-ecc/ # 交互式安装向导（新增） | |-- configure-ecc/ # 交互式安装向导 (新增)
| |-- security-scan/ # AgentShield 安全审计集成（新增） | |-- security-scan/ # AgentShield 安全审计集成 (新增)
| |-- java-coding-standards/ # Java 编码规范（新增） | |-- java-coding-standards/ # Java 编码规范 (新增)
| |-- jpa-patterns/ # JPA/Hibernate 模式（新增） | |-- jpa-patterns/ # JPA/Hibernate 模式 (新增)
| |-- postgres-patterns/ # PostgreSQL 优化模式（新增） | |-- postgres-patterns/ # PostgreSQL 优化模式 (新增)
| |-- nutrient-document-processing/ # 使用 Nutrient API 的文档处理（新增） | |-- nutrient-document-processing/ # 使用 Nutrient API 进行文档处理 (新增)
| |-- project-guidelines-example/ # 项目专用技能模板 | |-- project-guidelines-example/ # 项目专用技能模板
| |-- database-migrations/ # 迁移模式（Prisma、Drizzle、Django、Go）（新增） | |-- database-migrations/ # 数据库迁移模式 (Prisma、Drizzle、Django、Go) (新增)
| |-- api-design/ # REST API 设计、分页与错误响应（新增） | |-- api-design/ # REST API 设计、分页和错误响应 (新增)
| |-- deployment-patterns/ # CI/CD、Docker、健康检查与回滚（新增） | |-- deployment-patterns/ # CI/CD、Docker、健康检查和回滚 (新增)
| |-- docker-patterns/ # Docker Compose、网络、卷与容器安全（新增） | |-- docker-patterns/ # Docker Compose、网络、卷和容器安全 (新增)
| |-- e2e-testing/ # Playwright 端到端模式与页面对象模型（新增） | |-- e2e-testing/ # Playwright E2E 模式和 Page Object Model (新增)
| |-- content-hash-cache-pattern/ # 基于 SHA-256 内容哈希的文件处理缓存（新增） | |-- content-hash-cache-pattern/ # 使用 SHA-256 内容哈希进行文件处理缓存 (新增)
| |-- cost-aware-llm-pipeline/ # LLM 成本优化、模型路由与预算跟踪（新增） | |-- cost-aware-llm-pipeline/ # LLM 成本优化、模型路由和预算跟踪 (新增)
| |-- regex-vs-llm-structured-text/ # 决策框架：文本解析使用正则还是 LLM（新增） | |-- regex-vs-llm-structured-text/ # 文本解析决策框架：正则 vs LLM (新增)
| |-- swift-actor-persistence/ # 使用 Actor 实现线程安全的 Swift 数据持久化（新增） | |-- swift-actor-persistence/ # 使用 Actor 的线程安全 Swift 数据持久化 (新增)
| |-- swift-protocol-di-testing/ # 基于协议的依赖注入，实现可测试的 Swift 代码（新增） | |-- swift-protocol-di-testing/ # 基于 Protocol 的依赖注入用于可测试 Swift 代码 (新增)
| |-- search-first/ # 先研究后编码的工作流（新增） | |-- search-first/ # 先研究再编码的工作流 (新增)
| |-- skill-stocktake/ # 技能与命令质量审计（新增） | |-- skill-stocktake/ # 审计技能和命令质量 (新增)
| |-- liquid-glass-design/ # iOS 26 Liquid Glass 设计系统（新增） | |-- liquid-glass-design/ # iOS 26 Liquid Glass 设计系统 (新增)
| |-- foundation-models-on-device/ # Apple 设备端 LLM 与 FoundationModels（新增） | |-- foundation-models-on-device/ # Apple 设备端 LLM FoundationModels (新增)
| |-- swift-concurrency-6-2/ # Swift 6.2 易用并发（新增） | |-- swift-concurrency-6-2/ # Swift 6.2 易用并发模型 (新增)
| |-- autonomous-loops/ # 自动化循环模式：顺序流水线、PR 循环、DAG 编排 (新增)
| |-- plankton-code-quality/ # 使用 Plankton hooks 在编写阶段执行代码质量检查 (新增)
| |
|-- commands/ # 快速执行的斜杠命令 |-- commands/ # 用于快速执行的 Slash 命令
| |-- tdd.md # /tdd - 测试驱动开发 | |-- tdd.md # /tdd - 测试驱动开发
| |-- plan.md # /plan - 实现规划 | |-- plan.md # /plan - 实现规划
| |-- e2e.md # /e2e - 端到端测试生成 | |-- e2e.md # /e2e - E2E 测试生成
| |-- code-review.md # /code-review - 质量审查 | |-- code-review.md # /code-review - 代码质量审查
| |-- build-fix.md # /build-fix - 修复构建错误 | |-- build-fix.md # /build-fix - 修复构建错误
| |-- refactor-clean.md # /refactor-clean - 无用代码清理 | |-- refactor-clean.md # /refactor-clean - 删除无用代码
| |-- learn.md # /learn - 会话中提取模式（长文指南） | |-- learn.md # /learn - 在会话中提取模式 (Longform Guide)
| |-- learn-eval.md # /learn-eval - 提取、评估并保存模式（新增） | |-- learn-eval.md # /learn-eval - 提取、评估并保存模式 (新增)
| |-- checkpoint.md # /checkpoint - 保存验证状态（长文指南） | |-- checkpoint.md # /checkpoint - 保存验证状态 (Longform Guide)
| |-- verify.md # /verify - 执行验证循环（长文指南） | |-- verify.md # /verify - 运行验证循环 (Longform Guide)
| |-- setup-pm.md # /setup-pm - 配置包管理器 | |-- setup-pm.md # /setup-pm - 配置包管理器
| |-- go-review.md # /go-review - Go 代码审查（新增） | |-- go-review.md # /go-review - Go 代码审查 (新增)
| |-- go-test.md # /go-test - Go TDD 工作流（新增） | |-- go-test.md # /go-test - Go TDD 工作流 (新增)
| |-- go-build.md # /go-build - 修复 Go 构建错误（新增） | |-- go-build.md # /go-build - 修复 Go 构建错误 (新增)
| |-- skill-create.md # /skill-create - 从 git 历史生成技能（新增） | |-- skill-create.md # /skill-create - 从 git 历史生成技能 (新增)
| |-- instinct-status.md # /instinct-status - 查看已学习的直觉（新增） | |-- instinct-status.md # /instinct-status - 查看学习到的直觉规则 (新增)
| |-- instinct-import.md # /instinct-import - 导入直觉（新增） | |-- instinct-import.md # /instinct-import - 导入直觉规则 (新增)
| |-- instinct-export.md # /instinct-export - 导出直觉（新增） | |-- instinct-export.md # /instinct-export - 导出直觉规则 (新增)
| |-- evolve.md # /evolve - 将直觉聚类为技能 | |-- evolve.md # /evolve - 将直觉聚类为技能
| |-- pm2.md # /pm2 - PM2 服务生命周期管理（新增） | |-- pm2.md # /pm2 - PM2 服务生命周期管理 (新增)
| |-- multi-plan.md # /multi-plan - 多代理任务拆解（新增） | |-- multi-plan.md # /multi-plan - 多代理任务拆解 (新增)
| |-- multi-execute.md # /multi-execute - 编排式多代理工作流（新增） | |-- multi-execute.md # /multi-execute - 编排式多代理工作流 (新增)
| |-- multi-backend.md # /multi-backend - 后端多服务编排（新增） | |-- multi-backend.md # /multi-backend - 后端多服务编排 (新增)
| |-- multi-frontend.md # /multi-frontend - 前端多服务编排（新增） | |-- multi-frontend.md # /multi-frontend - 前端多服务编排 (新增)
| |-- multi-workflow.md # /multi-workflow - 通用多服务工作流（新增） | |-- multi-workflow.md # /multi-workflow - 通用多服务工作流 (新增)
| |-- orchestrate.md # /orchestrate - 多代理协调 | |-- orchestrate.md # /orchestrate - 多代理协调
| |-- sessions.md # /sessions - 会话历史管理 | |-- sessions.md # /sessions - 会话历史管理
| |-- eval.md # /eval - 按标准评估 | |-- eval.md # /eval - 按标准进行评估
| |-- test-coverage.md # /test-coverage - 测试覆盖率分析 | |-- test-coverage.md # /test-coverage - 测试覆盖率分析
| |-- update-docs.md # /update-docs - 更新文档 | |-- update-docs.md # /update-docs - 更新文档
| |-- update-codemaps.md # /update-codemaps - 更新代码映射 | |-- update-codemaps.md # /update-codemaps - 更新代码地图
| |-- python-review.md # /python-review - Python 代码审查（新增） | |-- python-review.md # /python-review - Python 代码审查 (新增)
| |
|-- rules/ # 必须遵循的规则（复制到 ~/.claude/rules/） |-- rules/ # 必须遵循的规则 (复制到 ~/.claude/rules/)
| |-- README.md # 结构说明与安装指南 | |-- README.md # 结构概览和安装指南
| |-- common/ # 与语言无关的原则 | |-- common/ # 与语言无关的原则
| | |-- coding-style.md # 不可变性与文件组织 | | |-- coding-style.md # 不可变性、文件组织
| | |-- git-workflow.md # 提交格式与 PR 流程 | | |-- git-workflow.md # 提交格式、PR 流程
| | |-- testing.md # TDD 与 80% 覆盖率要求 | | |-- testing.md # TDD、80% 覆盖率要求
| | |-- performance.md # 模型选择与上下文管理 | | |-- performance.md # 模型选择、上下文管理
| | |-- patterns.md # 设计模式与骨架项目 | | |-- patterns.md # 设计模式、骨架项目
| | |-- hooks.md # Hook 架构与 TodoWrite | | |-- hooks.md # Hook 架构、TodoWrite
| | |-- agents.md # 何时委派给子代理 | | |-- agents.md # 何时委派给子代理
| | |-- security.md # 强制安全检查 | | |-- security.md # 必须执行的安全检查
| |-- typescript/ # TypeScript/JavaScript 专用 | |-- typescript/ # TypeScript / JavaScript 专用
| |-- python/ # Python 专用 | |-- python/ # Python 专用
| |-- golang/ # Go 专用 | |-- golang/ # Go 专用
| |
|-- hooks/ # 基于触发器的自动化 |-- hooks/ # 基于触发器的自动化
| |-- README.md # Hook 文档、示例与自定义指南 | |-- README.md # Hook 文档、示例和自定义指南
| |-- hooks.json # 所有 Hook 配置（PreToolUse、PostToolUse、Stop 等） | |-- hooks.json # 所有 Hook 配置 (PreToolUse、PostToolUse、Stop 等)
| |-- memory-persistence/ # 会话生命周期 Hook（长文指南） | |-- memory-persistence/ # 会话生命周期 Hook (Longform Guide)
| |-- strategic-compact/ # 压缩建议（长文指南） | |-- strategic-compact/ # 压缩建议 (Longform Guide)
| |
|-- scripts/ # 跨平台 Node.js 脚本（新增） |-- scripts/ # 跨平台 Node.js 脚本 (新增)
| |-- lib/ # 共享工具 | |-- lib/ # 共享工具
| | |-- utils.js # 跨平台文件/路径/系统工具 | | |-- utils.js # 跨平台文件 / 路径 / 系统工具
| | |-- package-manager.js # 包管理器检测与选择 | | |-- package-manager.js # 包管理器检测与选择
| |-- hooks/ # Hook 实现 | |-- hooks/ # Hook 实现
| | |-- session-start.js # 会话开始时加载上下文 | | |-- session-start.js # 会话开始时加载上下文
@@ -349,28 +398,28 @@ everything-claude-code/
| | |-- evaluate-session.js # 从会话中提取模式 | | |-- evaluate-session.js # 从会话中提取模式
| |-- setup-package-manager.js # 交互式包管理器设置 | |-- setup-package-manager.js # 交互式包管理器设置
| |
|-- tests/ # 测试套件（新增） |-- tests/ # 测试套件 (新增)
| |-- lib/ # 库测试 | |-- lib/ # 库测试
| |-- hooks/ # Hook 测试 | |-- hooks/ # Hook 测试
| |-- run-all.js # 运行所有测试 | |-- run-all.js # 运行所有测试
| |
|-- contexts/ # 动态系统提示注入上下文（长文指南） |-- contexts/ # 动态系统提示上下文注入 (Longform Guide)
| |-- dev.md # 开发模式上下文 | |-- dev.md # 开发模式上下文
| |-- review.md # 代码审查模式上下文 | |-- review.md # 代码审查模式上下文
| |-- research.md # 研究/探索模式上下文 | |-- research.md # 研究 / 探索模式上下文
| |
|-- examples/ # 示例配置与会话 |-- examples/ # 示例配置和会话
| |-- CLAUDE.md # 项目级配置示例 | |-- CLAUDE.md # 项目级配置示例
| |-- user-CLAUDE.md # 用户级配置示例 | |-- user-CLAUDE.md # 用户级配置示例
| |-- saas-nextjs-CLAUDE.md # 实际 SaaS 示例（Next.js + Supabase + Stripe） | |-- saas-nextjs-CLAUDE.md # 真实 SaaS 示例 (Next.js + Supabase + Stripe)
| |-- go-microservice-CLAUDE.md # 实际 Go 微服务示例（gRPC + PostgreSQL） | |-- go-microservice-CLAUDE.md # 真实 Go 微服务示例 (gRPC + PostgreSQL)
| |-- django-api-CLAUDE.md # 实际 Django REST API 示例（DRF + Celery） | |-- django-api-CLAUDE.md # 真实 Django REST API 示例 (DRF + Celery)
| |-- rust-api-CLAUDE.md # 实际 Rust API 示例（Axum + SQLx + PostgreSQL）（新增） | |-- rust-api-CLAUDE.md # 真实 Rust API 示例 (Axum + SQLx + PostgreSQL) (新增)
| |
|-- mcp-configs/ # MCP 服务器配置 |-- mcp-configs/ # MCP 服务器配置
| |-- mcp-servers.json # GitHub、Supabase、Vercel、Railway 等 | |-- mcp-servers.json # GitHub、Supabase、Vercel、Railway 等
| |
|-- marketplace.json # 自托管市场配置（用于 /plugin marketplace add） |-- marketplace.json # 自托管市场配置 (用于 /plugin marketplace add)
``` ```
*** ***
@@ -441,6 +490,10 @@ npx ecc-agentshield init
[GitHub](https://github.com/affaan-m/agentshield) | [npm](https://www.npmjs.com/package/ecc-agentshield) [GitHub](https://github.com/affaan-m/agentshield) | [npm](https://www.npmjs.com/package/ecc-agentshield)
### 🔬 Plankton — 编写时代码质量强制执行
Plankton（致谢：@alxfazio）是用于编写时代码质量强制执行的推荐伴侣。它通过 PostToolUse 钩子在每次文件编辑时运行格式化程序和 20 多个代码检查器，然后生成 Claude 子进程（根据违规复杂度路由到 Haiku/Sonnet/Opus）来修复主智能体遗漏的问题。采用三阶段架构：静默自动格式化（解决 40-50% 的问题），将剩余的违规收集为结构化 JSON，委托给子进程修复。包含配置保护钩子，防止智能体修改检查器配置以通过检查而非修复代码。支持 Python、TypeScript、Shell、YAML、JSON、TOML、Markdown 和 Dockerfile。与 AgentShield 结合使用，实现安全 + 质量覆盖。完整集成指南请参阅 `skills/plankton-code-quality/`。
### 🧠 持续学习 v2 ### 🧠 持续学习 v2
基于本能的学习系统会自动学习您的模式： 基于本能的学习系统会自动学习您的模式：
@@ -559,8 +612,15 @@ cp -r everything-claude-code/rules/golang/* ~/.claude/rules/
# Copy commands # Copy commands
cp everything-claude-code/commands/*.md ~/.claude/commands/ cp everything-claude-code/commands/*.md ~/.claude/commands/
# Copy skills # Copy skills (core vs niche)
cp -r everything-claude-code/skills/* ~/.claude/skills/ # Recommended (new users): core/general skills only
cp -r everything-claude-code/.agents/skills/* ~/.claude/skills/
cp -r everything-claude-code/skills/search-first ~/.claude/skills/
# Optional: add niche/framework-specific skills only when needed
# for s in django-patterns django-tdd springboot-patterns; do
# cp -r everything-claude-code/skills/$s ~/.claude/skills/
# done
``` ```
#### 将钩子添加到 settings.json #### 将钩子添加到 settings.json
@@ -633,7 +693,7 @@ rules/
golang/ # Go specific patterns and tools golang/ # Go specific patterns and tools
``` ```
有关安装和结构详情，请参阅 [`rules/README.md`](../../rules/README.md)。 有关安装和结构详情，请参阅 [`rules/README.md`](rules/README.md)。
*** ***
@@ -741,13 +801,14 @@ cp -r everything-claude-code/rules/common/* ~/.claude/rules/
</details> </details>
<details> <details>
<summary><b>Does this work with Cursor / OpenCode / Codex?</b></summary> <summary><b>Does this work with Cursor / OpenCode / Codex / Antigravity?</b></summary>
是的。ECC 是跨平台的： 是的。ECC 是跨平台的：
* **Cursor**：`.cursor/` 中的预翻译配置。参见 [Cursor IDE 支持](#cursor-ide-支持)。 * **Cursor**：`.cursor/` 中的预翻译配置。请参阅 [Cursor IDE 支持](#cursor-ide-支持)。
* **OpenCode**：`.opencode/` 中的完整插件支持。参见 [OpenCode 支持](#-opencode-支持)。 * **OpenCode**：`.opencode/` 中的完整插件支持。请参阅 [OpenCode 支持](#-opencode-支持)。
* **Codex**：提供适配器漂移保护和 SessionStart 回退的一流支持。参见 PR [#257](https://github.com/affaan-m/everything-claude-code/pull/257)。 * **Codex**：对 macOS 应用和 CLI 的一流支持，带有适配器漂移防护和 SessionStart 回退。请参阅 PR [#257](https://github.com/affaan-m/everything-claude-code/pull/257)。
* **Antigravity**：`.agent/` 中针对工作流、技能和扁平化规则的紧密集成设置。
* **Claude Code**：原生支持 — 这是主要目标。 * **Claude Code**：原生支持 — 这是主要目标。
</details> </details>
@@ -860,20 +921,26 @@ alwaysApply: false
*** ***
## Codex CLI 支持 ## Codex macOS 应用 + CLI 支持
ECC 提供**一流的 Codex CLI 支持**，包含参考配置、Codex 特定的 AGENTS.md 补充和 16 个移植的技能。 ECC 为 macOS 应用和 CLI 提供 **一流的 Codex 支持**，包括参考配置、Codex 特定的 AGENTS.md 补充文档以及共享技能。
### 快速开始（Codex） ### 快速开始（Codex 应用 + CLI）
```bash ```bash
# Copy the reference config to your home directory # Copy the reference config to your home directory
cp .codex/config.toml ~/.codex/config.toml cp .codex/config.toml ~/.codex/config.toml
# Run Codex in the repo — AGENTS.md is auto-detected # Run Codex CLI in the repo — AGENTS.md is auto-detected
codex codex
``` ```
Codex macOS 应用：
* 将此仓库作为您的工作区打开。
* 根目录的 `AGENTS.md` 会被自动检测。
* 可选：将 `.codex/config.toml` 复制到 `~/.codex/config.toml` 以实现 CLI/应用行为一致性。
### 包含内容 ### 包含内容
| 组件 | 数量 | 详情 | | 组件 | 数量 | 详情 |
@@ -909,7 +976,7 @@ codex
### 关键限制 ### 关键限制
Codex CLI **尚不支持钩子**（[GitHub Issue #2109](https://github.com/openai/codex/issues/2109)，430+ 点赞）。安全强制执行是通过 `persistent_instructions` 中的指令和沙箱权限系统实现的。 Codex **尚未提供 Claude 风格的钩子执行对等性**。ECC 在该平台上的强制执行是通过 `AGENTS.md` 和 `persistent_instructions` 基于指令实现的，外加沙箱权限。
*** ***
@@ -933,12 +1000,12 @@ opencode
| 功能 | Claude Code | OpenCode | 状态 | | 功能 | Claude Code | OpenCode | 状态 |
|---------|-------------|----------|--------| |---------|-------------|----------|--------|
| 代理 | ✅ 13 个代理 | ✅ 12 个代理 | **Claude Code 领先** | | 智能体 | ✅ 16 个智能体 | ✅ 12 个智能体 | **Claude Code 领先** |
| 命令 | ✅ 33 个命令 | ✅ 24 个命令 | **Claude Code 领先** | | 命令 | ✅ 40 条命令 | ✅ 31 条命令 | **Claude Code 领先** |
| 技能 | ✅ 50+ 个技能 | ✅ 37 个技能 | **Claude Code 领先** | | 技能 | ✅ 65 项技能 | ✅ 37 项技能 | **Claude Code 领先** |
| 钩子 | ✅ 8 种事件类型 | ✅ 11 种事件 | **OpenCode 更多！** | | 钩子 | ✅ 8 种事件类型 | ✅ 11 种事件 | **OpenCode 更多！** |
| 规则 | ✅ 29 条规则 | ✅ 13 条指令 | **Claude Code 领先** | | 规则 | ✅ 29 条规则 | ✅ 13 条指令 | **Claude Code 领先** |
| MCP 服务器 | ✅ 14 个服务器 | ✅ 完整支持 | **完全对等** | | MCP 服务器 | ✅ 14 个服务器 | ✅ 完整 | **完全对等** |
| 自定义工具 | ✅ 通过钩子 | ✅ 6 个原生工具 | **OpenCode 更好** | | 自定义工具 | ✅ 通过钩子 | ✅ 6 个原生工具 | **OpenCode 更好** |
### 通过插件实现的钩子支持 ### 通过插件实现的钩子支持
@@ -955,7 +1022,7 @@ OpenCode 的插件系统比 Claude Code 更复杂，有 20 多种事件类型：
**额外的 OpenCode 事件**：`file.edited`、`file.watcher.updated`、`message.updated`、`lsp.client.diagnostics`、`tui.toast.show` 等等。 **额外的 OpenCode 事件**：`file.edited`、`file.watcher.updated`、`message.updated`、`lsp.client.diagnostics`、`tui.toast.show` 等等。
### 可用命令（32个） ### 可用命令（31+）
| 命令 | 描述 | | 命令 | 描述 |
|---------|-------------| |---------|-------------|
@@ -965,7 +1032,7 @@ OpenCode 的插件系统比 Claude Code 更复杂，有 20 多种事件类型：
| `/build-fix` | 修复构建错误 | | `/build-fix` | 修复构建错误 |
| `/e2e` | 生成端到端测试 | | `/e2e` | 生成端到端测试 |
| `/refactor-clean` | 移除死代码 | | `/refactor-clean` | 移除死代码 |
| `/orchestrate` | 多代理工作流 | | `/orchestrate` | 多智能体工作流 |
| `/learn` | 从会话中提取模式 | | `/learn` | 从会话中提取模式 |
| `/checkpoint` | 保存验证状态 | | `/checkpoint` | 保存验证状态 |
| `/verify` | 运行验证循环 | | `/verify` | 运行验证循环 |
@@ -976,7 +1043,7 @@ OpenCode 的插件系统比 Claude Code 更复杂，有 20 多种事件类型：
| `/go-review` | Go 代码审查 | | `/go-review` | Go 代码审查 |
| `/go-test` | Go TDD 工作流 | | `/go-test` | Go TDD 工作流 |
| `/go-build` | 修复 Go 构建错误 | | `/go-build` | 修复 Go 构建错误 |
| `/python-review` | Python 代码审查（PEP 8、类型提示、安全） | | `/python-review` | Python 代码审查（PEP 8、类型提示、安全性） |
| `/multi-plan` | 多模型协作规划 | | `/multi-plan` | 多模型协作规划 |
| `/multi-execute` | 多模型协作执行 | | `/multi-execute` | 多模型协作执行 |
| `/multi-backend` | 后端聚焦的多模型工作流 | | `/multi-backend` | 后端聚焦的多模型工作流 |
@@ -989,8 +1056,15 @@ OpenCode 的插件系统比 Claude Code 更复杂，有 20 多种事件类型：
| `/instinct-import` | 导入本能 | | `/instinct-import` | 导入本能 |
| `/instinct-export` | 导出本能 | | `/instinct-export` | 导出本能 |
| `/evolve` | 将本能聚类为技能 | | `/evolve` | 将本能聚类为技能 |
| `/learn-eval` | 在保存前提取和评估模式 | | `/promote` | 将项目本能提升到全局范围 |
| `/projects` | 列出已知项目和本能统计信息 |
| `/learn-eval` | 保存前提取和评估模式 |
| `/setup-pm` | 配置包管理器 | | `/setup-pm` | 配置包管理器 |
| `/harness-audit` | 审计平台可靠性、评估准备情况和风险状况 |
| `/loop-start` | 启动受控的智能体循环执行模式 |
| `/loop-status` | 检查活动循环状态和检查点 |
| `/quality-gate` | 对路径或整个仓库运行质量门检查 |
| `/model-route` | 根据复杂度和预算将任务路由到模型 |
### 插件安装 ### 插件安装
@@ -1030,19 +1104,19 @@ ECC 是**第一个最大化利用每个主要 AI 编码工具的插件**。以
| 功能 | Claude Code | Cursor IDE | Codex CLI | OpenCode | | 功能 | Claude Code | Cursor IDE | Codex CLI | OpenCode |
|---------|------------|------------|-----------|----------| |---------|------------|------------|-----------|----------|
| **代理** | 13 | 共享 (AGENTS.md) | 共享 (AGENTS.md) | 12 | | **智能体** | 16 | 共享（AGENTS.md） | 共享（AGENTS.md） | 12 |
| **命令** | 33 | 共享 | 基于指令 | 24 | | **命令** | 40 | 共享 | 基于指令 | 31 |
| **技能** | 50+ | 共享 | 10 (原生格式) | 37 | | **技能** | 65 | 共享 | 10（原生格式） | 37 |
| **钩子事件** | 8 种类型 | 15 种类型 | 尚无 | 11 种类型 | | **钩子事件** | 8 种类型 | 15 种类型 | 暂无 | 11 种类型 |
| **钩子脚本** | 9 个脚本 | 16 个脚本 (DRY 适配器) | 不适用 | 插件钩子 | | **钩子脚本** | 20+ 个脚本 | 16 个脚本（DRY 适配器） | 不适用 | 插件钩子 |
| **规则** | 29 (通用 + 语言) | 29 (YAML 前言) | 基于指令 | 13 条指令 | | **规则** | 29（通用 + 语言） | 29（YAML 前言） | 基于指令 | 13 条指令 |
| **自定义工具** | 通过钩子 | 通过钩子 | 不适用 | 6 个原生工具 | | **自定义工具** | 通过钩子 | 通过钩子 | 不适用 | 6 个原生工具 |
| **MCP 服务器** | 14 | 共享 (mcp.json) | 4 (基于命令) | 完整 | | **MCP 服务器** | 14 | 共享（mcp.json） | 4（基于命令） | 完整 |
| **配置格式** | settings.json | hooks.json + rules/ | config.toml | opencode.json | | **配置格式** | settings.json | hooks.json + rules/ | config.toml | opencode.json |
| **上下文文件** | CLAUDE.md + AGENTS.md | AGENTS.md | AGENTS.md | AGENTS.md | | **上下文文件** | CLAUDE.md + AGENTS.md | AGENTS.md | AGENTS.md | AGENTS.md |
| **密钥检测** | 基于钩子 | beforeSubmitPrompt 钩子 | 基于沙箱 | 基于钩子 | | **秘密检测** | 基于钩子 | beforeSubmitPrompt 钩子 | 基于沙箱 | 基于钩子 |
| **自动格式化** | PostToolUse 钩子 | afterFileEdit 钩子 | 不适用 | file.edited 钩子 | | **自动格式化** | PostToolUse 钩子 | afterFileEdit 钩子 | 不适用 | file.edited 钩子 |
| **版本** | 插件 | 插件 | 参考配置 | 1.6.0 | | **版本** | 插件 | 插件 | 参考配置 | 1.8.0 |
**关键架构决策：** **关键架构决策：**
@@ -1059,6 +1133,11 @@ ECC 是**第一个最大化利用每个主要 AI 编码工具的插件**。以
这些配置已在多个生产应用程序中经过实战测试。 这些配置已在多个生产应用程序中经过实战测试。
## 灵感致谢
* 灵感来自 [zarazhangrui](https://github.com/zarazhangrui)
* homunculus 灵感来自 [humanplane](https://github.com/humanplane)
*** ***
## 令牌优化 ## 令牌优化
@@ -1167,7 +1246,7 @@ ECC 是**第一个最大化利用每个主要 AI 编码工具的插件**。以
这个项目是免费和开源的。赞助商帮助保持其维护和发展。 这个项目是免费和开源的。赞助商帮助保持其维护和发展。
[**成为赞助商**](https://github.com/sponsors/affaan-m) | [赞助商等级](SPONSORS.md) [**成为赞助商**](https://github.com/sponsors/affaan-m) | [赞助层级](SPONSORS.md) | [赞助计划](SPONSORING.md)
*** ***

43
docs/zh-CN/SPONSORING.md Normal file
View File

@@ -0,0 +1,43 @@
# 赞助 ECC
ECC 作为一个开源智能体性能测试系统，在 Claude Code、Cursor、OpenCode 和 Codex 应用程序/CLI 中得到维护。
## 为何赞助
赞助直接资助以下方面：
* 更快的错误修复和发布周期
* 跨测试平台的平台一致性工作
* 为社区免费提供的公共文档、技能和可靠性工具
## 赞助层级
这些是实用的起点，可以根据合作范围进行调整。
| 层级 | 价格 | 最适合 | 包含内容 |
|------|-------|----------|----------|
| 试点合作伙伴 | $200/月 | 首次赞助合作 | 月度指标更新、路线图预览、优先维护者反馈 |
| 成长合作伙伴 | $500/月 | 积极采用 ECC 的团队 | 试点权益 + 月度办公时间同步 + 工作流集成指导 |
| 战略合作伙伴 | $1,000+/月 | 平台/生态系统合作伙伴 | 成长权益 + 协调发布支持 + 更深入的维护者协作 |
## 赞助报告
每月分享的指标可能包括：
* npm 下载量（`ecc-universal`、`ecc-agentshield`）
* 仓库采用情况（星标、分叉、贡献者）
* GitHub 应用安装趋势
* 发布节奏和可靠性里程碑
有关确切的命令片段和可重复的拉取流程，请参阅 [`docs/business/metrics-and-sponsorship.md`](../business/metrics-and-sponsorship.md)。
## 期望与范围
* 赞助支持维护和加速；不会转移项目所有权。
* 功能请求根据赞助层级、生态系统影响和维护风险进行优先级排序。
* 安全性和可靠性修复优先于全新功能。
## 在此赞助
* GitHub Sponsors: <https://github.com/sponsors/affaan-m>
* 项目网站: <https://ecc.tools>

26
docs/zh-CN/SPONSORS.md
View File

@@ -29,16 +29,28 @@
* **更好的支持** — 赞助者获得优先响应 * **更好的支持** — 赞助者获得优先响应
* **影响路线图** — Pro+ 赞助者可以对功能进行投票 * **影响路线图** — Pro+ 赞助者可以对功能进行投票
## 赞助者准备度信号
在赞助者对话中使用这些证明点：
* `ecc-universal` 和 `ecc-agentshield` 的实时 npm 安装/下载指标
* 通过 Marketplace 安装的 GitHub App 分发
* 公开采用信号：星标、分叉、贡献者、发布节奏
* 跨平台支持：Claude Code、Cursor、OpenCode、Codex 应用/CLI
有关复制/粘贴指标拉取工作流程，请参阅 [`docs/business/metrics-and-sponsorship.md`](../business/metrics-and-sponsorship.md)。
## 赞助等级 ## 赞助等级
| 等级 | 价格 | 权益 | | 层级 | 价格 | 权益 |
|------|-------|----------| |------|-------|----------|
| 支持者 | $5/月 | 名字出现在 README 中，早期访问 | | 支持者 | 每月 $5 | 名字出现在 README 中，早期访问 |
| 建造者 | $10/月 | 高级工具访问权限 | | 构建者 | 每月 $10 | 高级工具访问权限 |
| 专业版 | $25/月 | 优先支持，办公时间咨询 | | 专业版 | 每月 $25 | 优先支持，办公时间 |
| 团队 | $100/月 | 5个席位，团队配置 | | 团队版 | 每月 $100 | 5 个席位，团队配置 |
| 商业 | $500/月 | 25个席位，咨询额度 | | 平台合作伙伴 | 每月 $200 | 月度路线图同步，优先维护者反馈，发布说明提及 |
| 企业 | $2K/月 | 无限席位，定制工具 | | 商业版 | 每月 $500 | 25 个席位，咨询积分 |
| 企业版 | 每月 $2K | 无限制席位，自定义工具 |
[**Become a Sponsor →**](https://github.com/sponsors/affaan-m) [**Become a Sponsor →**](https://github.com/sponsors/affaan-m)

6
docs/zh-CN/agents/chief-of-staff.md
View File

@@ -150,6 +150,6 @@ claude /schedule-reply "Reply to Sarah about the board meeting"
## 先决条件 ## 先决条件
* [Claude Code](https://docs.anthropic.com/en/docs/claude-code) * [Claude Code](https://docs.anthropic.com/en/docs/claude-code)
* Gmail CLI (例如 [gog](https://gog by @pterm)) * Gmail CLI（例如，@pterm 的 gog）
* Node.js 18+ (用于 calendar-suggest.js) * Node.js 18+（用于 calendar-suggest.js）
* 可选：Slack MCP 服务器、Matrix 桥接 (LINE)、Chrome + Playwright (Messenger) * 可选：Slack MCP 服务器、Matrix 桥接（LINE）、Chrome + Playwright（Messenger）

14
docs/zh-CN/agents/code-reviewer.md
View File

@@ -222,3 +222,17 @@ Verdict: WARNING — 2 HIGH issues should be resolved before merge.
* 状态管理约定（Zustand、Redux、Context） * 状态管理约定（Zustand、Redux、Context）
根据项目已建立的模式调整你的审查。如有疑问，与代码库的其余部分保持一致。 根据项目已建立的模式调整你的审查。如有疑问，与代码库的其余部分保持一致。
## v1.8 AI 生成代码审查附录
在审查 AI 生成的更改时，请优先考虑：
1. 行为回归和边缘情况处理
2. 安全假设和信任边界
3. 隐藏的耦合或意外的架构漂移
4. 不必要的增加模型成本的复杂性
成本意识检查：
* 标记那些在没有明确理由需求的情况下升级到更高成本模型的工作流程。
* 建议对于确定性的重构，默认使用较低成本的层级。

4
docs/zh-CN/agents/database-reviewer.md
View File

@@ -7,7 +7,7 @@ model: sonnet
# 数据库审查员 # 数据库审查员
您是一位专注于查询优化、模式设计、安全性和性能的 PostgreSQL 数据库专家。您的任务是确保数据库代码遵循最佳实践、防止性能问题并保持数据完整性。融合了 [Supabase 的 postgres-best-practices](Supabase Agent Skills (credit: Supabase team)) 中的模式。 您是一位专注于查询优化、模式设计、安全性和性能的 PostgreSQL 数据库专家。您的使命是确保数据库代码遵循最佳实践，防止性能问题，并维护数据完整性。融入了 Supabase 的 postgres-best-practices 中的模式（致谢：Supabase 团队）。
## 核心职责 ## 核心职责
@@ -91,4 +91,4 @@ psql -c "SELECT indexrelname, idx_scan, idx_tup_read FROM pg_stat_user_indexes O
**请记住**：数据库问题通常是应用程序性能问题的根本原因。尽早优化查询和模式设计。使用 EXPLAIN ANALYZE 来验证假设。始终对外键和 RLS 策略列建立索引。 **请记住**：数据库问题通常是应用程序性能问题的根本原因。尽早优化查询和模式设计。使用 EXPLAIN ANALYZE 来验证假设。始终对外键和 RLS 策略列建立索引。
*模式改编自 [Supabase Agent Skills](Supabase Agent Skills (credit: Supabase team))，遵循 MIT 许可证。* *模式改编自 Supabase Agent Skills（致谢：Supabase 团队），遵循 MIT 许可证。*

35
docs/zh-CN/agents/harness-optimizer.md Normal file
View File

@@ -0,0 +1,35 @@
---
name: harness-optimizer
description: 分析并改进本地代理工具配置以提高可靠性、降低成本并增加吞吐量。
tools: ["Read", "Grep", "Glob", "Bash", "Edit"]
model: sonnet
color: teal
---
你是线束优化器。
## 使命
通过改进线束配置来提升智能体完成质量，而不是重写产品代码。
## 工作流程
1. 运行 `/harness-audit` 并收集基准分数。
2. 确定前 3 个高杠杆领域（钩子、评估、路由、上下文、安全性）。
3. 提出最小化、可逆的配置更改。
4. 应用更改并运行验证。
5. 报告前后差异。
## 约束
* 优先选择效果可衡量的小改动。
* 保持跨平台行为。
* 避免引入脆弱的 shell 引用。
* 保持与 Claude Code、Cursor、OpenCode 和 Codex 的兼容性。
## 输出
* 基准记分卡
* 应用的更改
* 测量的改进
* 剩余风险

37
docs/zh-CN/agents/loop-operator.md Normal file
View File

@@ -0,0 +1,37 @@
---
name: loop-operator
description: 操作自主代理循环，监控进度，并在循环停滞时安全地进行干预。
tools: ["Read", "Grep", "Glob", "Bash", "Edit"]
model: sonnet
color: orange
---
你是循环操作员。
## 任务
安全地运行自主循环，具备明确的停止条件、可观测性和恢复操作。
## 工作流程
1. 从明确的模式和模式开始循环。
2. 跟踪进度检查点。
3. 检测停滞和重试风暴。
4. 当故障重复出现时，暂停并缩小范围。
5. 仅在验证通过后恢复。
## 必要检查
* 质量门处于活动状态
* 评估基线存在
* 回滚路径存在
* 分支/工作树隔离已配置
## 升级
当任何条件为真时升级：
* 连续两个检查点没有进展
* 具有相同堆栈跟踪的重复故障
* 成本漂移超出预算窗口
* 合并冲突阻塞队列前进

11
docs/zh-CN/agents/tdd-guide.md
View File

@@ -83,3 +83,14 @@ npm run test:coverage
* \[ ] 覆盖率在 80% 以上 * \[ ] 覆盖率在 80% 以上
有关详细的模拟模式和特定框架示例，请参阅 `skill: tdd-workflow`。 有关详细的模拟模式和特定框架示例，请参阅 `skill: tdd-workflow`。
## v1.8 评估驱动型 TDD 附录
将评估驱动开发集成到 TDD 流程中：
1. 在实现之前，定义能力评估和回归评估。
2. 运行基线测试并捕获失败特征。
3. 实施能通过测试的最小变更。
4. 重新运行测试和评估；报告 pass@1 和 pass@3 结果。
发布关键路径在合并前应达到 pass@3 的稳定性目标。

72
docs/zh-CN/commands/claw.md
View File

@@ -1,10 +1,10 @@
--- ---
description: 启动 NanoClaw 代理 REPL —— 一个由 claude CLI 驱动的持久、会话感知的 AI 助手。 description: 启动 NanoClaw v2 — ECC 的持久、零依赖 REPL，具备模型路由、技能热加载、分支、压缩、导出和指标功能。
--- ---
# Claw 命令 # Claw 命令
启动一个交互式 AI 代理会话，该会话将会话历史持久化到磁盘，并可选择加载 ECC 技能上下文。 启动一个具有持久化 Markdown 历史记录和操作控制的交互式 AI 代理会话。
## 使用方法 ## 使用方法
@@ -23,57 +23,29 @@ npm run claw
| 变量 | 默认值 | 描述 | | 变量 | 默认值 | 描述 |
|----------|---------|-------------| |----------|---------|-------------|
| `CLAW_SESSION` | `default` | 会话名称（字母数字 + 连字符） | | `CLAW_SESSION` | `default` | 会话名称（字母数字 + 连字符） |
| `CLAW_SKILLS` | *(空)* | 要加载为系统上下文的技能名称，以逗号分隔 | | `CLAW_SKILLS` | *(空)* | 启动时加载的以逗号分隔的技能列表 |
| `CLAW_MODEL` | `sonnet` | 会话的默认模型 |
## REPL 命令 ## REPL 命令
在 REPL 内部，直接在提示符下输入这些命令： ```text
/help Show help
``` /clear Clear current session history
/clear Clear current session history /history Print full conversation history
/history Print full conversation history /sessions List saved sessions
/sessions List all saved sessions /model [name] Show/set model
/help Show available commands /load <skill-name> Hot-load a skill into context
exit Quit the REPL /branch <session-name> Branch current session
/search <query> Search query across sessions
/compact Compact old turns, keep recent context
/export <md|json|txt> [path] Export session
/metrics Show session metrics
exit Quit
``` ```
## 工作原理 ## 说明
1. 读取 `CLAW_SESSION` 环境变量以选择命名会话（默认：`default`） * NanoClaw 保持零依赖。
2. 从 `~/.claude/claw/{session}.md` 加载会话历史 * 会话存储在 `~/.claude/claw/<session>.md`。
3. 可选地从 `CLAW_SKILLS` 环境变量加载 ECC 技能上下文 * 压缩会保留最近的回合并写入压缩头。
4. 进入一个阻塞式提示循环 —— 每条用户消息都会连同完整历史记录发送到 `claude -p` * 导出支持 Markdown、JSON 回合和纯文本。
5. 响应会被追加到会话文件中，以便在重启后保持持久性
## 会话存储
会话以 Markdown 文件形式存储在 `~/.claude/claw/` 中：
```
~/.claude/claw/default.md
~/.claude/claw/my-project.md
```
每一轮对话的格式如下：
```markdown
### [2025-01-15T10:30:00.000Z] 用户
这个函数是做什么的？
---
### [2025-01-15T10:30:05.000Z] 助手
这个函数用于计算...
---
```
## 示例
```bash
# Start default session
node scripts/claw.js
# Named session
CLAW_SESSION=my-project node scripts/claw.js
# With skill context
CLAW_SKILLS=tdd-workflow,security-review node scripts/claw.js
```

83
docs/zh-CN/commands/evolve.md
View File

@@ -1,6 +1,6 @@
--- ---
name: evolve name: evolve
description: 将相关本能聚类为技能、命令或代理 description: 分析本能并建议或生成进化结构
command: true command: true
--- ---
@@ -30,9 +30,7 @@ python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py evolve [
``` ```
/evolve # Analyze all instincts and suggest evolutions /evolve # Analyze all instincts and suggest evolutions
/evolve --domain testing # Only evolve instincts in testing domain /evolve --generate # Also generate files under evolved/{skills,commands,agents}
/evolve --dry-run # Show what would be created without creating
/evolve --threshold 5 # Require 5+ related instincts to cluster
``` ```
## 演化规则 ## 演化规则
@@ -88,63 +86,50 @@ python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py evolve [
## 操作步骤 ## 操作步骤
1. 从 `~/.claude/homunculus/instincts/` 读取所有本能 1. 检测当前项目上下文
2. 按以下方式对本能进行分组： 2. 读取项目 + 全局本能（项目优先级高于 ID 冲突）
* 领域相似性 3. 按触发器/领域模式分组本能
* 触发器模式重叠 4. 识别：
* 操作序列关联性 * 技能候选（包含 2+ 个本能的触发器簇）
3. 对于每个包含 3 个以上相关本能的集群： * 命令候选（高置信度工作流本能）
* 确定演化类型（命令/技能/代理） * 智能体候选（更大、高置信度的簇）
* 生成相应的文件 5. 在适用时显示升级候选（项目 -> 全局）
* 保存到 `~/.claude/homunculus/evolved/{commands,skills,agents}/` 6. 如果传入了 `--generate`，则将文件写入：
4. 将演化后的结构链接回源本能 * 项目范围：`~/.claude/homunculus/projects/<project-id>/evolved/`
* 全局回退：`~/.claude/homunculus/evolved/`
## 输出格式 ## 输出格式
``` ```
🧬 Evolve Analysis ============================================================
================== EVOLVE ANALYSIS - 12 instincts
Project: my-app (a1b2c3d4e5f6)
Project-scoped: 8 | Global: 4
============================================================
Found 3 clusters ready for evolution: High confidence instincts (>=80%): 5
## Cluster 1: Database Migration Workflow ## SKILL CANDIDATES
Instincts: new-table-migration, update-schema, regenerate-types 1. Cluster: "adding tests"
Type: Command Instincts: 3
Confidence: 85% (based on 12 observations) Avg confidence: 82%
Domains: testing
Scopes: project
Would create: /new-table command ## COMMAND CANDIDATES (2)
Files: /adding-tests
- ~/.claude/homunculus/evolved/commands/new-table.md From: test-first-workflow [project]
Confidence: 84%
## Cluster 2: Functional Code Style ## AGENT CANDIDATES (1)
Instincts: prefer-functional, use-immutable, avoid-classes, pure-functions adding-tests-agent
Type: Skill Covers 3 instincts
Confidence: 78% (based on 8 observations) Avg confidence: 82%
Would create: functional-patterns skill
Files:
- ~/.claude/homunculus/evolved/skills/functional-patterns.md
## Cluster 3: Debugging Process
Instincts: debug-check-logs, debug-isolate, debug-reproduce, debug-verify
Type: Agent
Confidence: 72% (based on 6 observations)
Would create: debugger agent
Files:
- ~/.claude/homunculus/evolved/agents/debugger.md
---
Run `/evolve --execute` to create these files.
``` ```
## 标志 ## 标志
* `--execute`: 实际创建演化后的结构（默认为预览） * `--generate`：除了分析输出外，还生成进化后的文件
* `--dry-run`: 仅预览而不创建
* `--domain <name>`: 仅演化指定领域的本能
* `--threshold <n>`: 形成集群所需的最小本能数（默认：3）
* `--type <command|skill|agent>`: 仅创建指定类型
## 生成的文件格式 ## 生成的文件格式

59
docs/zh-CN/commands/harness-audit.md Normal file
View File

@@ -0,0 +1,59 @@
# 工具链审计命令
审计当前代码库的智能体工具链设置并返回一份优先级评分卡。
## 使用方式
`/harness-audit [scope] [--format text|json]`
* `scope` (可选): `repo` (默认), `hooks`, `skills`, `commands`, `agents`
* `--format`: 输出样式 (`text` 默认, `json` 用于自动化)
## 评估内容
将每个类别从 `0` 到 `10` 进行评分：
1. 工具覆盖度
2. 上下文效率
3. 质量门禁
4. 记忆持久化
5. 评估覆盖度
6. 安全护栏
7. 成本效率
## 输出约定
返回：
1. `overall_score` (满分 70)
2. 类别得分和具体发现
3. 前 3 项待办事项及其确切文件路径
4. 建议接下来应用的 ECC 技能
## 检查清单
* 检查 `hooks/hooks.json`, `scripts/hooks/` 以及钩子测试。
* 检查 `skills/`、命令覆盖度和智能体覆盖度。
* 验证 `.cursor/`, `.opencode/`, `.codex/` 在跨工具链间的一致性。
* 标记已损坏或过时的引用。
## 结果示例
```text
Harness Audit (repo): 52/70
- Quality Gates: 9/10
- Eval Coverage: 6/10
- Cost Efficiency: 4/10
Top 3 Actions:
1) Add cost tracking hook in scripts/hooks/cost-tracker.js
2) Add pass@k docs and templates in skills/eval-harness/SKILL.md
3) Add command parity for /harness-audit in .opencode/commands/
```
## 参数
$ARGUMENTS:
* `repo|hooks|skills|commands|agents` (可选范围)
* `--format text|json` (可选输出格式)

79
docs/zh-CN/commands/instinct-export.md
View File

@@ -1,6 +1,6 @@
--- ---
name: instinct-export name: instinct-export
description: 导出本能，与团队成员或其他项目共享 description: 将项目/全局范围的本能导出到文件
command: /instinct-export command: /instinct-export
--- ---
@@ -19,17 +19,18 @@ command: /instinct-export
/instinct-export --domain testing # Export only testing instincts /instinct-export --domain testing # Export only testing instincts
/instinct-export --min-confidence 0.7 # Only export high-confidence instincts /instinct-export --min-confidence 0.7 # Only export high-confidence instincts
/instinct-export --output team-instincts.yaml /instinct-export --output team-instincts.yaml
/instinct-export --scope project --output project-instincts.yaml
``` ```
## 操作步骤 ## 操作步骤
1. 从 `~/.claude/homunculus/instincts/personal/` 读取本能 1. 检测当前项目上下文
2. 根据标志进行筛选 2. 按选定范围加载本能：
3. 剥离敏感信息： * `project`: 仅限当前项目
* 移除会话 ID * `global`: 仅限全局
* 移除文件路径（仅保留模式） * `all`: 项目与全局合并（默认）
* 移除早于“上周”的时间戳 3. 应用过滤器（`--domain`, `--min-confidence`）
4. 生成导出文件 4. 将 YAML 格式的导出写入文件（如果未提供输出路径，则写入标准输出）
## 输出格式 ## 输出格式
@@ -41,54 +42,26 @@ command: /instinct-export
# Source: personal # Source: personal
# Count: 12 instincts # Count: 12 instincts
version: "2.0" ---
exported_by: "continuous-learning-v2" id: prefer-functional-style
export_date: "2025-01-22T10:30:00Z" trigger: "when writing new functions"
confidence: 0.8
domain: code-style
source: session-observation
scope: project
project_id: a1b2c3d4e5f6
project_name: my-app
---
instincts: # Prefer Functional Style
- id: prefer-functional-style
trigger: "when writing new functions"
action: "Use functional patterns over classes"
confidence: 0.8
domain: code-style
observations: 8
- id: test-first-workflow ## Action
trigger: "when adding new functionality" Use functional patterns over classes.
action: "Write test first, then implementation"
confidence: 0.9
domain: testing
observations: 12
- id: grep-before-edit
trigger: "when modifying code"
action: "Search with Grep, confirm with Read, then Edit"
confidence: 0.7
domain: workflow
observations: 6
``` ```
## 隐私考虑
导出内容包括：
* ✅ 触发模式
* ✅ 操作
* ✅ 置信度分数
* ✅ 领域
* ✅ 观察计数
导出内容不包括：
* ❌ 实际代码片段
* ❌ 文件路径
* ❌ 会话记录
* ❌ 个人标识符
## 标志 ## 标志
* `--domain <name>`：仅导出指定领域 * `--domain <name>`: 仅导出指定领域
* `--min-confidence <n>`：最低置信度阈值（默认：0.3） * `--min-confidence <n>`: 最低置信度阈值
* `--output <file>`：输出文件路径（默认：instincts-export-YYYYMMDD.yaml） * `--output <file>`: 输出文件路径（省略时打印到标准输出）
* `--format <yaml|json|md>`：输出格式（默认：yaml） * `--scope <project|global|all>`: 导出范围（默认：`all`）
* `--include-evidence`：包含证据文本（默认：排除）

77
docs/zh-CN/commands/instinct-import.md
View File

@@ -1,6 +1,6 @@
--- ---
name: instinct-import name: instinct-import
description: 从队友、技能创建者或其他来源导入本能 description: 从文件或URL导入本能到项目/全局作用域
command: true command: true
--- ---
@@ -11,7 +11,7 @@ command: true
使用插件根路径运行本能 CLI： 使用插件根路径运行本能 CLI：
```bash ```bash
python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" import <file-or-url> [--dry-run] [--force] [--min-confidence 0.7] python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" import <file-or-url> [--dry-run] [--force] [--min-confidence 0.7] [--scope project|global]
``` ```
或者，如果 `CLAUDE_PLUGIN_ROOT` 未设置（手动安装）： 或者，如果 `CLAUDE_PLUGIN_ROOT` 未设置（手动安装）：
@@ -20,19 +20,15 @@ python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cl
python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py import <file-or-url> python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py import <file-or-url>
``` ```
从以下来源导入本能： 从本地文件路径或 HTTP(S) URL 导入本能。
* 队友的导出
* 技能创建器（仓库分析）
* 社区集合
* 之前的机器备份
## 用法 ## 用法
``` ```
/instinct-import team-instincts.yaml /instinct-import team-instincts.yaml
/instinct-import https://github.com/org/repo/instincts.yaml /instinct-import https://github.com/org/repo/instincts.yaml
/instinct-import --from-skill-creator acme/webapp /instinct-import team-instincts.yaml --dry-run
/instinct-import team-instincts.yaml --scope global --force
``` ```
## 执行步骤 ## 执行步骤
@@ -41,7 +37,9 @@ python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py import <
2. 解析并验证格式 2. 解析并验证格式
3. 检查与现有本能的重复项 3. 检查与现有本能的重复项
4. 合并或添加新本能 4. 合并或添加新本能
5. 保存到 `~/.claude/homunculus/instincts/inherited/` 5. 保存到继承的本能目录：
* 项目范围：`~/.claude/homunculus/projects/<project-id>/instincts/inherited/`
* 全局范围：`~/.claude/homunculus/instincts/inherited/`
## 导入过程 ## 导入过程
@@ -72,66 +70,35 @@ Already have similar instincts:
Import: 0.9 confidence Import: 0.9 confidence
→ Update to import (higher confidence) → Update to import (higher confidence)
## Conflicting Instincts (1) Import 8 new, update 1?
These contradict local instincts:
❌ use-classes-for-services
Conflicts with: avoid-classes
→ Skip (requires manual resolution)
---
Import 8 new, update 1, skip 3?
``` ```
## 合并策略 ## 合并行为
### 针对重复项 当导入一个已存在 ID 的本能时：
当导入一个与现有本能匹配的本能时： * 置信度更高的导入会成为更新候选
* 置信度相等或更低的导入将被跳过
* **置信度高的胜出**：保留置信度更高的那个 * 除非使用 `--force`，否则需要用户确认
* **合并证据**：合并观察计数
* **更新时间戳**：标记为最近已验证
### 针对冲突
当导入一个与现有本能相矛盾的本能时：
* **默认跳过**：不导入冲突的本能
* **标记待审**：将两者都标记为需要注意
* **手动解决**：由用户决定保留哪个
## 来源追踪 ## 来源追踪
导入的本能被标记为： 导入的本能被标记为：
```yaml ```yaml
source: "inherited" source: inherited
scope: project
imported_from: "team-instincts.yaml" imported_from: "team-instincts.yaml"
imported_at: "2025-01-22T10:30:00Z" project_id: "a1b2c3d4e5f6"
original_source: "session-observation" # or "repo-analysis" project_name: "my-project"
``` ```
## 技能创建器集成
从技能创建器导入时：
```
/instinct-import --from-skill-creator acme/webapp
```
这会获取从仓库分析生成的本能：
* 来源：`repo-analysis`
* 更高的初始置信度（0.7+）
* 链接到源仓库
## 标志 ## 标志
* `--dry-run`：预览而不导入 * `--dry-run`：仅预览而不导入
* `--force`：即使存在冲突也导入 * `--force`：跳过确认提示
* `--merge-strategy <higher|local|import>`：如何处理重复项
* `--from-skill-creator <owner/repo>`：从技能创建器分析导入
* `--min-confidence <n>`：仅导入高于阈值的本能 * `--min-confidence <n>`：仅导入高于阈值的本能
* `--scope <project|global>`：选择目标范围（默认：`project`）
## 输出 ## 输出
@@ -142,7 +109,7 @@ original_source: "session-observation" # or "repo-analysis"
Added: 8 instincts Added: 8 instincts
Updated: 1 instinct Updated: 1 instinct
Skipped: 3 instincts (2 duplicates, 1 conflict) Skipped: 3 instincts (equal/higher confidence already exists)
New instincts saved to: ~/.claude/homunculus/instincts/inherited/ New instincts saved to: ~/.claude/homunculus/instincts/inherited/

69
docs/zh-CN/commands/instinct-status.md
View File

@@ -1,12 +1,12 @@
--- ---
name: instinct-status name: instinct-status
description: 显示所有已学习的本能及其置信水平 description: 展示已学习的本能（项目+全局）并充满信心
command: true command: true
--- ---
# 本能状态命令 # 本能状态命令
显示所有已学习的本能及其置信度分数，按领域分组。 显示当前项目学习到的本能以及全局本能，按领域分组。
## 实现 ## 实现
@@ -26,61 +26,34 @@ python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py status
``` ```
/instinct-status /instinct-status
/instinct-status --domain code-style
/instinct-status --low-confidence
``` ```
## 操作步骤 ## 操作步骤
1. 从 `~/.claude/homunculus/instincts/personal/` 读取所有本能文件 1. 检测当前项目上下文（git remote/路径哈希）
2. 从 `~/.claude/homunculus/instincts/inherited/` 读取继承的本能 2. 从 `~/.claude/homunculus/projects/<project-id>/instincts/` 读取项目本能
3. 按领域分组显示它们，并带有置信度条 3. 从 `~/.claude/homunculus/instincts/` 读取全局本能
4. 合并并应用优先级规则（当ID冲突时，项目本能覆盖全局本能）
5. 按领域分组显示，包含置信度条和观察统计数据
## 输出格式 ## 输出格式
``` ```
📊 Instinct Status ============================================================
================== INSTINCT STATUS - 12 total
============================================================
## Code Style (4 instincts) Project: my-app (a1b2c3d4e5f6)
Project instincts: 8
Global instincts: 4
### prefer-functional-style ## PROJECT-SCOPED (my-app)
Trigger: when writing new functions ### WORKFLOW (3)
Action: Use functional patterns over classes ███████░░░ 70% grep-before-edit [project]
Confidence: ████████░░ 80% trigger: when modifying code
Source: session-observation | Last updated: 2025-01-22
### use-path-aliases ## GLOBAL (apply to all projects)
Trigger: when importing modules ### SECURITY (2)
Action: Use @/ path aliases instead of relative imports █████████░ 85% validate-user-input [global]
Confidence: ██████░░░░ 60% trigger: when handling user input
Source: repo-analysis (github.com/acme/webapp)
## Testing (2 instincts)
### test-first-workflow
Trigger: when adding new functionality
Action: Write test first, then implementation
Confidence: █████████░ 90%
Source: session-observation
## Workflow (3 instincts)
### grep-before-edit
Trigger: when modifying code
Action: Search with Grep, confirm with Read, then Edit
Confidence: ███████░░░ 70%
Source: session-observation
---
Total: 9 instincts (4 personal, 5 inherited)
Observer: Running (last analysis: 5 min ago)
``` ```
## 标志
* `--domain <name>`：按领域过滤（code-style、testing、git 等）
* `--low-confidence`：仅显示置信度 < 0.5 的本能
* `--high-confidence`：仅显示置信度 >= 0.7 的本能
* `--source <type>`：按来源过滤（session-observation、repo-analysis、inherited）
* `--json`：以 JSON 格式输出，供编程使用

33
docs/zh-CN/commands/loop-start.md Normal file
View File

@@ -0,0 +1,33 @@
# 循环启动命令
使用安全默认设置启动一个受管理的自主循环模式。
## 用法
`/loop-start [pattern] [--mode safe|fast]`
* `pattern`: `sequential`, `continuous-pr`, `rfc-dag`, `infinite`
* `--mode`:
* `safe` (默认): 严格的质量门禁和检查点
* `fast`: 为速度而减少门禁
## 流程
1. 确认仓库状态和分支策略。
2. 选择循环模式和模型层级策略。
3. 为所选模式启用所需的钩子/配置文件。
4. 创建循环计划并在 `.claude/plans/` 下编写运行手册。
5. 打印用于启动和监控循环的命令。
## 必需的安全检查
* 在首次循环迭代前验证测试通过。
* 确保 `ECC_HOOK_PROFILE` 未在全局范围内被禁用。
* 确保循环有明确的停止条件。
## 参数
$ARGUMENTS:
* `<pattern>` 可选 (`sequential|continuous-pr|rfc-dag|infinite`)
* `--mode safe|fast` 可选

25
docs/zh-CN/commands/loop-status.md Normal file
View File

@@ -0,0 +1,25 @@
# 循环状态命令
检查活动循环状态、进度和故障信号。
## 用法
`/loop-status [--watch]`
## 报告内容
* 活动循环模式
* 当前阶段和最后一个成功的检查点
* 失败的检查（如果有）
* 预计的时间/成本偏差
* 建议的干预措施（继续/暂停/停止）
## 监视模式
当 `--watch` 存在时，定期刷新状态并显示状态变化。
## 参数
$ARGUMENTS:
* `--watch` 可选

27
docs/zh-CN/commands/model-route.md Normal file
View File

@@ -0,0 +1,27 @@
# 模型路由命令
根据任务复杂度和预算推荐最佳模型层级。
## 用法
`/model-route [task-description] [--budget low|med|high]`
## 路由启发式规则
* `haiku`: 确定性、低风险的机械性变更
* `sonnet`: 实现和重构的默认选择
* `opus`: 架构设计、深度评审、模糊需求
## 必需输出
* 推荐的模型
* 置信度
* 该模型适合的原因
* 如果首次尝试失败，备用的回退模型
## 参数
$ARGUMENTS:
* `[task-description]` 可选，自由文本
* `--budget low|med|high` 可选

4
docs/zh-CN/commands/multi-backend.md
View File

@@ -86,13 +86,13 @@ EOF",
### 阶段 0：提示词增强（可选） ### 阶段 0：提示词增强（可选）
`[Mode: Prepare]` - 如果 ace-tool MCP 可用，调用 `mcp__ace-tool__enhance_prompt`，**用增强后的结果替换原始的 $ARGUMENTS，用于后续的 Codex 调用**。不可用时，直接使用 `$ARGUMENTS`。 `[Mode: Prepare]` - 如果 ace-tool MCP 可用，调用 `mcp__ace-tool__enhance_prompt`，**将原始的 $ARGUMENTS 替换为增强后的结果，用于后续的 Codex 调用**。如果不可用，则按原样使用 `$ARGUMENTS`。
### 阶段 1：研究 ### 阶段 1：研究
`[Mode: Research]` - 理解需求并收集上下文 `[Mode: Research]` - 理解需求并收集上下文
1. **代码检索**（如果 ace-tool MCP 可用）：调用 `mcp__ace-tool__search_context` 以检索现有的 API、数据模型、服务架构。不可用时，使用内置工具：`Glob` 进行文件发现，`Grep` 进行符号/API 搜索，`Read` 进行上下文收集，`Task`（Explore 代理）进行更深入的探索。 1. **代码检索**（如果 ace-tool MCP 可用）：调用 `mcp__ace-tool__search_context` 来检索现有的 API、数据模型、服务架构。如果不可用，则使用内置工具：`Glob` 用于文件发现，`Grep` 用于符号/API 搜索，`Read` 用于上下文收集，`Task`（探索代理）用于更深入的探索。
2. 需求完整性评分（0-10）：>=7 继续，<7 停止并补充 2. 需求完整性评分（0-10）：>=7 继续，<7 停止并补充
### 阶段 2：构思 ### 阶段 2：构思

19
docs/zh-CN/commands/multi-execute.md
View File

@@ -140,26 +140,27 @@ TaskOutput({ task_id: "<task_id>", block: true, timeout: 600000 })
**如果 ace-tool MCP 可用**，使用它进行快速上下文检索： **如果 ace-tool MCP 可用**，使用它进行快速上下文检索：
基于计划中的”关键文件”列表，调用 `mcp__ace-tool__search_context`： 基于计划中的“关键文件”列表，调用 `mcp__ace-tool__search_context`：
``` ```
mcp__ace-tool__search_context({ mcp__ace-tool__search_context({
query: “<semantic query based on plan content, including key files, modules, function names>”, query: "<semantic query based on plan content, including key files, modules, function names>",
project_root_path: “$PWD” project_root_path: "$PWD"
}) })
``` ```
**检索策略**： **检索策略**：
* 从计划的”关键文件”表中提取目标路径 * 从计划的“关键文件”表中提取目标路径
* 构建语义查询覆盖：入口文件、依赖模块、相关类型定义 * 构建语义查询，涵盖：入口文件、依赖模块、相关类型定义
* 如果结果不足，添加 1-2 次递归检索 * 如果结果不足，添加 1-2 次递归检索
**如果 ace-tool MCP 不可用**，使用 Claude Code 内置工具作为回退： **如果 ace-tool MCP 不可用**，使用 Claude Code 内置工具作为后备方案：
1. **Glob**：从计划的”关键文件”表中查找目标文件（例如 `Glob(“src/components/**/*.tsx”)`）
1. **Glob**：从计划的“关键文件”表中查找目标文件（例如，`Glob("src/components/**/*.tsx")`）
2. **Grep**：在代码库中搜索关键符号、函数名、类型定义 2. **Grep**：在代码库中搜索关键符号、函数名、类型定义
3. **Read**：读取发现的文件以收集完整上下文 3. **Read**：读取发现的文件以收集完整的上下文
4. **Task（Explore 代理）**：如需更广泛的探索，使用 `Task` 并设置 `subagent_type: “Explore”` 4. **Task (探索代理)**：对于更广泛的探索，使用 `Task` 和 `subagent_type: "Explore"`
**检索后**： **检索后**：

6
docs/zh-CN/commands/multi-frontend.md
View File

@@ -86,14 +86,14 @@ EOF",
### 阶段 0: 提示词增强（可选） ### 阶段 0: 提示词增强（可选）
`[Mode: Prepare]` - 如果 ace-tool MCP 可用，调用 `mcp__ace-tool__enhance_prompt`，**将原始的 $ARGUMENTS 替换为增强后的结果，用于后续的 Gemini 调用**。不可用时，直接使用 `$ARGUMENTS`。 `[Mode: Prepare]` - 如果 ace-tool MCP 可用，调用 `mcp__ace-tool__enhance_prompt`，**用增强后的结果替换原始的 $ARGUMENTS，供后续 Gemini 调用使用**。如果不可用，则按原样使用 `$ARGUMENTS`。
### 阶段 1: 研究 ### 阶段 1: 研究
`[Mode: Research]` - 理解需求并收集上下文 `[Mode: Research]` - 理解需求并收集上下文
1. **代码检索**（如果 ace-tool MCP 可用）: 调用 `mcp__ace-tool__search_context` 来检索现有的组件、样式、设计系统。不可用时，使用内置工具：`Glob` 进行文件发现，`Grep` 进行组件/样式搜索，`Read` 进行上下文收集，`Task`（Explore 代理）进行更深入的探索。 1. **代码检索**（如果 ace-tool MCP 可用）：调用 `mcp__ace-tool__search_context` 来检索现有的组件、样式、设计系统。如果不可用，使用内置工具：`Glob` 用于文件发现，`Grep` 用于组件/样式搜索，`Read` 用于上下文收集，`Task`（探索代理）用于更深层次的探索。
2. 需求完整性评分（0-10）: >=7 继续，<7 停止并补充 2. 需求完整性评分（0-10分）：>=7 继续，<7 停止并补充
### 阶段 2: 构思 ### 阶段 2: 构思

17
docs/zh-CN/commands/multi-plan.md
View File

@@ -85,7 +85,7 @@ mcp__ace-tool__enhance_prompt({
等待增强后的提示，**将所有后续阶段的原始 $ARGUMENTS 替换为增强结果**。 等待增强后的提示，**将所有后续阶段的原始 $ARGUMENTS 替换为增强结果**。
**如果 ace-tool MCP 不可用**：跳过此步骤，在所有后续阶段中直接使用原始 `$ARGUMENTS`。 **如果 ace-tool MCP 不可用**：跳过此步骤，并在所有后续阶段直接使用原始的 `$ARGUMENTS`。
#### 1.2 上下文检索 #### 1.2 上下文检索
@@ -98,14 +98,15 @@ mcp__ace-tool__search_context({
}) })
``` ```
* 使用自然语言构建语义查询（Where/What/How） * 使用自然语言构建语义查询（在哪里/是什么/怎么样）
* **绝不基于假设回答** * **切勿基于假设回答**
**如果 ace-tool MCP 不可用**，使用 Claude Code 内置工具作为回退： **如果 ace-tool MCP 不可用**，使用 Claude Code 内置工具作为备用方案：
1. **Glob**：按模式查找相关文件（例如 `Glob("**/*.ts")`、`Glob("src/**/*.py")`）
2. **Grep**：搜索关键符号、函数名、类定义（例如 `Grep("className|functionName")`） 1. **Glob**：通过模式查找相关文件（例如，`Glob("**/*.ts")`、`Glob("src/**/*.py")`）
3. **Read**：读取发现的文件以收集完整上下文 2. **Grep**：搜索关键符号、函数名、类定义（例如，`Grep("className|functionName")`）
4. **Task（Explore 代理）**：如需更深入的探索，使用 `Task` 并设置 `subagent_type: "Explore"` 3. **Read**：读取发现的文件以收集完整的上下文
4. **Task (Explore agent)**：要进行更深入的探索，使用 `Task` 并配合 `subagent_type: "Explore"` 来搜索整个代码库
#### 1.3 完整性检查 #### 1.3 完整性检查

18
docs/zh-CN/commands/multi-workflow.md
View File

@@ -13,9 +13,9 @@
## 上下文 ## 上下文
* 待开发任务：$ARGUMENTS * 待开发任务：$ARGUMENTS
* 结构化的 6 阶段工作流程，包含质量门控 * 结构化的 6 阶段工作流程，带有质量关卡
* 多模型协作：Codex（后端） + Gemini（前端） + Claude（编排） * 多模型协作：Codex（后端） + Gemini（前端） + Claude（编排）
* MCP 服务集成（ace-tool，可选）以增强能力 * 集成 MCP 服务（ace-tool，可选）以增强能力
## 你的角色 ## 你的角色
@@ -23,8 +23,8 @@
**协作模型**： **协作模型**：
* **ace-tool MCP**（可选） – 代码检索 + 提示词增强 * **ace-tool MCP**（可选） – 代码检索 + 提示增强
* **Codex** – 后端逻辑、算法、调试（**后端权威，可信赖**） * **Codex** – 后端逻辑、算法、调试（**后端权威，值得信赖**）
* **Gemini** – 前端 UI/UX、视觉设计（**前端专家，后端意见仅供参考**） * **Gemini** – 前端 UI/UX、视觉设计（**前端专家，后端意见仅供参考**）
* **Claude（自身）** – 编排、规划、执行、交付 * **Claude（自身）** – 编排、规划、执行、交付
@@ -114,11 +114,11 @@ TaskOutput({ task_id: "<task_id>", block: true, timeout: 600000 })
`[Mode: Research]` - 理解需求并收集上下文： `[Mode: Research]` - 理解需求并收集上下文：
1. **提示词增强**（如果 ace-tool MCP 可用）：调用 `mcp__ace-tool__enhance_prompt`，**将所有后续对 Codex/Gemini 的调用中的原始 $ARGUMENTS 替换为增强后的结果**。不可用时，直接使用 `$ARGUMENTS`。 1. **提示增强**（如果 ace-tool MCP 可用）：调用 `mcp__ace-tool__enhance_prompt`，**用增强后的结果替换原始的 $ARGUMENTS，用于所有后续的 Codex/Gemini 调用**。如果不可用，直接使用 `$ARGUMENTS`。
2. **上下文检索**（如果 ace-tool MCP 可用）：调用 `mcp__ace-tool__search_context`。不可用时，使用内置工具：`Glob` 进行文件发现，`Grep` 进行符号搜索，`Read` 进行上下文收集，`Task`（Explore 代理）进行更深入的探索。 2. **上下文检索**（如果 ace-tool MCP 可用）：调用 `mcp__ace-tool__search_context`。如果不可用，使用内置工具：`Glob` 用于文件发现，`Grep` 用于符号搜索，`Read` 用于上下文收集，`Task`（探索代理）用于更深入的探索。
3. **需求完整性评分** (0-10)： 3. **需求完整性评分**（0-10）：
* 目标清晰度 (0-3)，预期成果 (0-3)，范围边界 (0-2)，约束条件 (0-2) * 目标清晰度（0-3）、预期结果（0-3）、范围边界（0-2）、约束条件（0-2）
* ≥7：继续 | <7：停止，询问澄清问题 * ≥7：继续 | <7：停止，询问澄清性问题
### 阶段 2：解决方案构思 ### 阶段 2：解决方案构思

39
docs/zh-CN/commands/projects.md Normal file
View File

@@ -0,0 +1,39 @@
---
name: projects
description: 列出已知项目及其本能统计数据
command: true
---
# 项目命令
列出项目注册条目以及每个项目的本能/观察计数，适用于 continuous-learning-v2。
## 实现
使用插件根路径运行本能 CLI：
```bash
python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" projects
```
或者如果 `CLAUDE_PLUGIN_ROOT` 未设置（手动安装）：
```bash
python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py projects
```
## 用法
```bash
/projects
```
## 操作步骤
1. 读取 `~/.claude/homunculus/projects.json`
2. 对于每个项目，显示：
* 项目名称、ID、根目录、远程地址
* 个人和继承的本能计数
* 观察事件计数
* 最后看到的时间戳
3. 同时显示全局本能总数

41
docs/zh-CN/commands/promote.md Normal file
View File

@@ -0,0 +1,41 @@
---
name: promote
description: 将项目范围内的本能推广到全局范围
command: true
---
# 提升命令
在 continuous-learning-v2 中将本能从项目范围提升到全局范围。
## 实现
使用插件根路径运行本能 CLI：
```bash
python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" promote [instinct-id] [--force] [--dry-run]
```
或者如果未设置 `CLAUDE_PLUGIN_ROOT`（手动安装）：
```bash
python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py promote [instinct-id] [--force] [--dry-run]
```
## 用法
```bash
/promote # Auto-detect promotion candidates
/promote --dry-run # Preview auto-promotion candidates
/promote --force # Promote all qualified candidates without prompt
/promote grep-before-edit # Promote one specific instinct from current project
```
## 操作步骤
1. 检测当前项目
2. 如果提供了 `instinct-id`，则仅提升该本能（如果存在于当前项目中）
3. 否则，查找跨项目候选本能，这些本能：
* 出现在至少 2 个项目中
* 满足置信度阈值
4. 将提升后的本能写入 `~/.claude/homunculus/instincts/personal/`，并设置 `scope: global`

30
docs/zh-CN/commands/quality-gate.md Normal file
View File

@@ -0,0 +1,30 @@
# 质量门命令
按需对文件或项目范围运行 ECC 质量管道。
## 用法
`/quality-gate [path|.] [--fix] [--strict]`
* 默认目标：当前目录 (`.`)
* `--fix`：在已配置的地方允许自动格式化/修复
* `--strict`：在支持的地方警告即失败
## 管道
1. 检测目标的语言/工具。
2. 运行格式化检查。
3. 在可用时运行代码检查/类型检查。
4. 生成简洁的修复列表。
## 备注
此命令镜像了钩子行为，但由操作员调用。
## 参数
$ARGUMENTS:
* `[path|.]` 可选的目标路径
* `--fix` 可选
* `--strict` 可选

220
docs/zh-CN/hooks/README.md Normal file
View File

@@ -0,0 +1,220 @@
# 钩子
钩子是事件驱动的自动化程序，在 Claude Code 工具执行前后触发。它们用于强制执行代码质量、及早发现错误以及自动化重复性检查。
## 钩子如何工作
```
User request → Claude picks a tool → PreToolUse hook runs → Tool executes → PostToolUse hook runs
```
* **PreToolUse** 钩子在工具执行前运行。它们可以**阻止**（退出码 2）或**警告**（stderr 输出但不阻止）。
* **PostToolUse** 钩子在工具完成后运行。它们可以分析输出但不能阻止执行。
* **Stop** 钩子在每次 Claude 响应后运行。
* **SessionStart/SessionEnd** 钩子在会话生命周期的边界处运行。
* **PreCompact** 钩子在上下文压缩前运行，适用于保存状态。
## 本插件中的钩子
### PreToolUse 钩子
| 钩子 | 匹配器 | 行为 | 退出码 |
|------|---------|----------|-----------|
| **开发服务器阻止器** | `Bash` | 在 tmux 外部阻止 `npm run dev` 等命令 —— 确保日志访问 | 2 (阻止) |
| **Tmux 提醒** | `Bash` | 建议对长时间运行的命令（npm test, cargo build, docker）使用 tmux | 0 (警告) |
| **Git push 提醒** | `Bash` | 提醒在 `git push` 前审查更改 | 0 (警告) |
| **文档文件警告** | `Write` | 警告非标准的 `.md`/`.txt` 文件（允许 README, CLAUDE, CONTRIBUTING, CHANGELOG, LICENSE, SKILL, docs/, skills/）；跨平台路径处理 | 0 (警告) |
| **策略性压缩** | `Edit\|Write` | 建议在逻辑间隔（约每 50 次工具调用）手动执行 `/compact` | 0 (警告) |
### PostToolUse 钩子
| 钩子 | 匹配器 | 功能 |
|------|---------|-------------|
| **PR 记录器** | `Bash` | 在 `gh pr create` 后记录 PR URL 和审查命令 |
| **构建分析** | `Bash` | 构建命令后的后台分析（异步，非阻塞） |
| **质量门** | `Edit\|Write\|MultiEdit` | 在编辑后运行快速质量检查 |
| **Prettier 格式化** | `Edit` | 编辑后使用 Prettier 自动格式化 JS/TS 文件 |
| **TypeScript 检查** | `Edit` | 在编辑 `.ts`/`.tsx` 文件后运行 `tsc --noEmit` |
| **console.log 警告** | `Edit` | 警告编辑的文件中存在 `console.log` 语句 |
### 生命周期钩子
| 钩子 | 事件 | 功能 |
|------|-------|-------------|
| **会话开始** | `SessionStart` | 加载先前上下文并检测包管理器 |
| **预压缩** | `PreCompact` | 在上下文压缩前保存状态 |
| **Console.log 审计** | `Stop` | 每次响应后检查所有修改的文件是否有 `console.log` |
| **会话摘要** | `Stop` | 当转录路径可用时持久化会话状态 |
| **模式提取** | `Stop` | 评估会话以提取可抽取的模式（持续学习） |
| **成本追踪器** | `Stop` | 发出轻量级的运行成本遥测标记 |
| **会话结束标记** | `SessionEnd` | 生命周期标记和清理日志 |
## 自定义钩子
### 禁用钩子
在 `hooks.json` 中移除或注释掉钩子条目。如果作为插件安装，请在您的 `~/.claude/settings.json` 中覆盖：
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "Write",
"hooks": [],
"description": "Override: allow all .md file creation"
}
]
}
}
```
### 运行时钩子控制（推荐）
使用环境变量控制钩子行为，无需编辑 `hooks.json`：
```bash
# minimal | standard | strict (default: standard)
export ECC_HOOK_PROFILE=standard
# Disable specific hook IDs (comma-separated)
export ECC_DISABLED_HOOKS="pre:bash:tmux-reminder,post:edit:typecheck"
```
配置文件：
* `minimal` —— 仅保留必要的生命周期和安全钩子。
* `standard` —— 默认；平衡的质量 + 安全检查。
* `strict` —— 启用额外的提醒和更严格的防护措施。
### 编写你自己的钩子
钩子是 shell 命令，通过 stdin 接收 JSON 格式的工具输入，并且必须在 stdout 上输出 JSON。
**基本结构：**
```javascript
// my-hook.js
let data = '';
process.stdin.on('data', chunk => data += chunk);
process.stdin.on('end', () => {
const input = JSON.parse(data);
// Access tool info
const toolName = input.tool_name; // "Edit", "Bash", "Write", etc.
const toolInput = input.tool_input; // Tool-specific parameters
const toolOutput = input.tool_output; // Only available in PostToolUse
// Warn (non-blocking): write to stderr
console.error('[Hook] Warning message shown to Claude');
// Block (PreToolUse only): exit with code 2
// process.exit(2);
// Always output the original data to stdout
console.log(data);
});
```
**退出码：**
* `0` —— 成功（继续执行）
* `2` —— 阻止工具调用（仅限 PreToolUse）
* 其他非零值 —— 错误（记录日志但不阻止）
### 钩子输入模式
```typescript
interface HookInput {
tool_name: string; // "Bash", "Edit", "Write", "Read", etc.
tool_input: {
command?: string; // Bash: the command being run
file_path?: string; // Edit/Write/Read: target file
old_string?: string; // Edit: text being replaced
new_string?: string; // Edit: replacement text
content?: string; // Write: file content
};
tool_output?: { // PostToolUse only
output?: string; // Command/tool output
};
}
```
### 异步钩子
对于不应阻塞主流程的钩子（例如，后台分析）：
```json
{
"type": "command",
"command": "node my-slow-hook.js",
"async": true,
"timeout": 30
}
```
异步钩子在后台运行。它们不能阻止工具执行。
## 常用钩子配方
### 警告 TODO 注释
```json
{
"matcher": "Edit",
"hooks": [{
"type": "command",
"command": "node -e \"let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const ns=i.tool_input?.new_string||'';if(/TODO|FIXME|HACK/.test(ns)){console.error('[Hook] New TODO/FIXME added - consider creating an issue')}console.log(d)})\""
}],
"description": "Warn when adding TODO/FIXME comments"
}
```
### 阻止创建大文件
```json
{
"matcher": "Write",
"hooks": [{
"type": "command",
"command": "node -e \"let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const c=i.tool_input?.content||'';const lines=c.split('\\n').length;if(lines>800){console.error('[Hook] BLOCKED: File exceeds 800 lines ('+lines+' lines)');console.error('[Hook] Split into smaller, focused modules');process.exit(2)}console.log(d)})\""
}],
"description": "Block creation of files larger than 800 lines"
}
```
### 使用 ruff 自动格式化 Python 文件
```json
{
"matcher": "Edit",
"hooks": [{
"type": "command",
"command": "node -e \"let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const p=i.tool_input?.file_path||'';if(/\\.py$/.test(p)){const{execFileSync}=require('child_process');try{execFileSync('ruff',['format',p],{stdio:'pipe'})}catch(e){}}console.log(d)})\""
}],
"description": "Auto-format Python files with ruff after edits"
}
```
### 要求新源文件附带测试文件
```json
{
"matcher": "Write",
"hooks": [{
"type": "command",
"command": "node -e \"const fs=require('fs');let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const p=i.tool_input?.file_path||'';if(/src\\/.*\\.(ts|js)$/.test(p)&&!/\\.test\\.|\\.spec\\./.test(p)){const testPath=p.replace(/\\.(ts|js)$/,'.test.$1');if(!fs.existsSync(testPath)){console.error('[Hook] No test file found for: '+p);console.error('[Hook] Expected: '+testPath);console.error('[Hook] Consider writing tests first (/tdd)')}}console.log(d)})\""
}],
"description": "Remind to create tests when adding new source files"
}
```
## 跨平台注意事项
钩子逻辑在 Node.js 脚本中实现，以便在 Windows、macOS 和 Linux 上具有跨平台行为。保留了少量 shell 包装器用于持续学习的观察者钩子；这些包装器受配置文件控制，并具有 Windows 安全的回退行为。
## 相关
* [rules/common/hooks.md](../rules/common/hooks.md) —— 钩子架构指南
* [skills/strategic-compact/](../../../skills/strategic-compact) —— 策略性压缩技能
* [scripts/hooks/](../../../scripts/hooks) —— 钩子脚本实现

4
docs/zh-CN/plugins/README.md
View File

@@ -14,7 +14,7 @@
# Add official Anthropic marketplace # Add official Anthropic marketplace
claude plugin marketplace add https://github.com/anthropics/claude-plugins-official claude plugin marketplace add https://github.com/anthropics/claude-plugins-official
# Add community marketplaces # Add community marketplaces (mgrep by @mixedbread-ai)
claude plugin marketplace add https://github.com/mixedbread-ai/mgrep claude plugin marketplace add https://github.com/mixedbread-ai/mgrep
``` ```
@@ -24,7 +24,7 @@ claude plugin marketplace add https://github.com/mixedbread-ai/mgrep
|-------------|--------| |-------------|--------|
| claude-plugins-official | `anthropics/claude-plugins-official` | | claude-plugins-official | `anthropics/claude-plugins-official` |
| claude-code-plugins | `anthropics/claude-code` | | claude-code-plugins | `anthropics/claude-code` |
| Mixedbread-Grep | `mixedbread-ai/mgrep` | | Mixedbread-Grep (@mixedbread-ai) | `mixedbread-ai/mgrep` |
*** ***

28
docs/zh-CN/rules/common/development-workflow.md
View File

@@ -2,28 +2,36 @@
> 本文档在 [common/git-workflow.md](git-workflow.md) 的基础上进行了扩展，涵盖了在 git 操作之前发生的完整功能开发过程。 > 本文档在 [common/git-workflow.md](git-workflow.md) 的基础上进行了扩展，涵盖了在 git 操作之前发生的完整功能开发过程。
功能实现工作流程描述了开发管道：规划、测试驱动开发、代码审查，然后提交到 git。 功能实现工作流描述了开发流水线：研究、规划、TDD、代码审查，然后提交到 git。
## 功能实现工作流程 ## 功能实现工作流程
1. **先行规划** 0. **研究与复用** *(任何新实现之前强制进行)*
* 使用 **planner** 代理创建实现计划 * **首先进行 GitHub 代码搜索：** 在编写任何新内容之前，运行 `gh search repos` 和 `gh search code` 以查找现有的实现、模板和模式。
* **使用 Exa MCP 进行研究：** 在规划阶段使用 `exa-web-search` MCP 进行更广泛的研究、数据摄取和发现现有技术。
* **检查包注册表：** 在编写工具代码之前，搜索 npm、PyPI、crates.io 和其他注册表。优先选择经过实战检验的库，而不是自己编写的解决方案。
* **搜索可适配的实现：** 寻找能够解决 80% 以上问题并且可以分叉、移植或包装的开源项目。
* 当满足要求时，优先采用或移植经过验证的方法，而不是编写全新的代码。
1. **先规划**
* 使用 **planner** 代理创建实施计划
* 在编码前生成规划文档：PRD、架构、系统设计、技术文档、任务列表
* 识别依赖项和风险 * 识别依赖项和风险
* 分解为多个阶段 * 分解为多个阶段
2. **测试驱动开发方法** 2. **TDD 方法**
* 使用 **tdd-guide** 代理 * 使用 **tdd-guide** 代理
* 先编写测试（红） * 先写测试 (RED)
* 实现代码以通过测试（绿） * 实现以通过测试 (GREEN)
* 重构（改进） * 重构 (IMPROVE)
* 验证 80% 以上的覆盖率 * 验证 80%+ 的覆盖率
3. **代码审查** 3. **代码审查**
* 编写代码后立即使用 **code-reviewer** 代理 * 编写代码后立即使用 **code-reviewer** 代理
* 解决 CRITICAL 和 HIGH 级别的问题 * 处理 CRITICAL 和 HIGH 级别的问题
* 尽可能修复 MEDIUM 级别的问题 * 尽可能修复 MEDIUM 级别的问题
4. **提交与推送** 4. **提交与推送**
* 详细的提交信息 * 详细的提交信息
* 遵循约定式提交格式 * 遵循约定式提交格式
* 有关提交信息格式和 PR 流程，请参阅 [git-workflow.md](git-workflow.md) * 关于提交信息格式和 PR 流程，请参阅 [git-workflow.md](git-workflow.md)

77
docs/zh-CN/skills/agent-harness-construction/SKILL.md Normal file
View File

@@ -0,0 +1,77 @@
---
name: agent-harness-construction
description: 设计和优化AI代理的动作空间、工具定义和观察格式，以提高完成率。
origin: ECC
---
# 智能体框架构建
当你在改进智能体的规划、调用工具、从错误中恢复以及收敛到完成状态的方式时，使用此技能。
## 核心模型
智能体输出质量受限于：
1. 行动空间质量
2. 观察质量
3. 恢复质量
4. 上下文预算质量
## 行动空间设计
1. 使用稳定、明确的工具名称。
2. 保持输入模式优先且范围狭窄。
3. 返回确定性的输出形状。
4. 除非无法隔离，否则避免使用全能型工具。
## 粒度规则
* 对高风险操作（部署、迁移、权限）使用微工具。
* 对常见的编辑/读取/搜索循环使用中等工具。
* 仅当往返开销是主要成本时使用宏工具。
## 观察设计
每个工具响应都应包括：
* `status`: success|warning|error
* `summary`: 一行结果
* `next_actions`: 可执行的后续步骤
* `artifacts`: 文件路径 / ID
## 错误恢复契约
对于每个错误路径，应包括：
* 根本原因提示
* 安全重试指令
* 明确的停止条件
## 上下文预算管理
1. 保持系统提示词最少且不变。
2. 将大量指导信息移至按需加载的技能中。
3. 优先引用文件，而不是内联长文档。
4. 在阶段边界处进行压缩，而不是任意的令牌阈值。
## 架构模式指导
* ReAct：最适合路径不确定的探索性任务。
* 函数调用：最适合结构化的确定性流程。
* 混合模式（推荐）：ReAct 规划 + 类型化工具执行。
## 基准测试
跟踪：
* 完成率
* 每项任务的重试次数
* pass@1 和 pass@3
* 每个成功任务的成本
## 反模式
* 太多语义重叠的工具。
* 不透明的工具输出，没有恢复提示。
* 仅输出错误而没有后续步骤。
* 上下文过载，包含不相关的引用。

66
docs/zh-CN/skills/agentic-engineering/SKILL.md Normal file
View File

@@ -0,0 +1,66 @@
---
name: agentic-engineering
description: 作为代理工程师，采用评估优先执行、分解和成本感知模型路由进行操作。
origin: ECC
---
# 智能体工程
在 AI 智能体执行大部分实施工作、而人类负责质量与风险控制的工程工作流中使用此技能。
## 操作原则
1. 在执行前定义完成标准。
2. 将工作分解为智能体可处理的单元。
3. 根据任务复杂度路由模型层级。
4. 使用评估和回归检查进行度量。
## 评估优先循环
1. 定义能力评估和回归评估。
2. 运行基线并捕获失败特征。
3. 执行实施。
4. 重新运行评估并比较差异。
## 任务分解
应用 15 分钟单元规则：
* 每个单元应可独立验证
* 每个单元应有一个主要风险
* 每个单元应暴露一个清晰的完成条件
## 模型路由
* Haiku：分类、样板转换、狭窄编辑
* Sonnet：实施和重构
* Opus：架构、根因分析、多文件不变量
## 会话策略
* 对于紧密耦合的单元，继续使用同一会话。
* 在主要阶段转换后，启动新的会话。
* 在里程碑完成后进行压缩，而不是在主动调试期间。
## AI 生成代码的审查重点
优先审查：
* 不变量和边界情况
* 错误边界
* 安全性和身份验证假设
* 隐藏的耦合和上线风险
当自动化格式化/代码检查工具已强制执行代码风格时，不要在仅涉及风格分歧的审查上浪费周期。
## 成本纪律
按任务跟踪：
* 模型
* 令牌估算
* 重试次数
* 实际用时
* 成功/失败
仅当较低层级的模型失败且存在清晰的推理差距时，才升级模型层级。

55
docs/zh-CN/skills/ai-first-engineering/SKILL.md Normal file
View File

@@ -0,0 +1,55 @@
---
name: ai-first-engineering
description: 团队中人工智能代理生成大部分实施输出的工程运营模型。
origin: ECC
---
# 人工智能优先工程
在为由人工智能辅助代码生成的团队设计流程、评审和架构时，使用此技能。
## 流程转变
1. 规划质量比打字速度更重要。
2. 评估覆盖率比主观信心更重要。
3. 评审重点从语法转向系统行为。
## 架构要求
优先选择对智能体友好的架构：
* 明确的边界
* 稳定的契约
* 类型化的接口
* 确定性的测试
避免隐含的行为分散在隐藏的惯例中。
## 人工智能优先团队中的代码评审
评审关注：
* 行为回归
* 安全假设
* 数据完整性
* 故障处理
* 发布安全性
尽量减少花在已由自动化覆盖的风格问题上的时间。
## 招聘和评估信号
强大的人工智能优先工程师：
* 能清晰地分解模糊的工作
* 定义可衡量的验收标准
* 生成高价值的提示和评估
* 在交付压力下执行风险控制
## 测试标准
提高生成代码的测试标准：
* 对涉及的领域要求回归测试覆盖率
* 明确的边界情况断言
* 接口边界的集成检查

621
docs/zh-CN/skills/autonomous-loops/SKILL.md Normal file
View File

@@ -0,0 +1,621 @@
---
name: autonomous-loops
description: "自主Claude代码循环的模式与架构——从简单的顺序管道到基于RFC的多智能体有向无环图系统。"
origin: ECC
---
# 自主循环技能
> 兼容性说明 (v1.8.0): `autonomous-loops` 保留一个发布周期。
> 规范的技能名称现在是 `continuous-agent-loop`。新的循环指南应在此处编写，而此技能继续可用以避免破坏现有工作流。
在循环中自主运行 Claude Code 的模式、架构和参考实现。涵盖从简单的 `claude -p` 管道到完整的 RFC 驱动的多智能体 DAG 编排的一切。
## 何时使用
* 建立无需人工干预即可运行的自主开发工作流
* 为你的问题选择正确的循环架构（简单与复杂）
* 构建 CI/CD 风格的持续开发管道
* 运行具有合并协调的并行智能体
* 在循环迭代中实现上下文持久化
* 为自主工作流添加质量门和清理步骤
## 循环模式谱系
从最简单到最复杂：
| 模式 | 复杂度 | 最适合 |
|---------|-----------|----------|
| [顺序管道](#1-顺序管道-claude--p) | 低 | 日常开发步骤，脚本化工作流 |
| [NanoClaw REPL](#2-nanoclaw-repl) | 低 | 交互式持久会话 |
| [无限智能体循环](#3-无限智能体循环) | 中 | 并行内容生成，规范驱动的工作 |
| [持续 Claude PR 循环](#4-持续-claude-pr-循环) | 中 | 具有 CI 门的跨天迭代项目 |
| [去草率化模式](#5-去草率化模式) | 附加 | 任何实现者步骤后的质量清理 |
| [Ralphinho / RFC 驱动的 DAG](#6-ralphinho--rfc-驱动的-dag-编排) | 高 | 大型功能，具有合并队列的多单元并行工作 |
***
## 1. 顺序管道 (`claude -p`)
**最简单的循环。** 将日常开发分解为一系列非交互式 `claude -p` 调用。每次调用都是一个具有清晰提示的专注步骤。
### 核心见解
> 如果你无法想出这样的循环，那意味着你甚至无法在交互模式下驱动 LLM 来修复你的代码。
`claude -p` 标志以非交互方式运行 Claude Code 并附带提示，完成后退出。链式调用来构建管道：
```bash
#!/bin/bash
# daily-dev.sh — Sequential pipeline for a feature branch
set -e
# Step 1: Implement the feature
claude -p "Read the spec in docs/auth-spec.md. Implement OAuth2 login in src/auth/. Write tests first (TDD). Do NOT create any new documentation files."
# Step 2: De-sloppify (cleanup pass)
claude -p "Review all files changed by the previous commit. Remove any unnecessary type tests, overly defensive checks, or testing of language features (e.g., testing that TypeScript generics work). Keep real business logic tests. Run the test suite after cleanup."
# Step 3: Verify
claude -p "Run the full build, lint, type check, and test suite. Fix any failures. Do not add new features."
# Step 4: Commit
claude -p "Create a conventional commit for all staged changes. Use 'feat: add OAuth2 login flow' as the message."
```
### 关键设计原则
1. **每个步骤都是隔离的** — 每次 `claude -p` 调用都是一个新的上下文窗口，意味着步骤之间没有上下文泄露。
2. **顺序很重要** — 步骤按顺序执行。每个步骤都建立在前一个步骤留下的文件系统状态之上。
3. **否定指令是危险的** — 不要说“不要测试类型系统。”相反，添加一个单独的清理步骤（参见[去草率化模式](#5-去草率化模式)）。
4. **退出代码会传播** — `set -e` 在失败时停止管道。
### 变体
**使用模型路由：**
```bash
# Research with Opus (deep reasoning)
claude -p --model opus "Analyze the codebase architecture and write a plan for adding caching..."
# Implement with Sonnet (fast, capable)
claude -p "Implement the caching layer according to the plan in docs/caching-plan.md..."
# Review with Opus (thorough)
claude -p --model opus "Review all changes for security issues, race conditions, and edge cases..."
```
**使用环境上下文：**
```bash
# Pass context via files, not prompt length
echo "Focus areas: auth module, API rate limiting" > .claude-context.md
claude -p "Read .claude-context.md for priorities. Work through them in order."
rm .claude-context.md
```
**使用 `--allowedTools` 限制：**
```bash
# Read-only analysis pass
claude -p --allowedTools "Read,Grep,Glob" "Audit this codebase for security vulnerabilities..."
# Write-only implementation pass
claude -p --allowedTools "Read,Write,Edit,Bash" "Implement the fixes from security-audit.md..."
```
***
## 2. NanoClaw REPL
**ECC 内置的持久循环。** 一个具有会话感知的 REPL，它使用完整的对话历史同步调用 `claude -p`。
```bash
# Start the default session
node scripts/claw.js
# Named session with skill context
CLAW_SESSION=my-project CLAW_SKILLS=tdd-workflow,security-review node scripts/claw.js
```
### 工作原理
1. 从 `~/.claude/claw/{session}.md` 加载对话历史
2. 每个用户消息都连同完整历史记录作为上下文发送给 `claude -p`
3. 响应被追加到会话文件中（Markdown 作为数据库）
4. 会话在重启后持久存在
### NanoClaw 与顺序管道的选择
| 用例 | NanoClaw | 顺序管道 |
|----------|----------|-------------------|
| 交互式探索 | 是 | 否 |
| 脚本化自动化 | 否 | 是 |
| 会话持久性 | 内置 | 手动 |
| 上下文累积 | 每轮增长 | 每个步骤都是新的 |
| CI/CD 集成 | 差 | 优秀 |
有关完整详情，请参阅 `/claw` 命令文档。
***
## 3. 无限智能体循环
**一个双提示系统**，用于编排并行子智能体以进行规范驱动的生成。由 disler 开发（致谢：@disler）。
### 架构：双提示系统
```
PROMPT 1 (Orchestrator) PROMPT 2 (Sub-Agents)
┌─────────────────────┐ ┌──────────────────────┐
│ Parse spec file │ │ Receive full context │
│ Scan output dir │ deploys │ Read assigned number │
│ Plan iteration │────────────│ Follow spec exactly │
│ Assign creative dirs │ N agents │ Generate unique output │
│ Manage waves │ │ Save to output dir │
└─────────────────────┘ └──────────────────────┘
```
### 模式
1. **规范分析** — 编排器读取一个定义要生成内容的规范文件（Markdown）
2. **目录侦察** — 扫描现有输出以找到最高的迭代编号
3. **并行部署** — 启动 N 个子智能体，每个都有：
* 完整的规范
* 独特的创意方向
* 特定的迭代编号（无冲突）
* 现有迭代的快照（用于确保唯一性）
4. **波次管理** — 对于无限模式，部署 3-5 个智能体的波次，直到上下文耗尽
### 通过 Claude Code 命令实现
创建 `.claude/commands/infinite.md`：
```markdown
从 $ARGUMENTS 中解析以下参数：
1. spec_file — 规范 Markdown 文件的路径
2. output_dir — 保存迭代结果的目录
3. count — 整数 1-N 或 "infinite"
阶段 1： 读取并深入理解规范。
阶段 2： 列出 output_dir，找到最高的迭代编号。从 N+1 开始。
阶段 3： 规划创意方向 — 每个代理获得一个**不同的**主题/方法。
阶段 4： 并行部署子代理（使用 Task 工具）。每个代理接收：
- 完整的规范文本
- 当前目录快照
- 它们被分配的迭代编号
- 它们独特的创意方向
阶段 5（无限模式）： 以 3-5 个为一波进行循环，直到上下文不足为止。
```
**调用：**
```bash
/project:infinite specs/component-spec.md src/ 5
/project:infinite specs/component-spec.md src/ infinite
```
### 批处理策略
| 数量 | 策略 |
|-------|----------|
| 1-5 | 所有智能体同时运行 |
| 6-20 | 每批 5 个 |
| 无限 | 3-5 个一波，逐步复杂化 |
### 关键见解：通过分配实现唯一性
不要依赖智能体自我区分。编排器**分配**给每个智能体一个特定的创意方向和迭代编号。这可以防止并行智能体之间的概念重复。
***
## 4. 持续 Claude PR 循环
**一个生产级的 shell 脚本**，在持续循环中运行 Claude Code，创建 PR，等待 CI，并自动合并。由 AnandChowdhary 创建（致谢：@AnandChowdhary）。
### 核心循环
```
┌─────────────────────────────────────────────────────┐
│ CONTINUOUS CLAUDE ITERATION │
│ │
│ 1. Create branch (continuous-claude/iteration-N) │
│ 2. Run claude -p with enhanced prompt │
│ 3. (Optional) Reviewer pass — separate claude -p │
│ 4. Commit changes (claude generates message) │
│ 5. Push + create PR (gh pr create) │
│ 6. Wait for CI checks (poll gh pr checks) │
│ 7. CI failure? → Auto-fix pass (claude -p) │
│ 8. Merge PR (squash/merge/rebase) │
│ 9. Return to main → repeat │
│ │
│ Limit by: --max-runs N | --max-cost $X │
│ --max-duration 2h | completion signal │
└─────────────────────────────────────────────────────┘
```
### 安装
```bash
curl -fsSL https://raw.githubusercontent.com/AnandChowdhary/continuous-claude/HEAD/install.sh | bash
```
### 用法
```bash
# Basic: 10 iterations
continuous-claude --prompt "Add unit tests for all untested functions" --max-runs 10
# Cost-limited
continuous-claude --prompt "Fix all linter errors" --max-cost 5.00
# Time-boxed
continuous-claude --prompt "Improve test coverage" --max-duration 8h
# With code review pass
continuous-claude \
--prompt "Add authentication feature" \
--max-runs 10 \
--review-prompt "Run npm test && npm run lint, fix any failures"
# Parallel via worktrees
continuous-claude --prompt "Add tests" --max-runs 5 --worktree tests-worker &
continuous-claude --prompt "Refactor code" --max-runs 5 --worktree refactor-worker &
wait
```
### 跨迭代上下文：SHARED\_TASK\_NOTES.md
关键创新：一个 `SHARED_TASK_NOTES.md` 文件在迭代间持久存在：
```markdown
## 进展
- [x] 已添加认证模块测试（第1轮）
- [x] 已修复令牌刷新中的边界情况（第2轮）
- [ ] 仍需完成：速率限制测试、错误边界测试
## 后续步骤
- 接下来专注于速率限制模块
- 测试中位于 `tests/helpers.ts` 的模拟设置可以复用
```
Claude 在迭代开始时读取此文件，并在迭代结束时更新它。这弥合了独立 `claude -p` 调用之间的上下文差距。
### CI 失败恢复
当 PR 检查失败时，持续 Claude 会自动：
1. 通过 `gh run list` 获取失败的运行 ID
2. 生成一个新的带有 CI 修复上下文的 `claude -p`
3. Claude 通过 `gh run view` 检查日志，修复代码，提交，推送
4. 重新等待检查（最多 `--ci-retry-max` 次尝试）
### 完成信号
Claude 可以通过输出一个魔法短语来发出“我完成了”的信号：
```bash
continuous-claude \
--prompt "Fix all bugs in the issue tracker" \
--completion-signal "CONTINUOUS_CLAUDE_PROJECT_COMPLETE" \
--completion-threshold 3 # Stops after 3 consecutive signals
```
连续三次迭代发出完成信号会停止循环，防止在已完成的工作上浪费运行。
### 关键配置
| 标志 | 目的 |
|------|---------|
| `--max-runs N` | 在 N 次成功迭代后停止 |
| `--max-cost $X` | 在花费 $X 后停止 |
| `--max-duration 2h` | 在时间过去后停止 |
| `--merge-strategy squash` | squash、merge 或 rebase |
| `--worktree <name>` | 通过 git worktrees 并行执行 |
| `--disable-commits` | 试运行模式（无 git 操作） |
| `--review-prompt "..."` | 每次迭代添加审阅者审核 |
| `--ci-retry-max N` | 自动修复 CI 失败（默认：1） |
***
## 5. 去草率化模式
**任何循环的附加模式。** 在每个实现者步骤之后添加一个专门的清理/重构步骤。
### 问题
当你要求 LLM 使用 TDD 实现时，它对“编写测试”的理解过于字面：
* 测试验证 TypeScript 的类型系统是否有效（测试 `typeof x === 'string'`）
* 对类型系统已经保证的东西进行过度防御的运行时检查
* 测试框架行为而非业务逻辑
* 过多的错误处理掩盖了实际代码
### 为什么不使用否定指令？
在实现者提示中添加“不要测试类型系统”或“不要添加不必要的检查”会产生下游影响：
* 模型对所有测试都变得犹豫不决
* 它会跳过合法的边缘情况测试
* 质量不可预测地下降
### 解决方案：单独的步骤
与其限制实现者，不如让它彻底。然后添加一个专注的清理智能体：
```bash
# Step 1: Implement (let it be thorough)
claude -p "Implement the feature with full TDD. Be thorough with tests."
# Step 2: De-sloppify (separate context, focused cleanup)
claude -p "Review all changes in the working tree. Remove:
- Tests that verify language/framework behavior rather than business logic
- Redundant type checks that the type system already enforces
- Over-defensive error handling for impossible states
- Console.log statements
- Commented-out code
Keep all business logic tests. Run the test suite after cleanup to ensure nothing breaks."
```
### 在循环上下文中
```bash
for feature in "${features[@]}"; do
# Implement
claude -p "Implement $feature with TDD."
# De-sloppify
claude -p "Cleanup pass: review changes, remove test/code slop, run tests."
# Verify
claude -p "Run build + lint + tests. Fix any failures."
# Commit
claude -p "Commit with message: feat: add $feature"
done
```
### 关键见解
> 与其添加具有下游质量影响的否定指令，不如添加一个单独的去草率化步骤。两个专注的智能体胜过一个有约束的智能体。
***
## 6. Ralphinho / RFC 驱动的 DAG 编排
**最复杂的模式。** 一个 RFC 驱动的多智能体管道，将规范分解为依赖关系 DAG，通过分层质量管道运行每个单元，并通过智能体驱动的合并队列落地。由 enitrat 创建（致谢：@enitrat）。
### 架构概述
```
RFC/PRD Document
│
▼
DECOMPOSITION (AI)
Break RFC into work units with dependency DAG
│
▼
┌──────────────────────────────────────────────────────┐
│ RALPH LOOP (up to 3 passes) │
│ │
│ For each DAG layer (sequential, by dependency): │
│ │
│ ┌── Quality Pipelines (parallel per unit) ───────┐ │
│ │ Each unit in its own worktree: │ │
│ │ Research → Plan → Implement → Test → Review │ │
│ │ (depth varies by complexity tier) │ │
│ └────────────────────────────────────────────────┘ │
│ │
│ ┌── Merge Queue ─────────────────────────────────┐ │
│ │ Rebase onto main → Run tests → Land or evict │ │
│ │ Evicted units re-enter with conflict context │ │
│ └────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────┘
```
### RFC 分解
AI 读取 RFC 并生成工作单元：
```typescript
interface WorkUnit {
id: string; // kebab-case identifier
name: string; // Human-readable name
rfcSections: string[]; // Which RFC sections this addresses
description: string; // Detailed description
deps: string[]; // Dependencies (other unit IDs)
acceptance: string[]; // Concrete acceptance criteria
tier: "trivial" | "small" | "medium" | "large";
}
```
**分解规则：**
* 倾向于更少、内聚的单元（最小化合并风险）
* 最小化跨单元文件重叠（避免冲突）
* 保持测试与实现在一起（永远不要分开“实现 X” + “测试 X”）
* 仅在实际存在代码依赖关系的地方设置依赖关系
依赖关系 DAG 决定了执行顺序：
```
Layer 0: [unit-a, unit-b] ← no deps, run in parallel
Layer 1: [unit-c] ← depends on unit-a
Layer 2: [unit-d, unit-e] ← depend on unit-c
```
### 复杂度层级
不同的层级获得不同深度的管道：
| 层级 | 管道阶段 |
|------|----------------|
| **trivial** | implement → test |
| **small** | implement → test → code-review |
| **medium** | research → plan → implement → test → PRD-review + code-review → review-fix |
| **large** | research → plan → implement → test → PRD-review + code-review → review-fix → final-review |
这可以防止对简单更改进行昂贵的操作，同时确保架构更改得到彻底审查。
### 独立的上下文窗口（消除作者偏见）
每个阶段在其自己的智能体进程中运行，拥有自己的上下文窗口：
| 阶段 | 模型 | 目的 |
|-------|-------|---------|
| Research | Sonnet | 读取代码库 + RFC，生成上下文文档 |
| Plan | Opus | 设计实现步骤 |
| Implement | Codex | 按照计划编写代码 |
| Test | Sonnet | 运行构建 + 测试套件 |
| PRD Review | Sonnet | 规范合规性检查 |
| Code Review | Opus | 质量 + 安全检查 |
| Review Fix | Codex | 处理审阅问题 |
| Final Review | Opus | 质量门（仅限大型层级） |
**关键设计：** 审阅者从未编写过它要审阅的代码。这消除了作者偏见——这是自我审阅中遗漏问题的最常见原因。
### 具有驱逐功能的合并队列
质量管道完成后，单元进入合并队列：
```
Unit branch
│
├─ Rebase onto main
│ └─ Conflict? → EVICT (capture conflict context)
│
├─ Run build + tests
│ └─ Fail? → EVICT (capture test output)
│
└─ Pass → Fast-forward main, push, delete branch
```
**文件重叠智能：**
* 非重叠单元并行推测性地落地
* 重叠单元逐个落地，每次重新变基
**驱逐恢复：**
被驱逐时，会捕获完整上下文（冲突文件、差异、测试输出）并反馈给下一个 Ralph 轮次的实现者：
```markdown
## 合并冲突 — 在下一次推送前解决
您之前的实现与另一个已先推送的单元发生了冲突。
请重构您的更改以避免以下冲突的文件/行。
{完整的排除上下文及差异}
```
### 阶段间的数据流
```
research.contextFilePath ──────────────────→ plan
plan.implementationSteps ──────────────────→ implement
implement.{filesCreated, whatWasDone} ─────→ test, reviews
test.failingSummary ───────────────────────→ reviews, implement (next pass)
reviews.{feedback, issues} ────────────────→ review-fix → implement (next pass)
final-review.reasoning ────────────────────→ implement (next pass)
evictionContext ───────────────────────────→ implement (after merge conflict)
```
### 工作树隔离
每个单元在隔离的工作树中运行（使用 jj/Jujutsu，而不是 git）：
```
/tmp/workflow-wt-{unit-id}/
```
同一单元的管道阶段**共享**一个工作树，在 research → plan → implement → test → review 之间保留状态（上下文文件、计划文件、代码更改）。
### 关键设计原则
1. **确定性执行** — 预先分解锁定并行性和顺序
2. **在杠杆点进行人工审阅** — 工作计划是单一最高杠杆干预点
3. **关注点分离** — 每个阶段在独立的上下文窗口中，由独立的智能体负责
4. **带上下文的冲突恢复** — 完整的驱逐上下文支持智能重试，而非盲目重试
5. **层级驱动的深度** — 琐碎更改跳过研究/审阅；大型更改获得最大审查
6. **可恢复的工作流** — 完整状态持久化到 SQLite；可从任何点恢复
### 何时使用 Ralphinho 与更简单的模式
| 信号 | 使用 Ralphinho | 使用更简单的模式 |
|--------|--------------|-------------------|
| 多个相互依赖的工作单元 | 是 | 否 |
| 需要并行实现 | 是 | 否 |
| 可能出现合并冲突 | 是 | 否（顺序即可） |
| 单文件更改 | 否 | 是（顺序管道） |
| 跨天项目 | 是 | 可能（持续-claude） |
| 规范/RFC 已编写 | 是 | 可能 |
| 对单个事物的快速迭代 | 否 | 是（NanoClaw 或管道） |
***
## 选择正确的模式
### 决策矩阵
```
Is the task a single focused change?
├─ Yes → Sequential Pipeline or NanoClaw
└─ No → Is there a written spec/RFC?
├─ Yes → Do you need parallel implementation?
│ ├─ Yes → Ralphinho (DAG orchestration)
│ └─ No → Continuous Claude (iterative PR loop)
└─ No → Do you need many variations of the same thing?
├─ Yes → Infinite Agentic Loop (spec-driven generation)
└─ No → Sequential Pipeline with de-sloppify
```
### 模式组合
这些模式可以很好地组合：
1. **顺序流水线 + 去草率化** — 最常见的组合。每个实现步骤都进行一次清理。
2. **连续 Claude + 去草率化** — 为每次迭代添加带有去草率化指令的 `--review-prompt`。
3. **任何循环 + 验证** — 在提交前，使用 ECC 的 `/verify` 命令或 `verification-loop` 技能作为关卡。
4. **Ralphinho 在简单循环中的分层方法** — 即使在顺序流水线中，你也可以将简单任务路由到 Haiku，复杂任务路由到 Opus：
```bash
# 简单的格式修复
claude -p --model haiku "Fix the import ordering in src/utils.ts"
# 复杂的架构变更
claude -p --model opus "Refactor the auth module to use the strategy pattern"
```
***
## 反模式
### 常见错误
1. **没有退出条件的无限循环** — 始终设置最大运行次数、最大成本、最大持续时间或完成信号。
2. **迭代之间没有上下文桥接** — 每次 `claude -p` 调用都从头开始。使用 `SHARED_TASK_NOTES.md` 或文件系统状态来桥接上下文。
3. **重试相同的失败** — 如果一次迭代失败，不要只是重试。捕获错误上下文并将其提供给下一次尝试。
4. **使用负面指令而非清理过程** — 不要说“不要做 X”。添加一个单独的步骤来移除 X。
5. **所有智能体都在一个上下文窗口中** — 对于复杂的工作流，将关注点分离到不同的智能体进程中。审查者永远不应该是作者。
6. **在并行工作中忽略文件重叠** — 如果两个并行智能体可能编辑同一个文件，你需要一个合并策略（顺序落地、变基或冲突解决）。
***
## 参考资料
| 项目 | 作者 | 链接 |
|---------|--------|------|
| Ralphinho | enitrat | credit: @enitrat |
| Infinite Agentic Loop | disler | credit: @disler |
| Continuous Claude | AnandChowdhary | credit: @AnandChowdhary |
| NanoClaw | ECC | 此仓库中的 `/claw` 命令 |
| Verification Loop | ECC | 此仓库中的 `skills/verification-loop/` |

23
docs/zh-CN/skills/configure-ecc/SKILL.md
View File

@@ -67,7 +67,24 @@ mkdir -p $TARGET/skills $TARGET/rules
## 步骤 2：选择并安装技能 ## 步骤 2：选择并安装技能
### 2a：选择技能类别 ### 2a: 选择范围（核心 vs 细分领域）
默认为 **核心（推荐给新用户）** — 对于研究优先的工作流，复制 `.agents/skills/*` 加上 `skills/search-first/`。此捆绑包涵盖工程、评估、验证、安全、战略压缩、前端设计以及 Anthropic 跨职能技能（文章写作、内容引擎、市场研究、前端幻灯片）。
使用 `AskUserQuestion`（单选）：
```
Question: "Install core skills only, or include niche/framework packs?"
Options:
- "Core only (recommended)" — "tdd, e2e, evals, verification, research-first, security, frontend patterns, compacting, cross-functional Anthropic skills"
- "Core + selected niche" — "Add framework/domain-specific skills after core"
- "Niche only" — "Skip core, install specific framework/domain skills"
Default: Core only
```
如果用户选择细分领域或核心 + 细分领域，则继续下面的类别选择，并且仅包含他们选择的那些细分领域技能。
### 2b: 选择技能类别
共有 27 项技能，分为 4 个类别。使用 `AskUserQuestion` 和 `multiSelect: true`： 共有 27 项技能，分为 4 个类别。使用 `AskUserQuestion` 和 `multiSelect: true`：
@@ -80,7 +97,7 @@ Options:
- "All skills" — "Install every available skill" - "All skills" — "Install every available skill"
``` ```
### 2b：确认单项技能 ### 2c: 确认个人技能
对于每个选定的类别，打印下面的完整技能列表，并要求用户确认或取消选择特定的技能。如果列表超过 4 项，将列表打印为文本，并使用 `AskUserQuestion`，提供一个 "安装所有列出项" 的选项，以及一个 "其他" 选项供用户粘贴特定名称。 对于每个选定的类别，打印下面的完整技能列表，并要求用户确认或取消选择特定的技能。如果列表超过 4 项，将列表打印为文本，并使用 `AskUserQuestion`，提供一个 "安装所有列出项" 的选项，以及一个 "其他" 选项供用户粘贴特定名称。
@@ -143,7 +160,7 @@ Options:
|-------|-------------| |-------|-------------|
| `project-guidelines-example` | 用于创建项目特定技能的模板 | | `project-guidelines-example` | 用于创建项目特定技能的模板 |
### 2c：执行安装 ### 2d: 执行安装
对于每个选定的技能，复制整个技能目录： 对于每个选定的技能，复制整个技能目录：

46
docs/zh-CN/skills/continuous-agent-loop/SKILL.md Normal file
View File

@@ -0,0 +1,46 @@
---
name: continuous-agent-loop
description: 具有质量门、评估和恢复控制的连续自主代理循环模式。
origin: ECC
---
# 持续代理循环
这是 v1.8+ 的规范循环技能名称。它在保持一个发布版本的兼容性的同时，取代了 `autonomous-loops`。
## 循环选择流程
```text
Start
|
+-- Need strict CI/PR control? -- yes --> continuous-pr
|
+-- Need RFC decomposition? -- yes --> rfc-dag
|
+-- Need exploratory parallel generation? -- yes --> infinite
|
+-- default --> sequential
```
## 组合模式
推荐的生产栈：
1. RFC 分解 (`ralphinho-rfc-pipeline`)
2. 质量门 (`plankton-code-quality` + `/quality-gate`)
3. 评估循环 (`eval-harness`)
4. 会话持久化 (`nanoclaw-repl`)
## 故障模式
* 循环空转，没有可衡量的进展
* 因相同根本原因而重复重试
* 合并队列停滞
* 无限制升级导致的成本漂移
## 恢复
* 冻结循环
* 运行 `/harness-audit`
* 将范围缩小到失败单元
* 使用明确的验收标准重放

304
docs/zh-CN/skills/continuous-learning-v2/SKILL.md
View File

@@ -1,33 +1,48 @@
--- ---
name: continuous-learning-v2 name: continuous-learning-v2
description: 基于本能的学习系统，通过钩子观察会话，创建具有置信度评分的原子本能，并将其进化为技能/命令/代理。 description: 基于本能的学习系统，通过钩子观察会话，创建带置信度评分的原子本能，并将其进化为技能/命令/代理。v2.1版本增加了项目范围的本能，以防止跨项目污染。
origin: ECC origin: ECC
version: 2.0.0 version: 2.1.0
--- ---
# 持续学习 v2 - 基于本能的架构 # 持续学习 v2.1 - 基于本能
的架构
一个高级学习系统，通过原子化的“本能”——带有置信度评分的小型习得行为——将你的 Claude Code 会话转化为可重用的知识。 一个高级学习系统，通过原子化的“本能”——带有置信度评分的小型习得行为——将你的 Claude Code 会话转化为可重用的知识。
部分灵感来源于 humanplane (credit: @humanplane) 的 Homunculus 项目。 **v2.1** 新增了**项目作用域的本能** — React 模式保留在你的 React 项目中，Python 约定保留在你的 Python 项目中，而通用模式（如“始终验证输入”）则全局共享。
## 何时激活 ## 何时激活
* 设置从 Claude Code 会话中自动学习时 * 设置从 Claude Code 会话自动学习
* 通过钩子配置基于本能的行为提取时 * 通过钩子配置基于本能的行为提取
* 调整学习行为的置信度阈值时 * 调整已学习行为的置信度阈值
* 审查、导出或导入本能库时 * 查看、导出或导入本能库
* 将本能进化为完整技能、命令或代理时 * 将本能进化为完整的技能、命令或代理
* 管理项目作用域与全局本能
* 将本能从项目作用域提升到全局作用域
## v2 的新特性 ## v2.1 的新特性
| 特性 | v2.0 | v2.1 |
|---------|------|------|
| 存储 | 全局 (~/.claude/homunculus/) | 项目作用域 (projects/<hash>/) |
| 作用域 | 所有本能随处适用 | 项目作用域 + 全局 |
| 检测 | 无 | git remote URL / 仓库路径 |
| 提升 | 不适用 | 在 2+ 个项目中出现时，项目 → 全局 |
| 命令 | 4个 (status/evolve/export/import) | 6个 (+promote/projects) |
| 跨项目 | 存在污染风险 | 默认隔离 |
## v2 的新特性（对比 v1）
| 特性 | v1 | v2 | | 特性 | v1 | v2 |
|---------|----|----| |---------|----|----|
| 观察 | 停止钩子（会话结束） | 工具使用前/后（100% 可靠） | | 观察 | 停止钩子（会话结束） | PreToolUse/PostToolUse (100% 可靠) |
| 分析 | 主上下文 | 后台代理（Haiku） | | 分析 | 主上下文 | 后台代理 (Haiku) |
| 粒度 | 完整技能 | 原子化的“本能” | | 粒度 | 完整技能 | 原子化“本能” |
| 置信度 | 无 | 0.3-0.9 加权 | | 置信度 | 无 | 0.3-0.9 加权 |
| 演进 | 直接到技能 | 本能 → 聚类 → 技能/命令/代理 | | 进化 | 直接进化为技能 | 本能 -> 聚类 -> 技能/命令/代理 |
| 共享 | 无 | 导出/导入本能 | | 共享 | 无 | 导出/导入本能 |
## 本能模型 ## 本能模型
@@ -41,6 +56,9 @@ trigger: "when writing new functions"
confidence: 0.7 confidence: 0.7
domain: "code-style" domain: "code-style"
source: "session-observation" source: "session-observation"
scope: project
project_id: "a1b2c3d4e5f6"
project_name: "my-react-app"
--- ---
# Prefer Functional Style # Prefer Functional Style
@@ -55,51 +73,69 @@ Use functional patterns over classes when appropriate.
**属性：** **属性：**
* **原子性** — 一个触发条件，一个动作 * **原子化** -- 一个触发条件，一个动作
* **置信度加权** — 0.3 = 尝试性的，0.9 = 近乎确定 * **置信度加权** -- 0.3 = 试探性，0.9 = 几乎确定
* **领域标记** — 代码风格、测试、git、调试、工作流等 * **领域标记** -- 代码风格、测试、git、调试、工作流等
* **证据支持** — 追踪是哪些观察创建了它 * **有证据支持** -- 追踪是哪些观察创建了它
* **作用域感知** -- `project` (默认) 或 `global`
## 工作原理 ## 工作原理
``` ```
Session Activity Session Activity (in a git repo)
│ |
│ Hooks capture prompts + tool use (100% reliable) | Hooks capture prompts + tool use (100% reliable)
▼ | + detect project context (git remote / repo path)
┌─────────────────────────────────────────┐ v
│ observations.jsonl │ +---------------------------------------------+
│ (prompts, tool calls, outcomes) │ | projects/<project-hash>/observations.jsonl |
└─────────────────────────────────────────┘ | (prompts, tool calls, outcomes, project) |
│ +---------------------------------------------+
│ Observer agent reads (background, Haiku) |
▼ | Observer agent reads (background, Haiku)
┌─────────────────────────────────────────┐ v
│ PATTERN DETECTION │ +---------------------------------------------+
│ • User corrections → instinct │ | PATTERN DETECTION |
│ • Error resolutions → instinct │ | * User corrections -> instinct |
│ • Repeated workflows → instinct │ | * Error resolutions -> instinct |
└─────────────────────────────────────────┘ | * Repeated workflows -> instinct |
│ | * Scope decision: project or global? |
│ Creates/updates +---------------------------------------------+
▼ |
┌─────────────────────────────────────────┐ | Creates/updates
│ instincts/personal/ │ v
│ • prefer-functional.md (0.7) │ +---------------------------------------------+
│ • always-test-first.md (0.9) │ | projects/<project-hash>/instincts/personal/ |
│ • use-zod-validation.md (0.6) │ | * prefer-functional.yaml (0.7) [project] |
└─────────────────────────────────────────┘ | * use-react-hooks.yaml (0.9) [project] |
│ +---------------------------------------------+
│ /evolve clusters | instincts/personal/ (GLOBAL) |
▼ | * always-validate-input.yaml (0.85) [global]|
┌─────────────────────────────────────────┐ | * grep-before-edit.yaml (0.6) [global] |
│ evolved/ │ +---------------------------------------------+
│ • commands/new-feature.md │ |
│ • skills/testing-workflow.md │ | /evolve clusters + /promote
│ • agents/refactor-specialist.md │ v
└─────────────────────────────────────────┘ +---------------------------------------------+
| projects/<hash>/evolved/ (project-scoped) |
| evolved/ (global) |
| * commands/new-feature.md |
| * skills/testing-workflow.md |
| * agents/refactor-specialist.md |
+---------------------------------------------+
``` ```
## 项目检测
系统会自动检测您当前的项目：
1. **`CLAUDE_PROJECT_DIR` 环境变量** (最高优先级)
2. **`git remote get-url origin`** -- 哈希化以创建可移植的项目 ID (同一仓库在不同机器上获得相同的 ID)
3. **`git rev-parse --show-toplevel`** -- 使用仓库路径作为后备方案 (机器特定)
4. **全局后备方案** -- 如果未检测到项目，本能将进入全局作用域
每个项目都会获得一个 12 字符的哈希 ID (例如 `a1b2c3d4e5f6`)。`~/.claude/homunculus/projects.json` 处的注册表文件将 ID 映射到人类可读的名称。
## 快速开始 ## 快速开始
### 1. 启用观察钩子 ### 1. 启用观察钩子
@@ -115,14 +151,14 @@ Session Activity
"matcher": "*", "matcher": "*",
"hooks": [{ "hooks": [{
"type": "command", "type": "command",
"command": "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/hooks/observe.sh pre" "command": "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/hooks/observe.sh"
}] }]
}], }],
"PostToolUse": [{ "PostToolUse": [{
"matcher": "*", "matcher": "*",
"hooks": [{ "hooks": [{
"type": "command", "type": "command",
"command": "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/hooks/observe.sh post" "command": "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/hooks/observe.sh"
}] }]
}] }]
} }
@@ -138,14 +174,14 @@ Session Activity
"matcher": "*", "matcher": "*",
"hooks": [{ "hooks": [{
"type": "command", "type": "command",
"command": "~/.claude/skills/continuous-learning-v2/hooks/observe.sh pre" "command": "~/.claude/skills/continuous-learning-v2/hooks/observe.sh"
}] }]
}], }],
"PostToolUse": [{ "PostToolUse": [{
"matcher": "*", "matcher": "*",
"hooks": [{ "hooks": [{
"type": "command", "type": "command",
"command": "~/.claude/skills/continuous-learning-v2/hooks/observe.sh post" "command": "~/.claude/skills/continuous-learning-v2/hooks/observe.sh"
}] }]
}] }]
} }
@@ -154,93 +190,125 @@ Session Activity
### 2. 初始化目录结构 ### 2. 初始化目录结构
Python CLI 会自动创建这些目录，但你也可以手动创建： 系统会在首次使用时自动创建目录，但您也可以手动创建：
```bash ```bash
mkdir -p ~/.claude/homunculus/{instincts/{personal,inherited},evolved/{agents,skills,commands}} # Global directories
touch ~/.claude/homunculus/observations.jsonl mkdir -p ~/.claude/homunculus/{instincts/{personal,inherited},evolved/{agents,skills,commands},projects}
# Project directories are auto-created when the hook first runs in a git repo
``` ```
### 3. 使用本能命令 ### 3. 使用本能命令
```bash ```bash
/instinct-status # Show learned instincts with confidence scores /instinct-status # Show learned instincts (project + global)
/evolve # Cluster related instincts into skills/commands /evolve # Cluster related instincts into skills/commands
/instinct-export # Export instincts for sharing /instinct-export # Export instincts to file
/instinct-import # Import instincts from others /instinct-import # Import instincts from others
/promote # Promote project instincts to global scope
/projects # List all known projects and their instinct counts
``` ```
## 命令 ## 命令
| 命令 | 描述 | | 命令 | 描述 |
|---------|-------------| |---------|-------------|
| `/instinct-status` | 显示所有已习得的本能及其置信度 | | `/instinct-status` | 显示所有本能 (项目作用域 + 全局) 及其置信度 |
| `/evolve` | 将相关本能聚类为技能/命令 | | `/evolve` | 将相关本能聚类成技能/命令，建议提升 |
| `/instinct-export` | 导出本能用于共享 | | `/instinct-export` | 导出本能 (可按作用域/领域过滤) |
| `/instinct-import <file>` | 从他人处导入本能 | | `/instinct-import <file>` | 导入本能 (带作用域控制) |
| `/promote [id]` | 将项目本能提升到全局作用域 |
| `/projects` | 列出所有已知项目及其本能数量 |
## 配置 ## 配置
编辑 `config.json`： 编辑 `config.json` 以控制后台观察器：
```json ```json
{ {
"version": "2.0", "version": "2.1",
"observation": {
"enabled": true,
"store_path": "~/.claude/homunculus/observations.jsonl",
"max_file_size_mb": 10,
"archive_after_days": 7
},
"instincts": {
"personal_path": "~/.claude/homunculus/instincts/personal/",
"inherited_path": "~/.claude/homunculus/instincts/inherited/",
"min_confidence": 0.3,
"auto_approve_threshold": 0.7,
"confidence_decay_rate": 0.05
},
"observer": { "observer": {
"enabled": true, "enabled": false,
"model": "haiku",
"run_interval_minutes": 5, "run_interval_minutes": 5,
"patterns_to_detect": [ "min_observations_to_analyze": 20
"user_corrections",
"error_resolutions",
"repeated_workflows",
"tool_preferences"
]
},
"evolution": {
"cluster_threshold": 3,
"evolved_path": "~/.claude/homunculus/evolved/"
} }
} }
``` ```
| 键 | 默认值 | 描述 |
|-----|---------|-------------|
| `observer.enabled` | `false` | 启用后台观察器代理 |
| `observer.run_interval_minutes` | `5` | 观察器分析观察结果的频率 |
| `observer.min_observations_to_analyze` | `20` | 运行分析所需的最小观察次数 |
其他行为 (观察捕获、本能阈值、项目作用域、提升标准) 通过 `instinct-cli.py` 和 `observe.sh` 中的代码默认值进行配置。
## 文件结构 ## 文件结构
``` ```
~/.claude/homunculus/ ~/.claude/homunculus/
├── identity.json # Your profile, technical level +-- identity.json # Your profile, technical level
├── observations.jsonl # Current session observations +-- projects.json # Registry: project hash -> name/path/remote
├── observations.archive/ # Processed observations +-- observations.jsonl # Global observations (fallback)
├── instincts/ +-- instincts/
│ ├── personal/ # Auto-learned instincts | +-- personal/ # Global auto-learned instincts
│ └── inherited/ # Imported from others | +-- inherited/ # Global imported instincts
└── evolved/ +-- evolved/
├── agents/ # Generated specialist agents | +-- agents/ # Global generated agents
├── skills/ # Generated skills | +-- skills/ # Global generated skills
└── commands/ # Generated commands | +-- commands/ # Global generated commands
+-- projects/
+-- a1b2c3d4e5f6/ # Project hash (from git remote URL)
| +-- observations.jsonl
| +-- observations.archive/
| +-- instincts/
| | +-- personal/ # Project-specific auto-learned
| | +-- inherited/ # Project-specific imported
| +-- evolved/
| +-- skills/
| +-- commands/
| +-- agents/
+-- f6e5d4c3b2a1/ # Another project
+-- ...
``` ```
## 与技能创建器的集成 ## 作用域决策指南
当你使用 [技能创建器 GitHub 应用](https://skill-creator.app) 时，它现在会生成**两者**： | 模式类型 | 作用域 | 示例 |
|-------------|-------|---------|
| 语言/框架约定 | **项目** | "使用 React hooks", "遵循 Django REST 模式" |
| 文件结构偏好 | **项目** | "测试放在 `__tests__`/", "组件放在 src/components/" |
| 代码风格 | **项目** | "使用函数式风格", "首选数据类" |
| 错误处理策略 | **项目** | "对错误使用 Result 类型" |
| 安全实践 | **全局** | "验证用户输入", "清理 SQL" |
| 通用最佳实践 | **全局** | "先写测试", "始终处理错误" |
| 工具工作流偏好 | **全局** | "编辑前先 Grep", "写入前先读取" |
| Git 实践 | **全局** | "约定式提交", "小而专注的提交" |
* 传统的 SKILL.md 文件（用于向后兼容） ## 本能提升 (项目 -> 全局)
* 本能集合（用于 v2 学习系统）
来自仓库分析的本能带有 `source: "repo-analysis"` 标记，并包含源仓库 URL。 当同一个本能在多个项目中以高置信度出现时，它就有资格被提升到全局作用域。
**自动提升标准：**
* 相同的本能 ID 出现在 2+ 个项目中
* 平均置信度 >= 0.8
**如何提升：**
```bash
# Promote a specific instinct
python3 instinct-cli.py promote prefer-explicit-errors
# Auto-promote all qualifying instincts
python3 instinct-cli.py promote
# Preview without changes
python3 instinct-cli.py promote --dry-run
```
`/evolve` 命令也会建议可提升的候选本能。
## 置信度评分 ## 置信度评分
@@ -267,7 +335,7 @@ touch ~/.claude/homunculus/observations.jsonl
## 为什么用钩子而非技能进行观察？ ## 为什么用钩子而非技能进行观察？
> “v1 依赖技能进行观察。技能是概率性的——它们基于 Claude 的判断，大约有 50-80% 的概率触发。” > "v1 依赖技能来观察。技能是概率性的 -- 根据 Claude 的判断，它们触发的概率约为 50-80%。"
钩子**100% 触发**，是确定性的。这意味着： 钩子**100% 触发**，是确定性的。这意味着：
@@ -277,18 +345,20 @@ touch ~/.claude/homunculus/observations.jsonl
## 向后兼容性 ## 向后兼容性
v2 与 v1 完全兼容： v2.1 与 v2.0 和 v1 完全兼容：
* 现有的 `~/.claude/skills/learned/` 技能仍然有效 * `~/.claude/homunculus/instincts/` 中现有的全局本能仍然作为全局本能工作
* 停止钩子仍然运行（但现在也输入到 v2） * 来自 v1 的现有 `~/.claude/skills/learned/` 技能仍然有效
* 渐进式迁移路径：并行运行两者 * 停止钩子仍然运行 (但现在也会输入到 v2)
* 逐步迁移：并行运行两者
## 隐私 ## 隐私
* 观察数据**保留在**你的本地机器上 * 观察结果**本地**保留在您的机器上
* 只有**本能**（模式）可以被导出 * 项目作用域的本能按项目隔离
* 只有**本能** (模式) 可以被导出 — 而不是原始观察数据
* 不会共享实际的代码或对话内容 * 不会共享实际的代码或对话内容
* 你控制导出的内容 * 您控制导出和提升的内容
## 相关链接 ## 相关链接
@@ -298,4 +368,4 @@ v2 与 v1 完全兼容：
*** ***
*基于本能的学习：一次一个观察，教会 Claude 你的模式。* *基于本能的学习：一次一个项目，教会 Claude 您的模式。*

126
docs/zh-CN/skills/continuous-learning-v2/agents/observer.md
View File

@@ -1,8 +1,7 @@
--- ---
name: observer name: observer
description: 背景代理，通过分析会话观察来检测模式并创建本能。使用俳句以实现成本效益。 description: 分析会话观察以检测模式并创建本能的背景代理。使用Haiku以实现成本效益。v2.1版本增加了项目范围的本能。
model: haiku model: haiku
run_mode: background
--- ---
# Observer Agent # Observer Agent
@@ -11,20 +10,22 @@ run_mode: background
## 何时运行 ## 何时运行
* 在显著会话活动后（20+ 工具调用） * 在积累足够多的观察后（可配置，默认 20 条）
* 当用户运行 `/analyze-patterns` 时 * 在计划的时间间隔（可配置，默认 5 分钟）
* 按计划间隔（可配置，默认 5 分钟） * 当通过向观察者进程发送 SIGUSR1 信号手动触发时
* 当被观察钩子触发时 (SIGUSR1)
## 输入 ## 输入
从 `~/.claude/homunculus/observations.jsonl` 读取观察结果： 从**项目作用域**的观察文件中读取观察记录：
* 项目：`~/.claude/homunculus/projects/<project-hash>/observations.jsonl`
* 全局后备：`~/.claude/homunculus/observations.jsonl`
```jsonl ```jsonl
{"timestamp":"2025-01-22T10:30:00Z","event":"tool_start","session":"abc123","tool":"Edit","input":"..."} {"timestamp":"2025-01-22T10:30:00Z","event":"tool_start","session":"abc123","tool":"Edit","input":"...","project_id":"a1b2c3d4e5f6","project_name":"my-react-app"}
{"timestamp":"2025-01-22T10:30:01Z","event":"tool_complete","session":"abc123","tool":"Edit","output":"..."} {"timestamp":"2025-01-22T10:30:01Z","event":"tool_complete","session":"abc123","tool":"Edit","output":"...","project_id":"a1b2c3d4e5f6","project_name":"my-react-app"}
{"timestamp":"2025-01-22T10:30:05Z","event":"tool_start","session":"abc123","tool":"Bash","input":"npm test"} {"timestamp":"2025-01-22T10:30:05Z","event":"tool_start","session":"abc123","tool":"Bash","input":"npm test","project_id":"a1b2c3d4e5f6","project_name":"my-react-app"}
{"timestamp":"2025-01-22T10:30:10Z","event":"tool_complete","session":"abc123","tool":"Bash","output":"All tests pass"} {"timestamp":"2025-01-22T10:30:10Z","event":"tool_complete","session":"abc123","tool":"Bash","output":"All tests pass","project_id":"a1b2c3d4e5f6","project_name":"my-react-app"}
``` ```
## 模式检测 ## 模式检测
@@ -73,28 +74,76 @@ run_mode: background
## 输出 ## 输出
在 `~/.claude/homunculus/instincts/personal/` 中创建/更新本能： 在**项目作用域**的本能目录中创建/更新本能：
* 项目：`~/.claude/homunculus/projects/<project-hash>/instincts/personal/`
* 全局：`~/.claude/homunculus/instincts/personal/`（用于通用模式）
### 项目作用域本能（默认）
```yaml ```yaml
--- ---
id: prefer-grep-before-edit id: use-react-hooks-pattern
trigger: "when searching for code to modify" trigger: "when creating React components"
confidence: 0.65 confidence: 0.65
domain: "workflow" domain: "code-style"
source: "session-observation" source: "session-observation"
scope: project
project_id: "a1b2c3d4e5f6"
project_name: "my-react-app"
--- ---
# Prefer Grep Before Edit # Use React Hooks Pattern
## Action ## Action
Always use Grep to find the exact location before using Edit. Always use functional components with hooks instead of class components.
## Evidence ## Evidence
- Observed 8 times in session abc123 - Observed 8 times in session abc123
- Pattern: Grep → Read → Edit sequence - Pattern: All new components use useState/useEffect
- Last observed: 2025-01-22 - Last observed: 2025-01-22
``` ```
### 全局本能（通用模式）
```yaml
---
id: always-validate-user-input
trigger: "when handling user input"
confidence: 0.75
domain: "security"
source: "session-observation"
scope: global
---
# Always Validate User Input
## Action
Validate and sanitize all user input before processing.
## Evidence
- Observed across 3 different projects
- Pattern: User consistently adds input validation
- Last observed: 2025-01-22
```
## 作用域决策指南
创建本能时，请根据以下经验法则确定其作用域：
| 模式类型 | 作用域 | 示例 |
|-------------|-------|---------|
| 语言/框架约定 | **项目** | "使用 React hooks"、"遵循 Django REST 模式" |
| 文件结构偏好 | **项目** | "测试在 `__tests__`/"、"组件在 src/components/" |
| 代码风格 | **项目** | "使用函数式风格"、"首选数据类" |
| 错误处理策略 | **项目**（通常） | "使用 Result 类型处理错误" |
| 安全实践 | **全局** | "验证用户输入"、"清理 SQL" |
| 通用最佳实践 | **全局** | "先写测试"、"始终处理错误" |
| 工具工作流偏好 | **全局** | "编辑前先 Grep"、"写之前先读" |
| Git 实践 | **全局** | "约定式提交"、"小而专注的提交" |
**如果不确定，默认选择 `scope: project`** — 先设为项目作用域，之后再提升，这比污染全局空间更安全。
## 置信度计算 ## 置信度计算
基于观察频率的初始置信度： 基于观察频率的初始置信度：
@@ -110,35 +159,49 @@ Always use Grep to find the exact location before using Edit.
* 每次矛盾性观察 -0.1 * 每次矛盾性观察 -0.1
* 每周无观察 -0.02（衰减） * 每周无观察 -0.02（衰减）
## 本能提升（项目 → 全局）
当一个本能满足以下条件时，应从项目作用域提升到全局：
1. **相同模式**（通过 id 或类似触发器）存在于 **2 个以上不同的项目**中
2. 每个实例的置信度 **>= 0.8**
3. 其领域属于全局友好列表（安全、通用最佳实践、工作流）
提升操作由 `instinct-cli.py promote` 命令或 `/evolve` 分析处理。
## 重要准则 ## 重要准则
1. **保持保守**：仅为清晰模式（3+ 次观察）创建本能 1. **保持保守**：只为明确的模式（3 次以上观察）创建本能
2. **保持具体**：狭窄的触发器优于宽泛的触发器 2. **保持具体**：狭窄的触发器优于宽泛的触发器
3. **跟踪证据**：始终包含导致本能的观察结果 3. **追踪证据**：始终包含导致该本能的观察记录
4. **尊重隐私**：绝不包含实际代码片段，只包含模式 4. **尊重隐私**：切勿包含实际的代码片段，只包含模式
5. **合并相似项**：如果新本能与现有本能相似，则更新而非重复 5. **合并相似项**：如果新本能与现有本能相似，则更新而非重复创建
6. **默认项目作用域**：除非模式明显是通用的，否则设为项目作用域
7. **包含项目上下文**：对于项目作用域的本能，始终设置 `project_id` 和 `project_name`
## 示例分析会话 ## 示例分析会话
给定观察结果： 给定观察结果：
```jsonl ```jsonl
{"event":"tool_start","tool":"Grep","input":"pattern: useState"} {"event":"tool_start","tool":"Grep","input":"pattern: useState","project_id":"a1b2c3","project_name":"my-app"}
{"event":"tool_complete","tool":"Grep","output":"Found in 3 files"} {"event":"tool_complete","tool":"Grep","output":"Found in 3 files","project_id":"a1b2c3","project_name":"my-app"}
{"event":"tool_start","tool":"Read","input":"src/hooks/useAuth.ts"} {"event":"tool_start","tool":"Read","input":"src/hooks/useAuth.ts","project_id":"a1b2c3","project_name":"my-app"}
{"event":"tool_complete","tool":"Read","output":"[file content]"} {"event":"tool_complete","tool":"Read","output":"[file content]","project_id":"a1b2c3","project_name":"my-app"}
{"event":"tool_start","tool":"Edit","input":"src/hooks/useAuth.ts..."} {"event":"tool_start","tool":"Edit","input":"src/hooks/useAuth.ts...","project_id":"a1b2c3","project_name":"my-app"}
``` ```
分析： 分析：
* 检测到工作流：Grep → Read → Edit * 检测到的工作流：Grep → Read → Edit
* 频率：本次会话中看到 5 次 * 频率：本次会话中观察到 5 次
* **作用域决策**：这是一种通用工作流模式（非项目特定）→ **全局**
* 创建本能： * 创建本能：
* 触发器："when modifying code" * 触发器："当修改代码时"
* 操作："Search with Grep, confirm with Read, then Edit" * 操作："用 Grep 搜索，用 Read 确认，然后 Edit"
* 置信度：0.6 * 置信度：0.6
* 领域："workflow" * 领域："workflow"
* 作用域："global"
## 与 Skill Creator 集成 ## 与 Skill Creator 集成
@@ -146,5 +209,6 @@ Always use Grep to find the exact location before using Edit.
* `source: "repo-analysis"` * `source: "repo-analysis"`
* `source_repo: "https://github.com/..."` * `source_repo: "https://github.com/..."`
* `scope: "project"`（因为它们来自特定的仓库）
这些应被视为具有更高初始置信度（0.7+）的团队/项目约定。 这些应被视为具有更高初始置信度（0.7+）的团队/项目约定。

2
docs/zh-CN/skills/continuous-learning/SKILL.md
View File

@@ -117,4 +117,4 @@ Homunculus v2 采用了更复杂的方法：
4. **领域标记** - 代码风格、测试、git、调试等 4. **领域标记** - 代码风格、测试、git、调试等
5. **演进路径** - 将相关本能聚类为技能/命令 5. **演进路径** - 将相关本能聚类为技能/命令
完整规格请参见：`docs/continuous-learning-v2-spec.md` 参见：`docs/continuous-learning-v2-spec.md` 以获取完整规范。

3
docs/zh-CN/skills/cpp-testing/SKILL.md
View File

@@ -161,7 +161,8 @@ include(FetchContent)
set(GTEST_VERSION v1.17.0) # Adjust to project policy. set(GTEST_VERSION v1.17.0) # Adjust to project policy.
FetchContent_Declare( FetchContent_Declare(
googletest googletest
URL Google Test framework (official repository) https://github.com/google/googletest/archive/refs/tags/${GTEST_VERSION}.zip # Google Test framework (official repository)
URL https://github.com/google/googletest/archive/refs/tags/${GTEST_VERSION}.zip
) )
FetchContent_MakeAvailable(googletest) FetchContent_MakeAvailable(googletest)

52
docs/zh-CN/skills/enterprise-agent-ops/SKILL.md Normal file
View File

@@ -0,0 +1,52 @@
---
name: enterprise-agent-ops
description: 通过可观测性、安全边界和生命周期管理来操作长期运行的代理工作负载。
origin: ECC
---
# 企业级智能体运维
使用此技能用于需要超越单次 CLI 会话操作控制的云托管或持续运行的智能体系统。
## 运维领域
1. 运行时生命周期（启动、暂停、停止、重启）
2. 可观测性（日志、指标、追踪）
3. 安全控制（作用域、权限、紧急停止开关）
4. 变更管理（发布、回滚、审计）
## 基线控制
* 不可变的部署工件
* 最小权限凭证
* 环境级别的密钥注入
* 硬性超时和重试预算
* 高风险操作的审计日志
## 需跟踪的指标
* 成功率
* 每项任务的平均重试次数
* 恢复时间
* 每项成功任务的成本
* 故障类别分布
## 事故处理模式
当故障激增时：
1. 冻结新发布
2. 捕获代表性追踪数据
3. 隔离故障路径
4. 应用最小的安全变更进行修补
5. 运行回归测试 + 安全检查
6. 逐步恢复
## 部署集成
此技能可与以下工具配合使用：
* PM2 工作流
* systemd 服务
* 容器编排器
* CI/CD 门控

35
docs/zh-CN/skills/eval-harness/SKILL.md
View File

@@ -267,3 +267,38 @@ npm test -- --testPathPattern="existing"
状态：可以发布 状态：可以发布
``` ```
## 产品评估 (v1.8)
当单元测试无法单独捕获行为质量时，使用产品评估。
### 评分器类型
1. 代码评分器（确定性断言）
2. 规则评分器（正则表达式/模式约束）
3. 模型评分器（LLM 作为评判者的评估准则）
4. 人工评分器（针对模糊输出的人工裁定）
### pass@k 指南
* `pass@1`：直接可靠性
* `pass@3`：受控重试下的实际可靠性
* `pass^3`：稳定性测试（所有 3 次运行必须通过）
推荐阈值：
* 能力评估：pass@3 >= 0.90
* 回归评估：对于发布关键路径，pass^3 = 1.00
### 评估反模式
* 将提示过度拟合到已知的评估示例
* 仅测量正常路径输出
* 在追求通过率时忽略成本和延迟漂移
* 在发布关卡中允许不稳定的评分器
### 最小评估工件布局
* `.claude/evals/<feature>.md` 定义
* `.claude/evals/<feature>.log` 运行历史
* `docs/releases/<version>/eval-summary.md` 发布快照

2
docs/zh-CN/skills/frontend-slides/SKILL.md
View File

@@ -8,7 +8,7 @@ origin: ECC
创建零依赖、动画丰富的 HTML 演示文稿，完全在浏览器中运行。 创建零依赖、动画丰富的 HTML 演示文稿，完全在浏览器中运行。
灵感来源于 [zarazhangrui](https://github.com/zarazhangrui) 的作品中展示的视觉探索方法。 受 zarazhangrui（鸣谢：@zarazhangrui）作品中展示的视觉探索方法的启发。
## 何时启用 ## 何时启用

33
docs/zh-CN/skills/nanoclaw-repl/SKILL.md Normal file
View File

@@ -0,0 +1,33 @@
---
name: nanoclaw-repl
description: 操作并扩展NanoClaw v2，这是ECC基于claude -p构建的零依赖会话感知REPL。
origin: ECC
---
# NanoClaw REPL
在运行或扩展 `scripts/claw.js` 时使用此技能。
## 能力
* 持久的、基于 Markdown 的会话
* 使用 `/model` 进行模型切换
* 使用 `/load` 进行动态技能加载
* 使用 `/branch` 进行会话分支
* 使用 `/search` 进行跨会话搜索
* 使用 `/compact` 进行历史压缩
* 使用 `/export` 导出为 md/json/txt 格式
* 使用 `/metrics` 查看会话指标
## 操作指南
1. 保持会话聚焦于任务。
2. 在进行高风险更改前进行分支。
3. 在完成主要里程碑后进行压缩。
4. 在分享或存档前进行导出。
## 扩展规则
* 保持零外部运行时依赖
* 保持以 Markdown 作为数据库的兼容性
* 保持命令处理器的确定性和本地性

243
docs/zh-CN/skills/plankton-code-quality/SKILL.md Normal file
View File

@@ -0,0 +1,243 @@
---
name: plankton-code-quality
description: "使用Plankton进行编写时代码质量强制执行——通过钩子在每次文件编辑时自动格式化、代码检查和Claude驱动的修复。"
origin: community
---
# Plankton 代码质量技能
Plankton（作者：@alxfazio）的集成参考，这是一个用于 Claude Code 的编写时代码质量强制执行系统。Plankton 通过 PostToolUse 钩子在每次文件编辑时运行格式化程序和 linter，然后生成 Claude 子进程来修复代理未捕获的违规。
## 何时使用
* 你希望每次文件编辑时都自动格式化和检查（不仅仅是提交时）
* 你需要防御代理修改 linter 配置以通过检查，而不是修复代码
* 你想要针对修复的分层模型路由（简单样式用 Haiku，逻辑用 Sonnet，类型用 Opus）
* 你使用多种语言（Python、TypeScript、Shell、YAML、JSON、TOML、Markdown、Dockerfile）
## 工作原理
### 三阶段架构
每次 Claude Code 编辑或写入文件时，Plankton 的 `multi_linter.sh` PostToolUse 钩子都会运行：
```
Phase 1: Auto-Format (Silent)
├─ Runs formatters (ruff format, biome, shfmt, taplo, markdownlint)
├─ Fixes 40-50% of issues silently
└─ No output to main agent
Phase 2: Collect Violations (JSON)
├─ Runs linters and collects unfixable violations
├─ Returns structured JSON: {line, column, code, message, linter}
└─ Still no output to main agent
Phase 3: Delegate + Verify
├─ Spawns claude -p subprocess with violations JSON
├─ Routes to model tier based on violation complexity:
│ ├─ Haiku: formatting, imports, style (E/W/F codes) — 120s timeout
│ ├─ Sonnet: complexity, refactoring (C901, PLR codes) — 300s timeout
│ └─ Opus: type system, deep reasoning (unresolved-attribute) — 600s timeout
├─ Re-runs Phase 1+2 to verify fixes
└─ Exit 0 if clean, Exit 2 if violations remain (reported to main agent)
```
### 主代理看到的内容
| 场景 | 代理看到 | 钩子退出码 |
|----------|-----------|-----------|
| 无违规 | 无 | 0 |
| 全部由子进程修复 | 无 | 0 |
| 子进程后仍存在违规 | `[hook] N violation(s) remain` | 2 |
| 建议性警告（重复项、旧工具） | `[hook:advisory] ...` | 0 |
主代理只看到子进程无法修复的问题。大多数质量问题都是透明解决的。
### 配置保护（防御规则博弈）
LLM 会修改 `.ruff.toml` 或 `biome.json` 来禁用规则，而不是修复代码。Plankton 通过三层防御阻止这种行为：
1. **PreToolUse 钩子** — `protect_linter_configs.sh` 在编辑发生前阻止对所有 linter 配置的修改
2. **Stop 钩子** — `stop_config_guardian.sh` 在会话结束时通过 `git diff` 检测配置更改
3. **受保护文件列表** — `.ruff.toml`, `biome.json`, `.shellcheckrc`, `.yamllint`, `.hadolint.yaml` 等
### 包管理器强制执行
Bash 上的 PreToolUse 钩子会阻止遗留包管理器：
* `pip`, `pip3`, `poetry`, `pipenv` → 被阻止（使用 `uv`）
* `npm`, `yarn`, `pnpm` → 被阻止（使用 `bun`）
* 允许的例外：`npm audit`, `npm view`, `npm publish`
## 设置
### 快速开始
```bash
# Clone Plankton into your project (or a shared location)
# Note: Plankton is by @alxfazio
git clone https://github.com/alexfazio/plankton.git
cd plankton
# Install core dependencies
brew install jaq ruff uv
# Install Python linters
uv sync --all-extras
# Start Claude Code — hooks activate automatically
claude
```
无需安装命令，无需插件配置。当你运行 Claude Code 时，`.claude/settings.json` 中的钩子会在 Plankton 目录中被自动拾取。
### 按项目集成
要在你自己的项目中使用 Plankton 钩子：
1. 将 `.claude/hooks/` 目录复制到你的项目
2. 复制 `.claude/settings.json` 钩子配置
3. 复制 linter 配置文件（`.ruff.toml`, `biome.json` 等）
4. 为你使用的语言安装 linter
### 语言特定依赖
| 语言 | 必需 | 可选 |
|----------|----------|----------|
| Python | `ruff`, `uv` | `ty`（类型）, `vulture`（死代码）, `bandit`（安全） |
| TypeScript/JS | `biome` | `oxlint`, `semgrep`, `knip`（死导出） |
| Shell | `shellcheck`, `shfmt` | — |
| YAML | `yamllint` | — |
| Markdown | `markdownlint-cli2` | — |
| Dockerfile | `hadolint` (>= 2.12.0) | — |
| TOML | `taplo` | — |
| JSON | `jaq` | — |
## 与 ECC 配对使用
### 互补而非重叠
| 关注点 | ECC | Plankton |
|---------|-----|----------|
| 代码质量强制执行 | PostToolUse 钩子 (Prettier, tsc) | PostToolUse 钩子 (20+ linter + 子进程修复) |
| 安全扫描 | AgentShield, security-reviewer 代理 | Bandit (Python), Semgrep (TypeScript) |
| 配置保护 | — | PreToolUse 阻止 + Stop 钩子检测 |
| 包管理器 | 检测 + 设置 | 强制执行（阻止遗留包管理器） |
| CI 集成 | — | 用于 git 的 pre-commit 钩子 |
| 模型路由 | 手动 (`/model opus`) | 自动（违规复杂度 → 层级） |
### 推荐组合
1. 将 ECC 安装为你的插件（代理、技能、命令、规则）
2. 添加 Plankton 钩子以实现编写时质量强制执行
3. 使用 AgentShield 进行安全审计
4. 在 PR 之前使用 ECC 的 verification-loop 作为最后一道关卡
### 避免钩子冲突
如果同时运行 ECC 和 Plankton 钩子：
* ECC 的 Prettier 钩子和 Plankton 的 biome 格式化程序可能在 JS/TS 文件上冲突
* 解决方案：使用 Plankton 时禁用 ECC 的 Prettier PostToolUse 钩子（Plankton 的 biome 更全面）
* 两者可以在不同的文件类型上共存（ECC 处理 Plankton 未覆盖的内容）
## 配置参考
Plankton 的 `.claude/hooks/config.json` 控制所有行为：
```json
{
"languages": {
"python": true,
"shell": true,
"yaml": true,
"json": true,
"toml": true,
"dockerfile": true,
"markdown": true,
"typescript": {
"enabled": true,
"js_runtime": "auto",
"biome_nursery": "warn",
"semgrep": true
}
},
"phases": {
"auto_format": true,
"subprocess_delegation": true
},
"subprocess": {
"tiers": {
"haiku": { "timeout": 120, "max_turns": 10 },
"sonnet": { "timeout": 300, "max_turns": 10 },
"opus": { "timeout": 600, "max_turns": 15 }
},
"volume_threshold": 5
}
}
```
**关键设置：**
* 禁用你不使用的语言以加速钩子
* `volume_threshold` — 违规数量超过此值自动升级到更高的模型层级
* `subprocess_delegation: false` — 完全跳过第 3 阶段（仅报告违规）
## 环境变量覆盖
| 变量 | 目的 |
|----------|---------|
| `HOOK_SKIP_SUBPROCESS=1` | 跳过第 3 阶段，直接报告违规 |
| `HOOK_SUBPROCESS_TIMEOUT=N` | 覆盖层级超时时间 |
| `HOOK_DEBUG_MODEL=1` | 记录模型选择决策 |
| `HOOK_SKIP_PM=1` | 绕过包管理器强制执行 |
## 参考
* Plankton（作者：@alxfazio）
* Plankton REFERENCE.md — 完整的架构文档（作者：@alxfazio）
* Plankton SETUP.md — 详细的安装指南（作者：@alxfazio）
## ECC v1.8 新增内容
### 可复制的钩子配置文件
设置严格的质量行为：
```bash
export ECC_HOOK_PROFILE=strict
export ECC_QUALITY_GATE_FIX=true
export ECC_QUALITY_GATE_STRICT=true
```
### 语言关卡表
* TypeScript/JavaScript：首选 Biome，Prettier 作为后备
* Python：Ruff 格式/检查
* Go：gofmt
### 配置篡改防护
在质量强制执行期间，标记同一迭代中对配置文件的更改：
* `biome.json`, `.eslintrc*`, `prettier.config*`, `tsconfig.json`, `pyproject.toml`
如果配置被更改以抑制违规，则要求在合并前进行明确审查。
### CI 集成模式
在 CI 中使用与本地钩子相同的命令：
1. 运行格式化程序检查
2. 运行 lint/类型检查
3. 严格模式下快速失败
4. 发布修复摘要
### 健康指标
跟踪：
* 被关卡标记的编辑
* 平均修复时间
* 按类别重复违规
* 因关卡失败导致的合并阻塞

2
docs/zh-CN/skills/postgres-patterns/SKILL.md
View File

@@ -151,4 +151,4 @@ SELECT pg_reload_conf();
*** ***
*基于 [Supabase Agent Skills](Supabase Agent Skills (credit: Supabase team)) (MIT License)* *基于 Supabase 代理技能（致谢：Supabase 团队）（MIT 许可证）*

69
docs/zh-CN/skills/ralphinho-rfc-pipeline/SKILL.md Normal file
View File

@@ -0,0 +1,69 @@
---
name: ralphinho-rfc-pipeline
description: 基于RFC驱动的多智能体DAG执行模式，包含质量门、合并队列和工作单元编排。
origin: ECC
---
# Ralphinho RFC 管道
灵感来源于 [humanplane](https://github.com/humanplane) 风格的 RFC 分解模式和多单元编排工作流。
当一个功能对于单次代理处理来说过于庞大，必须拆分为独立可验证的工作单元时，请使用此技能。
## 管道阶段
1. RFC 接收
2. DAG 分解
3. 单元分配
4. 单元实现
5. 单元验证
6. 合并队列与集成
7. 最终系统验证
## 单元规范模板
每个工作单元应包含：
* `id`
* `depends_on`
* `scope`
* `acceptance_tests`
* `risk_level`
* `rollback_plan`
## 复杂度层级
* 层级 1：独立文件编辑，确定性测试
* 层级 2：多文件行为变更，中等集成风险
* 层级 3：架构/认证/性能/安全性变更
## 每个单元的质量管道
1. 研究
2. 实现计划
3. 实现
4. 测试
5. 审查
6. 合并就绪报告
## 合并队列规则
* 永不合并存在未解决依赖项失败的单元。
* 始终将单元分支变基到最新的集成分支上。
* 每次队列合并后重新运行集成测试。
## 恢复
如果一个单元停滞：
* 从活动队列中移除
* 快照发现结果
* 重新生成范围缩小的单元
* 使用更新的约束条件重试
## 输出
* RFC 执行日志
* 单元记分卡
* 依赖关系图快照
* 集成风险摘要

9
docs/zh-CN/skills/search-first/SKILL.md
View File

@@ -62,10 +62,11 @@ origin: ECC
在编写实用程序或添加功能之前，在脑中过一遍： 在编写实用程序或添加功能之前，在脑中过一遍：
1. 这是常见问题吗？ → 搜索 npm/PyPI 0. 这已经在仓库中存在吗？ → 首先通过相关模块/测试检查 `rg`
2. 有相关的 MCP 吗？ → 检查 `~/.claude/settings.json` 并搜索 1. 这是一个常见问题吗？ → 搜索 npm/PyPI
3. 有相关的技能吗？ → 检查 `~/.claude/skills/` 2. 有对应的 MCP 吗？ → 检查 `~/.claude/settings.json` 并进行搜索
4. 有 GitHub 模板吗？ → 搜索 GitHub 3. 有对应的技能吗？ → 检查 `~/.claude/skills/`
4. 有 GitHub 上的实现/模板吗？ → 在编写全新代码之前，先运行 GitHub 代码搜索以查找维护中的开源项目
### 完整模式（代理） ### 完整模式（代理）

4
docs/zh-CN/the-longform-guide.md
View File

@@ -136,8 +136,8 @@ alias claude-research='claude --system-prompt "$(cat ~/.claude/contexts/research
用 mgrep 替换 grep——与传统 grep 或 ripgrep 相比，平均减少约 50% 的令牌： 用 mgrep 替换 grep——与传统 grep 或 ripgrep 相比，平均减少约 50% 的令牌：
![mgrep Benchmark](../../assets/images/longform/06-mgrep-benchmark.png) ![mgrep 基准测试](../../assets/images/longform/06-mgrep-benchmark.png)
*在我们的 50 项任务基准测试中，mgrep + Claude Code 使用的 token 数量比基于 grep 的工作流少约 2 倍，且判断质量相似或更好。来源：mgrep by @mixedbread-ai* *在我们的 50 个任务基准测试中，mgrep + Claude Code 在相似或更好的判断质量下，使用的 token 数比基于 grep 的工作流少约 2 倍。来源：@mixedbread-ai 的 mgrep*
**模块化代码库的好处：** **模块化代码库的好处：**