aigroup-workflow 2.0.1 → 2.0.2

package/cli/utils/scaffold.mjs

@@ -335,6 +335,8 @@ export function scaffold(pkgRoot, projectRoot, options = {}) {
   }
 
   // 5. Skill 模块（manifest 驱动）
+  // Claude Code 启动自动加载位置：.claude/skills/<name>/SKILL.md
+  // Codex 端按文件路径手动加载，沿用根 skills/<name>/SKILL.md
   const allSkillModules = getSkillModules(pkgRoot)
   const selectedIds = modules || getDefaultSkillModuleIds(pkgRoot)
 
@@ -347,8 +349,19 @@ export function scaffold(pkgRoot, projectRoot, options = {}) {
     if (!modTargets.some(t => targets.includes(t))) continue
 
     let modCopied = 0
-    for (const path of mod.paths) {
-      modCopied += copyDirRecursive(join(pkgRoot, path), join(projectRoot, path), { overwrite })
+    for (const skillPath of mod.paths) {
+      const src = join(pkgRoot, skillPath)
+      // skills/<name> → 根据 target 决定落盘位置
+      // Claude target：.claude/skills/<name>（Claude Code 自动加载）
+      // Codex target：skills/<name>（文件路径手动加载）
+      if (targets.includes('claude')) {
+        const claudeDest = join(projectRoot, skillPath.replace(/^skills\//, '.claude/skills/'))
+        modCopied += copyDirRecursive(src, claudeDest, { overwrite })
+      }
+      if (targets.includes('codex')) {
+        const codexDest = join(projectRoot, skillPath)
+        modCopied += copyDirRecursive(src, codexDest, { overwrite })
+      }
     }
     sections.push({
       name: `skill 模块: ${modId} — ${mod.description || ''}`,
@@ -420,18 +433,21 @@ export function scaffoldUpdate(pkgRoot, projectRoot) {
     totalCopied += codexCopied
   }
 
-  // Skill 模块
+  // Skill 模块（按 target 分流：claude → .claude/skills/，codex → skills/）
   const allSkillModules = getSkillModules(pkgRoot)
   for (const modId of modules) {
     const mod = allSkillModules.find(m => m.id === modId)
     if (!mod) continue
     let modCopied = 0
-    for (const path of mod.paths) {
-      modCopied += copyDirRecursive(
-        join(pkgRoot, path),
-        join(projectRoot, path),
-        { overwrite: true }
-      )
+    for (const skillPath of mod.paths) {
+      const src = join(pkgRoot, skillPath)
+      if (targets.includes('claude')) {
+        const claudeDest = join(projectRoot, skillPath.replace(/^skills\//, '.claude/skills/'))
+        modCopied += copyDirRecursive(src, claudeDest, { overwrite: true })
+      }
+      if (targets.includes('codex')) {
+        modCopied += copyDirRecursive(src, join(projectRoot, skillPath), { overwrite: true })
+      }
     }
     sections.push({ name: `skill 模块: ${modId}`, count: modCopied })
     totalCopied += modCopied

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aigroup-workflow",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "AI 团队协作框架 — 通过角色派遣、工作流管道和 Harness 传感器驱动 AI 协作开发",
   "type": "module",
   "bin": {

package/skills/entropy-management/SKILL.md

@@ -22,7 +22,7 @@ AI Agent 会复制仓库中已有的模式——包括不好的模式。随着
 ## 触发条件
 
 - 完成 5 个以上任务后（定期维护）
-- Kyle 审查中反复出现同类问题（模式漂移信号）
+- `code-reviewer` 审查中反复出现同类问题（模式漂移信号）
 - 用户主动要求代码库健康检查
 - 怀疑文档与代码不一致
 - 新成员加入前（确保仓库状态良好）

package/skills/finishing-a-development-branch/SKILL.md

@@ -22,7 +22,7 @@ description: 当所有实现任务完成并通过审查后使用。验证测试
 
 在使用本技能之前，必须满足：
 - 所有实现任务已完成
-- Kyle 的两阶段审查（规格 + 质量）已通过
+- `code-reviewer` 双阶段审查（Stage 1 规格 + Stage 2 代码质量）已通过
 - 最终整体审查已通过
 
 ## 流程

package/skills/subagent-driven-development/SKILL.md

@@ -5,33 +5,31 @@ description: 当有实现计划且任务相互独立时使用。使用 Agent 工
 
 # 子代理驱动开发
 
-使用 **Agent 工具** 按实现计划逐任务派遣新的隔离子代理（Jarvis）执行，每个任务完成后由审查子代理（Kyle）进行两阶段审查。
+按实现计划逐任务派遣独立子代理执行（实现 + 测试），每任务完成后由 `code-reviewer` 执行两阶段审查。
 
 ## 关键概念：真正的子代理 vs 角色切换
 
 ```
 ❌ 错误方式（角色切换）：
-   主会话 在当前对话里"假装变成 Jarvis"然后开始写代码
-   → 共享上下文、无隔离、主会话 的项目管理视角被污染
+   主会话在当前对话里"假装变成实现 agent"然后开始写代码
+   → 共享上下文、无隔离、协调视角被污染
 
 ✅ 正确方式（Agent 工具派遣）：
-   主会话 调用 Agent({subagent_type: "jarvis", ...}) → 创建独立子代理
-   → 子代理有自己的上下文、技能和门控
-   → 子代理完成后返回结果给 主会话 → 主会话 继续协调
+   主会话调用 Agent({ subagent_type: "tdd-guide", ... }) → 创建独立子代理
+   → 子代理有自己的上下文与工具权限
+   → 子代理完成后返回结果 → 主会话继续协调
 ```
 
-**铁律：主会话 自己绝不写代码。所有开发/审查工作必须通过 Agent 工具委派给隔离的子代理（`.claude/agents/{ella,jarvis,kyle}.md`）。**
+**铁律：主会话不亲自写代码 / 做审查 / 跑测试。所有这些工作通过 Agent 工具委派给隔离的子代理（详见 `.claude/agents/`）。**
 
 ## 铁律
 
-```
-1. 使用 Agent 工具派遣，不是角色切换。主会话 不写代码。
+1. 使用 Agent 工具派遣，不是角色切换
 2. 每个任务一个全新子代理，禁止复用上下文
-3. 两阶段审查顺序不可颠倒：先规格符合性，再代码质量
-4. 审查不通过 = 修复 + 重新审查，不得跳过
+3. 两阶段审查顺序不可颠倒：先规格符合性（Stage 1），再代码质量（Stage 2）
+4. 审查不通过 = 修复 + 重审，不得跳过
 5. 禁止并行派遣多个实现子代理（避免冲突）
-6. 不让子代理自己读计划文件，由 主会话 提取任务全文注入 prompt
-```
+6. 不让子代理自己读计划文件，由主会话提取任务全文注入 prompt
 
 ## 流程
 
@@ -40,171 +38,136 @@ description: 当有实现计划且任务相互独立时使用。使用 Agent 工
 
   ┌──────────── 每个任务循环 ────────────┐
   │                                       │
-  │  Agent 工具派遣 Jarvis（含完整任务）   │
+  │  Agent 派遣实现 agent（含完整任务）   │
   │         ↓                             │
-  │  Jarvis 实现、测试、提交、自检         │
+  │  实现 agent：实现 + 测试 + 自检       │
   │         ↓                             │
-  │  Agent 工具派遣 Kyle：规格符合性审查   │
-  │    ├─ 不通过 → Agent 派遣 Jarvis 修复 │
-  │    └─ 通过 ↓                          │
-  │  Agent 工具派遣 Kyle：代码质量审查     │
-  │    ├─ 不通过 → Agent 派遣 Jarvis 修复 │
-  │    └─ 通过 ↓                          │
+  │  Agent 派遣 code-reviewer             │
+  │  （单次响应输出 Stage 1 + Stage 2）   │
+  │    ├─ Stage 1 不通过 → 派遣实现修复  │
+  │    └─ Stage 1 通过 ↓                  │
+  │    ├─ Stage 2 不通过 → 派遣实现修复  │
+  │    └─ Stage 2 通过 ↓                  │
   │  标记任务完成                          │
   │                                       │
   └───────────────────────────────────────┘
 
-所有任务完成 → 推进到 testing 阶段
+所有任务完成 → 进入测试 / 文档更新 phase
 ```
 
-## 派遣 Jarvis 实现子代理 — 具体操作
+## 派遣实现子代理
 
-主会话 必须使用 **Agent 工具** 派遣 Jarvis。以下是具体的调用方式：
+按任务类型选择 agent：
 
-### 步骤 1：准备 prompt
+| 任务类型 | 派遣 |
+|---------|------|
+| TDD 流程（先写失败测试）| `tdd-guide` |
+| 构建 / 类型 / 依赖错误 | `build-error-resolver` |
+| 死代码清理 / 重构 | `refactor-cleaner` |
+| 文档更新 | `doc-updater` |
+| 关键浏览器路径 | `e2e-runner` |
+| 其他实现工作 | 主对话直接做（不需要切 agent） |
 
-Jarvis 子代理已在 `.claude/agents/jarvis.md` 里定义了身份、门控、必读技能和报告规范，prompt 只需注入**任务本身和上下文**：
+### Prompt 模板
 
-```
-prompt 模板：
+agent 身份 / 工具 / 输出格式已在 `.claude/agents/<name>.md` frontmatter 注入，prompt 只写**任务**和**上下文**：
 
+```
 ## 任务
-[此处粘贴从实现计划中提取的完整任务文本，包含：
-- 要修改的文件和路径
-- 完整代码
-- 测试代码
-- 验证命令和预期输出]
+[从实现计划中粘贴该任务全文：要改的文件 / 完整代码 / 测试 / 验证命令]
 
 ## 上下文
 - 该任务在整体计划中的位置：第 N/M 个任务
-- 设计文档路径：.orchestration/<session>/architect/YYYY-MM-DD-xxx-design.md
-- 实现计划路径：.orchestration/<session>/planner/YYYY-MM-DD-xxx-plan.md
-
-## 工作规范
-- 遵循 TDD：先写失败测试 → 确认失败 → 写最小实现 → 确认通过 → 提交
-- 参照实现计划中的验收条件逐项确认
-```
-
-### 步骤 2：调用 Agent 工具
+- session：<session 名>
+- 设计文档路径：.orchestration/<session>/architect/handoff.md
+- 实现计划路径：.orchestration/<session>/planner/handoff.md
 
-```
-Agent({
-  subagent_type: "jarvis",
-  description: "Jarvis: [任务简述]",
-  prompt: "[上面组装好的 prompt]"
-})
+## 验收
+- 测试全绿（命令 + 输出）
+- 改动文件在 handoff 中列出
 ```
 
-### 步骤 3：处理返回结果
+### 处理返回
 
-子代理完成后会返回结果给 主会话。主会话 根据状态处理：
+| 状态 | 主会话动作 |
+|------|-----------|
+| **DONE** | 派 `code-reviewer` 审查 |
+| **DONE_WITH_CONCERNS** | 先评估疑虑再决定 |
+| **NEEDS_CONTEXT** | 补上下文，重新派遣 |
+| **BLOCKED** | 评估阻塞原因（见下） |
 
-| 状态 | 主会话 的处理方式 |
-|------|-------------|
-| **DONE** | 进入审查：Agent 工具派遣 Kyle |
-| **DONE_WITH_CONCERNS** | 先评估疑虑，再决定是否审查 |
-| **NEEDS_CONTEXT** | 补充上下文，重新 Agent 派遣 |
-| **BLOCKED** | 评估阻塞原因（见下文） |
+**BLOCKED 处理**：
 
-### BLOCKED 处理
+1. 上下文不足 → 补 + 重派
+2. 任务太大 → 拆小再派
+3. 计划本身错 → 回到 `planner` 修计划
+4. **永远不要**忽略阻塞或强推
 
-1. 上下文问题 → 补充上下文，重新派遣
-2. 任务太大 → 拆分为更小的任务
-3. 计划有问题 → 上报给用户讨论
-4. **永远不要**忽略阻塞或强制重试
+## 派遣审查子代理
 
-## 派遣 Kyle 审查子代理 — 具体操作
+### `code-reviewer`（双阶段一次完成）
 
-Kyle 子代理已在 `.claude/agents/kyle.md` 里定义了身份、门控、两阶段审查流程和报告模板，prompt 只需注入**审查基准和对象**：
-
-### Stage 1：规格符合性审查
+agent 在 `.claude/agents/code-reviewer.md` 已规定输出格式包含 Stage 1 + Stage 2，prompt 只写**审查基准**和**对象**：
 
 ```
 Agent({
-  subagent_type: "kyle",
-  description: "Kyle: Stage 1 规格审查 - [功能名]",
-  prompt: "
-## Stage 1：规格符合性审查
-
-审查基准（实现计划规格）：
-[此处粘贴实现计划中该任务的完整规格]
-
-Jarvis 修改的文件：
-[此处列出 Jarvis 报告中的变更文件列表]
-
-设计文档路径：.orchestration/<session>/architect/YYYY-MM-DD-xxx-design.md
-
-### 检查要求
-- 代码是否实现了计划的每条要求？
-- 多做了什么？（未要求的功能 = 需要移除）
-- 少做了什么？（遗漏的需求 = 需要补充）
-
-## 输出
-审查报告保存到 `.orchestration/<session>/code-reviewer/YYYY-MM-DD-xxx-review.md`
-结论：通过 / 不通过（附具体问题清单）
-  "
+  subagent_type: "code-reviewer",
+  description: "Code review: [功能名]",
+  prompt: `
+## 审查基准（Stage 1 用）
+[粘贴实现计划中该任务的完整规格]
+
+## 审查对象
+- 实现 agent 报告的变更文件清单
+- session：<session 名>
+- 设计文档：.orchestration/<session>/architect/handoff.md
+
+主会话会把你的响应抄进 .orchestration/<session>/code-reviewer/handoff.md。
+按 agent frontmatter 规定的格式输出 Stage 1 + Stage 2 + Verdict。
+  `
 })
 ```
 
-### Stage 2：代码质量审查（Stage 1 通过后）
+### 安全敏感时追加 `security-reviewer`
+
+涉及 auth / 支付 / PII / 外部输入 / 加密时，追加：
 
 ```
 Agent({
-  subagent_type: "kyle",
-  description: "Kyle: Stage 2 质量审查 - [功能名]",
-  prompt: "
-## Stage 2：代码质量审查（Stage 1 已通过）
-
-代码变更的 git diff：
-```bash
-git diff HEAD~1
-```
-
-### 检查要求
-- 代码是否干净、可读、可维护？
-- 有无安全隐患？
-- 有无性能问题？
-- 测试是否充分？
-- 命名是否清晰？
-
-## 输出
-在 `.orchestration/<session>/code-reviewer/` 的审查报告中追加 Stage 2 结论
-结论：通过 / 不通过（附问题清单和修复建议）
-  "
+  subagent_type: "security-reviewer",
+  description: "Security review: [功能名]",
+  prompt: "[审查范围 + git diff 引用]"
 })
 ```
 
 ## 审查不通过的修复循环
 
 ```
-Kyle Stage 1 不通过
-  → 主会话 提取问题清单
-  → Agent 派遣新的 Jarvis 子代理修复
-  → Agent 派遣新的 Kyle 重审 Stage 1
-
-Kyle Stage 2 不通过
-  → 主会话 提取问题清单
-  → Agent 派遣新的 Jarvis 子代理修复
-  → Agent 派遣新的 Kyle 重审 Stage 2
+Stage 1 不通过
+  → 主会话提取问题清单
+  → Agent 派遣实现 agent 修复
+  → Agent 派遣新 code-reviewer 重审
+
+Stage 2 不通过
+  → 同上
 ```
 
-**每次修复和重审都是新的 Agent 调用**，不复用之前的子代理。
+**每次修复和重审都是新的 Agent 调用**——不复用之前的子代理。
 
 ## Red Flags — 停下来
 
 | 信号 | 行动 |
 |------|------|
-| 主会话 自己开始写代码 | 停，使用 Agent 工具派遣 Jarvis |
-| 在当前对话中"变成 Jarvis" | 停，这是角色切换不是子代理 |
-| 在 Stage 1 通过前开始 Stage 2 | 停，先完成规格审查 |
-| 审查发现问题但跳过了 | 停，Jarvis 修复后重审 |
+| 主会话自己开始写代码 | 停，派遣实现 agent |
+| "在当前对话中变成 X agent" | 停，这是角色切换不是子代理 |
+| Stage 1 通过前开始 Stage 2 | 停，按 agent 输出格式顺序 |
+| 审查发现问题但跳过 | 停，修复后重审 |
 | 同时派遣多个实现子代理 | 停，一次只能一个 |
-| Jarvis 报告 BLOCKED 但继续强推 | 停，评估阻塞原因 |
-| 没有实现计划就开始执行 | 停，先完成 writing-plans |
+| 实现 agent 报告 BLOCKED 但继续强推 | 停，评估阻塞原因 |
+| 没有实现计划就开始执行 | 停，先 `planner` 出计划 |
 
-## 关联技能
+## 关联
 
-- **writing-plans** — 产出实现计划（本技能的输入）
-- **testing** — 测试验证阶段（本技能完成后的下一阶段）
-- **verification-before-completion** — Jarvis 每个任务完成时必须验证
-- **systematic-debugging** — Jarvis 遇到 Bug 时使用
+- 输入：`writing-plans` / `planner` 产出的实现计划
+- 之后：测试验证 / 文档更新 phase
+- 横切：`verification-before-completion` / `systematic-debugging`

package/skills/writing-plans/SKILL.md

@@ -13,13 +13,13 @@ description: 当你有了设计方案或需求规格，在动手写代码之前
 
 假设执行者是有能力的开发者，但对项目的工具链和问题域几乎一无所知，测试设计能力不强。
 
-**上下文**：此技能应在 brainstorming 技能完成设计批准后调用。
+**上下文**：此技能在需求工程 / 方案设计完成后调用，由 `planner` agent 或主会话使用。
 
-**计划保存到**：`.orchestration/<session>/planner/YYYY-MM-DD-<功能名>-plan.md`
+**产物**：主会话把 planner 响应写入 `.orchestration/<session>/planner/handoff.md`。
 
 ## 范围检查
 
-如果设计方案覆盖了多个独立子系统，应该在 brainstorming 阶段就拆分为子项目。
+如果设计方案覆盖了多个独立子系统，应该在需求工程阶段就拆分为子项目。
 如果没有拆分，建议分成独立的计划——每个子系统一个。每个计划应能独立产出可工作、可测试的软件。
 
 ## 文件结构
@@ -57,7 +57,7 @@ description: 当你有了设计方案或需求规格，在动手写代码之前
 
 **技术栈**：[关键技术/库]
 
-**设计文档**：[链接到 brainstorming 产出的设计文档]
+**设计文档**：`.orchestration/<session>/architect/handoff.md`
 
 ---
 ```
@@ -137,21 +137,21 @@ git commit -m "feat: 添加某功能"
 
 保存计划后，向用户提供执行选项：
 
-> "计划已保存到 `.orchestration/<session>/planner/<文件名>.md`。推荐执行方式：
+> "计划已保存到 `.orchestration/<session>/planner/handoff.md`。推荐执行方式：
 >
-> **子代理驱动（推荐）** — 主会话按任务派遣 Jarvis 执行，每任务独立上下文，Kyle 两阶段审查
+> **子代理驱动（推荐）** — 主会话按任务派遣实现 agent（如 `tdd-guide`）执行，每任务独立上下文，`code-reviewer` 双阶段审查
 >
 > 确认后开始执行？"
 
 **如果选择子代理驱动：**
-- 使用 subagent-driven-development 技能
-- 每任务派遣新的 Jarvis 子代理 + Kyle 两阶段审查
+- 加载 `subagent-driven-development` 技能
+- 每任务派遣新的实现 agent + `code-reviewer` 双阶段审查
 
 ## Red Flags — 停下来
 
 | 信号 | 行动 |
 |------|------|
-| 没有设计方案就开始写计划 | 停下来，先完成 brainstorming |
+| 没有设计方案就开始写计划 | 停下来，先完成需求工程 / architect 设计 |
 | 任务步骤没有代码块 | 不合格，补上完整代码 |
 | 出现"待定""TODO"等占位符 | 不合格，现在就确定内容 |
 | 计划没有引用设计文档 | 在计划头补上设计文档链接 |
@@ -160,6 +160,7 @@ git commit -m "feat: 添加某功能"
 
 ## 关联技能
 
-- **brainstorming** — 产出设计方案（本技能的输入）
+- **requirement-engineering** — 产出需求文档（本技能的输入）
+- **architecture-designer** — 方案 / ADR（本技能的另一输入）
 - **subagent-driven-development** — 执行本计划（本技能的输出）
 - **verification-before-completion** — 每个任务完成时验证