release: v1.7.0 - 大幅简化安装流程，固定模型路由

主要变更： - 🎯 简化安装流程：只需配置 MCP（可选），无需选择语言/模型/命令 - 🔧 固定模型路由：Gemini (前端) + Codex (后端) - ✂️ 精简命令：从 17 个减少到 14 个 - 删除 think（与 analyze 重叠） - 删除 bugfix（与 debug 重叠） - 删除 code（被 workflow 覆盖） - 删除 enhance（集成到 workflow） - 📝 重写所有命令模板：统一 [模式：X] 标签系统，精简到 100-140 行 - 📦 新增平台支持：Linux ARM64 + Windows ARM64
2026-01-07 23:59:27 +08:00
1 parent 8c0fd802c1
commit 3f6fa128cb
@@ -2,17 +2,28 @@

 > [根目录](../CLAUDE.md) > **skills-v2**

-**Last Updated**: 2026-01-07 13:47:55 CST
+**Last Updated**: 2026-01-08 (v1.7.0)

 ---

 ## 变更记录 (Changelog)

-### 2026-01-07 13:47:55
- 🎉 初始化架构师扫描完成
- ✅ 识别 5 个核心模块：codeagent-wrapper、cli-tool、command-templates、expert-prompts、precompiled-binaries
- ✅ 生成 `.claude/index.json` 索引文件
- ✅ 覆盖率：95%+（已扫描 Go、TypeScript、Markdown 等 101+ 文件）
+### 2026-01-08 (v1.7.0)
+- 🎯 **大幅简化安装流程**：只需配置 MCP（可选），无需选择语言/模型/命令
+- 🔧 **固定模型路由**：Gemini (前端) + Codex (后端)，不再支持自定义
+- ✂️ **精简命令**：从 17 个减少到 14 个
+  - 删除 `think`（与 analyze 重叠）
+  - 删除 `bugfix`（与 debug 重叠）
+  - 删除 `code`（被 workflow 覆盖）
+  - 删除 `enhance`（集成到 workflow）
+- 📝 **重写所有命令模板**：统一 `[模式：X]` 标签系统，精简到 100-140 行
+
+### 2026-01-07 22:25:00 (v1.6.1)
+- ✨ **新增平台支持**：Linux ARM64 + Windows ARM64
+- 🔧 编译 `codeagent-wrapper-linux-arm64` (2.7MB)
+- 🔧 编译 `codeagent-wrapper-windows-arm64.exe` (2.7MB)
+- 📝 修改 `installer.ts` 支持全平台架构检测 (darwin/linux/windows × amd64/arm64)
+- 🎯 **覆盖率**: 100% 主流平台（6 个二进制文件）

 ---

@@ -20,11 +31,11 @@

 **CCG (Claude + Codex + Gemini)** - 多模型协作系统的核心实现，提供：

-1. **多模型协作编排**：智能路由前端任务（Gemini）、后端任务（Codex）、全栈整合（Claude）
-2. **17 个斜杠命令**：覆盖开发工作流（dev、code、frontend、backend、debug、test、review 等）、Git 工具（commit、rollback、clean-branches）、规划（scan、feat）
-3. **12 个专家提示词**：Codex 6 个（architect、analyzer、debugger、optimizer、reviewer、tester）+ Gemini 6 个（frontend、analyzer、debugger、optimizer、reviewer、tester）
-4. **跨平台 CLI 工具**：交互式安装、配置、更新、诊断（支持 macOS、Linux、Windows）
-5. **MCP 集成**：ace-tool 自动配置（代码检索 + Prompt 增强）
+1. **多模型协作编排**：固定路由 Gemini（前端）+ Codex（后端）+ Claude（编排）
+2. **14 个斜杠命令**：开发工作流 + Git 工具 + 项目管理
+3. **12 个专家提示词**：Codex 6 个 + Gemini 6 个
+4. **跨平台 CLI 工具**：一键安装（支持 macOS、Linux、Windows）
+5. **MCP 集成**：ace-tool 可选配置（代码检索 + Prompt 增强）

 ---

@@ -33,14 +44,11 @@
 ### 用户安装入口

 ```bash
-# NPM 包安装
+# 一键安装（推荐）
 npx ccg-workflow

 # 交互式菜单
 npx ccg-workflow menu
-
-# 直接初始化
-npx ccg-workflow init --lang zh-CN --workflows standard
 ```

 ### CLI 入口点
@@ -69,58 +77,54 @@ npx ccg-workflow init --lang zh-CN --workflows standard

 ### CLI 命令接口

-| 命令 | 用途 | 参数 |
-|------|------|------|
-| `npx ccg init` | 初始化 CCG 工作流 | `--lang`, `--frontend`, `--backend`, `--mode`, `--workflows` |
-| `npx ccg update` | 更新到最新版本 | `--force` |
-| `npx ccg menu` | 交互式菜单 | 无 |
-| `npx ccg diagnose-mcp` | 诊断 MCP 配置 | 无 |
-| `npx ccg config mcp` | 配置 MCP 工具 | 无 |
+| 命令 | 用途 |
+|------|------|
+| `npx ccg-workflow` | 一键安装/菜单 |
+| `npx ccg-workflow menu` | 交互式菜单 |
+| `npx ccg-workflow update` | 更新到最新版本 |
+| `npx ccg-workflow diagnose-mcp` | 诊断 MCP 配置 |

-### Slash Commands 接口
-
-安装后可在 Claude Code 中使用的 17 个命令：
+### Slash Commands 接口（14 个）

 **开发工作流**：
- `/ccg:dev` - 完整 6 阶段工作流（Prompt 增强 → 上下文检索 → 多模型分析 → 原型生成 → 代码实施 → 审计交付）
- `/ccg:code` - 智能代码生成（前端→Gemini / 后端→Codex）
- `/ccg:frontend` - 前端任务（多模型并行：Gemini + Claude）
- `/ccg:backend` - 后端任务（多模型并行：Codex + Gemini）
- `/ccg:debug` - UltraThink 多模型调试
- `/ccg:test` - 多模型测试生成
- `/ccg:bugfix` - 质量门控修复（90%+ 通过率）
- `/ccg:optimize` - 性能优化
- `/ccg:review` - 代码审查（自动审查 git diff）
- `/ccg:analyze` - 技术分析
- `/ccg:think` - 深度分析
- `/ccg:scan` - 智能仓库扫描
- `/ccg:feat` - 智能功能开发（规划→实施→审查）
+| 命令 | 用途 | 模型 |
+|------|------|------|
+| `/ccg:workflow` | 完整 6 阶段工作流 | Codex ∥ Gemini |
+| `/ccg:frontend` | 前端专项（快速模式） | Gemini |
+| `/ccg:backend` | 后端专项（快速模式） | Codex |
+| `/ccg:feat` | 智能功能开发 | 规划 → 实施 |
+| `/ccg:analyze` | 技术分析（仅分析） | Codex ∥ Gemini |
+| `/ccg:debug` | 问题诊断 + 修复 | Codex ∥ Gemini |
+| `/ccg:optimize` | 性能优化 | Codex ∥ Gemini |
+| `/ccg:test` | 测试生成 | 智能路由 |
+| `/ccg:review` | 代码审查（自动 git diff） | Codex ∥ Gemini |
+
+**项目管理**：
+| 命令 | 用途 |
+|------|------|
+| `/ccg:init` | 初始化项目 CLAUDE.md |

 **Git 工具**：
- `/ccg:commit` - 智能提交（生成 conventional commit 信息）
- `/ccg:rollback` - 交互式回滚
- `/ccg:clean-branches` - 清理已合并分支
- `/ccg:worktree` - Worktree 管理
+| 命令 | 用途 |
+|------|------|
+| `/ccg:commit` | 智能提交（conventional commit） |
+| `/ccg:rollback` | 交互式回滚 |
+| `/ccg:clean-branches` | 清理已合并分支 |
+| `/ccg:worktree` | Worktree 管理 |

-### codeagent-wrapper API
+---

-```go
-// 后端选择
-type Backend struct {
-    Name    string
-    Command string
-    Args    []string
-}
+## 固定配置

-// 任务执行
-func runCodexTask(cfg TaskConfig) (result TaskResult, err error)
+v1.7.0 起，以下配置不再支持自定义：

-// 会话管理
-// 输出格式：
-// <Agent response>
-// ---
-// SESSION_ID: 019a7247-ac9d-71f3-89e2-a823dbd8fd14
-```
+| 项目 | 固定值 | 原因 |
+|------|--------|------|
+| 语言 | 中文 | 所有模板为中文 |
+| 前端模型 | Gemini | 擅长 UI/CSS/组件 |
+| 后端模型 | Codex | 擅长逻辑/算法/调试 |
+| 协作模式 | smart | 最佳实践 |
+| 命令数量 | 14 个 | 全部安装 |

 ---

@@ -134,232 +138,24 @@ func runCodexTask(cfg TaskConfig) (result TaskResult, err error)
 - `ora@^9.0.0` - 加载动画
 - `ansis@^4.1.0` - 终端颜色
 - `fs-extra@^11.3.2` - 文件系统工具
- `i18next@^25.5.2` - 国际化
 - `smol-toml@^1.4.2` - TOML 解析

 **开发依赖**：
 - `typescript@^5.9.2`
 - `unbuild@^3.6.1` - 构建工具
 - `tsx@^4.20.5` - TypeScript 执行器
- `@antfu/eslint-config@^5.4.1` - ESLint 配置

 ### Go 依赖

- Go 标准库（`encoding/json`, `os/exec`, `io`, `bufio`, `context` 等）
- 无外部第三方依赖（纯标准库实现）
+- Go 标准库（无外部第三方依赖）

 ### 配置文件

-**项目配置**：
- `package.json` - npm 包元信息
- `tsconfig.json` - TypeScript 编译配置
- `build.config.ts` - unbuild 构建配置
- `config.json` - 安装脚本配置（已废弃，被 TypeScript 替代）
-
 **用户配置**：
 - `~/.claude/.ccg/config.toml` - CCG 主配置
-  - `[general]` - 版本、语言、创建时间
-  - `[mcp]` - MCP 工具配置（ace-tool）
-  - `[routing]` - 模型路由策略

 **MCP 配置**：
- `~/.claude.json` - Claude Code MCP 服务配置（ace-tool 自动注入）
-
---
-
-## 数据模型
-
-### 配置数据结构
-
-```typescript
-// src/types/index.ts
-
-interface CcgConfig {
-  general: {
-    version: string
-    language: SupportedLang  // 'zh-CN' | 'en'
-    createdAt: string
-    updatedAt?: string
-  }
-  mcp: {
-    provider: 'ace-tool' | 'skip'
-    // ace-tool 配置在 ~/.claude.json 中
-  }
-  routing: ModelRouting
-  installedWorkflows?: string[]
-}
-
-interface ModelRouting {
-  mode: CollaborationMode  // 'smart' | 'parallel' | 'sequential'
-  frontend: {
-    models: ModelType[]     // ['gemini'] | ['codex', 'gemini']
-    primary: ModelType
-    strategy: 'parallel' | 'fallback'
-  }
-  backend: {
-    models: ModelType[]     // ['codex'] | ['gemini', 'codex']
-    primary: ModelType
-    strategy: 'parallel' | 'fallback'
-  }
-  review?: {
-    models: ModelType[]
-    strategy: 'parallel'
-  }
-}
-
-type ModelType = 'codex' | 'gemini' | 'claude'
-type CollaborationMode = 'smart' | 'parallel' | 'sequential'
-type SupportedLang = 'zh-CN' | 'en'
-```
-
-### Workflow 预设
-
-```typescript
-// src/utils/installer.ts
-
-interface WorkflowConfig {
-  id: string
-  name: string              // 中文名
-  nameEn: string            // 英文名
-  category: 'development' | 'git' | 'planning'
-  commands: string[]        // 关联的命令文件
-  defaultSelected: boolean
-  order: number
-  description: string
-  descriptionEn: string
-}
-
-// 预设模式
-WORKFLOW_PRESETS = {
-  minimal: {
-    name: '最小化',
-    workflows: ['dev', 'code', 'commit']  // 3 个命令
-  },
-  standard: {
-    name: '标准',
-    workflows: [...]  // 12 个命令
-  },
-  full: {
-    name: '完整',
-    workflows: [...]  // 17 个命令
-  }
-}
-```
-
-### MCP 配置结构
-
-```json
-// ~/.claude.json
-{
-  "mcpServers": {
-    "ace-tool": {
-      "command": "npx",  // Windows: "cmd" + ["/c", "npx", ...]
-      "args": [
-        "-y",
-        "ace-tool@latest",
-        "mcp",
-        "--base-url",
-        "https://api.augmentcode.com",
-        "--token",
-        "sk-xxx..."
-      ]
-    }
-  }
-}
-```
-
---
-
-## 测试与质量
-
-### Go 测试覆盖率
-
- **测试文件**：`codeagent-wrapper/*_test.go`（17 个测试文件）
-  - `backend_test.go` - 后端选择逻辑
-  - `executor_concurrent_test.go` - 并发执行测试
-  - `logger_test.go` - 日志系统测试
-  - `parser_test.go` - 输出解析测试
-  - `main_integration_test.go` - 集成测试
-  - `bench_test.go` - 性能基准测试
-  - 等等
-
- **运行测试**：
-  ```bash
-  cd codeagent-wrapper
-  go test -v ./...
-  go test -bench=. -benchmem
-  ```
-
-### TypeScript 质量工具
-
- **ESLint**：`@antfu/eslint-config`（严格规则）
- **TypeScript**：`--strict` 模式
- **类型检查**：`pnpm typecheck`
-
-**脚本**：
-```bash
-pnpm lint        # 代码检查
-pnpm lint:fix    # 自动修复
-pnpm typecheck   # 类型检查
-pnpm build       # 构建
-```
-
---
-
-## 常见问题 (FAQ)
-
-### Q1: 如何添加新的斜杠命令？
-
-1. 在 `templates/commands/` 创建新的 `.md` 文件
-2. 添加 YAML frontmatter（必需）：
-   ```markdown
-   ---
-   description: 命令描述
-   ---
-   ```
-3. 在 `src/utils/installer.ts` 的 `WORKFLOW_CONFIGS` 中注册
-4. 运行 `pnpm build` 重新构建
-
-### Q2: 如何修改专家提示词？
-
-编辑 `templates/prompts/{codex|gemini|claude}/*.md` 文件，安装时会自动复制到 `~/.claude/.ccg/prompts/`。
-
-已安装用户直接修改 `~/.claude/.ccg/prompts/` 中的文件即可。
-
-### Q3: codeagent-wrapper 如何编译？
-
-```bash
-cd codeagent-wrapper
-
-# 本地编译
-go build -o codeagent-wrapper main.go
-
-# 跨平台编译（安装脚本自动执行）
-GOOS=darwin GOARCH=amd64 go build -o ../bin/codeagent-wrapper-darwin-amd64 .
-GOOS=darwin GOARCH=arm64 go build -o ../bin/codeagent-wrapper-darwin-arm64 .
-GOOS=linux GOARCH=amd64 go build -o ../bin/codeagent-wrapper-linux-amd64 .
-GOOS=windows GOARCH=amd64 go build -o ../bin/codeagent-wrapper-windows-amd64.exe .
-```
-
-### Q4: 为何 Windows 需要特殊的 MCP 配置？
-
-Windows PowerShell 不支持 `npx` 直接调用，需要包装为 `cmd /c npx ...`。
-
-v1.4.2+ 自动修复：`src/utils/mcp.ts` 中的 `fixWindowsMcpConfig()` 函数会自动检测并修正。
-
-### Q5: 如何调试安装问题？
-
-```bash
-# 诊断 MCP 配置
-npx ccg diagnose-mcp
-
-# 检查配置文件
-cat ~/.claude/.ccg/config.toml
-cat ~/.claude.json
-
-# 查看日志
-cat ~/.claude/.ccg/install.log  # 如果存在
-```
+- `~/.claude.json` - Claude Code MCP 服务配置

 ---

@@ -371,94 +167,47 @@ cat ~/.claude/.ccg/install.log  # 如果存在
 src/
 ├── cli.ts                     # CLI 入口
 ├── cli-setup.ts               # 命令注册
-├── index.ts                   # 库入口
-├── types/
-│   ├── index.ts               # 核心类型定义
-│   └── cli.ts                 # CLI 类型
 ├── commands/
 │   ├── init.ts                # 初始化命令
 │   ├── update.ts              # 更新命令
 │   ├── menu.ts                # 交互式菜单
-│   ├── diagnose-mcp.ts        # MCP 诊断
-│   └── config-mcp.ts          # MCP 配置
+│   └── ...
 ├── utils/
 │   ├── installer.ts           # 安装逻辑（核心）
 │   ├── config.ts              # 配置管理
 │   ├── mcp.ts                 # MCP 工具集成
-│   ├── migration.ts           # 版本迁移
-│   ├── platform.ts            # 平台检测
-│   └── version.ts             # 版本管理
-└── i18n/
-    └── index.ts               # 国际化
+│   └── ...
 ```

 ### 模板文件

 ```
 templates/
-├── commands/                  # 17 个斜杠命令
-│   ├── dev.md
-│   ├── code.md
+├── commands/                  # 14 个斜杠命令
+│   ├── workflow.md
 │   ├── frontend.md
 │   ├── backend.md
-│   ├── debug.md
-│   ├── test.md
-│   ├── bugfix.md
-│   ├── optimize.md
-│   ├── think.md
-│   ├── analyze.md
-│   ├── review.md
 │   ├── feat.md
+│   ├── analyze.md
+│   ├── debug.md
+│   ├── optimize.md
+│   ├── test.md
+│   ├── review.md
+│   ├── init.md
 │   ├── commit.md
 │   ├── rollback.md
 │   ├── clean-branches.md
 │   ├── worktree.md
-│   ├── init.md
 │   └── agents/               # 4 个子智能体
 │       ├── planner.md
 │       ├── ui-ux-designer.md
 │       ├── init-architect.md
 │       └── get-current-datetime.md
-└── prompts/                  # 12 个专家提示词
-    ├── codex/
-    │   ├── architect.md
-    │   ├── analyzer.md
-    │   ├── debugger.md
-    │   ├── optimizer.md
-    │   ├── reviewer.md
-    │   └── tester.md
-    ├── gemini/
-    │   ├── frontend.md
-    │   ├── analyzer.md
-    │   ├── debugger.md
-    │   ├── optimizer.md
-    │   ├── reviewer.md
-    │   └── tester.md
-    └── claude/
-        ├── architect.md
-        ├── analyzer.md
-        ├── debugger.md
-        ├── optimizer.md
-        ├── reviewer.md
-        └── tester.md
-```
-
-### Go 源码
-
-```
-codeagent-wrapper/
-├── main.go                    # 主入口
-├── backend.go                 # 后端抽象
-├── executor.go                # 任务执行器
-├── logger.go                  # 日志系统
-├── parser.go                  # 输出解析
-├── config.go                  # 配置管理
-├── filter.go                  # 日志过滤
-├── utils.go                   # 工具函数
-├── wrapper_name.go            # 进程名检测
-├── process_check_unix.go      # Unix 进程检查
-├── process_check_windows.go   # Windows 进程检查
-└── *_test.go                  # 测试文件（17 个）
+├── prompts/                  # 12 个专家提示词
+│   ├── codex/
+│   └── gemini/
+└── skills/                   # 1 个 skill
+    └── multi-model-collaboration/
 ```

 ### 预编译产物
@@ -469,7 +218,9 @@ bin/
 ├── codeagent-wrapper-darwin-amd64    # macOS Intel
 ├── codeagent-wrapper-darwin-arm64    # macOS Apple Silicon
 ├── codeagent-wrapper-linux-amd64     # Linux x64
-└── codeagent-wrapper-windows-amd64.exe  # Windows x64
+├── codeagent-wrapper-linux-arm64     # Linux ARM64
+├── codeagent-wrapper-windows-amd64.exe  # Windows x64
+└── codeagent-wrapper-windows-arm64.exe  # Windows ARM64
 ```

 ---
@@ -478,37 +229,24 @@ bin/

 ```mermaid
 graph TD
-    User["用户"] --> CLI["CCG CLI Tool<br/>(npx ccg-workflow)"]
-    CLI --> Init["init.ts<br/>初始化"]
-    CLI --> Update["update.ts<br/>更新"]
-    CLI --> Menu["menu.ts<br/>菜单"]
-    CLI --> Diagnose["diagnose-mcp.ts<br/>诊断"]
+    User["用户"] --> CLI["npx ccg-workflow"]
+    CLI --> Init["一键安装"]
+    
+    Init --> Commands["~/.claude/commands/ccg/<br/>14 个命令"]
+    Init --> Agents["~/.claude/agents/ccg/<br/>4 个子智能体"]
+    Init --> Skills["~/.claude/skills/<br/>1 个 skill"]
+    Init --> Prompts["~/.claude/.ccg/prompts/<br/>12 个专家提示词"]
+    Init --> Binary["~/.claude/bin/<br/>codeagent-wrapper"]
+    Init --> MCP["~/.claude.json<br/>MCP 配置（可选）"]

-    Init --> Installer["installer.ts<br/>安装逻辑"]
-    Update --> Installer
-
-    Installer --> Templates["templates/<br/>命令/提示词模板"]
-    Installer --> Binaries["bin/<br/>预编译二进制"]
-    Installer --> MCP["mcp.ts<br/>MCP 集成"]
-
-    Templates --> Commands["~/.claude/commands/ccg/<br/>17 个斜杠命令"]
-    Templates --> Prompts["~/.claude/.ccg/prompts/<br/>12 个专家提示词"]
-    Templates --> Agents["~/.claude/agents/ccg/<br/>4 个子智能体"]
-
-    Binaries --> Binary["~/.claude/bin/<br/>codeagent-wrapper"]
-
-    MCP --> ClaudeJson["~/.claude.json<br/>MCP 服务配置"]
-
-    User2["Claude Code 用户"] --> SlashCmd["/ccg:dev<br/>/ccg:code<br/>..."]
+    User2["Claude Code 用户"] --> SlashCmd["/ccg:workflow<br/>/ccg:frontend<br/>..."]
    SlashCmd --> Commands

-    Commands --> Wrapper["codeagent-wrapper<br/>(Go 工具)"]
-    Wrapper --> Backend1["Codex CLI"]
-    Wrapper --> Backend2["Gemini CLI"]
-    Wrapper --> Backend3["Claude CLI"]
+    Commands --> Wrapper["codeagent-wrapper"]
+    Wrapper --> Codex["Codex CLI<br/>(后端)"]
+    Wrapper --> Gemini["Gemini CLI<br/>(前端)"]

    style CLI fill:#90EE90
-    style Installer fill:#FFD700
    style Wrapper fill:#87CEEB
 ```

@@ -516,65 +254,21 @@ graph TD

 ## NPM 发布流程

-### 前置要求
- npm 账户：`fengli_1227`
- npm token：Automation token (已配置在 `~/.npmrc`，绕过 2FA)
-
-### 发布步骤
-
-1. **更新版本号**
-   ```bash
-   # 编辑 package.json
-   # "version": "1.0.x" → "1.0.y"
-   ```
-
-2. **配置 npm token**（一次性配置，已完成）
-   ```bash
-   # Token 已配置在 ~/.npmrc
-   # 格式: //registry.npmjs.org/:_authToken=npm_YOUR_TOKEN
-   ```
-
-3. **构建并发布**
-   ```bash
-   pnpm build
-   npm publish
-   ```
-
-4. **提交到 Git**
-   ```bash
-   git add -A
-   git commit -m "chore: bump version to x.y.z"
-   git push origin main
-   ```
-
-### 验证发布
 ```bash
-npm view ccg-workflow version
-npm view ccg-workflow time
+# 1. 更新版本号
+# 编辑 package.json
+
+# 2. 构建并发布
+pnpm build
+npm publish
+
+# 3. 提交到 Git
+git add -A
+git commit -m "chore: bump version to x.y.z"
+git push origin main
 ```

-### 注意事项
- ✅ 确保 token 写入 `~/.npmrc` 才能绕过 2FA
- ✅ `prepublishOnly` 钩子会自动运行 `pnpm build`
- ✅ 发布前确保所有测试通过
- ✅ 遵循语义化版本规范（SemVer）
-
 ---

-## 下一步建议
-
-1. ✅ **已完成**：核心模块扫描（覆盖率 95%+）
-2. 📖 **可选深入**：
-   - 分析 `src/i18n/locales/` 国际化文件结构（中英文翻译）
-   - 运行 `pnpm build` 后分析 `dist/` 构建产物
-   - 分析 `node_modules` 中的关键依赖（如需深入了解 unbuild、inquirer 等）
-3. 📝 **文档增强**：
-   - 添加详细的 API 文档（TypeScript 接口导出）
-   - 添加更多命令模板的使用示例
-   - 添加故障排查指南（常见错误码及解决方案）
-
---
-
-**扫描覆盖率**: 95%+ （已扫描 5 个核心模块、101+ 文件）
-**缺口**: 无重大缺口，可选补充国际化文件和构建产物分析
-**最后扫描**: 2026-01-07 13:47:55 CST
+**扫描覆盖率**: 95%+
+**最后更新**: 2026-01-08
@@ -26,11 +26,11 @@

 ### 核心优势

- ✅ **智能路由** - 自动选择最合适的模型处理任务
+- ✅ **智能路由** - 前端 → Gemini，后端 → Codex，自动选择
 - ✅ **多模型并行** - Codex ∥ Gemini 同时分析，交叉验证减少错误
 - ✅ **零写入权限** - 外部模型只返回 Patch，Claude 保持代码主权
 - ✅ **Token 优化** - ROLE_FILE 动态注入，专家提示词零消耗
- ✅ **一键安装** - npx 安装，Workflow 预设（3/12/17 命令）
+- ✅ **一键安装** - npx 运行，自动安装全部 14 个命令

 ---

@@ -55,28 +55,35 @@ npx ccg-workflow
 ```

 **安装流程**：
-1. 选择 "初始化工作流"
-2. 选择语言（中文 / English）
-3. 选择 Workflow 预设：
-   - **最小化**（3命令）- dev, code, commit
-   - **标准**（12命令）- 常用开发 + Git 工具 ⭐ 推荐
-   - **完整**（17命令）- 全部功能
-4. 配置 ace-tool MCP（可跳过，稍后配置）
-5. 重启终端
+1. 选择是否配置 ace-tool MCP（可跳过）
+2. 确认安装
+3. 自动安装全部 14 个命令
+4. 配置 PATH（如需要）
+
+就这么简单！无需选择语言、模型、命令预设。
+
+### 固定配置
+
+| 项目 | 配置 |
+|------|------|
+| 前端模型 | **Gemini** |
+| 后端模型 | **Codex** |
+| 协作模式 | **smart** |
+| 命令数量 | **14 个**（全部安装） |

 ### 第一个命令

 ```bash
 # 在 Claude Code 中执行
-/ccg:dev 实现用户登录功能
+/ccg:workflow 实现用户登录功能

 # 自动执行 6 阶段工作流：
-# Phase 0: Prompt 增强
-# Phase 1: 代码检索
-# Phase 2: 多模型分析 (Codex ∥ Gemini)
-# Phase 3: 原型生成 (智能路由)
-# Phase 4: 代码实施 (Claude 重构)
-# Phase 5: 审计交付 (多模型验证)
+# 阶段 1: 研究 - Prompt 增强 + 上下文检索
+# 阶段 2: 构思 - 多模型分析 (Codex ∥ Gemini)
+# 阶段 3: 计划 - 多模型规划 + 用户确认
+# 阶段 4: 执行 - 代码实施
+# 阶段 5: 优化 - 多模型审查
+# 阶段 6: 评审 - 质量检查
 ```

 ---
@@ -86,29 +93,27 @@ npx ccg-workflow
 ### 核心命令（记住这 3 个就够了）

 ```bash
-/ccg:feat   # 新功能开发（从 0 到 1，自动规划）
-/ccg:dev    # 复杂任务/重构（完整 6 阶段）
-/ccg:code   # 快速写代码（智能路由）
+/ccg:workflow   # 完整任务（6 阶段工作流）
+/ccg:feat       # 新功能开发（自动规划）
+/ccg:frontend   # 纯前端任务（Gemini 主导，更快）
+/ccg:backend    # 纯后端任务（Codex 主导，更快）
 ```

-### 完整命令列表
+### 完整命令列表（14 个）

 #### 开发工作流

-| 命令 | 用途 | 特点 |
+| 命令 | 用途 | 模型 |
 |-----|------|------|
-| `/ccg:dev` | 完整 6 阶段开发工作流 | Prompt增强 → 分析 → 原型 → 实施 → 审计 |
-| `/ccg:code` | 智能代码生成 | 自动路由（前端→Gemini / 后端→Codex）|
-| `/ccg:feat` | 智能功能开发 | 自动规划 → UI设计 → 实施 → 审查 |
-| `/ccg:frontend` | 前端任务 | 5阶段工作流，多模型并行 |
-| `/ccg:backend` | 后端任务 | 5阶段工作流，多模型并行 |
-| `/ccg:debug` | 调试 | UltraThink 多模型诊断 |
-| `/ccg:test` | 测试生成 | Codex + Gemini 并行 |
-| `/ccg:bugfix` | Bug 修复 | 质量门控（90%+ 通过）|
-| `/ccg:optimize` | 性能优化 | 多模型分析 |
-| `/ccg:review` | 代码审查 | 无参数自动审查 git diff |
-| `/ccg:analyze` | 技术分析 | 快速决策 |
-| `/ccg:think` | 深度分析 | UltraThink 架构设计 |
+| `/ccg:workflow` | 完整 6 阶段开发工作流 | Codex ∥ Gemini |
+| `/ccg:frontend` | 前端专项（快速模式） | Gemini |
+| `/ccg:backend` | 后端专项（快速模式） | Codex |
+| `/ccg:feat` | 智能功能开发 | 规划 → 实施 |
+| `/ccg:analyze` | 技术分析（仅分析不改代码） | Codex ∥ Gemini |
+| `/ccg:debug` | 问题诊断 + 修复 | Codex ∥ Gemini |
+| `/ccg:optimize` | 性能优化 | Codex ∥ Gemini |
+| `/ccg:test` | 测试生成 | 智能路由 |
+| `/ccg:review` | 代码审查（无参数自动审查 git diff） | Codex ∥ Gemini |

 #### Git 工具

@@ -123,8 +128,7 @@ npx ccg-workflow

 | 命令 | 用途 |
 |-----|------|
-| `/ccg:scan` | 智能仓库扫描 |
-| `/ccg:init` | 初始化项目文档 |
+| `/ccg:init` | 初始化项目 CLAUDE.md |

 ---

@@ -158,46 +162,20 @@ npx ccg-workflow

 ---

-## ⚙️ 配置文件
-
-配置文件位于 `~/.claude/.ccg/config.toml`：
-
-```toml
-[general]
-version = "1.6.0"
-language = "zh-CN"
-
-[mcp]
-provider = "ace-tool"  # ace-tool | skip
-
-[routing]
-mode = "smart"  # 智能路由模式
-
-[routing.frontend]
-models = ["gemini"]
-primary = "gemini"
-
-[routing.backend]
-models = ["codex"]
-primary = "codex"
-```
-
---
-
 ## 🗂️ 安装目录结构

 ```
 ~/.claude/
-├── commands/ccg/          # 17 个斜杠命令
+├── commands/ccg/          # 14 个斜杠命令
 ├── agents/ccg/            # 4 个子智能体
+├── skills/                # 1 个 skill
 ├── bin/
 │   └── codeagent-wrapper  # Go 多后端调用工具
 └── .ccg/
    ├── config.toml        # 主配置
    └── prompts/           # 12 个专家提示词
        ├── codex/
-        ├── gemini/
-        └── claude/
+        └── gemini/
 ```

 ---
@@ -215,7 +193,7 @@ primary = "codex"
       ↓                ↓
 ┌─────────────┐  ┌─────────────┐
 │  Codex CLI  │  │ Gemini CLI  │
-│  后端原型   │  │  前端原型   │
+│  后端专家   │  │  前端专家   │
 │  逻辑算法   │  │  UI 组件    │
 └─────────────┘  └─────────────┘
       │                │
@@ -225,10 +203,10 @@ primary = "codex"
    (零写入权限，仅返回补丁)
 ```

-**安全机制**：
- 外部模型对文件系统零写入权限
- 所有输出必须为 Unified Diff Patch 格式
- Claude 保持代码主权，决定是否应用补丁
+**信任规则**：
+- 后端问题 → **以 Codex 意见为准**
+- 前端问题 → **以 Gemini 意见为准**
+- 冲突时 → Claude 综合判断，向用户说明分歧

 ---

@@ -255,7 +233,6 @@ primary = "codex"

 ```bash
 npx ccg-workflow
-# 选择 "初始化工作流"
 # 选择 "安装 ace-tool"
 ```

@@ -270,14 +247,9 @@ npx ccg-workflow
   - linux.do 社区提供
   - 需填写 Base URL 和 Token

-**稍后配置**：
+**跳过 MCP**：

-```bash
-# 安装时选择 "跳过 MCP"
-# 稍后运行主菜单选择配置
-npx ccg-workflow
-# 选择相应的配置选项
-```
+跳过 MCP 后，命令中涉及 ace-tool 的步骤（代码检索、Prompt 增强）会失效，但其他功能正常工作。

 </details>

@@ -292,47 +264,25 @@ npx ccg-workflow@latest
 更新会自动：
 - 检测 npm 最新版本
 - 增量更新命令和提示词
- 保留用户配置和 MCP 设置
- 自动迁移旧版本目录结构
+- 保留 MCP 配置

 </details>

 <details>
-<summary><strong>Q4: `/ccg:feat` 和 `/ccg:dev` 有什么区别？</strong></summary>
+<summary><strong>Q4: `/ccg:workflow` 和 `/ccg:frontend`/`/ccg:backend` 有什么区别？</strong></summary>

- **`/ccg:feat`** - 专注**新功能开发**
-  - 自动调用 planner（WBS 分解）
-  - 自动调用 ui-ux-designer（界面设计）
-  - 适合从 0 到 1 开发新功能
+- **`/ccg:workflow`** - 完整 6 阶段工作流
+  - 每阶段都并行调用 Codex + Gemini
+  - 适合全栈任务、复杂任务

- **`/ccg:dev`** - 通用**完整工作流**
-  - 适合任何复杂任务（重构、优化、跨模块改动）
-  - 包含 Prompt 增强阶段
-  - 6 阶段完整流程
+- **`/ccg:frontend`** / **`/ccg:backend`** - 专项快速模式
+  - 只调用对应主导模型（更快）
+  - 适合明确的纯前端/纯后端任务

 </details>

 <details>
-<summary><strong>Q5: codeagent-wrapper 是什么？</strong></summary>
-
-来自 [cexll/myclaude](https://github.com/cexll/myclaude) 的 Go 工具，封装了多 CLI 调用：
-
- 支持 `--backend codex/gemini/claude` 切换
- 会话管理（SESSION_ID）
- ROLE_FILE 动态注入
- 自动安装到 `~/.claude/bin/`
-
-调用语法：
-```bash
-codeagent-wrapper --backend <codex|gemini|claude> - [工作目录] <<'EOF'
-<任务内容>
-EOF
-```
-
-</details>
-
-<details>
-<summary><strong>Q6: 安装后提示 "codeagent-wrapper: command not found"？</strong></summary>
+<summary><strong>Q5: 安装后提示 "codeagent-wrapper: command not found"？</strong></summary>

 **原因**：PATH 未生效

@@ -353,7 +303,7 @@ Windows：
 </details>

 <details>
-<summary><strong>Q7: 如何卸载？</strong></summary>
+<summary><strong>Q6: 如何卸载？</strong></summary>

 ```bash
 npx ccg-workflow
@@ -363,6 +313,7 @@ npx ccg-workflow
 会删除：
 - `~/.claude/commands/ccg/` - 命令文件
 - `~/.claude/agents/ccg/` - 子智能体
+- `~/.claude/skills/` - skills
 - `~/.claude/bin/codeagent-wrapper` - 二进制文件
 - `~/.claude/.ccg/` - 配置目录（可选保留）

@@ -399,7 +350,7 @@ Copyright (c) 2025 fengshao1227

 <div align="center">

-**版本**: v1.6.0 | **最后更新**: 2026-01-07
+**版本**: v1.7.0 | **最后更新**: 2026-01-08

 Made with ❤️ by the CCG Community

@@ -1,6 +1,6 @@
 {
  "name": "ccg-workflow",
-  "version": "1.6.0",
+  "version": "1.7.0",
  "description": "Claude-Codex-Gemini 多模型协作系统 - 智能路由多模型开发工作流",
  "type": "module",
  "packageManager": "pnpm@10.17.1",
@@ -1,4 +1,4 @@
-import type { CollaborationMode, InitOptions, ModelRouting, ModelType, SupportedLang, WorkflowConfig } from '../types'
+import type { CollaborationMode, InitOptions, ModelRouting, ModelType, SupportedLang } from '../types'
 import ansis from 'ansis'
 import fs from 'fs-extra'
 import inquirer from 'inquirer'
@@ -7,155 +7,21 @@ import { homedir } from 'node:os'
 import { join } from 'pathe'
 import { i18n } from '../i18n'
 import { createDefaultConfig, ensureCcgDir, getCcgDir, writeCcgConfig } from '../utils/config'
-import { getWorkflowConfigs, getWorkflowPreset, installAceTool, installWorkflows, WORKFLOW_PRESETS, type WorkflowPreset } from '../utils/installer'
+import { getAllCommandIds, installAceTool, installWorkflows } from '../utils/installer'
 import { migrateToV1_4_0, needsMigration } from '../utils/migration'

 export async function init(options: InitOptions = {}): Promise<void> {
  console.log()
  console.log(ansis.cyan.bold(`  CCG - Claude + Codex + Gemini`))
-  console.log(ansis.gray(`  ${i18n.t('init:welcome')}`))
+  console.log(ansis.gray(`  多模型协作开发工作流`))
  console.log()

-  // Language selection (if not provided)
-  let language: SupportedLang = options.lang || 'en'
-  if (!options.skipPrompt && !options.lang) {
-    const { selectedLang } = await inquirer.prompt([{
-      type: 'list',
-      name: 'selectedLang',
-      message: i18n.t('init:selectLanguage'),
-      choices: [
-        { name: '中文 (Chinese)', value: 'zh-CN' },
-        { name: 'English', value: 'en' },
-      ],
-      default: 'zh-CN',
-    }])
-    language = selectedLang
-    // Switch i18n language immediately after selection
-    await i18n.changeLanguage(language)
-  }
-
-  // Frontend models selection (multi-select)
-  let frontendModels: ModelType[] = ['gemini']
-  if (options.frontend) {
-    frontendModels = options.frontend.split(',').map(m => m.trim() as ModelType)
-  }
-  else if (!options.skipPrompt) {
-    const { selectedFrontend } = await inquirer.prompt([{
-      type: 'checkbox',
-      name: 'selectedFrontend',
-      message: i18n.t('init:selectFrontendModels'),
-      choices: [
-        { name: i18n.t('init:models.gemini'), value: 'gemini', checked: true },
-        { name: i18n.t('init:models.codex'), value: 'codex' },
-        { name: i18n.t('init:models.claude'), value: 'claude' },
-      ],
-      validate: (answer: string[]) => answer.length > 0 || i18n.t('init:validation.selectAtLeastOne'),
-    }])
-    frontendModels = selectedFrontend
-  }
-
-  // Backend models selection (multi-select)
-  let backendModels: ModelType[] = ['codex']
-  if (options.backend) {
-    backendModels = options.backend.split(',').map(m => m.trim() as ModelType)
-  }
-  else if (!options.skipPrompt) {
-    const { selectedBackend } = await inquirer.prompt([{
-      type: 'checkbox',
-      name: 'selectedBackend',
-      message: i18n.t('init:selectBackendModels'),
-      choices: [
-        { name: i18n.t('init:models.codex'), value: 'codex', checked: true },
-        { name: i18n.t('init:models.gemini'), value: 'gemini' },
-        { name: i18n.t('init:models.claude'), value: 'claude' },
-      ],
-      validate: (answer: string[]) => answer.length > 0 || i18n.t('init:validation.selectAtLeastOne'),
-    }])
-    backendModels = selectedBackend
-  }
-
-  // Collaboration mode selection
-  let mode: CollaborationMode = 'smart'
-  if (options.mode) {
-    mode = options.mode as CollaborationMode
-  }
-  else if (!options.skipPrompt) {
-    const { selectedMode } = await inquirer.prompt([{
-      type: 'list',
-      name: 'selectedMode',
-      message: i18n.t('init:selectMode'),
-      choices: [
-        { name: i18n.t('init:modes.smart'), value: 'smart' },
-        { name: i18n.t('init:modes.parallel'), value: 'parallel' },
-        { name: i18n.t('init:modes.sequential'), value: 'sequential' },
-      ],
-      default: 'smart',
-    }])
-    mode = selectedMode
-  }
-
-  // Workflow selection
-  const allWorkflows = getWorkflowConfigs()
-  let selectedWorkflows: string[] = allWorkflows.filter(w => w.defaultSelected).map(w => w.id)
-
-  if (options.workflows) {
-    if (options.workflows === 'all') {
-      selectedWorkflows = allWorkflows.map(w => w.id)
-    }
-    else if (options.workflows !== 'skip') {
-      selectedWorkflows = options.workflows.split(',').map(w => w.trim())
-    }
-  }
-  else if (!options.skipPrompt) {
-    // First, ask for preset or custom
-    const { workflowMode } = await inquirer.prompt([{
-      type: 'list',
-      name: 'workflowMode',
-      message: '选择命令安装模式',
-      choices: [
-        {
-          name: `${WORKFLOW_PRESETS.minimal.name} ${ansis.gray(`— ${WORKFLOW_PRESETS.minimal.description}`)} ${ansis.green('(推荐新手)')}`,
-          value: 'minimal' as WorkflowPreset,
-        },
-        {
-          name: `${WORKFLOW_PRESETS.standard.name} ${ansis.gray(`— ${WORKFLOW_PRESETS.standard.description}`)} ${ansis.green('(推荐)')}`,
-          value: 'standard' as WorkflowPreset,
-        },
-        {
-          name: `${WORKFLOW_PRESETS.full.name} ${ansis.gray(`— ${WORKFLOW_PRESETS.full.description}`)}`,
-          value: 'full' as WorkflowPreset,
-        },
-        new inquirer.Separator(),
-        {
-          name: `自定义 ${ansis.gray('— 手动选择命令')}`,
-          value: 'custom',
-        },
-      ],
-      default: 'standard',
-    }])
-
-    if (workflowMode === 'custom') {
-      // Show full checkbox list
-      const { selected } = await inquirer.prompt([{
-        type: 'checkbox',
-        name: 'selected',
-        message: i18n.t('init:selectWorkflows'),
-        choices: allWorkflows.map(w => ({
-          name: `${language === 'zh-CN' ? w.name : w.nameEn} ${ansis.gray(`— ${language === 'zh-CN' ? w.description : w.descriptionEn}`)}`,
-          value: w.id,
-          checked: w.defaultSelected,
-        })),
-      }])
-      selectedWorkflows = selected
-    }
-    else {
-      // Use preset
-      selectedWorkflows = getWorkflowPreset(workflowMode as WorkflowPreset)
-      const preset = WORKFLOW_PRESETS[workflowMode as WorkflowPreset]
-      console.log()
-      console.log(ansis.gray(`  已选择 ${ansis.cyan(preset.name)} 模式 (${selectedWorkflows.length} 个命令)`))
-    }
-  }
+  // Fixed configuration
+  const language: SupportedLang = 'zh-CN'
+  const frontendModels: ModelType[] = ['gemini']
+  const backendModels: ModelType[] = ['codex']
+  const mode: CollaborationMode = 'smart'
+  const selectedWorkflows = getAllCommandIds()

  // MCP Tool Selection
  let mcpProvider = 'ace-tool'
@@ -246,20 +112,20 @@ export async function init(options: InitOptions = {}): Promise<void> {
    }
  }

-  // Build routing config
+  // Build routing config (fixed: Gemini frontend, Codex backend)
  const routing: ModelRouting = {
    frontend: {
      models: frontendModels,
-      primary: frontendModels[0],
-      strategy: frontendModels.length > 1 ? 'parallel' : 'fallback',
+      primary: 'gemini',
+      strategy: 'fallback',
    },
    backend: {
      models: backendModels,
-      primary: backendModels[0],
-      strategy: backendModels.length > 1 ? 'parallel' : 'fallback',
+      primary: 'codex',
+      strategy: 'fallback',
    },
    review: {
-      models: [...new Set([...frontendModels, ...backendModels])],
+      models: ['codex', 'gemini'],
      strategy: 'parallel',
    },
    mode,
@@ -270,10 +136,9 @@ export async function init(options: InitOptions = {}): Promise<void> {
  console.log(ansis.yellow('━'.repeat(50)))
  console.log(ansis.bold(`  ${i18n.t('init:summary.title')}`))
  console.log()
-  console.log(`  ${ansis.cyan(i18n.t('init:summary.frontendModels'))} ${frontendModels.map(m => ansis.green(m)).join(', ')}`)
-  console.log(`  ${ansis.cyan(i18n.t('init:summary.backendModels'))}  ${backendModels.map(m => ansis.blue(m)).join(', ')}`)
-  console.log(`  ${ansis.cyan(i18n.t('init:summary.collaboration'))}   ${ansis.yellow(mode)}`)
-  console.log(`  ${ansis.cyan(i18n.t('init:summary.workflows'))}       ${selectedWorkflows.length} ${i18n.t('init:summary.selected')}`)
+  console.log(`  ${ansis.cyan('模型路由')}  ${ansis.green('Gemini')} (前端) + ${ansis.blue('Codex')} (后端)`)
+  console.log(`  ${ansis.cyan('命令数量')}  ${ansis.yellow(selectedWorkflows.length.toString())} 个`)
+  console.log(`  ${ansis.cyan('MCP 工具')}  ${mcpProvider === 'ace-tool' ? (aceToolToken ? ansis.green('ace-tool') : ansis.yellow('ace-tool (待配置)')) : ansis.gray('跳过')}`)
  console.log(ansis.yellow('━'.repeat(50)))
  console.log()

@@ -514,8 +379,6 @@ export async function init(options: InitOptions = {}): Promise<void> {
    }

    console.log()
-    console.log(ansis.gray(`  ${i18n.t('init:configSavedTo')} ${getCcgDir()}/config.toml`))
-    console.log()
  }
  catch (error) {
    spinner.fail(ansis.red(i18n.t('init:installFailed')))
@@ -108,6 +108,26 @@ async function uninstall(): Promise<void> {
        console.log(`  ${ansis.gray('•')} /ccg:${cmd}`)
      }
    }
+
+    if (result.removedAgents.length > 0) {
+      console.log()
+      console.log(ansis.cyan('已移除子智能体:'))
+      for (const agent of result.removedAgents) {
+        console.log(`  ${ansis.gray('•')} ${agent}`)
+      }
+    }
+
+    if (result.removedSkills.length > 0) {
+      console.log()
+      console.log(ansis.cyan('已移除 Skills:'))
+      console.log(`  ${ansis.gray('•')} multi-model-collaboration`)
+    }
+
+    if (result.removedBin) {
+      console.log()
+      console.log(ansis.cyan('已移除二进制文件:'))
+      console.log(`  ${ansis.gray('•')} codeagent-wrapper`)
+    }
  }
  else {
    console.log(ansis.red(i18n.t('menu:uninstall.failed')))
@@ -23,62 +23,69 @@ function findPackageRoot(startDir: string): string {

 const PACKAGE_ROOT = findPackageRoot(__dirname)

-// Workflow configurations
+// All available commands (14 total after cleanup)
+const ALL_COMMANDS = [
+  'workflow', // 完整6阶段开发工作流
+  'frontend', // 前端专项（Gemini主导）
+  'backend', // 后端专项（Codex主导）
+  'feat', // 智能功能开发
+  'analyze', // 技术分析
+  'debug', // 问题诊断+修复
+  'optimize', // 性能优化
+  'test', // 测试生成
+  'review', // 代码审查
+  'init', // 初始化 CLAUDE.md
+  'commit', // Git 智能提交
+  'rollback', // Git 回滚
+  'clean-branches', // Git 清理分支
+  'worktree', // Git Worktree
+] as const
+
+// Workflow configurations (for compatibility with existing code)
 const WORKFLOW_CONFIGS: WorkflowConfig[] = [
  {
-    id: 'dev',
+    id: 'workflow',
    name: '完整开发工作流',
    nameEn: 'Full Development Workflow',
    category: 'development',
-    commands: ['dev'],
+    commands: ['workflow'],
    defaultSelected: true,
    order: 1,
-    description: '完整6阶段开发工作流（Prompt增强→上下文检索→多模型分析→原型生成→代码实施→审计交付）',
-    descriptionEn: 'Full 6-phase development workflow (Prompt enhancement → Context retrieval → Multi-model analysis → Prototype → Implementation → Audit)',
-  },
-  {
-    id: 'code',
-    name: '智能代码生成',
-    nameEn: 'Smart Code Generation',
-    category: 'development',
-    commands: ['code'],
-    defaultSelected: true,
-    order: 2,
-    description: '多模型代码生成（智能路由：前端→Gemini，后端→Codex）',
-    descriptionEn: 'Multi-model code generation (smart routing: frontend→Gemini, backend→Codex)',
+    description: '完整6阶段开发工作流（研究→构思→计划→执行→优化→评审）',
+    descriptionEn: 'Full 6-phase development workflow',
  },
  {
    id: 'frontend',
-    name: '前端任务',
+    name: '前端专项',
    nameEn: 'Frontend Tasks',
    category: 'development',
    commands: ['frontend'],
    defaultSelected: true,
-    order: 3,
-    description: '前端/UI/样式任务，自动路由到 Gemini',
-    descriptionEn: 'Frontend/UI/style tasks, auto-route to Gemini',
+    order: 2,
+    description: '前端专项任务（Gemini主导，更快更精准）',
+    descriptionEn: 'Frontend tasks (Gemini-led, faster)',
  },
  {
    id: 'backend',
-    name: '后端任务',
+    name: '后端专项',
    nameEn: 'Backend Tasks',
    category: 'development',
    commands: ['backend'],
    defaultSelected: true,
-    order: 4,
-    description: '后端/逻辑/算法任务，自动路由到 Codex',
-    descriptionEn: 'Backend/logic/algorithm tasks, auto-route to Codex',
+    order: 3,
+    description: '后端专项任务（Codex主导，更快更精准）',
+    descriptionEn: 'Backend tasks (Codex-led, faster)',
  },
  {
-    id: 'review',
-    name: '代码审查',
-    nameEn: 'Code Review',
+    id: 'feat',
+    name: '智能功能开发',
+    nameEn: 'Smart Feature Development',
    category: 'development',
-    commands: ['review'],
+    commands: ['feat'],
    defaultSelected: true,
-    order: 5,
-    description: '双模型代码审查（Codex + Gemini 并行），无参数时自动审查 git diff',
-    descriptionEn: 'Dual-model code review (Codex + Gemini parallel), auto-review git diff when no args',
+    order: 4,
+    description: '智能功能开发 - 自动规划、设计、实施',
+    descriptionEn: 'Smart feature development - auto plan, design, implement',
  },
  {
    id: 'analyze',
@@ -87,141 +94,108 @@ const WORKFLOW_CONFIGS: WorkflowConfig[] = [
    category: 'development',
    commands: ['analyze'],
    defaultSelected: true,
-    order: 6,
-    description: '双模型技术分析（Codex + Gemini 并行），交叉验证后综合见解',
-    descriptionEn: 'Dual-model technical analysis (Codex + Gemini parallel), comprehensive insights after cross-validation',
-  },
-  {
-    id: 'enhance',
-    name: 'Prompt 增强',
-    nameEn: 'Prompt Enhancement',
-    category: 'development',
-    commands: ['enhance'],
-    defaultSelected: true,
-    order: 7,
-    description: '使用 ace-tool enhance_prompt 优化 Prompt',
-    descriptionEn: 'Optimize prompts using ace-tool enhance_prompt',
+    order: 5,
+    description: '双模型技术分析，仅分析不修改代码',
+    descriptionEn: 'Dual-model technical analysis, analysis only',
  },
  {
    id: 'debug',
-    name: 'UltraThink 调试',
-    nameEn: 'UltraThink Debug',
+    name: '问题诊断',
+    nameEn: 'Debug',
    category: 'development',
    commands: ['debug'],
-    defaultSelected: false,
-    order: 8,
-    description: 'UltraThink 多模型调试（Codex 后端诊断 + Gemini 前端诊断）',
-    descriptionEn: 'UltraThink multi-model debugging (Codex backend diagnosis + Gemini frontend diagnosis)',
-  },
-  {
-    id: 'test',
-    name: '多模型测试生成',
-    nameEn: 'Multi-Model Test Generation',
-    category: 'development',
-    commands: ['test'],
-    defaultSelected: false,
-    order: 9,
-    description: '多模型测试生成（Codex 后端测试 + Gemini 前端测试）',
-    descriptionEn: 'Multi-model test generation (Codex backend tests + Gemini frontend tests)',
-  },
-  {
-    id: 'bugfix',
-    name: '质量门控修复',
-    nameEn: 'Quality Gate Bugfix',
-    category: 'development',
-    commands: ['bugfix'],
-    defaultSelected: false,
-    order: 10,
-    description: '质量门控修复（双模型交叉验证，90%+ 通过）',
-    descriptionEn: 'Quality gate bugfix (dual-model cross-validation, 90%+ pass)',
-  },
-  {
-    id: 'think',
-    name: 'UltraThink 深度分析',
-    nameEn: 'UltraThink Deep Analysis',
-    category: 'development',
-    commands: ['think'],
-    defaultSelected: false,
-    order: 11,
-    description: 'UltraThink 深度分析（双模型并行分析 + 综合见解）',
-    descriptionEn: 'UltraThink deep analysis (dual-model parallel analysis + comprehensive insights)',
+    defaultSelected: true,
+    order: 6,
+    description: '多模型诊断 + 修复',
+    descriptionEn: 'Multi-model diagnosis + fix',
  },
  {
    id: 'optimize',
-    name: '多模型性能优化',
-    nameEn: 'Multi-Model Optimization',
+    name: '性能优化',
+    nameEn: 'Performance Optimization',
    category: 'development',
    commands: ['optimize'],
-    defaultSelected: false,
-    order: 12,
-    description: '多模型性能优化（Codex 后端优化 + Gemini 前端优化）',
-    descriptionEn: 'Multi-model performance optimization (Codex backend + Gemini frontend)',
+    defaultSelected: true,
+    order: 7,
+    description: '多模型性能优化',
+    descriptionEn: 'Multi-model performance optimization',
+  },
+  {
+    id: 'test',
+    name: '测试生成',
+    nameEn: 'Test Generation',
+    category: 'development',
+    commands: ['test'],
+    defaultSelected: true,
+    order: 8,
+    description: '智能路由测试生成',
+    descriptionEn: 'Smart routing test generation',
+  },
+  {
+    id: 'review',
+    name: '代码审查',
+    nameEn: 'Code Review',
+    category: 'development',
+    commands: ['review'],
+    defaultSelected: true,
+    order: 9,
+    description: '双模型代码审查，无参数时自动审查 git diff',
+    descriptionEn: 'Dual-model code review, auto-review git diff when no args',
+  },
+  {
+    id: 'init-project',
+    name: '项目初始化',
+    nameEn: 'Project Init',
+    category: 'init',
+    commands: ['init'],
+    defaultSelected: true,
+    order: 10,
+    description: '初始化项目 AI 上下文，生成 CLAUDE.md',
+    descriptionEn: 'Initialize project AI context, generate CLAUDE.md',
  },
  {
    id: 'commit',
-    name: 'Git 智能提交',
-    nameEn: 'Git Smart Commit',
+    name: 'Git 提交',
+    nameEn: 'Git Commit',
    category: 'git',
    commands: ['commit'],
    defaultSelected: true,
    order: 20,
-    description: '仅用 Git 分析改动并自动生成 conventional commit 信息（可选 emoji）',
-    descriptionEn: 'Git-only analysis to auto-generate conventional commit messages (optional emoji)',
+    description: '智能生成 conventional commit 信息',
+    descriptionEn: 'Smart conventional commit message generation',
  },
  {
    id: 'rollback',
-    name: 'Git 交互式回滚',
-    nameEn: 'Git Interactive Rollback',
+    name: 'Git 回滚',
+    nameEn: 'Git Rollback',
    category: 'git',
    commands: ['rollback'],
    defaultSelected: true,
    order: 21,
-    description: '交互式回滚 Git 分支到历史版本；列分支、列版本、二次确认后执行',
-    descriptionEn: 'Interactive Git branch rollback; list branches, versions, confirm before execution',
+    description: '交互式回滚分支到历史版本',
+    descriptionEn: 'Interactive rollback to historical version',
  },
  {
    id: 'clean-branches',
-    name: '清理 Git 分支',
-    nameEn: 'Clean Git Branches',
+    name: 'Git 清理分支',
+    nameEn: 'Git Clean Branches',
    category: 'git',
    commands: ['clean-branches'],
    defaultSelected: true,
    order: 22,
-    description: '安全查找并清理已合并或过期的 Git 分支，支持 dry-run 模式',
-    descriptionEn: 'Safely find and clean merged or stale Git branches, supports dry-run mode',
+    description: '安全清理已合并或过期分支',
+    descriptionEn: 'Safely clean merged or stale branches',
  },
  {
    id: 'worktree',
-    name: 'Git Worktree 管理',
-    nameEn: 'Git Worktree Management',
+    name: 'Git Worktree',
+    nameEn: 'Git Worktree',
    category: 'git',
    commands: ['worktree'],
-    defaultSelected: false,
+    defaultSelected: true,
    order: 23,
-    description: '管理 Git worktree，在项目平级的 ../.ccg/项目名/ 目录下创建',
-    descriptionEn: 'Manage Git worktree, create in ../.ccg/project-name/ directory parallel to project',
-  },
-  {
-    id: 'init-project',
-    name: '项目 AI 上下文初始化',
-    nameEn: 'Project AI Context Init',
-    category: 'init',
-    commands: ['init'],
-    defaultSelected: true,
-    order: 30,
-    description: '初始化项目 AI 上下文，生成/更新根级与模块级 CLAUDE.md 索引',
-    descriptionEn: 'Initialize project AI context, generate/update root and module level CLAUDE.md index',
-  },
-  {
-    id: 'feat',
-    name: '智能功能开发',
-    nameEn: 'Smart Feature Development',
-    category: 'planning',
-    commands: ['feat'],
-    defaultSelected: true,
-    order: 32,
-    description: '智能功能开发 - 自动规划、设计、实施（支持需求规划/讨论迭代/执行实施）',
-    descriptionEn: 'Smart feature development - auto plan, design, implement (supports planning/iteration/execution modes)',
+    description: '管理 Git worktree',
+    descriptionEn: 'Manage Git worktree',
  },
 ]

@@ -234,28 +208,23 @@ export function getWorkflowById(id: string): WorkflowConfig | undefined {
 }

 /**
- * Workflow presets for different use cases
+ * Get all command IDs for installation
+ * No more presets - always install all commands
+ */
+export function getAllCommandIds(): string[] {
+  return WORKFLOW_CONFIGS.map(w => w.id)
+}
+
+/**
+ * @deprecated Use getAllCommandIds() instead
+ * Kept for backward compatibility
 */
 export const WORKFLOW_PRESETS = {
-  minimal: {
-    name: '最小化',
-    nameEn: 'Minimal',
-    description: '核心开发命令（3个）',
-    descriptionEn: 'Core development commands (3)',
-    workflows: ['dev', 'code', 'commit'] as string[],
-  },
-  standard: {
-    name: '标准',
-    nameEn: 'Standard',
-    description: '常用开发 + Git 命令（12个）',
-    descriptionEn: 'Common dev + Git commands (12)',
-    workflows: ['dev', 'code', 'frontend', 'backend', 'review', 'analyze', 'debug', 'test', 'commit', 'rollback', 'clean-branches', 'feat'] as string[],
-  },
  full: {
    name: '完整',
    nameEn: 'Full',
-    description: '全部命令（17个）',
-    descriptionEn: 'All commands (17)',
+    description: '全部命令（14个）',
+    descriptionEn: 'All commands (14)',
    workflows: WORKFLOW_CONFIGS.map(w => w.id),
  },
 }
@@ -473,6 +442,37 @@ ${workflow.description}
    }
  }

+  // Install skills (multi-model-collaboration, etc. - should go to ~/.claude/skills/)
+  const skillsTemplateDir = join(templateDir, 'skills')
+  const skillsDestDir = join(installDir, 'skills')
+  if (await fs.pathExists(skillsTemplateDir)) {
+    try {
+      const skillDirs = await fs.readdir(skillsTemplateDir)
+      for (const skillName of skillDirs) {
+        const srcSkillDir = join(skillsTemplateDir, skillName)
+        const destSkillDir = join(skillsDestDir, skillName)
+        const stat = await fs.stat(srcSkillDir)
+        if (stat.isDirectory()) {
+          await fs.ensureDir(destSkillDir)
+          const files = await fs.readdir(srcSkillDir)
+          for (const file of files) {
+            const srcFile = join(srcSkillDir, file)
+            const destFile = join(destSkillDir, file)
+            if (force || !(await fs.pathExists(destFile))) {
+              const templateContent = await fs.readFile(srcFile, 'utf-8')
+              const processedContent = replaceHomePathsInTemplate(templateContent, installDir)
+              await fs.writeFile(destFile, processedContent, 'utf-8')
+            }
+          }
+        }
+      }
+    }
+    catch (error) {
+      result.errors.push(`Failed to install skills: ${error}`)
+      result.success = false
+    }
+  }
+
  // Install codeagent-wrapper binary
  try {
    const binDir = join(installDir, 'bin')
@@ -487,10 +487,10 @@ ${workflow.description}
      binaryName = arch === 'arm64' ? 'codeagent-wrapper-darwin-arm64' : 'codeagent-wrapper-darwin-amd64'
    }
    else if (platform === 'linux') {
-      binaryName = 'codeagent-wrapper-linux-amd64'
+      binaryName = arch === 'arm64' ? 'codeagent-wrapper-linux-arm64' : 'codeagent-wrapper-linux-amd64'
    }
    else if (platform === 'win32') {
-      binaryName = 'codeagent-wrapper-windows-amd64.exe'
+      binaryName = arch === 'arm64' ? 'codeagent-wrapper-windows-arm64.exe' : 'codeagent-wrapper-windows-amd64.exe'
    }
    else {
      result.errors.push(`Unsupported platform: ${platform}`)
@@ -545,6 +545,9 @@ export interface UninstallResult {
  success: boolean
  removedCommands: string[]
  removedPrompts: string[]
+  removedAgents: string[]
+  removedSkills: string[]
+  removedBin: boolean
  errors: string[]
 }

@@ -556,11 +559,18 @@ export async function uninstallWorkflows(installDir: string): Promise<UninstallR
    success: true,
    removedCommands: [],
    removedPrompts: [],
+    removedAgents: [],
+    removedSkills: [],
+    removedBin: false,
    errors: [],
  }

  const commandsDir = join(installDir, 'commands', 'ccg')
-  const promptsDir = join(installDir, 'prompts', 'ccg')
+  const promptsDir = join(installDir, '.ccg', 'prompts')
+  const agentsDir = join(installDir, 'agents', 'ccg')
+  const skillsDir = join(installDir, 'skills', 'multi-model-collaboration')
+  const binDir = join(installDir, 'bin')
+  const ccgConfigDir = join(installDir, '.ccg')

  // Remove CCG commands directory
  if (await fs.pathExists(commandsDir)) {
@@ -572,6 +582,11 @@ export async function uninstallWorkflows(installDir: string): Promise<UninstallR
          result.removedCommands.push(file.replace('.md', ''))
        }
      }
+      // Also remove agents subdirectory if exists
+      const agentsSubDir = join(commandsDir, 'agents')
+      if (await fs.pathExists(agentsSubDir)) {
+        await fs.remove(agentsSubDir)
+      }
      // Remove the directory if empty
      const remaining = await fs.readdir(commandsDir)
      if (remaining.length === 0) {
@@ -584,19 +599,42 @@ export async function uninstallWorkflows(installDir: string): Promise<UninstallR
    }
  }

-  // Remove CCG prompts directory
+  // Remove CCG agents directory
+  if (await fs.pathExists(agentsDir)) {
+    try {
+      const files = await fs.readdir(agentsDir)
+      for (const file of files) {
+        await fs.remove(join(agentsDir, file))
+        result.removedAgents.push(file.replace('.md', ''))
+      }
+      await fs.remove(agentsDir)
+    }
+    catch (error) {
+      result.errors.push(`Failed to remove agents: ${error}`)
+      result.success = false
+    }
+  }
+
+  // Remove CCG skills directory
+  if (await fs.pathExists(skillsDir)) {
+    try {
+      const files = await fs.readdir(skillsDir)
+      for (const file of files) {
+        result.removedSkills.push(file)
+      }
+      await fs.remove(skillsDir)
+    }
+    catch (error) {
+      result.errors.push(`Failed to remove skills: ${error}`)
+      result.success = false
+    }
+  }
+
+  // Remove CCG prompts directory (in .ccg/)
  if (await fs.pathExists(promptsDir)) {
    try {
-      const files = await fs.readdir(promptsDir)
-      for (const file of files) {
-        await fs.remove(join(promptsDir, file))
-        result.removedPrompts.push(file)
-      }
-      // Remove the directory if empty
-      const remaining = await fs.readdir(promptsDir)
-      if (remaining.length === 0) {
-        await fs.remove(promptsDir)
-      }
+      await fs.remove(promptsDir)
+      result.removedPrompts.push('codex', 'gemini')
    }
    catch (error) {
      result.errors.push(`Failed to remove prompts: ${error}`)
@@ -604,6 +642,25 @@ export async function uninstallWorkflows(installDir: string): Promise<UninstallR
    }
  }

+  // Remove codeagent-wrapper binary
+  if (await fs.pathExists(binDir)) {
+    try {
+      const wrapperName = process.platform === 'win32' ? 'codeagent-wrapper.exe' : 'codeagent-wrapper'
+      const wrapperPath = join(binDir, wrapperName)
+      if (await fs.pathExists(wrapperPath)) {
+        await fs.remove(wrapperPath)
+        result.removedBin = true
+      }
+    }
+    catch (error) {
+      result.errors.push(`Failed to remove binary: ${error}`)
+      result.success = false
+    }
+  }
+
+  // Remove .ccg config directory (optional - keep config.toml for now)
+  // Users can manually delete ~/.claude/.ccg/ if they want
+
  return result
 }

@@ -1,77 +1,134 @@
 ---
-description: 多模型技术分析（并行执行），交叉验证后综合见解
+description: '多模型技术分析（并行执行）：Codex 后端视角 + Gemini 前端视角，交叉验证后综合见解'
 ---

-## 用法
-`/analyze <QUESTION_OR_TASK>`
+# Analyze - 多模型技术分析

-## 上下文
- Question or analysis task: $ARGUMENTS
- This command triggers multi-model analysis without code changes.
- Configured models provide perspectives for cross-validation.
+使用双模型并行分析，交叉验证得出综合技术见解。**仅分析，不修改代码。**

-## 你的角色
-You are the **Analysis Coordinator** orchestrating multi-model research. You direct:
-1. **ace-tool** – for codebase context retrieval
-2. **Configured Models** – for comprehensive multi-perspective analysis
-3. **Claude (Self)** – for synthesizing insights
-
-## 流程
-
-### Step 1: 上下文检索
-
-1. Call `mcp__ace-tool__search_context` to understand relevant code:
-   - `project_root_path`: Project root directory absolute path
-   - `query`: Natural language description of what to analyze
-5. Identify key files, patterns, and architecture
-
-### Step 2: 并行分析
-
-**并行调用所有配置的分析模型**（使用 `run_in_background: true`）：
-
-遍历后端模型 {{BACKEND_MODELS}} 和前端模型 {{FRONTEND_MODELS}}（合并去重）：
+## 使用方法

 ```bash
-# 合并并去重后端和前端模型列表
-BACKEND='{{BACKEND_MODELS}}'
-FRONTEND='{{FRONTEND_MODELS}}'
-ALL_MODELS=$(echo "$BACKEND $FRONTEND" | jq -s 'add | unique' | jq -r '.[]')
-
-# 遍历所有分析模型
-for model in $ALL_MODELS; do
-  codeagent-wrapper --backend $model - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/$model/analyzer.md
-
-<TASK>
-分析任务: {{分析问题或任务}}
-Context: {{从 MCP 获取的相关代码}}
-</TASK>
-
-OUTPUT: Detailed analysis with recommendations.
-EOF
-done
-wait  # 等待所有后台任务完成
+/analyze <分析问题或任务>
 ```

-### Step 3: 交叉验证
-使用 `TaskOutput` 获取所有任务的结果，然后：
-1. Compare perspectives from all configured models
-2. Identify agreements and disagreements
-3. Evaluate trade-offs objectively
-4. Weight opinions based on model strengths
+## 多模型调用语法

-### Step 4: 综合输出
-Present unified analysis combining all perspectives.
+**必须使用 heredoc 语法调用外部模型**：

-## 输出格式
-1. **Configuration** – models used for analysis
-2. **Context Overview** – relevant codebase elements
-3. **Model Perspectives** – analysis from each configured model
-4. **Synthesis** – combined insights and trade-offs
-5. **Recommendations** – actionable next steps
+```bash
+codeagent-wrapper --backend <codex|gemini> - $PWD <<'EOF'
+ROLE_FILE: ~/.claude/.ccg/prompts/<model>/<role>.md
+<TASK>
+任务描述
+</TASK>
+OUTPUT: 期望输出格式
+EOF
+```

-## 注意事项
- This command is for analysis only, no code changes
- **Use `run_in_background: true` for parallel execution** to avoid blocking
- 多模型结果交叉验证，取长补短
- Use HEREDOC syntax (`<<'EOF'`) to avoid shell escaping issues
+## 你的角色
+
+你是**分析协调者**，编排多模型分析流程：
+- **ace-tool** – 代码上下文检索
+- **Codex** – 后端/系统视角（**后端权威**）
+- **Gemini** – 前端/用户视角（**前端权威**）
+- **Claude (自己)** – 综合见解
+
+---
+
+## 执行工作流
+
+**分析任务**：$ARGUMENTS
+
+### 🔍 阶段 1：上下文检索
+
+`[模式：研究]`
+
+1. 调用 `mcp__ace-tool__search_context` 检索相关代码
+2. 识别分析范围和关键组件
+3. 列出已知约束和假设
+
+### 💡 阶段 2：并行分析
+
+`[模式：分析]`
+
+**并行调用两个模型**：
+
+**执行步骤**：
+1. 在**同一个 Bash 调用**中启动两个后台进程（不加 wait，立即返回）：
+```bash
+codeagent-wrapper --backend codex - $PWD <<'EOF' &
+ROLE_FILE: ~/.claude/.ccg/prompts/codex/analyzer.md
+<TASK>
+分析需求: $ARGUMENTS
+Context: <阶段1检索到的上下文>
+</TASK>
+OUTPUT: 技术可行性、架构影响、性能考量
+EOF
+
+codeagent-wrapper --backend gemini - $PWD <<'EOF' &
+ROLE_FILE: ~/.claude/.ccg/prompts/gemini/analyzer.md
+<TASK>
+分析需求: $ARGUMENTS
+Context: <阶段1检索到的上下文>
+</TASK>
+OUTPUT: UI/UX 影响、用户体验、视觉设计考量
+EOF
+```
+2. 使用 `TaskOutput` 监控并获取 2 个模型的分析结果。
+
+**⚠️ 强制规则：必须等待 TaskOutput 返回两个模型的完整结果后才能进入下一阶段，禁止跳过或提前继续！**
+
+### 🔀 阶段 3：交叉验证
+
+`[模式：验证]`
+
+1. 对比双方分析结果
+2. 识别：
+   - **一致观点**（强信号）
+   - **分歧点**（需权衡）
+   - **互补见解**（各自领域洞察）
+3. 按信任规则权衡：后端以 Codex 为准，前端以 Gemini 为准
+
+### 📊 阶段 4：综合输出
+
+`[模式：总结]`
+
+```markdown
+## 🔬 技术分析：<主题>
+
+### 一致观点（强信号）
+1. <双方都认同的点>
+
+### 分歧点（需权衡）
+| 议题 | Codex 观点 | Gemini 观点 | 建议 |
+|------|------------|-------------|------|
+
+### 核心结论
+<1-2 句话总结>
+
+### 推荐方案
+**首选**：<方案>
+- 理由 / 风险 / 缓解措施
+
+### 后续行动
+1. [ ] <具体步骤>
+```
+
+---
+
+## 适用场景
+
+| 场景 | 示例 |
+|------|------|
+| 技术选型 | "比较 Redux vs Zustand" |
+| 架构评估 | "评估微服务拆分方案" |
+| 性能分析 | "分析 API 响应慢的原因" |
+| 安全审计 | "评估认证模块安全性" |
+
+## 关键规则
+
+1. **仅分析不修改** – 本命令不执行任何代码变更
+2. **使用后台进程 `&` + `TaskOutput` 获取结果**
+3. **必须等待所有模型返回完整结果后才能进入下一阶段**，禁止跳过或提前继续
+4. **信任规则** – 后端以 Codex 为准，前端以 Gemini 为准
@@ -1,198 +1,129 @@
 ---
-description: 后端/逻辑/算法任务，自动路由到配置的后端模型进行原型生成和审计
+description: '后端专项工作流（研究→构思→计划→执行→优化→评审），Codex主导'
 ---

-## 用法
-`/backend <LOGIC_TASK_DESCRIPTION>`
+# Backend - 后端专项开发
+
+## 使用方法
+
+```bash
+/backend <后端任务描述>
+```

 ## 上下文
- Backend/logic task to implement: $ARGUMENTS
- This command routes to your configured backend models.
- Default authority for algorithms, APIs, and business logic.

-## ⭐ v1.6.0 重大升级
+- 后端任务：$ARGUMENTS
+- Codex 主导，Gemini 辅助参考
+- 适用：API设计、算法实现、数据库优化、业务逻辑

-**从单模型调用升级为多模型并行工作流！**
+## 你的角色

-### 新增功能
+你是**后端编排者**，协调多模型完成服务端任务（研究 → 构思 → 计划 → 执行 → 优化 → 评审），用中文协助用户。

-✅ **5阶段完整工作流**：
- Step 1: 上下文检索（MCP）
- Step 2: **多模型后端分析**（Codex + Gemini 并行） ← 新增
- Step 3: **多模型原型生成**（所有后端模型并行） ← 增强
- Step 4: 重构与实施（Claude 综合各模型优势）
- Step 5: **多模型审计交付**（Codex + Gemini 交叉验证） ← 新增
+**协作模型**：
+- **Codex** – 后端逻辑、算法（**后端权威，可信赖**）
+- **Gemini** – 前端视角（**后端意见仅供参考**）
+- **Claude (自己)** – 编排、计划、执行、交付

-✅ **交叉验证机制**：
- Codex 提供深度后端专业知识（算法、调试）
- Gemini 提供现代架构视角
- Claude 综合各家所长，重构为生产级代码
+[沟通守则]

-✅ **强制用户确认**：
- Step 2 分析完成后，会询问"是否继续执行此方案？(Y/N)"
- 避免盲目执行，确保用户对方案满意
-
-### 与 /ccg:dev 的区别
-
-| 特性 | /ccg:backend | /ccg:dev |
-|------|-------------|----------|
-| **模型范围** | 仅后端模型（Codex + Gemini）| 全部模型（前端+后端）|
-| **适用场景** | 后端专项任务 | 全栈功能开发 |
-| **Prompt 增强** | ❌ 不包含 | ✅ Phase 0 |
-| **工作流阶段** | 5 阶段 | 6 阶段（含 Prompt 增强）|
-| **推荐用户** | 后端开发者 | 全栈开发者 |
-
-### 使用建议
-
- 🎯 **纯后端任务**：使用 `/ccg:backend`（如：API 设计、数据库优化、算法实现）
- 🎯 **全栈功能**：使用 `/ccg:dev`（如：用户登录功能，涉及前后端）
- 🎯 **需要 Prompt 增强**：使用 `/ccg:dev`（复杂需求，需先优化需求描述）
+1. 响应以模式标签 `[模式：X]` 开始，初始为 `[模式：研究]`
+2. 严格按 `研究 → 构思 → 计划 → 执行 → 优化 → 评审` 顺序流转

 ---

-## 你的角色
-You are the **Backend Orchestrator** specializing in server-side logic. You coordinate:
-1. **ace-tool** – for retrieving existing backend code and architecture
-2. **Configured Backend Models** – for generating logic, algorithms, and API implementations
-3. **Claude (Self)** – for refactoring prototypes into production code
+## 多模型调用语法

-## 流程
-
-### Step 1: 上下文检索
-1. Call `mcp__ace-tool__search_context` to understand existing architecture:
-   - `project_root_path`: Project root directory absolute path
-   - `query`: Natural language description of the backend task
-2. Identify API patterns, data models, services, and dependencies
-3. 如需求仍不清晰，提出澄清问题
-
-### Step 2: 多模型后端分析
-
-**并行调用所有配置的后端模型进行分析**（使用 `run_in_background: true`）：
-
-遍历 {{BACKEND_MODELS}} 中的每个模型进行后端分析：
- 每个模型使用对应的 `~/.claude/.ccg/prompts/<模型名>/analyzer.md`
- 输出：`Structured analysis/diagnostic report`
-
-**总共并行调用次数**: {{BACKEND_MODELS}} 长度（例如：配置 codex + gemini = 2次）
-
-调用示例：
 ```bash
-# 遍历后端模型列表（假设配置了 codex 和 gemini）
-for model in codex gemini; do
-  codeagent-wrapper --backend $model - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/$model/analyzer.md
+# Codex 调用（后端主力）
+~/.claude/bin/codeagent-wrapper --backend codex - "$PWD" <<'EOF'
+[角色提示词内容]

-<TASK>
-分析后端需求: {{后端任务描述}}
-Context: {{从 MCP 获取的 API 架构和数据模型}}
-关注点:
- API 设计和 RESTful 规范
- 数据模型和关系设计
- 业务逻辑复杂度
- 性能瓶颈和优化点
- 安全风险和防护措施
-</TASK>
-
-OUTPUT: Structured analysis/diagnostic report.
+[任务内容]
+EOF
+
+# Gemini 调用（前端参考）
+~/.claude/bin/codeagent-wrapper --backend gemini - "$PWD" <<'EOF'
+[任务内容]
 EOF
-done
 ```

-使用 `TaskOutput` 获取所有模型的分析结果，交叉验证后综合方案。
+---

-**强制停止**: 询问用户 **"是否继续执行此方案？(Y/N)"** 并等待确认
+## 核心工作流

-### Step 3: 多模型原型生成
+### 🔍 阶段 1：研究

-**并行调用所有配置的后端模型生成原型**（使用 `run_in_background: true`）：
+`[模式：研究]` - 理解需求并收集上下文

-遍历 {{BACKEND_MODELS}} 中的每个模型生成后端原型：
- 每个模型使用对应的 `~/.claude/.ccg/prompts/<模型名>/architect.md`
- 输出：`Unified Diff Patch ONLY`
+1. 检索现有 API、数据模型、服务架构
+2. 需求完整性评分（0-10 分）：≥7 继续，<7 停止补充

-**总共并行调用次数**: {{BACKEND_MODELS}} 长度（例如：配置 codex + gemini = 2次）
+### 💡 阶段 2：构思
+
+`[模式：构思]` - Codex 主导分析
+
+**调用示例**：

-调用示例：
 ```bash
-# 遍历后端模型生成原型
-for model in $(echo '{{BACKEND_MODELS}}' | jq -r '.[]'); do
-  codeagent-wrapper --backend $model - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/$model/architect.md
+~/.claude/bin/codeagent-wrapper --backend codex - "$PWD" <<'EOF'
+你是后端分析专家，擅长 API 设计、算法、数据库优化。

-<TASK>
-生成后端原型: {{后端任务描述}}
-Context: {{相关代码和架构}}
-实现要点:
- 遵循现有 API 设计模式
- 实现完整的错误处理
- 添加必要的参数验证
- 考虑并发和性能
-</TASK>
+任务：分析以下后端需求，提供设计方案
+- API 接口设计
+- 数据模型结构
+- 性能与安全考虑
+- 错误处理策略

-OUTPUT: Unified Diff Patch ONLY. Strictly prohibit any actual modifications.
+需求：[具体任务描述]
 EOF
-done
 ```

-使用 `TaskOutput` 收集所有模型的原型结果。
+**⚠️ 等待 Codex 返回后继续**

-### Step 4: 重构与实施
-1. 将所有模型的原型视为"脏原型" – 仅作参考
-2. **交叉验证所有模型结果，集各家所长**：
-   - 分析每个模型的优势和不足
-   - Codex 通常在算法和调试上更强
-   - Gemini 可能提供更现代的架构思路
-   - 选择最佳实现方案或综合创新点
-3. 重构为干净的生产级代码
-4. 确保正确的错误处理和安全性
-5. 验证变更不会引入副作用
+输出方案（至少 2 个），等待用户选择。

-### Step 5: 多模型审计交付
+### 📋 阶段 3：计划

-**并行调用所有配置的后端模型进行审计**（使用 `run_in_background: true`）：
+`[模式：计划]` - Codex 主导规划

-遍历 {{BACKEND_MODELS}} 中的每个模型进行代码审查：
- 每个模型使用对应的 `~/.claude/.ccg/prompts/<模型名>/reviewer.md`
- 输出：`Review comments only`
+调用 Codex（`architect.md`）→ 文件结构、函数/类设计、依赖

-**总共并行调用次数**: {{BACKEND_MODELS}} 长度（例如：配置 codex + gemini = 2次）
+**⚠️ 等待 Codex 返回后继续**

-调用示例：
-```bash
-# 遍历后端模型列表进行审计
-for model in $(echo '{{BACKEND_MODELS}}' | jq -r '.[]'); do
-  codeagent-wrapper --backend $model - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/$model/reviewer.md
+Claude 综合规划，请求用户批准后存入 `.claude/plan/任务名.md`

-<TASK>
-审查后端代码: {{实施的代码变更}}
-关注点:
- 安全性（SQL 注入、XSS、CSRF 等）
- 性能（N+1 查询、缓存策略）
- 错误处理（异常捕获、日志记录）
- 代码质量（可读性、可维护性）
- API 规范（RESTful 设计、HTTP 状态码）
-</TASK>
+### ⚡ 阶段 4：执行

-OUTPUT: Review comments only. No code modifications.
-EOF
-done
-```
+`[模式：执行]` - 代码开发

-使用 `TaskOutput` 收集所有模型的审计结果，交叉验证后提供综合反馈。
+- 严格按批准的计划实施
+- 遵循项目现有代码规范
+- 确保错误处理、安全性、性能优化

-**最终交付**: 根据审计反馈进行必要的调整，确保代码达到生产级质量。
+### 🚀 阶段 5：优化

-## 输出格式
-1. **Configuration** – 使用的模型和策略 ({{BACKEND_MODELS}})
-2. **Architecture Analysis** – 现有模式和依赖关系
-3. **Multi-Model Analysis** – 所有后端模型的分析报告（交叉验证）
-4. **Multi-Model Prototypes** – 所有后端模型的原型（交叉验证）
-5. **Refined Implementation** – 综合各模型优势的生产级代码
-6. **Multi-Model Audit** – 所有后端模型的审计反馈（交叉验证）
+`[模式：优化]` - Codex 主导审查

-## 注意事项
- Codex excels at complex logic and debugging
- Codex uses read-only sandbox by default
- Always request Unified Diff Patch format
- Use HEREDOC syntax (`<<'EOF'`) to avoid shell escaping issues
+调用 Codex（`reviewer.md`）→ 安全性、性能、错误处理、API规范
+
+**⚠️ 等待 Codex 返回后继续**
+
+整合审查意见，用户确认后执行优化。
+
+### ✅ 阶段 6：评审
+
+`[模式：评审]` - 最终评估
+
+- 对照计划检查完成情况
+- 运行测试验证功能
+- 报告问题与建议
+
+---
+
+## 关键规则
+
+1. **Codex 后端意见可信赖**
+2. **Gemini 后端意见仅供参考**
+3. 外部模型对文件系统**零写入权限**
+4. Claude 负责所有代码写入和文件操作
@@ -1,114 +0,0 @@
---
-description: 质量门控修复（双模型交叉验证，90%+ 通过）
---
-
-## 用法
-`/bugfix <bug描述>`
-
-## 上下文
- Bug 描述: $ARGUMENTS
- 使用双模型交叉验证确保修复质量
- 质量门控：90%+ 评分才能通过，最多 3 轮迭代
-
-## 流程
-
-### Phase 1: Bug 分析
-1. 调用 `mcp__ace-tool__search_context` 检索相关代码:
-   - `project_root_path`: 项目根目录绝对路径
-   - `query`: Bug 的自然语言描述
-2. 分析 bug 类型：前端/后端/全栈
-3. 收集复现步骤、错误日志、预期行为
-
-### Phase 2: 双模型诊断
-**并行调用**（`run_in_background: true`）:
-
-**调用方式**: 使用 `Bash` 工具调用 `codeagent-wrapper`
-
-```bash
-# Codex 后端诊断修复
-codeagent-wrapper --backend {{BACKEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/architect.md
-
-<TASK>
-Bug 修复: {{Bug 描述}}
-Context: {{从 ace-tool 获取的相关代码}}
-</TASK>
-
-OUTPUT: Unified Diff Patch for the fix.
-EOF
-```
-
-```bash
-# Gemini 前端诊断修复
-codeagent-wrapper --backend {{FRONTEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{FRONTEND_PRIMARY}}/frontend.md
-
-<TASK>
-Bug 修复: {{Bug 描述}}
-Context: {{从 ace-tool 获取的相关代码}}
-</TASK>
-
-OUTPUT: Unified Diff Patch for the fix.
-EOF
-```
-
- **Codex** + `architect` 角色 → 后端分析
- **Gemini** + `frontend` 角色 → 前端分析
-
-### Phase 3: 修复整合
-1. 收集双模型的修复方案（`TaskOutput`）
-2. 综合分析：识别共同点、合并互补修复、选择最优方案
-3. Claude 重构为生产级代码
-
-### Phase 4: 实施修复
-应用修复代码，记录变更内容
-
-### Phase 5: 质量门控验证
-**并行调用** Codex + Gemini + `reviewer` 角色验证
-
-**调用方式**: 使用 `Bash` 工具调用 `codeagent-wrapper`
-
-```bash
-# Codex 审查修复
-codeagent-wrapper --backend {{BACKEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/reviewer.md
-
-<TASK>
-审查修复: {{实施的修复代码}}
-评分标准: 正确性、安全性、性能、可维护性
-</TASK>
-
-OUTPUT: Review with score (0-100%) and specific feedback.
-EOF
-```
-
-```bash
-# Gemini 审查修复
-codeagent-wrapper --backend {{FRONTEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{FRONTEND_PRIMARY}}/reviewer.md
-
-<TASK>
-审查修复: {{实施的修复代码}}
-评分标准: 正确性、用户体验、可访问性、设计一致性
-</TASK>
-
-OUTPUT: Review with score (0-100%) and specific feedback.
-EOF
-```
-
-### Phase 6: 质量门控决策
-```
-综合评分 = (Codex 评分 + Gemini 评分) / 2
-```
-
-| 综合评分 | 结果 | 动作 |
-|----------|------|------|
-| ≥ 90% | ✅ PASS | 完成修复，可提交 |
-| 70-89% | ⚠️ ITERATE | 返回 Phase 3，携带反馈 |
-| 3轮后 < 90% | ❌ FAIL | 需人工介入 |
-
-## 关键原则
-1. **双模型交叉验证** - 避免单一视角的盲区
-2. **量化质量评估** - 使用评分制而非主观判断
-3. **迭代改进** - 每轮携带具体反馈
-4. **止损机制** - 最多 3 轮，防止无限循环
@@ -1,102 +1,117 @@
 ---
-description: 安全查找并清理已合并或过期的 Git 分支，支持 dry-run 模式与自定义基准/保护分支
-allowed-tools: Read(**), Exec(git fetch, git config, git branch, git remote, git push, git for-each-ref, git log), Write()
-argument-hint: [--base <branch>] [--stale <days>] [--remote] [--force] [--dry-run] [--yes]
-# examples:
-#   - /git-cleanBranches --dry-run
-#   - /git-cleanBranches --base release/v2.1 --stale 90
-#   - /git-cleanBranches --remote --yes
+description: '清理 Git 分支：安全清理已合并或过期分支，默认 dry-run 模式'
 ---

-# Claude Command: Clean Branches
+# Clean-Branches - 清理 Git 分支

-该命令**安全地**识别并清理**已合并**或**长期未更新 (stale)** 的 Git 分支。
-默认以**只读预览 (`--dry-run`)** 模式运行，需明确指令才会执行删除操作。
+安全识别并清理已合并或长期未更新的分支。

---
-
-## Usage
+## 使用方法

 ```bash
-# [最安全] 预览将要清理的分支，不执行任何删除
-/git-cleanBranches --dry-run
-
-# 清理已合并到 main 且超过 90 天未动的本地分支 (需逐一确认)
-/git-cleanBranches --stale 90
-
-# 清理已合并到 release/v2.1 的本地与远程分支 (自动确认)
-/git-cleanBranches --base release/v2.1 --remote --yes
-
-# [危险] 强制删除一个未合并的本地分支
-/git-cleanBranches --force outdated-feature
+/clean-branches [options]
 ```

-### Options
+## 选项

- `--base <branch>`：指定清理的基准分支（默认为仓库的 `main`/`master`）。
- `--stale <days>`：清理超过指定天数未提交的分支（默认不启用）。
- `--remote`：同时清理远程已合并/过期的分支。
- `--dry-run`：**默认行为**。仅列出将要删除的分支，不执行任何操作。
- `--yes`：跳过逐一确认的步骤，直接删除所有已识别的分支（适合 CI/CD）。
- `--force`：使用 `-D` 强制删除本地分支（即使未合并）。
+| 选项 | 说明 |
+|------|------|
+| `--base <branch>` | 基准分支（默认 main/master） |
+| `--stale <days>` | 清理超过 N 天未更新的分支 |
+| `--remote` | 同时清理远程分支 |
+| `--dry-run` | 只预览，不执行（**默认**） |
+| `--yes` | 跳过确认直接删除 |
+| `--force` | 强制删除未合并分支 |

 ---

-## What This Command Does
+## 执行工作流

-1. **配置与安全预检**
-   - **更新信息**：自动执行 `git fetch --all --prune`，确保分支状态最新。
-   - **读取保护分支**：从 Git 配置读取不应被清理的分支列表（见下文“Configuration”）。
-   - **确定基准**：使用 `--base` 参数或自动识别的 `main`/`master` 作为比较基准。
+### 🔍 阶段 1：预检

-2. **分析识别（Find）**
-   - **已合并分支**：找出已完全合并到 `--base` 的本地（及远程，如加 `--remote`）分支。
-   - **过期分支**：如指定 `--stale <days>`，找出最后一次提交在 N 天前的分支。
-   - **排除保护分支**：从待清理列表中移除所有已配置的保护分支。
+`[模式：准备]`

-3. **报告预览（Report）**
-   - 清晰列出“将要删除的已合并分支”与“将要删除的过期分支”。
-   - 若无 `--yes` 参数，**命令到此结束**，等待用户确认后再次执行（不带 `--dry-run`）。
+1. 同步远端：`git fetch --all --prune`
+2. 读取保护分支配置
+3. 确定基准分支

-4. **执行清理（Execute）**
-   - **仅在不带 `--dry-run` 且用户确认后**（或带 `--yes`）执行。
-   - 逐一删除已识别的分支，除非用户在交互式确认中选择跳过。
-   - 本地用 `git branch -d <branch>`；远程用 `git push origin --delete <branch>`。
-   - 若指定 `--force`，本地删除会改用 `git branch -D <branch>`。
+### 📋 阶段 2：分析识别

---
+`[模式：分析]`

-## Configuration (一次配置，永久生效)
+**已合并分支**：
+- 已完全合并到 `--base` 的分支

-为防止误删重要分支（如 `develop`, `release/*`），请在仓库的 Git 配置中添加保护规则。命令会自动读取。
+**过期分支**（如指定 `--stale`）：
+- 最后提交在 N 天前的分支
+
+**排除**：
+- 从待清理列表中移除保护分支
+
+### 📊 阶段 3：报告预览
+
+`[模式：报告]`
+
+```markdown
+## 将要删除的分支
+
+### 已合并分支
+- feature/old-feature (合并于 3 天前)
+- bugfix/fixed-issue (合并于 7 天前)
+
+### 过期分支
+- experiment/old-test (最后更新 90 天前)
+```
+
+### ✅ 阶段 4：执行清理
+
+`[模式：执行]`
+
+仅在不带 `--dry-run` 且确认后执行：

 ```bash
-# 保护 develop 分支
-git config --add branch.cleanup.protected develop
+# 本地分支
+git branch -d <branch>

-# 保护所有 release/ 开头的分支 (通配符)
+# 远程分支（如果 --remote）
+git push origin --delete <branch>
+
+# 强制删除（如果 --force）
+git branch -D <branch>
+```
+
+---
+
+## 保护分支配置
+
+```bash
+# 添加保护分支
+git config --add branch.cleanup.protected develop
 git config --add branch.cleanup.protected 'release/*'

-# 查看所有已配置的保护分支
+# 查看保护分支
 git config --get-all branch.cleanup.protected
 ```

 ---

-## Best Practices for Embedded Devs
+## 示例

- **优先 `--dry-run`**：养成先预览再执行的习惯。
- **活用 `--base`**：维护长期 `release` 分支时，用它来清理已合并到该 release 的 `feature` 或 `hotfix` 分支。
- **谨慎 `--force`**：除非你百分百确定某个未合并分支是无用功，否则不要强制删除。
- **团队协作**：在清理共享的远程分支前，先在团队频道通知一声。
- **定期运行**：每月或每季度运行一次，保持仓库清爽。
+```bash
+# 预览将清理的分支
+/clean-branches --dry-run

---
+# 清理已合并且超过 90 天未动的分支
+/clean-branches --stale 90

-## Why This Version Is Better
+# 清理已合并到 release/v2.1 的分支
+/clean-branches --base release/v2.1 --remote --yes
+```

- ✅ **更安全**：默认只读预览，且有可配置的保护分支列表。
- ✅ **更灵活**：支持自定义基准分支，完美适配 `release` / `develop` 工作流。
- ✅ **更兼容**：避免了在不同系统上行为不一的 `date -d` 等命令。
- ✅ **更直观**：将复杂的 16 步清单，浓缩成一个带安全选项的、可直接执行的命令。
- ✅ **风格一致**：与 `/commit` 命令共享相似的参数设计与文档结构。
+## 最佳实践
+
+1. **优先 dry-run** – 先预览再执行
+2. **活用 --base** – 适配 release 工作流
+3. **谨慎 --force** – 除非确定无用
+4. **团队协作** – 清理远程分支前先通知
+5. **定期运行** – 每月/季度一次保持清爽
@@ -1,255 +0,0 @@
---
-description: 三模型代码生成（Codex + Gemini + Claude 并行原型，集各家所长）
---
-
-## 用法
-`/code <功能描述>`
-
-## 上下文
- 功能描述: $ARGUMENTS
- **三模型并行生成原型**，编排者集各家所长
- 生成的原型经 Claude (编排者) 重构为生产级代码
-
-## 工作流程
-
-### Phase 1: 需求分析
-
-1. 调用 `mcp__ace-tool__search_context` 检索:
-   - `project_root_path`: 项目根目录绝对路径
-   - `query`: 功能需求的自然语言描述
-   - 相关模块和文件结构
-   - 现有代码模式和风格
-   - 依赖和接口定义
-2. 分析任务类型：
-   - **前端**: UI 组件、样式、用户交互
-   - **后端**: API、业务逻辑、数据库操作
-   - **全栈**: 同时涉及前后端
-
-### Phase 2: 三模型并行原型生成
-
-**同时调用三个模型**（`run_in_background: true`）：
-
-**调用方式**: 使用 `Bash` 工具调用 `codeagent-wrapper`
-
-```bash
-# Codex 后端架构原型
-codeagent-wrapper --backend {{BACKEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/architect.md
-
-<TASK>
-生成原型: {{功能需求}}
-Context: {{从 ace-tool 获取的相关代码}}
-</TASK>
-
-OUTPUT: Unified Diff Patch ONLY. Strictly prohibit any actual modifications.
-EOF
-```
-
-```bash
-# Gemini 前端 UI 原型
-codeagent-wrapper --backend {{FRONTEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{FRONTEND_PRIMARY}}/frontend.md
-
-<TASK>
-生成原型: {{功能需求}}
-Context: {{从 ace-tool 获取的相关代码}}
-</TASK>
-
-OUTPUT: Unified Diff Patch ONLY. Strictly prohibit any actual modifications.
-EOF
-```
-
-```bash
-# Claude 全栈整合原型
-codeagent-wrapper --backend claude - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/claude/architect.md
-
-<TASK>
-生成原型: {{功能需求}}
-Context: {{从 ace-tool 获取的相关代码}}
-</TASK>
-
-OUTPUT: Unified Diff Patch ONLY. Strictly prohibit any actual modifications.
-EOF
-```
-
-1. **Codex** + `architect` 角色 → 后端架构视角
-2. **Gemini** + `frontend` 角色 → 前端 UI 视角
-3. **Claude** + `architect` 角色 → 全栈整合视角
-
-**三模型差异化价值**：
-| 模型 | 专注点 | 独特贡献 |
-|------|--------|----------|
-| Codex | 后端逻辑、算法、API | 深度后端专业知识 |
-| Gemini | 前端 UI、样式、交互 | 视觉设计和用户体验 |
-| Claude | 全栈整合、契约设计 | 桥接前后端视角 |
-
-定义清晰的接口契约：
-```
-API Contract:
- Endpoint: POST /api/xxx
- Request: { field1: string, field2: number }
- Response: { data: T, error?: string }
-```
-
-### Phase 3: 原型整合
-
-1. 收集三个模型输出（使用 `TaskOutput`）
-2. 将 Unified Diff 视为"脏原型"
-3. **交叉验证，集各家所长**：
-   - Codex 的后端逻辑和 API 设计
-   - Gemini 的前端组件和 UI 交互
-   - Claude 的整合视角和契约一致性
-4. Claude (编排者) 重构：
-   - 统一代码风格
-   - 确保前后端接口一致
-   - 优化实现细节
-   - 移除冗余代码
-
-### Phase 4: 代码实施
-
-1. 应用重构后的代码
-2. 确保不破坏现有功能
-3. 验证编译/类型检查通过
-
-### Phase 5: 三模型审查
-
-**并行启动审查**（`run_in_background: true`）：
-
-**调用方式**: 使用 `Bash` 工具调用 `codeagent-wrapper`
-
-```bash
-# Codex 安全性审查
-codeagent-wrapper --backend {{BACKEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/reviewer.md
-
-<TASK>
-审查代码: {{实施的代码变更}}
-关注点: 安全性、性能、错误处理
-</TASK>
-
-OUTPUT: Review comments with specific line references.
-EOF
-```
-
-```bash
-# Gemini 设计审查
-codeagent-wrapper --backend {{FRONTEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{FRONTEND_PRIMARY}}/reviewer.md
-
-<TASK>
-审查代码: {{实施的代码变更}}
-关注点: 可访问性、响应式设计、设计一致性
-</TASK>
-
-OUTPUT: Review comments with specific line references.
-EOF
-```
-
-```bash
-# Claude 集成审查
-codeagent-wrapper --backend claude - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/claude/reviewer.md
-
-<TASK>
-审查代码: {{实施的代码变更}}
-关注点: 集成正确性、契约一致性
-</TASK>
-
-OUTPUT: Review comments with specific line references.
-EOF
-```
-
- **Codex** + `reviewer` 角色 → 安全性、性能、错误处理
- **Gemini** + `reviewer` 角色 → 可访问性、响应式、设计一致性
- **Claude** + `reviewer` 角色 → 集成正确性、契约一致性
-
-### Phase 6: 修正与交付
-
-1. 综合三模型审查意见
-2. 修正发现的问题
-3. 最终交付
-
-## 输出格式
-
-```
-## 🚀 Code: <功能描述>
-
-### Phase 1: 需求分析
- 任务类型: [前端/后端/全栈]
- 相关文件: <文件列表>
- 现有模式: <识别的模式>
-
-### Phase 2: 代码生成
-#### Codex 原型 (后端视角)
-<Unified Diff 摘要>
-
-#### Gemini 原型 (前端视角)
-<Unified Diff 摘要>
-
-#### Claude 原型 (全栈视角)
-<Unified Diff 摘要>
-
-### Phase 3: 整合重构
-<重构说明>
-
-### Phase 4: 实施
-<变更文件列表>
-
-### Phase 5: 审查
-#### Codex 审查 (安全/性能)
- <审查意见 1>
- <审查意见 2>
-
-#### Gemini 审查 (可访问性/设计)
- <审查意见 1>
- <审查意见 2>
-
-#### Claude 审查 (集成/契约)
- <审查意见 1>
- <审查意见 2>
-
-### Phase 6: 交付
-✅ 实施完成
- 新增文件: X
- 修改文件: Y
- 代码行数: +N / -M
-```
-
-## 任务类型检测
-
-| 关键词 | 类型 | 路由 |
-|--------|------|------|
-| component, UI, style, CSS, React, Vue | 前端 | Gemini |
-| API, endpoint, database, auth, backend | 后端 | Codex |
-| full-stack, 全栈, 页面+接口 | 全栈 | 并行 |
-
-## 代码质量标准
-
-### 前端代码 (Gemini 专注)
- [ ] TypeScript 类型完整
- [ ] 响应式设计
- [ ] 无障碍属性
- [ ] 加载/错误状态
- [ ] 遵循设计系统
-
-### 后端代码 (Codex 专注)
- [ ] 输入验证
- [ ] 错误处理
- [ ] 安全检查
- [ ] 查询优化
- [ ] API 一致性
-
-### 全栈整合 (Claude 专注)
- [ ] 前后端接口一致
- [ ] 类型定义共享
- [ ] 错误码统一
- [ ] 契约文档完整
-
-## 关键原则
-
-1. **三模型并行** - 同时获取三个视角的原型
-2. **集各家所长** - 交叉验证，取最优方案
-3. **接口优先** - 先定义 API 契约
-4. **编排者重构** - 原型需要 Claude (编排者) 整合
-5. **三重审查** - 代码必须经过三模型审查
@@ -1,158 +1,122 @@
 ---
-description: 仅用 Git 分析改动并自动生成 conventional commit 信息（可选 emoji）；必要时建议拆分提交，默认运行本地 Git 钩子（可 --no-verify 跳过）
-allowed-tools: Read(**), Exec(git status, git diff, git add, git restore --staged, git commit, git rev-parse, git config), Write(.git/COMMIT_EDITMSG)
-argument-hint: [--no-verify] [--all] [--amend] [--signoff] [--emoji] [--scope <scope>] [--type <type>]
-# examples:
-#   - /git-commit                           # 分析当前改动，生成提交信息
-#   - /git-commit --all                     # 暂存所有改动并提交
-#   - /git-commit --no-verify               # 跳过 Git 钩子检查
-#   - /git-commit --emoji                   # 在提交信息中包含 emoji
-#   - /git-commit --scope ui --type feat    # 指定作用域和类型
-#   - /git-commit --amend --signoff         # 修补上次提交并签名
+description: '智能 Git 提交：分析改动生成 Conventional Commit 信息，支持拆分建议'
 ---

-# Claude Command: Commit (Git-only)
+# Commit - 智能 Git 提交

-该命令在**不依赖任何包管理器/构建工具**的前提下，仅通过 **Git**：
+分析当前改动，生成 Conventional Commits 风格的提交信息。

- 读取改动（staged/unstaged）
- 判断是否需要**拆分为多次提交**
- 为每个提交生成 **Conventional Commits** 风格的信息（可选 emoji）
- 按需执行 `git add` 与 `git commit`（默认运行本地 Git 钩子；可 `--no-verify` 跳过）
-
---
-
-## Usage
+## 使用方法

 ```bash
-/git-commit
-/git-commit --no-verify
-/git-commit --emoji
-/git-commit --all --signoff
-/git-commit --amend
-/git-commit --scope ui --type feat --emoji
+/commit [options]
 ```

-### Options
+## 选项

- `--no-verify`：跳过本地 Git 钩子（`pre-commit`/`commit-msg` 等）。
- `--all`：当暂存区为空时，自动 `git add -A` 将所有改动纳入本次提交。
- `--amend`：在不创建新提交的情况下**修补**上一次提交（保持提交作者与时间，除非本地 Git 配置另有指定）。
- `--signoff`：附加 `Signed-off-by` 行（遵循 DCO 流程时使用）。
- `--emoji`：在提交信息中包含 emoji 前缀（省略则使用纯文本）。
- `--scope <scope>`：指定提交作用域（如 `ui`、`docs`、`api`），写入消息头部。
- `--type <type>`：强制提交类型（如 `feat`、`fix`、`docs` 等），覆盖自动判断。
-
-> 注：如框架不支持交互式确认，可在 front-matter 中开启 `confirm: true` 以避免误操作。
+| 选项 | 说明 |
+|------|------|
+| `--no-verify` | 跳过 Git 钩子 |
+| `--all` | 暂存所有改动 |
+| `--amend` | 修补上次提交 |
+| `--signoff` | 附加签名 |
+| `--emoji` | 包含 emoji 前缀 |
+| `--scope <scope>` | 指定作用域 |
+| `--type <type>` | 指定提交类型 |

 ---

-## What This Command Does
+## 执行工作流

-1. **仓库/分支校验**
-   - 通过 `git rev-parse --is-inside-work-tree` 判断是否位于 Git 仓库。
-   - 读取当前分支/HEAD 状态；如处于 rebase/merge 冲突状态，先提示处理冲突后再继续。
+### 🔍 阶段 1：仓库校验

-2. **改动检测**
-   - 用 `git status --porcelain` 与 `git diff` 获取已暂存与未暂存的改动。
-   - 若已暂存文件为 0：
-     - 若传入 `--all` → 执行 `git add -A`。
-     - 否则提示你选择：继续仅分析未暂存改动并给出**建议**，或取消命令后手动分组暂存。
+`[模式：检查]`

-3. **拆分建议（Split Heuristics）**
-   - 按**关注点**、**文件模式**、**改动类型**聚类（示例：源代码 vs 文档、测试；不同目录/包；新增 vs 删除）。
-   - 若检测到**多组独立变更**或 diff 规模过大（如 > 300 行 / 跨多个顶级目录），建议拆分提交，并给出每一组的 pathspec（便于后续执行 `git add <paths>`）。
+1. 验证 Git 仓库状态
+2. 检测 rebase/merge 冲突
+3. 读取当前分支/HEAD 状态

-4. **提交信息生成（Conventional 规范，可选 Emoji）**
-   - 自动推断 `type`（`feat`/`fix`/`docs`/`refactor`/`test`/`chore`/`perf`/`style`/`ci`/`revert` …）与可选 `scope`。
-   - 生成消息头：`[<emoji>] <type>(<scope>)?: <subject>`（首行 ≤ 72 字符，祈使语气，仅在使用 `--emoji` 时包含 emoji）。
-   - 生成消息体：要点列表（动机、实现要点、影响范围、BREAKING CHANGE 如有）。
-   - 根据 Git 历史提交的主要语言选择提交信息语言。优先检查最近提交主题（例如 `git log -n 50 --pretty=%s`）判断中文/英文；若无法判断，则回退到仓库主要语言或英文。
-   - 将草稿写入 `.git/COMMIT_EDITMSG`，并用于 `git commit`。
+### 📋 阶段 2：改动检测

-5. **执行提交**
-   - 单提交场景：`git commit [-S] [--no-verify] [-s] -F .git/COMMIT_EDITMSG`
-   - 多提交场景（如接受拆分建议）：按分组给出 `git add <paths> && git commit ...` 的明确指令；若允许执行则逐一完成。
+`[模式：分析]`

-6. **安全回滚**
-   - 如误暂存，可用 `git restore --staged <paths>` 撤回暂存（命令会给出指令，不修改文件内容）。
+1. 获取已暂存与未暂存改动
+2. 若暂存区为空：
+   - `--all` → 执行 `git add -A`
+   - 否则提示选择
+
+### ✂️ 阶段 3：拆分建议
+
+`[模式：建议]`
+
+按以下维度聚类：
+- 关注点（源代码 vs 文档/测试）
+- 文件模式（不同目录/包）
+- 改动类型（新增 vs 删除）
+
+若检测到多组独立变更（>300 行 / 跨多个顶级目录），建议拆分。
+
+### ✍️ 阶段 4：生成提交信息
+
+`[模式：生成]`
+
+**格式**：`[emoji] <type>(<scope>): <subject>`
+
+- 首行 ≤ 72 字符
+- 祈使语气
+- 消息体：动机、实现要点、影响范围
+
+**语言**：根据最近 50 次提交判断中文/英文
+
+### ✅ 阶段 5：执行提交
+
+`[模式：执行]`
+
+```bash
+git commit [-S] [--no-verify] [-s] -F .git/COMMIT_EDITMSG
+```

 ---

-## Best Practices for Commits
+## Type 与 Emoji 映射

- **Atomic commits**：一次提交只做一件事，便于回溯与审阅。
- **先分组再提交**：按目录/模块/功能点拆分。
- **清晰主题**：首行 ≤ 72 字符，祈使语气（如 “add… / fix…”）。
- **正文含上下文**：说明动机、方案、影响范围、风险与后续工作。
- **遵循 Conventional Commits**：`<type>(<scope>): <subject>`。
+| Emoji | Type | 说明 |
+|-------|------|------|
+| ✨ | `feat` | 新增功能 |
+| 🐛 | `fix` | 缺陷修复 |
+| 📝 | `docs` | 文档更新 |
+| 🎨 | `style` | 代码格式 |
+| ♻️ | `refactor` | 重构 |
+| ⚡️ | `perf` | 性能优化 |
+| ✅ | `test` | 测试相关 |
+| 🔧 | `chore` | 构建/工具 |
+| 👷 | `ci` | CI/CD |
+| ⏪️ | `revert` | 回滚 |

 ---

-## Type 与 Emoji 映射（使用 --emoji 时）
+## 示例

- ✨ `feat`：新增功能
- 🐛 `fix`：缺陷修复（含 🔥 删除代码/文件、🚑️ 紧急修复、👽️ 适配外部 API 变更、🔒️ 安全修复、🚨 解决告警、💚 修复 CI）
- 📝 `docs`：文档与注释
- 🎨 `style`：风格/格式（不改语义）
- ♻️ `refactor`：重构（不新增功能、不修缺陷）
- ⚡️ `perf`：性能优化
- ✅ `test`：新增/修复测试、快照
- 🔧 `chore`：构建/工具/杂务（合并分支、更新配置、发布标记、依赖 pin、.gitignore 等）
- 👷 `ci`：CI/CD 配置与脚本
- ⏪️ `revert`：回滚提交
- 💥 `feat`：破坏性变更（`BREAKING CHANGE:` 段落中说明）
+```bash
+# 基本提交
+/commit

-> 若传入 `--type`/`--scope`，将**覆盖**自动推断。
-> 仅在指定 `--emoji` 标志时才会包含 emoji。
+# 暂存所有并提交
+/commit --all

---
+# 带 emoji 提交
+/commit --emoji

-## Guidelines for Splitting Commits
+# 指定类型和作用域
+/commit --scope ui --type feat --emoji

-1. **不同关注点**：互不相关的功能/模块改动应拆分。
-2. **不同类型**：不要将 `feat`、`fix`、`refactor` 混在同一提交。
-3. **文件模式**：源代码 vs 文档/测试/配置分组提交。
-4. **规模阈值**：超大 diff（示例：>300 行或跨多个顶级目录）建议拆分。
-5. **可回滚性**：确保每个提交可独立回退。
+# 修补上次提交
+/commit --amend --signoff
+```

---
+## 关键规则

-## Examples
-
-**Good (使用 --emoji)**
-
- ✨ feat(ui): add user authentication flow
- 🐛 fix(api): handle token refresh race condition
- 📝 docs: update API usage examples
- ♻️ refactor(core): extract retry logic into helper
- ✅ test: add unit tests for rate limiter
- 🔧 chore: update git hooks and repository settings
- ⏪️ revert: revert "feat(core): introduce streaming API"
-
-**Good (不使用 --emoji)**
-
- feat(ui): add user authentication flow
- fix(api): handle token refresh race condition
- docs: update API usage examples
- refactor(core): extract retry logic into helper
- test: add unit tests for rate limiter
- chore: update git hooks and repository settings
- revert: revert "feat(core): introduce streaming API"
-
-**Split Example**
-
- `feat(types): add new type defs for payment method`
- `docs: update API docs for new types`
- `test: add unit tests for payment types`
- `fix: address linter warnings in new files` ←（如你的仓库有钩子报错）
-
---
-
-## Important Notes
-
- **仅使用 Git**：不调用任何包管理器/构建命令（无 `pnpm`/`npm`/`yarn` 等）。
- **尊重钩子**：默认执行本地 Git 钩子；使用 `--no-verify` 可跳过。
- **不改源码内容**：命令只读写 `.git/COMMIT_EDITMSG` 与暂存区；不会直接编辑工作区文件。
- **安全提示**：在 rebase/merge 冲突、detached HEAD 等状态下会先提示处理/确认再继续。
- **可审可控**：如开启 `confirm: true`，每个实际 `git add`/`git commit` 步骤都会进行二次确认。
+1. **仅使用 Git** – 不调用包管理器
+2. **尊重钩子** – 默认执行，`--no-verify` 可跳过
+3. **不改源码** – 只读写 `.git/COMMIT_EDITMSG`
+4. **原子提交** – 一次提交只做一件事
@@ -1,133 +1,137 @@
 ---
-description: UltraThink 多模型调试（Codex 后端诊断 + Gemini 前端诊断）
+description: '多模型调试：Codex 后端诊断 + Gemini 前端诊断，交叉验证定位问题'
 ---

-## 用法
-`/debug <问题描述>`
+# Debug - 多模型调试

-## 上下文
- 问题描述: $ARGUMENTS
- 使用 ace-tool 检索相关代码上下文
- Codex 专注后端/逻辑问题，Gemini 专注前端/UI问题
+双模型并行诊断，交叉验证快速定位问题根因。

-## 流程
+## 多模型调用语法

-### Phase 1: 上下文检索
+**⚠️ 必须使用 heredoc 语法调用外部模型**：

-1. 调用 `mcp__ace-tool__search_context` 检索相关代码:
-   - `project_root_path`: 项目根目录绝对路径
-   - `query`: 问题的自然语言描述
+```bash
+~/.claude/bin/codeagent-wrapper --backend <codex|gemini> - "$PWD" <<'EOF'
+<任务内容>
+EOF
+```
+
+- `--backend codex` – 后端/逻辑问题诊断
+- `--backend gemini` – 前端/UI 问题诊断
+- `$PWD` – 当前工作目录
+
+---
+
+## 使用方法
+
+```bash
+/debug <问题描述>
+```
+
+## 你的角色
+
+你是**调试协调者**，编排多模型诊断流程：
+- **Codex** – 后端诊断（**后端问题权威**）
+- **Gemini** – 前端诊断（**前端问题权威**）
+- **Claude (自己)** – 综合诊断、执行修复
+
+---
+
+## 执行工作流
+
+**问题描述**：$ARGUMENTS
+
+### 🔍 阶段 1：上下文收集
+
+`[模式：研究]`
+
+1. 调用 `mcp__ace-tool__search_context` 检索相关代码（如可用）
 2. 收集错误日志、堆栈信息、复现步骤
-3. 识别问题涉及的模块（前端/后端/全栈）
+3. 识别问题类型：[后端/前端/全栈]

-### Phase 2: 并行诊断
+### 🔬 阶段 2：并行诊断

-**同时启动两个后台任务**（`run_in_background: true`）：
+`[模式：诊断]`

-**调用方式**: 使用 `Bash` 工具调用 `codeagent-wrapper`
+**并行调用 Codex + Gemini**：

+**执行步骤**：
+1. 在**同一个 Bash 调用**中启动两个后台进程（不加 wait，立即返回）：
 ```bash
 # Codex 后端诊断
-codeagent-wrapper --backend {{BACKEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/debugger.md
+~/.claude/bin/codeagent-wrapper --backend codex - "$PWD" <<'EOF' &
+角色：后端调试专家

-<TASK>
-诊断问题: {{问题描述}}
-Context: {{从 ace-tool 获取的相关代码}}
-</TASK>
+问题：$ARGUMENTS

-OUTPUT: Structured diagnostic report. No code modifications.
+任务：
+1. 分析逻辑错误、数据流、异常处理
+2. 检查 API、数据库、服务间通信
+3. 输出诊断假设（按可能性排序）
 EOF
-```

-```bash
 # Gemini 前端诊断
-codeagent-wrapper --backend {{FRONTEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{FRONTEND_PRIMARY}}/debugger.md
+~/.claude/bin/codeagent-wrapper --backend gemini - "$PWD" <<'EOF' &
+角色：前端调试专家

-<TASK>
-诊断问题: {{问题描述}}
-Context: {{从 ace-tool 获取的相关代码}}
-</TASK>
+问题：$ARGUMENTS

-OUTPUT: Structured diagnostic report. No code modifications.
+任务：
+1. 分析 UI 渲染、状态管理、事件绑定
+2. 检查组件生命周期、样式冲突
+3. 输出诊断假设（按可能性排序）
 EOF
 ```
+2. 使用 `TaskOutput` 监控并获取 2 个模型的诊断结果。

- **Codex** + `debugger` 角色 → 后端诊断
- **Gemini** + `debugger` 角色 → 前端诊断
+**⚠️ 强制规则：必须等待 TaskOutput 返回两个模型的完整结果后才能进入下一阶段，禁止跳过或提前继续！**

-### Phase 3: 假设整合
+### 🔀 阶段 3：假设整合

-1. 收集两个模型的诊断报告（使用 `TaskOutput`）
-2. 交叉验证：识别重叠和互补的假设
-3. **UltraThink 综合**：
-   - 整合所有假设，按可能性排序
-   - 筛选出 **Top 1-2 最可能原因**
-   - 设计验证策略
+`[模式：验证]`

-### Phase 4: 用户确认（Hard Stop）
+1. 交叉验证双方诊断结果
+2. 筛选 **Top 1-2 最可能原因**
+3. 设计验证策略

-输出格式：
-```
+### ⛔ 阶段 4：用户确认（Hard Stop）
+
+`[模式：确认]`
+
+```markdown
 ## 🔍 诊断结果

 ### Codex 分析（后端视角）
-<Codex 诊断摘要>
+<诊断摘要>

 ### Gemini 分析（前端视角）
-<Gemini 诊断摘要>
+<诊断摘要>

 ### 综合诊断
 **最可能原因**：<具体诊断>
-**证据**：<支持证据>
 **验证方案**：<如何确认>

 ---
 **确认后我将执行修复。是否继续？(Y/N)**
 ```

-⚠️ **必须等待用户确认后才能进入 Phase 5**
+**⚠️ 必须等待用户确认后才能进入阶段 5**

-### Phase 5: 修复与验证
+### 🔧 阶段 5：修复与验证

-1. 根据确认的诊断实施修复
-2. 修复完成后，**并行调用** Codex + Gemini + `reviewer` 角色审查修复
-3. 综合审查意见，确认问题解决
+`[模式：执行]`

-## 输出格式
+用户确认后：
+1. 根据诊断实施修复
+2. 运行测试验证修复
+3. **可选**：并行调用 Codex + Gemini 审查修复

-```
-## Phase 1: 上下文检索
- 检索到 X 个相关文件
- 问题类型: [前端/后端/全栈]
+---

-## Phase 2: 并行诊断
-### Codex 诊断
-<诊断内容>
+## 关键规则

-### Gemini 诊断
-<诊断内容>
-
-## Phase 3: 综合分析
-### Top 假设
-1. [最可能原因] - 可能性: High
-2. [次可能原因] - 可能性: Medium
-
-### 验证策略
- [具体验证步骤]
-
-## Phase 4: 确认
-**是否按此诊断进行修复？(Y/N)**
-
-## Phase 5: 修复验证（用户确认后）
- 修复内容: <具体修改>
- 双模型审查: <审查结果>
-```
-
-## 关键原则
-
-1. **不假设，先验证** - 所有假设需要证据支持
-2. **并行诊断** - 充分利用双模型的不同视角
-3. **用户确认** - 修复前必须获得确认
-4. **交叉审查** - 修复后双模型验证
+1. **heredoc 语法** – 外部模型调用必须使用 heredoc
+2. **使用后台进程 `&` + `TaskOutput` 获取结果**
+3. **必须等待所有模型返回完整结果后才能进入下一阶段**，禁止跳过或提前继续
+4. **用户确认** – 修复前必须获得确认
+5. **信任规则** – 后端问题以 Codex 为准，前端问题以 Gemini 为准
@@ -1,179 +0,0 @@
---
-description: 完整6阶段多模型协作工作流（Prompt增强 → 上下文检索 → 多模型分析 → 原型生成 → 代码实施 → 审计交付）
---
-
-## 用法
-`/dev <功能描述>`
-
-## 上下文
- 要实现的功能: $ARGUMENTS
- 此命令触发完整的 6 阶段多模型协作工作流
-
-## 你的角色
-你是**编排者**，协调三模型协作系统。你指挥:
-1. **ace-tool MCP** – 代码库检索 (`search_context`) 和 Prompt 增强 (`enhance_prompt`)
-2. **Codex** – 后端逻辑、算法、调试专家
-3. **Gemini** – 前端 UI/UX、视觉设计专家
-4. **Claude (子进程)** – 全栈整合、契约设计、跨层问题
-5. **Claude (自己)** – 编排、重构、最终交付
-
-## 流程
-
-### 阶段 0: Prompt 增强
-1. **Prompt 增强**（调用 `mcp__ace-tool__enhance_prompt`）:
-   - 参数：
-     - `prompt`（必需）：用户的原始需求
-     - `conversation_history`（可选）：最近 5-10 轮对话历史
-     - `project_root_path`（可选）：当前项目根目录绝对路径
-   - 如果工具不可用，直接使用原始 prompt
-
-2. 向用户展示原始和增强后的 prompt:
-
-```
-📝 原始需求:
-<原始需求>
-
-✨ 增强后需求:
-<增强后需求>
-
-🔧 模型配置:
- 前端模型: {{FRONTEND_MODELS}}
- 后端模型: {{BACKEND_MODELS}}
- 协作模式: {{ROUTING_MODE}}
-
---
-**使用增强后的需求继续？(Y/N)**
-```
-
-3. **强制停止**: 等待用户确认
-   - 如果 Y: 后续阶段使用增强后的 prompt
-   - 如果 N: 使用原始 prompt 或要求修改
-
-### 阶段 1: 上下文检索
-1. **代码库检索**（调用 `mcp__ace-tool__search_context`）:
-   - 参数：
-     - `project_root_path`（必需）：项目根目录的绝对路径
-     - `query`（必需）：增强后的需求描述（自然语言）
-2. 识别所有相关文件、类、函数和依赖
-3. 如需求仍不清晰，提出澄清问题
-
-### 阶段 2: 多模型分析
-
-**并行调用 codex 和 gemini 进行分析**（使用 `run_in_background: true`）：
-
-1. **Codex 分析**：`~/.claude/.ccg/prompts/codex/analyzer.md`
-   - 输出：`Structured analysis/diagnostic report`
-
-2. **Gemini 分析**：`~/.claude/.ccg/prompts/gemini/analyzer.md`
-   - 输出：`Structured analysis/diagnostic report`
-
-调用示例：
-```bash
-codeagent-wrapper --backend codex - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/codex/analyzer.md
-<TASK>
-分析需求: {{增强后的需求}}
-Context: {{从 MCP 获取的代码上下文}}
-</TASK>
-OUTPUT: Structured analysis/diagnostic report.
-EOF
-
-codeagent-wrapper --backend gemini - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/gemini/analyzer.md
-<TASK>
-分析需求: {{增强后的需求}}
-Context: {{从 MCP 获取的代码上下文}}
-</TASK>
-OUTPUT: Structured analysis/diagnostic report.
-EOF
-```
-
-使用 `TaskOutput` 获取 2 个模型的分析结果，交叉验证后综合方案。
-
-**强制停止**: 询问用户 **"是否继续执行此方案？(Y/N)"** 并等待确认
-
-### 阶段 3: 原型生成
-
-**并行调用所有配置的模型生成原型**（使用 `run_in_background: true`）：
-
-1. **后端模型**：遍历 {{BACKEND_MODELS}} 中的每个模型生成后端原型
-   - 每个模型使用对应的 `~/.claude/.ccg/prompts/<模型名>/architect.md`
-   - 输出：`Unified Diff Patch ONLY`
-
-2. **前端模型**：遍历 {{FRONTEND_MODELS}} 中的每个模型生成前端原型
-   - **优先使用 frontend.md**：如果模型有 `~/.claude/.ccg/prompts/<模型名>/frontend.md`，使用该文件
-   - **降级使用 architect.md**：如果没有 frontend.md，使用 `~/.claude/.ccg/prompts/<模型名>/architect.md`
-   - 输出：`Unified Diff Patch ONLY`
-
-**总共并行调用次数**: {{BACKEND_MODELS}} 长度 + {{FRONTEND_MODELS}} 长度（例如：2个后端模型 + 2个前端模型 = 4次）
-
-调用示例：
-```bash
-# 遍历后端模型生成原型
-for model in $(echo '{{BACKEND_MODELS}}' | jq -r '.[]'); do
-  codeagent-wrapper --backend $model - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/$model/architect.md
-<TASK>
-生成后端原型: {{功能需求}}
-Context: {{相关代码}}
-</TASK>
-OUTPUT: Unified Diff Patch ONLY.
-EOF
-done
-```
-
-使用 `TaskOutput` 收集所有模型的原型结果。
-
-### 阶段 4: 代码实施
-1. 将所有模型的原型视为"脏原型" – 仅作参考
-2. **交叉验证所有模型结果，集各家所长**：
-   - 分析每个模型的优势和不足
-   - 选择最佳实现方案
-   - 综合多个模型的创新点
-3. 重构为干净的生产级代码
-4. 验证变更不会引入副作用
-
-### 阶段 5: 审计与交付
-
-**并行调用所有配置的审查模型**（使用 `run_in_background: true`）：
-
-遍历 {{REVIEW_MODELS}} 中的每个模型进行代码审查：
- 每个模型使用对应的 `~/.claude/.ccg/prompts/<模型名>/reviewer.md`
- 输出：`Review comments only`
-
-**总共并行调用次数**: {{REVIEW_MODELS}} 长度（例如：2个审查模型 = 2次）
-
-调用示例：
-```bash
-# 遍历审查模型列表（默认: codex, gemini）
-for model in $(echo '{{REVIEW_MODELS}}' | jq -r '.[]'); do
-  codeagent-wrapper --backend $model - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/$model/reviewer.md
-<TASK>
-审查代码: {{实施的代码变更}}
-关注点: 安全性、性能、错误处理、可访问性、设计一致性
-</TASK>
-OUTPUT: Review comments only. No code modifications.
-EOF
-done
-```
-
-使用 `TaskOutput` 获取所有审查结果，整合各方反馈后修正并交付。
-
-## 输出格式
-1. **增强后需求** – 优化后的 prompt (阶段 0)
-2. **上下文摘要** – 识别的相关代码元素
-3. **实施方案** – 逐步执行方案
-4. **代码变更** – 生产级实现
-5. **审计报告** – 审查反馈和修正
-6. **后续步骤** – 部署或跟进操作
-
-## 关键规则
- 未经用户批准不得跳过任何阶段
- **阶段 0 的 prompt 增强是强制性的** – 必须先展示增强后的 prompt
- 始终要求外部模型输出 Unified Diff Patch
- 外部模型对文件系统**零写入权限**
- 实时向用户报告当前阶段和下一阶段
- 使用 HEREDOC 语法 (`<<'EOF'`) 避免 shell 转义问题
- **三模型并行调用使用 `run_in_background: true`** 避免阻塞
- **三模型结果需交叉验证，集各家所长**
@@ -1,348 +1,127 @@
 ---
-name: ccg:feat
-description: 🚀 智能功能开发 - 自动规划、设计、实施
-tools: Task, Read, Write, Bash, AskUserQuestion, Glob
+description: '智能功能开发 - 自动识别输入类型，规划/讨论/实施全流程'
 ---

-# CCG 智能功能开发
+# Feat - 智能功能开发

-智能识别用户输入类型，自动选择工作流：
- **需求规划**：需求分析 → 任务分解 → 生成计划文档
- **讨论迭代**：基于现有计划调整优化
- **执行实施**：按计划调用多模型实施开发
+$ARGUMENTS
+
+## 核心工作流程
+
+### 1. 输入类型判断
+
+**每次交互必须首先声明**：「我判断此次操作类型为：[具体类型]」
+
+| 类型 | 关键词 | 动作 |
+|------|--------|------|
+| **需求规划** | 实现、开发、新增、添加、构建、设计 | → 步骤 2（完整规划） |
+| **讨论迭代** | 调整、修改、优化、改进、包含计划文件路径 | → 读取现有计划 → 步骤 2.3 |
+| **执行实施** | 开始实施、执行计划、按照计划、根据计划 | → 步骤 3（直接实施） |

 ---

-## 执行流程
-
-### 步骤 1：输入类型识别
-
-分析用户输入，识别关键词：
-
-#### 1.1 需求规划模式（默认）
-**关键词**：实现、开发、新增、添加、构建、需求、设计、规划
-**示例**："实现用户登录功能"、"开发商品管理模块"
-**执行**：→ 步骤 2（完整规划）
-
-#### 1.2 讨论迭代模式
-**关键词**：调整、修改、优化、改进、更新、重新规划、包含计划文件路径
-**示例**："调整登录功能方案"、"优化 .claude/plan/登录功能.md"
-**执行**：→ 读取现有计划 → 步骤 2.4（重新规划）
-
-#### 1.3 执行实施模式
-**关键词**：开始实施、执行计划、按照计划、根据计划
-**示例**："开始实施登录功能"、"按照 .claude/plan/登录功能.md 开发"
-**执行**：→ 步骤 3（直接实施）
-
---
-
-### 步骤 2：需求规划流程
+### 2. 需求规划流程

 #### 2.1 上下文检索

-调用 mcp__ace-tool__search_context 检索相关代码：
-
-```
-mcp__ace-tool__search_context {
-  "query": "{{用户需求关键词}} + 相关代码实现、API、组件、数据模型、技术栈"
-}
-```
-
-**期望结果**：现有代码位置、可复用组件、数据模型、API 结构、技术栈
-
---
+调用 `mcp__ace-tool__search_context` 检索相关代码、组件、技术栈。

 #### 2.2 任务类型判断

-基于用户需求和检索结果：
-
 | 任务类型 | 判断依据 | 调用流程 |
 |----------|----------|----------|
 | **前端** | 页面、组件、UI、样式、布局 | ui-ux-designer → planner |
 | **后端** | API、接口、数据库、逻辑、算法 | planner |
 | **全栈** | 同时包含前后端 | ui-ux-designer → planner |

---
+#### 2.3 调用 Agents

-#### 2.3 调用 ui-ux-designer（前端/全栈）
-
-如果是前端或全栈任务：
-
-```bash
-Task(subagent_type="general-purpose", description="调用 UI/UX 设计师") {
-  prompt: "
+**前端/全栈任务**：先调用 `ui-ux-designer` agent
+```
 执行 agent: ~/.claude/agents/ccg/ui-ux-designer.md
-
-项目上下文: {{MCP 检索结果}}
-用户需求: {{原始需求}}
-技术栈: {{从检索结果提取}}
-
-输出: UI/UX 设计方案（Markdown）
-"
-}
+输入: 项目上下文 + 用户需求 + 技术栈
+输出: UI/UX 设计方案
 ```

---
-
-#### 2.4 调用 planner
-
-```bash
-Task(subagent_type="general-purpose", description="调用任务规划师") {
-  prompt: "
+**所有任务**：调用 `planner` agent
+```
 执行 agent: ~/.claude/agents/ccg/planner.md
-
-项目上下文: {{MCP 检索结果}}
-{{如果有 UI/UX 设计方案，附加在此}}
-用户需求: {{原始需求}}
-技术栈: {{从检索结果提取}}
-
-输出: 生成功能规划文档并保存到 .claude/plan/{{功能名}}.md
-"
-}
+输入: 项目上下文 + UI设计方案(如有) + 用户需求
+输出: 功能规划文档
 ```

+#### 2.4 保存计划
+
+**文件命名规则**：
+- 首次规划：`.claude/plan/功能名.md`
+- 迭代版本：`.claude/plan/功能名-1.md`、`.claude/plan/功能名-2.md`...
+
+#### 2.5 交互确认
+
+规划完成后询问用户：
+- **开始实施** → 步骤 3
+- **讨论调整** → 重新执行步骤 2.3
+- **重新规划** → 删除当前计划，重新执行步骤 2
+- **仅保存计划** → 退出
+
 ---

-#### 2.5 计划版本控制
+### 3. 执行实施流程

-**首次规划**：
-```bash
-FEATURE_NAME="{{从需求提取的功能名}}"
-PLAN_FILE=".claude/plan/${FEATURE_NAME}.md"
+#### 3.1 读取计划

-if [ -f "$PLAN_FILE" ]; then
-  PLAN_FILE=".claude/plan/${FEATURE_NAME}-1.md"
-fi
-```
-
-**讨论迭代**：
-```bash
-EXISTING_PLAN=$(find .claude/plan -name "*{{关键词}}*.md" | head -n 1)
-
-if [ -n "$EXISTING_PLAN" ]; then
-  BASE_NAME=$(basename "$EXISTING_PLAN" .md)
-  if [[ $BASE_NAME =~ -([0-9]+)$ ]]; then
-    VERSION=$((${BASH_REMATCH[1]} + 1))
-    NEW_PLAN=".claude/plan/${BASE_NAME%-*}-${VERSION}.md"
-  else
-    NEW_PLAN=".claude/plan/${BASE_NAME}-1.md"
-  fi
-fi
-```
-
---
-
-#### 2.6 交互确认
-
-```bash
-AskUserQuestion {
-  question: "功能规划已完成，请选择下一步操作：",
-  header: "下一步",
-  options: [
-    { label: "开始实施（推荐）", description: "根据计划调用多模型开发" },
-    { label: "讨论调整", description: "修改计划中的某些部分" },
-    { label: "重新规划", description: "推翻当前方案重新开始" },
-    { label: "仅保存计划", description: "暂不实施，稍后手动执行" }
-  ]
-}
-```
-
-**处理逻辑**：
- 开始实施 → 步骤 3
- 讨论调整 → 重新执行步骤 2.4
- 重新规划 → 删除当前计划，重新执行步骤 2
- 仅保存计划 → 退出
-
---
-
-### 步骤 3：执行实施
-
-#### 3.1 读取计划文档
-
-```bash
-if [[ "$USER_INPUT" =~ \.claude/plan/.*\.md ]]; then
-  PLAN_FILE="{{用户指定路径}}"
-else
-  PLAN_FILE=$(ls -t .claude/plan/*.md | head -n 1)
-fi
-
-PLAN_CONTENT=$(Read("$PLAN_FILE"))
-```
-
---
+优先使用用户指定路径，否则读取最新的计划文件。

 #### 3.2 任务类型分析

-从计划提取分类：
-
-```bash
-FRONTEND_TASKS=$(echo "$PLAN_CONTENT" | grep -E "模块.*：前端" || echo "")
-BACKEND_TASKS=$(echo "$PLAN_CONTENT" | grep -E "模块.*：后端" || echo "")
-
-if [ -n "$FRONTEND_TASKS" ] && [ -n "$BACKEND_TASKS" ]; then
-  TASK_TYPE="fullstack"
-elif [ -n "$FRONTEND_TASKS" ]; then
-  TASK_TYPE="frontend"
-elif [ -n "$BACKEND_TASKS" ]; then
-  TASK_TYPE="backend"
-fi
-```
-
-如无法判断，询问用户选择任务类型。
-
---
+从计划提取任务分类：前端 / 后端 / 全栈

 #### 3.3 多模型路由实施

-##### 前端任务 → {{FRONTEND_PRIMARY}}
+**参考 `multi-model-collaboration` skill 调用外部模型**

-```bash
-if [ "$TASK_TYPE" == "frontend" ] || [ "$TASK_TYPE" == "fullstack" ]; then
-  FRONTEND_PLAN=$(echo "$PLAN_CONTENT" | sed -n '/模块.*：前端/,/模块.*：/p')
+**前端任务 → Gemini**：
+- 使用 `codeagent-wrapper --backend gemini`
+- 角色提示词：`~/.claude/.ccg/prompts/gemini/frontend.md`
+- 输出：前端组件代码

-  codeagent-wrapper --backend {{FRONTEND_PRIMARY}} - "$PROJECT_DIR" <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{FRONTEND_PRIMARY}}/frontend.md
+**后端任务 → Codex**：
+- 使用 `codeagent-wrapper --backend codex`
+- 角色提示词：`~/.claude/.ccg/prompts/codex/architect.md`
+- 输出：后端 API 代码

-<TASK>
-根据以下计划实施前端功能：
-$FRONTEND_PLAN
-
-要求：
-1. 创建/修改所有需要的组件文件
-2. 符合项目代码风格
-3. 实现响应式设计
-4. 添加 TypeScript 类型定义
-5. 处理 Loading/Success/Error 状态
-6. 遵循无障碍访问最佳实践
-</TASK>
-EOF
-
-  GEMINI_SESSION=$(echo "$OUTPUT" | grep "SESSION_ID:" | awk '{print $2}')
-fi
-```
-
-##### 后端任务 → {{BACKEND_PRIMARY}}
-
-```bash
-if [ "$TASK_TYPE" == "backend" ] || [ "$TASK_TYPE" == "fullstack" ]; then
-  BACKEND_PLAN=$(echo "$PLAN_CONTENT" | sed -n '/模块.*：后端/,/模块.*：/p')
-
-  codeagent-wrapper --backend {{BACKEND_PRIMARY}} - "$PROJECT_DIR" <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/architect.md
-
-<TASK>
-根据以下计划实施后端功能：
-$BACKEND_PLAN
-
-要求：
-1. 创建/修改所有 API 端点
-2. 实现数据验证（Zod/Joi）
-3. 统一错误处理
-4. 添加中间件（认证、日志、CORS）
-5. 编写数据库查询
-6. 确保代码可测试性
-</TASK>
-EOF
-
-  CODEX_SESSION=$(echo "$OUTPUT" | grep "SESSION_ID:" | awk '{print $2}')
-fi
-```
-
-##### 全栈任务 → 并行调用
-
-```bash
-if [ "$TASK_TYPE" == "fullstack" ]; then
-  { 前端任务 } &
-  { 后端任务 } &
-  wait
-fi
-```
-
---
+**全栈任务 → 并行调用**：
+**执行步骤**：
+1. 在**同一个 Bash 调用**中启动两个后台进程（不加 wait，立即返回）：
+   - Codex 后端 + Gemini 前端同时运行
+2. 使用 `TaskOutput` 监控并获取结果
+3. **⚠️ 强制规则：必须等待 TaskOutput 返回两个模型的完整结果后才能进入下一阶段，禁止跳过或提前继续！**

 #### 3.4 实施后验证

 ```bash
 git status --short
 git diff --name-status
-
-AskUserQuestion {
-  question: "是否运行代码审查？",
-  options: [
-    { label: "是，运行 /ccg:review", description: "双模型代码审查" },
-    { label: "跳过，手动检查", description: "稍后自行审查代码" }
-  ]
-}
 ```

-如果用户选择审查，调用 `/ccg:review`。
+询问用户是否运行代码审查（`/ccg:review`）。

 ---

-### 步骤 4：后续建议
+### 4. 关键执行原则
+
+1. **强制响应要求**：每次交互必须首先说明判断的操作类型
+2. **文档一致性**：规划文档与实际执行保持同步
+3. **依赖关系管理**：前端任务必须确保 UI 设计完整性
+4. **多模型信任规则**：
+   - 前端以 Gemini 为准
+   - 后端以 Codex 为准
+5. **用户沟通透明**：所有判断和动作都要明确告知用户
+
+---
+
+## 使用方法

 ```bash
-echo "✅ 功能开发完成！"
-echo ""
-echo "📋 后续步骤："
-echo "  1. 运行测试：npm run test"
-echo "  2. 启动开发服务器：npm run dev"
-echo "  3. 验证功能是否正常"
-echo "  4. 运行 /ccg:commit 提交代码"
-echo ""
-echo "📂 计划文档：$PLAN_FILE"
+/feat <功能描述>
 ```
-
---
-
-## 命令参数
-
-```bash
-/ccg:feat --mode=plan "实现用户登录"        # 显式指定规划模式
-/ccg:feat --mode=implement "path/to/plan"   # 显式指定实施模式
-/ccg:feat --mode=iterate "path" "调整需求"  # 显式指定迭代模式
-/ccg:feat --type=frontend "实现登录页面"    # 指定任务类型
-/ccg:feat --type=backend "实现登录 API"
-/ccg:feat --type=fullstack "实现完整登录"
-```
-
---
-
-## 使用示例
-
-```bash
-# 示例 1：完整流程
-/ccg:feat 实现用户登录功能
-
-→ 系统识别：需求规划模式
-→ 检索上下文（MCP）
-→ 判断任务类型：全栈
-→ 调用 ui-ux-designer
-→ 调用 planner
-→ 生成计划：.claude/plan/用户登录功能.md
-→ 用户确认：开始实施
-→ 并行调用 Gemini（前端）+ Codex（后端）
-→ 实施完成
-→ 可选：运行代码审查
-
-# 示例 2：讨论迭代
-/ccg:feat 调整登录功能，增加"记住我"选项
-
-→ 系统识别：讨论迭代模式
-→ 读取现有计划：.claude/plan/用户登录功能.md
-→ 调用 planner 重新规划
-→ 生成新版本：.claude/plan/用户登录功能-1.md
-
-# 示例 3：直接实施
-/ccg:feat 按照 .claude/plan/用户登录功能.md 开始实施
-
-→ 系统识别：执行实施模式
-→ 读取计划文档
-→ 分析任务类型：全栈
-→ 并行调用 Gemini + Codex
-→ 实施完成
-```
-
---
-
-现在开始智能功能开发！
@@ -1,200 +1,129 @@
 ---
-description: 前端/UI/样式任务，自动路由到配置的前端模型进行原型生成和审计
+description: '前端专项工作流（研究→构思→计划→执行→优化→评审），Gemini主导'
 ---

-## 用法
-`/frontend <UI_TASK_DESCRIPTION>`
+# Frontend - 前端专项开发
+
+## 使用方法
+
+```bash
+/frontend <UI任务描述>
+```

 ## 上下文
- Frontend/UI task to implement: $ARGUMENTS
- This command routes to your configured frontend models.
- Default authority for CSS, React, Vue, and visual design.

-## ⭐ v1.6.0 重大升级
+- 前端任务：$ARGUMENTS
+- Gemini 主导，Codex 辅助参考
+- 适用：组件设计、响应式布局、UI动画、样式优化

-**从单模型调用升级为多模型并行工作流！**
+## 你的角色

-### 新增功能
+你是**前端编排者**，协调多模型完成 UI/UX 任务（研究 → 构思 → 计划 → 执行 → 优化 → 评审），用中文协助用户。

-✅ **5阶段完整工作流**：
- Step 1: 上下文检索（MCP）
- Step 2: **多模型前端分析**（Gemini + Claude 并行） ← 新增
- Step 3: **多模型原型生成**（所有前端模型并行） ← 增强
- Step 4: 重构与实施（Claude 综合各模型优势）
- Step 5: **多模型审计交付**（Gemini + Claude 交叉验证） ← 新增
+**协作模型**：
+- **Gemini** – 前端 UI/UX（**前端权威，可信赖**）
+- **Codex** – 后端视角（**前端意见仅供参考**）
+- **Claude (自己)** – 编排、计划、执行、交付

-✅ **交叉验证机制**：
- Gemini 提供视觉设计和 UI 创新优势
- Claude 提供更好的可访问性和代码结构
- 综合各模型优势，重构为生产级 UI 代码
+[沟通守则]

-✅ **强制用户确认**：
- Step 2 分析完成后，会询问"是否继续执行此方案？(Y/N)"
- 避免盲目执行，确保用户对方案满意
-
-### 与 /ccg:dev 的区别
-
-| 特性 | /ccg:frontend | /ccg:dev |
-|------|--------------|----------|
-| **模型范围** | 仅前端模型（Gemini + Claude）| 全部模型（前端+后端）|
-| **适用场景** | 前端专项任务 | 全栈功能开发 |
-| **Prompt 增强** | ❌ 不包含 | ✅ Phase 0 |
-| **工作流阶段** | 5 阶段 | 6 阶段（含 Prompt 增强）|
-| **推荐用户** | 前端/UI 开发者 | 全栈开发者 |
-
-### 使用建议
-
- 🎯 **纯前端任务**：使用 `/ccg:frontend`（如：组件设计、响应式布局、UI 动画）
- 🎯 **全栈功能**：使用 `/ccg:dev`（如：用户登录功能，涉及前后端）
- 🎯 **需要 Prompt 增强**：使用 `/ccg:dev`（复杂需求，需先优化需求描述）
+1. 响应以模式标签 `[模式：X]` 开始，初始为 `[模式：研究]`
+2. 严格按 `研究 → 构思 → 计划 → 执行 → 优化 → 评审` 顺序流转

 ---

-## 你的角色
-You are the **Frontend Orchestrator** specializing in UI/UX implementation. You coordinate:
-1. **ace-tool** – for retrieving existing frontend code and components
-2. **Configured Frontend Models** – for generating CSS/React/Vue prototypes
-3. **Claude (Self)** – for refactoring prototypes into production code
+## 多模型调用语法

-## 流程
-
-### Step 1: 上下文检索
-1. Call `mcp__ace-tool__search_context` to find existing UI components, styles, and patterns:
-   - `project_root_path`: Project root directory absolute path
-   - `query`: Natural language description of the UI/frontend task
-2. Identify the design system, component library, and styling conventions in use
-3. 如需求仍不清晰，提出澄清问题
-
-### Step 2: 多模型前端分析
-
-**并行调用所有配置的前端模型进行分析**（使用 `run_in_background: true`）：
-
-遍历 {{FRONTEND_MODELS}} 中的每个模型进行前端分析：
- 每个模型使用对应的 `~/.claude/.ccg/prompts/<模型名>/analyzer.md`
- 输出：`Structured analysis/diagnostic report`
-
-**总共并行调用次数**: {{FRONTEND_MODELS}} 长度（例如：配置 gemini + claude = 2次）
-
-调用示例：
 ```bash
-# 遍历前端模型列表（假设配置了 gemini 和 claude）
-for model in gemini claude; do
-  codeagent-wrapper --backend $model - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/$model/analyzer.md
+# Gemini 调用（前端主力）
+~/.claude/bin/codeagent-wrapper --backend gemini - "$PWD" <<'EOF'
+[角色提示词内容]

-<TASK>
-分析前端需求: {{前端任务描述}}
-Context: {{从 MCP 获取的组件和样式}}
-关注点:
- 组件设计和复用性
- UI/UX 交互流程
- 响应式布局策略
- 可访问性 (a11y) 要求
- 性能优化（懒加载、代码分割）
- 设计系统一致性
-</TASK>
-
-OUTPUT: Structured analysis/diagnostic report.
+[任务内容]
+EOF
+
+# Codex 调用（后端参考）
+~/.claude/bin/codeagent-wrapper --backend codex - "$PWD" <<'EOF'
+[任务内容]
 EOF
-done
 ```

-使用 `TaskOutput` 获取所有模型的分析结果，交叉验证后综合方案。
+---

-**强制停止**: 询问用户 **"是否继续执行此方案？(Y/N)"** 并等待确认
+## 核心工作流

-### Step 3: 多模型原型生成
+### 🔍 阶段 1：研究

-**并行调用所有配置的前端模型生成原型**（使用 `run_in_background: true`）：
+`[模式：研究]` - 理解需求并收集上下文

-遍历 {{FRONTEND_MODELS}} 中的每个模型生成前端原型：
- 每个模型使用对应的 `~/.claude/.ccg/prompts/<模型名>/frontend.md`（如无 frontend 角色，使用 architect）
- 输出：`Unified Diff Patch ONLY`
+1. 检索现有组件、样式、设计系统
+2. 需求完整性评分（0-10 分）：≥7 继续，<7 停止补充

-**总共并行调用次数**: {{FRONTEND_MODELS}} 长度（例如：配置 gemini + claude = 2次）
+### 💡 阶段 2：构思
+
+`[模式：构思]` - Gemini 主导分析
+
+**调用示例**：

-调用示例：
 ```bash
-# 遍历前端模型生成原型
-for model in $(echo '{{FRONTEND_MODELS}}' | jq -r '.[]'); do
-  codeagent-wrapper --backend $model - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/$model/frontend.md
+~/.claude/bin/codeagent-wrapper --backend gemini - "$PWD" <<'EOF'
+你是前端分析专家，擅长 UI/UX、组件设计、响应式布局。

-<TASK>
-生成前端原型: {{前端任务描述}}
-Context: {{相关组件和样式}}
-实现要点:
- 遵循现有组件设计模式
- 实现响应式布局
- 确保可访问性 (ARIA 标签)
- 使用设计系统的 tokens
- 考虑性能优化
-</TASK>
+任务：分析以下前端需求，提供设计方案
+- 组件结构与状态管理
+- 响应式策略
+- 可访问性考虑
+- 性能优化建议

-OUTPUT: Unified Diff Patch ONLY. Strictly prohibit any actual modifications.
+需求：[具体任务描述]
 EOF
-done
 ```

-使用 `TaskOutput` 收集所有模型的原型结果。
+**⚠️ 等待 Gemini 返回后继续**

-### Step 4: 重构与实施
-1. 将所有模型的原型视为"脏原型" – 仅作参考
-2. **交叉验证所有模型结果，集各家所长**：
-   - 分析每个模型的优势和不足
-   - Gemini 通常在视觉设计和 UI 创新上更强
-   - Claude 可能提供更好的可访问性和代码结构
-   - 选择最佳实现方案或综合创新点
-3. 重构为干净的生产级代码
-4. 确保与现有组件的一致性
-5. 验证响应式布局和可访问性
+输出方案（至少 2 个），等待用户选择。

-### Step 5: 多模型审计交付
+### 📋 阶段 3：计划

-**并行调用所有配置的前端模型进行审计**（使用 `run_in_background: true`）：
+`[模式：计划]` - Gemini 主导规划

-遍历 {{FRONTEND_MODELS}} 中的每个模型进行代码审查：
- 每个模型使用对应的 `~/.claude/.ccg/prompts/<模型名>/reviewer.md`
- 输出：`Review comments only`
+调用 Gemini（`architect.md`）→ 组件结构、UI流程、样式方案

-**总共并行调用次数**: {{FRONTEND_MODELS}} 长度（例如：配置 gemini + claude = 2次）
+**⚠️ 等待 Gemini 返回后继续**

-调用示例：
-```bash
-# 遍历前端模型列表进行审计
-for model in $(echo '{{FRONTEND_MODELS}}' | jq -r '.[]'); do
-  codeagent-wrapper --backend $model - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/$model/reviewer.md
+Claude 综合规划，请求用户批准后存入 `.claude/plan/任务名.md`

-<TASK>
-审查前端代码: {{实施的代码变更}}
-关注点:
- 可访问性（WCAG 2.1 AA 标准）
- 响应式设计（移动端适配）
- 性能（首屏渲染、Lighthouse 分数）
- 设计一致性（颜色、字体、间距）
- 代码质量（组件复用、prop 类型）
- 浏览器兼容性
-</TASK>
+### ⚡ 阶段 4：执行

-OUTPUT: Review comments only. No code modifications.
-EOF
-done
-```
+`[模式：执行]` - 代码开发

-使用 `TaskOutput` 收集所有模型的审计结果，交叉验证后提供综合反馈。
+- 严格按批准的计划实施
+- 遵循项目现有设计系统和代码规范
+- 确保响应式、可访问性

-**最终交付**: 根据审计反馈进行必要的调整，确保 UI 达到生产级质量。
+### 🚀 阶段 5：优化

-## 输出格式
-1. **Configuration** – 使用的模型和策略 ({{FRONTEND_MODELS}})
-2. **Component Analysis** – 现有组件模式和设计系统
-3. **Multi-Model Analysis** – 所有前端模型的分析报告（交叉验证）
-4. **Multi-Model Prototypes** – 所有前端模型的原型（交叉验证）
-5. **Refined Implementation** – 综合各模型优势的生产级 UI 代码
-6. **Multi-Model Audit** – 所有前端模型的审计反馈（交叉验证）
+`[模式：优化]` - Gemini 主导审查

-## 注意事项
- Gemini context limit: < 32k tokens
- Always request Unified Diff Patch format
- Use HEREDOC syntax (`<<'EOF'`) to avoid shell escaping issues
+调用 Gemini（`reviewer.md`）→ 可访问性、响应式、性能、设计一致性
+
+**⚠️ 等待 Gemini 返回后继续**
+
+整合审查意见，用户确认后执行优化。
+
+### ✅ 阶段 6：评审
+
+`[模式：评审]` - 最终评估
+
+- 对照计划检查完成情况
+- 验证响应式和可访问性
+- 报告问题与建议
+
+---
+
+## 关键规则
+
+1. **Gemini 前端意见可信赖**
+2. **Codex 前端意见仅供参考**
+3. 外部模型对文件系统**零写入权限**
+4. Claude 负责所有代码写入和文件操作
@@ -1,53 +1,117 @@
 ---
-description: 初始化项目 AI 上下文，生成/更新根级与模块级 CLAUDE.md 索引
-allowed-tools: Read(**), Write(CLAUDE.md, **/CLAUDE.md)
-argument-hint: <项目摘要或名称>
+description: '初始化项目 AI 上下文：生成根级与模块级 CLAUDE.md 索引'
 ---

-## 用法
+# Init - 初始化项目 AI 上下文

-`/init-project <项目摘要或名称>`
+以「根级简明 + 模块级详尽」策略生成项目 AI 上下文文档。

-## 目标
+## 使用方法

-以"根级简明 + 模块级详尽"的混合策略初始化项目 AI 上下文：
+```bash
+/init <项目摘要或名称>
+```

- 在仓库根生成/更新 `CLAUDE.md`（高层愿景、架构总览、模块索引、全局规范）。
- 在识别的各模块目录生成/更新本地 `CLAUDE.md`（接口、依赖、入口、测试、关键文件等）。
- ✨ **为了提升可读性，会在根 `CLAUDE.md` 中自动生成 Mermaid 结构图，并为每个模块 `CLAUDE.md` 添加导航面包屑**。
+## 上下文

-## 编排说明
+- 项目摘要：$ARGUMENTS
+- 生成/更新根级与模块级 `CLAUDE.md`
+- 自动生成 Mermaid 结构图和导航面包屑

-**步骤 1**：调用 `get-current-datetime` 子智能体获取当前时间戳。
+## 你的角色

-**步骤 2**：调用一次 `init-architect` 子智能体，输入：
+你是**项目架构师**，负责扫描仓库并生成 AI 上下文文档：
+- 根级 `CLAUDE.md`：高层愿景、架构总览、模块索引
+- 模块级 `CLAUDE.md`：接口、依赖、入口、测试、关键文件

- `project_summary`: $ARGUMENTS
- `current_timestamp`: (来自步骤1的时间戳)
+---

-## 执行策略（由 Agent 自适应决定，不需要用户传参）
+## 执行工作流

- **阶段 A：全仓清点（轻量）**
-  快速统计文件与目录，识别模块根（package.json、pyproject.toml、go.mod、apps/_、packages/_、services/\* 等）。
- **阶段 B：模块优先扫描（中等）**
-  对每个模块做"入口/接口/依赖/测试/数据模型/质量工具"的定点读取与样本抽取。
- **阶段 C：深度补捞（按需）**
-  若仓库较小或模块规模较小，则扩大读取面；若较大，则对高风险/高价值路径分批追加扫描。
- **覆盖率度量与可续跑**
-  输出"已扫描文件数 / 估算总文件数、已覆盖模块占比、被忽略/跳过原因"，并列出"建议下一步深挖的子路径"。重复运行 `/init-project` 时按上次索引做**增量更新**与**断点续扫**。
+### 🔍 阶段 A：全仓清点

-## 安全与边界
+`[模式：扫描]`

- 只读/写文档与索引，不改源代码。
- 默认忽略常见生成物与二进制大文件。
- 结果在主对话打印"摘要"，全文写入仓库。
+1. 调用 `get-current-datetime` 子智能体获取当前时间戳
+2. 快速统计文件与目录
+3. 识别模块根：
+   - `package.json` / `pyproject.toml` / `go.mod`
+   - `apps/*` / `packages/*` / `services/*`

-## 输出要求
+### 📦 阶段 B：模块优先扫描

- 在主对话中打印"初始化结果摘要"，包含：
-  - 根级 `CLAUDE.md` 是否创建/更新、主要栏目概览。
-  - 识别的模块数量及其路径列表。
-  - 每个模块 `CLAUDE.md` 的生成/更新情况。
-  - ✨ **明确提及"已生成 Mermaid 结构图"和"已为 N 个模块添加导航面包屑"**。
-  - 覆盖率与主要缺口。
-  - 若未读全：说明"为何到此为止"，并列出**推荐的下一步**（例如"建议优先补扫：packages/auth/src/controllers"）。
+`[模式：分析]`
+
+对每个模块做定点读取：
+- 入口文件
+- 接口定义
+- 依赖关系
+- 测试覆盖
+- 数据模型
+- 质量工具
+
+### 🔬 阶段 C：深度补捞（按需）
+
+`[模式：深度]`
+
+- 仓库较小：扩大读取面
+- 仓库较大：对高价值路径分批追加扫描
+
+### ✅ 阶段 D：生成文档
+
+`[模式：执行]`
+
+1. 生成根级 `CLAUDE.md`
+   - 项目概述
+   - 架构图（Mermaid）
+   - 模块索引
+   - 全局规范
+2. 生成模块级 `CLAUDE.md`
+   - 导航面包屑
+   - 模块职责
+   - 关键文件
+   - 接口说明
+
+---
+
+## 输出格式
+
+```markdown
+## 初始化结果摘要
+
+### 根级文档
+- 状态：[创建/更新]
+- 主要栏目：<列表>
+
+### 模块识别
+- 识别模块数：X
+- 模块列表：
+  1. <模块路径>
+  2. ...
+
+### 覆盖率
+- 已扫描文件：X / Y
+- 覆盖模块：X%
+- 跳过原因：<如有>
+
+### 生成内容
+- ✅ Mermaid 结构图
+- ✅ N 个模块导航面包屑
+
+### 推荐下一步
+- [ ] 补扫：<路径>
+```
+
+---
+
+## 安全边界
+
+1. **只读/写文档** – 不改源代码
+2. **忽略生成物** – 跳过 `node_modules`、`dist`、二进制文件
+3. **增量更新** – 重复运行时做断点续扫
+
+## 关键规则
+
+1. 调用 `init-architect` 子智能体执行扫描
+2. 结果在主对话打印摘要，全文写入仓库
+3. 输出覆盖率与建议下一步
@@ -1,98 +1,141 @@
 ---
-description: 多模型性能优化（Codex 后端优化 + Gemini 前端优化）
+description: '多模型性能优化：Codex 后端优化 + Gemini 前端优化'
 ---

-## 用法
-`/optimize <优化目标>`
+# Optimize - 多模型性能优化
+
+双模型并行分析性能瓶颈，按性价比排序优化建议。
+
+## 多模型调用语法
+
+**必须使用 heredoc 语法调用外部模型**：
+
+```bash
+~/.claude/bin/codeagent-wrapper --backend <codex|gemini> - $PWD <<'EOF'
+<任务内容>
+EOF
+```
+
+> ⚠️ 禁止使用 `echo | codeagent-wrapper` 管道语法，会导致多行内容截断。
+
+---
+
+## 使用方法
+
+```bash
+/optimize <优化目标>
+```

 ## 上下文
- 优化目标: $ARGUMENTS
+
+- 优化目标：$ARGUMENTS
 - Codex 专注后端性能（数据库、算法、缓存）
 - Gemini 专注前端性能（渲染、加载、交互）

-## 流程
+## 你的角色

-### Phase 1: 性能基线分析
-1. 调用 `mcp__ace-tool__search_context` 检索目标代码:
-   - `project_root_path`: 项目根目录绝对路径
-   - `query`: 需要优化的目标代码描述
+你是**性能工程师**，编排多模型优化流程：
+- **Codex** – 后端性能优化（**后端权威**）
+- **Gemini** – 前端性能优化（**前端权威**）
+- **Claude (自己)** – 综合优化、实施变更
+
+---
+
+## 执行工作流
+
+**优化目标**：$ARGUMENTS
+
+### 🔍 阶段 1：性能基线
+
+`[模式：研究]`
+
+1. 调用 `mcp__ace-tool__search_context` 检索目标代码（如可用）
 2. 识别性能关键路径
-3. 收集现有指标（如有）：
-   - 后端: 响应时间、查询耗时、内存占用
-   - 前端: LCP、FID、CLS、Bundle Size
+3. 收集现有指标（如有）

-### Phase 2: 并行性能分析
-**同时调用**（`run_in_background: true`）:
+### 🔬 阶段 2：并行性能分析

-**调用方式**: 使用 `Bash` 工具调用 `codeagent-wrapper`
+`[模式：分析]`

+**并行调用两个模型**：
+
+**执行步骤**：
+1. 在**同一个 Bash 调用**中启动两个后台进程（不加 wait，立即返回）：
 ```bash
-# Codex 后端性能分析
-codeagent-wrapper --backend {{BACKEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/optimizer.md
+# Codex：后端性能分析
+~/.claude/bin/codeagent-wrapper --backend codex - $PWD <<'EOF' &
+[角色] 你是后端性能优化专家

-<TASK>
-性能优化: {{优化目标}}
-Context: {{从 ace-tool 获取的相关代码和性能指标}}
-</TASK>
+[任务] 分析以下代码的后端性能问题：
+$ARGUMENTS

-OUTPUT: Analysis report + Unified Diff Patch for optimizations.
+[输出格式]
+1. 性能瓶颈列表（按严重程度排序）
+2. 每个问题的优化方案（含代码 Diff）
+3. 预期收益评估
+EOF
+
+# Gemini：前端性能分析
+~/.claude/bin/codeagent-wrapper --backend gemini - $PWD <<'EOF' &
+[角色] 你是前端性能优化专家
+
+[任务] 分析以下代码的前端性能问题：
+$ARGUMENTS
+
+[输出格式]
+1. Core Web Vitals 问题列表
+2. 每个问题的优化方案（含代码 Diff）
+3. 预期收益评估
 EOF
 ```
+2. 使用 `TaskOutput` 监控并获取 2 个模型的分析结果。

-```bash
-# Gemini 前端性能分析
-codeagent-wrapper --backend {{FRONTEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{FRONTEND_PRIMARY}}/optimizer.md
+**⚠️ 强制规则：必须等待 TaskOutput 返回两个模型的完整结果后才能进入下一阶段，禁止跳过或提前继续！**

-<TASK>
-性能优化: {{优化目标}}
-Context: {{从 ace-tool 获取的相关代码和性能指标}}
-</TASK>
+### 🔀 阶段 3：优化整合

-OUTPUT: Analysis report + Unified Diff Patch for optimizations.
-EOF
-```
+`[模式：计划]`

- **Codex** + `optimizer` 角色 → 后端性能分析
- **Gemini** + `optimizer` 角色 → 前端性能分析
+1. 收集双模型分析结果
+2. **优先级排序**：按 `影响程度 × 实施难度⁻¹` 计算性价比
+3. 请求用户确认优化方案

-### Phase 3: 优化整合
-1. 收集双模型分析（`TaskOutput`）
-2. **优先级排序**：按影响程度 × 实施难度 计算性价比
-3. Claude 重构优化代码
+### ⚡ 阶段 4：实施优化

-### Phase 4: 实施优化
-1. 按优先级实施
-2. 确保不破坏现有功能
-3. 添加必要的性能监控
+`[模式：执行]`

-### Phase 5: 验证
-1. 运行性能测试（如有）
-2. 对比优化前后指标
-3. 双模型审查优化效果
+用户确认后按优先级实施，确保不破坏现有功能。
+
+### ✅ 阶段 5：验证
+
+`[模式：评审]`
+
+运行测试验证功能，对比优化前后指标。
+
+---

 ## 性能指标参考

-### 后端
-| 指标 | 良好 | 需优化 | 严重 |
-|------|------|--------|------|
-| API 响应 | <100ms | 100-500ms | >500ms |
-| 数据库查询 | <50ms | 50-200ms | >200ms |
-
-### 前端 (Core Web Vitals)
-| 指标 | 良好 | 需改进 | 差 |
-|------|------|--------|-----|
-| LCP | <2.5s | 2.5-4s | >4s |
-| FID | <100ms | 100-300ms | >300ms |
-| CLS | <0.1 | 0.1-0.25 | >0.25 |
+| 类型 | 指标 | 良好 | 需优化 |
+|------|------|------|--------|
+| 后端 | API 响应 | <100ms | >500ms |
+| 后端 | 数据库查询 | <50ms | >200ms |
+| 前端 | LCP | <2.5s | >4s |
+| 前端 | FID | <100ms | >300ms |
+| 前端 | CLS | <0.1 | >0.25 |

 ## 常见优化模式
-**后端**: N+1 查询→批量加载、缺少索引→复合索引、重复计算→缓存、同步阻塞→异步
-**前端**: 大 Bundle→代码分割、频繁重渲染→memo、大列表→虚拟滚动、未优化图片→WebP/懒加载

-## 关键原则
-1. **先测量后优化** - 没有数据不盲目优化
-2. **性价比优先** - 高影响 + 低难度优先
-3. **不破坏功能** - 优化不能引入 bug
-4. **可观测性** - 添加监控便于持续优化
+**后端**：N+1→批量加载、缺索引→复合索引、重复计算→缓存、同步→异步
+
+**前端**：大Bundle→代码分割、频繁重渲染→memo、大列表→虚拟滚动、未优化图片→WebP
+
+---
+
+## 关键规则
+
+1. **先测量后优化** – 没有数据不盲目优化
+2. **性价比优先** – 高影响 + 低难度优先
+3. **不破坏功能** – 优化不能引入 bug
+4. **信任规则** – 后端以 Codex 为准，前端以 Gemini 为准
+5. **必须等待所有模型返回** – 禁止提前进入下一步
@@ -1,89 +1,134 @@
 ---
-description: 多模型代码审查（并行执行），无参数时自动审查 git diff
+description: '多模型代码审查：无参数时自动审查 git diff，双模型交叉验证'
 ---

-## 用法
-`/review [CODE_OR_DESCRIPTION]`
+# Review - 多模型代码审查

-## 上下文
- Arguments: $ARGUMENTS
- This command triggers multi-model code review based on your configuration.
- Configured models review simultaneously for comprehensive feedback.
+双模型并行审查，交叉验证综合反馈。无参数时自动审查当前 git 变更。

-## 行为
- **No arguments**: Automatically review current git changes (staged + unstaged)
- **With arguments**: Review specified code or description
+## 多模型调用语法

-## 你的角色
-You are the **Code Review Coordinator** orchestrating multi-model review. You direct:
-1. **ace-tool** – for retrieving code context
-2. **Configured Review Models** – for comprehensive code review
-3. **Claude (Self)** – for synthesizing feedback and recommendations
+**⚠️ 必须使用 heredoc 语法调用外部模型**：

-## 流程
-
-### Step 1: 获取待审查代码
-
-**If no arguments provided**, run git commands to get current changes:
 ```bash
-# Get staged and unstaged changes
+~/.claude/bin/codeagent-wrapper --backend <codex|gemini> - "$PWD" <<'EOF'
+<任务内容>
+EOF
+```
+
+---
+
+## 使用方法
+
+```bash
+/review [代码或描述]
+```
+
+- **无参数**：自动审查 `git diff HEAD`
+- **有参数**：审查指定代码或描述
+
+---
+
+## 执行工作流
+
+### 🔍 阶段 1：获取待审查代码
+
+`[模式：研究]`
+
+**无参数时**：
+```bash
 git diff HEAD
 git status --short
 ```

-**If arguments provided**, use the specified code/description.
+**有参数时**：使用指定的代码/描述

-Then call `mcp__ace-tool__search_context` to get related context:
-   - `project_root_path`: Project root directory absolute path
-   - `query`: Description of code/files to review
+调用 `mcp__ace-tool__search_context` 获取相关上下文。

-### Step 2: 并行审查
+### 🔬 阶段 2：并行审查

-**并行调用所有配置的审查模型**（使用 `run_in_background: true`）：
+`[模式：审查]`

-遍历 {{REVIEW_MODELS}} 中的每个模型进行代码审查：
+**并行调用两个模型**：

+**执行步骤**：
+1. 在**同一个 Bash 调用**中启动两个后台进程（不加 wait，立即返回）：
 ```bash
-# 遍历审查模型列表（默认: codex, gemini）
-for model in $(echo '{{REVIEW_MODELS}}' | jq -r '.[]'); do
-  codeagent-wrapper --backend $model - $PROJECT_DIR <<'EOF' &
-ROLE_FILE: ~/.claude/.ccg/prompts/$model/reviewer.md
+# Codex 后端审查
+~/.claude/bin/codeagent-wrapper --backend codex - "$PWD" <<'EOF' &
+[角色] 后端代码审查专家
+[任务] 审查以下代码变更

-<TASK>
-审查代码: {{待审查的代码变更}}
-关注点: 安全性、性能、错误处理、可访问性、响应式设计、设计一致性
-</TASK>
+## 审查重点
+- 安全性：注入、认证、授权
+- 性能：N+1 查询、缓存、复杂度
+- 错误处理：异常捕获、边界条件
+- 可维护性：命名、结构、文档

-OUTPUT: Review comments only. No code modifications.
-EOF
-done
-wait  # 等待所有后台任务完成
-```
-
-### Step 3: 综合反馈
-使用 `TaskOutput` 获取所有任务的结果，然后：
-1. Collect feedback from all configured models
-2. Categorize by severity (Critical, Major, Minor, Suggestion)
-3. Remove duplicate concerns
-4. Cross-validate findings across models
-5. Prioritize actionable items
-
-### Step 4: 呈现审查结果
-Provide unified review report to user with recommendations.
+## 待审查代码
+<粘贴 git diff 内容>

 ## 输出格式
-1. **Configuration** – models used for review
-2. **Review Summary** – overall assessment
-3. **Critical Issues** – must fix before merge
-4. **Major Issues** – should fix
-5. **Minor Issues** – nice to fix
-6. **Suggestions** – optional improvements
-7. **Recommended Actions** – prioritized fix list
+按 Critical/Major/Minor/Suggestion 分类列出问题
+EOF

-## 注意事项
- **审查模型已在安装时注入**: {{REVIEW_MODELS}}
- **No arguments** = auto-review git changes (`git diff HEAD`)
- **With arguments** = review specified content
- **Use `run_in_background: true` for parallel execution** to avoid blocking
- 多模型结果交叉验证，综合反馈
- Use HEREDOC syntax (`<<'EOF'`) to avoid shell escaping issues
+# Gemini 前端审查
+~/.claude/bin/codeagent-wrapper --backend gemini - "$PWD" <<'EOF' &
+[角色] 前端代码审查专家
+[任务] 审查以下代码变更
+
+## 审查重点
+- 可访问性：ARIA、键盘导航、色彩对比
+- 响应式：移动端适配、断点
+- 设计一致性：组件复用、样式规范
+- 用户体验：加载状态、错误提示
+
+## 待审查代码
+<粘贴 git diff 内容>
+
+## 输出格式
+按 Critical/Major/Minor/Suggestion 分类列出问题
+EOF
+```
+2. 使用 `TaskOutput` 监控并获取 2 个模型的审查结果。
+
+**⚠️ 强制规则：必须等待 TaskOutput 返回两个模型的完整结果后才能进入下一阶段，禁止跳过或提前继续！**
+
+### 🔀 阶段 3：综合反馈
+
+`[模式：综合]`
+
+1. 收集双方审查结果
+2. 按严重程度分类：Critical / Major / Minor / Suggestion
+3. 去重合并 + 交叉验证
+
+### 📊 阶段 4：呈现审查结果
+
+`[模式：总结]`
+
+```markdown
+## 📋 代码审查报告
+
+### 审查范围
+- 变更文件：<数量> | 代码行数：+X / -Y
+
+### 关键问题 (Critical)
+> 必须修复才能合并
+1. <问题描述> - [Codex/Gemini]
+
+### 主要问题 (Major) / 次要问题 (Minor) / 建议 (Suggestions)
+...
+
+### 总体评价
+- 代码质量：[优秀/良好/需改进]
+- 是否可合并：[是/否/需修复后]
+```
+
+---
+
+## 关键规则
+
+1. **无参数 = 审查 git diff** – 自动获取当前变更
+2. **heredoc 语法** – 必须使用 `<<'EOF'` 传递多行任务
+3. **双模型交叉验证** – 后端问题以 Codex 为准，前端问题以 Gemini 为准
+4. **必须等待所有模型返回** – 禁止提前进入下一步
@@ -1,90 +1,116 @@
 ---
-description: 交互式回滚 Git 分支到历史版本；列分支、列版本、二次确认后执行 reset / revert
-allowed-tools: Read(**), Exec(git fetch, git branch, git tag, git log, git reflog, git checkout, git reset, git revert, git switch), Write()
-argument-hint: [--branch <branch>] [--target <rev>] [--mode reset|revert] [--depth <n>] [--dry-run] [--yes]
-# examples:
-#   - /git-rollback                # 全交互模式，dry‑run
-#   - /git-rollback --branch dev   # 直接选 dev，其他交互
-#   - /git-rollback --branch dev --target v1.2.0 --mode reset --yes
+description: '交互式 Git 回滚：安全回滚分支到历史版本，支持 reset/revert 模式'
 ---

-# Claude Command: Git Rollback
+# Rollback - 交互式 Git 回滚

-**目的**：安全、可视地将指定分支回滚到旧版本。
-默认处于 **只读预览 (`--dry-run`)**；真正执行需加 `--yes` 或在交互中确认。
+安全地将分支回滚到指定历史版本，默认 dry-run 模式。

---
-
-## Usage
+## 使用方法

 ```bash
-# 纯交互：列出分支 → 选分支 → 列最近 20 个版本 → 选目标 → 选择 reset 或 revert → 二次确认
-/git-rollback
-
-# 指定分支，其他交互
-/git-rollback --branch feature/calculator
-
-# 指定分支与目标 commit，并用 hard‑reset 一键执行（危险）
-/git-rollback --branch main --target 1a2b3c4d --mode reset --yes
-
-# 只想生成 revert 提交（非破坏式回滚），预览即可
-/git-rollback --branch release/v2.1 --target v2.0.5 --mode revert --dry-run
+/rollback [options]
 ```

-### Options
+## 选项

-| 选项                   | 说明                                                                               |
-| ---------------------- | ---------------------------------------------------------------------------------- |
-| `--branch <branch>`    | 要回滚的分支；缺省时交互选择。                                                     |
-| `--target <rev>`       | 目标版本（commit Hash、Tag、reflog 引用都行）；缺省时交互选择近 `--depth` 条记录。 |
-| `--mode reset\|revert` | `reset`：硬回滚历史；`revert`：生成反向提交保持历史完整。默认询问。                |
-| `--depth <n>`          | 在交互模式下列出最近 n 个版本（默认 20）。                                         |
-| `--dry-run`            | **默认开启**，只预览即将执行的命令。                                               |
-| `--yes`                | 跳过所有确认直接执行，适合 CI/CD 脚本。                                            |
+| 选项 | 说明 |
+|------|------|
+| `--branch <branch>` | 要回滚的分支 |
+| `--target <rev>` | 目标版本（commit/tag/reflog） |
+| `--mode reset\|revert` | 回滚模式 |
+| `--depth <n>` | 列出最近 n 个版本（默认 20） |
+| `--dry-run` | 只预览，不执行（**默认**） |
+| `--yes` | 跳过确认直接执行 |

 ---

-## 交互流程
+## 执行工作流

-1. **同步远端** → `git fetch --all --prune`
-2. **列分支** → `git branch -a`（本地＋远端，过滤受保护分支）
-3. **选分支** → 用户输入或传参
-4. **列版本** → `git log --oneline -n <depth>` + `git tag --merged` + `git reflog -n <depth>`
-5. **选目标** → 用户输入 commit hash / tag
-6. **选模式** → `reset` 或 `revert`
-7. **最终确认** （除非 `--yes`）
-8. **执行回滚**
-   - `reset`：`git switch <branch> && git reset --hard <target>`
-   - `revert`：`git switch <branch> && git revert --no-edit <target>..HEAD`
-9. **推送建议** → 提示是否 `git push --force-with-lease`（reset）或普通 `git push`（revert）
+### 🔍 阶段 1：同步远端
+
+`[模式：准备]`
+
+```bash
+git fetch --all --prune
+```
+
+### 📋 阶段 2：选择分支
+
+`[模式：选择]`
+
+1. 列出本地 + 远端分支
+2. 过滤受保护分支
+3. 用户选择或使用 `--branch` 参数
+
+### 📜 阶段 3：选择版本
+
+`[模式：选择]`
+
+1. 显示最近 N 个版本（`git log --oneline`）
+2. 显示相关 tags（`git tag --merged`）
+3. 用户选择或使用 `--target` 参数
+
+### ⚙️ 阶段 4：选择模式
+
+`[模式：决策]`
+
+| 模式 | 说明 | 推送方式 |
+|------|------|----------|
+| `reset` | 硬回滚，改变历史 | `--force-with-lease` |
+| `revert` | 生成反向提交，保留历史 | 普通 push |
+
+### ⛔ 阶段 5：最终确认
+
+`[模式：确认]`
+
+显示即将执行的命令，等待用户确认（除非 `--yes`）。
+
+### ✅ 阶段 6：执行回滚
+
+`[模式：执行]`
+
+**reset 模式**：
+```bash
+git switch <branch>
+git reset --hard <target>
+```
+
+**revert 模式**：
+```bash
+git switch <branch>
+git revert --no-edit <target>..HEAD
+```

 ---

 ## 安全护栏

- **备份**：执行前自动在 reflog 中记录当前 HEAD，可用 `git switch -c backup/<timestamp>` 恢复。
- **保护分支**：如检测到 `main` / `master` / `production` 等受保护分支且开启 `reset` 模式，将要求额外确认。
- **--dry-run 默认开启**：防止误操作。
- **--force 禁止**：不提供 `--force`；如需强推，请手动输入 `git push --force-with-lease`。
+1. **备份**：执行前自动记录当前 HEAD 到 reflog
+2. **保护分支**：`main`/`master`/`production` 需额外确认
+3. **dry-run 默认**：防止误操作
+4. **禁止 --force**：如需强推，手动执行

 ---

-## 适用场景示例
+## 示例

-| 场景                                            | 调用示例                                                         |
-| ----------------------------------------------- | ---------------------------------------------------------------- |
-| 热修补丁上线后发现 bug，需要回到 Tag `v1.2.0`   | `/git-rollback --branch release/v1 --target v1.2.0 --mode reset` |
-| 运维同事误推了 debug 日志提交，需要生成反向提交 | `/git-rollback --branch main --target 3f2e7c9 --mode revert`     |
-| 调研历史 bug，引导新人浏览分支历史              | `/git-rollback` （全交互，dry‑run）                              |
+```bash
+# 全交互模式（dry-run）
+/rollback

---
+# 指定分支
+/rollback --branch dev

-## 注意
+# 完整指定，一键执行
+/rollback --branch main --target v1.2.0 --mode reset --yes

-1. **reset vs revert**
-   - **reset** 会改变历史，需要强推并可能影响其他协作者，谨慎使用。
-   - **revert** 更安全，生成新提交保留历史，但会增加一次记录。
-2. **嵌入式仓库** 常有大体积二进制文件；回滚前请确保 LFS/子模块状态一致。
-3. 若仓库启用了 CI 强制校验，回滚后可能自动触发流水线；确认管控策略以免误部署旧版本。
+# 生成反向提交
+/rollback --branch release/v2.1 --target v2.0.5 --mode revert
+```

---
+## 注意事项
+
+- **reset vs revert**：reset 改变历史，需强推；revert 更安全
+- **LFS/子模块**：回滚前确保状态一致
+- **CI 触发**：回滚后可能自动触发流水线
@@ -1,83 +1,148 @@
 ---
-description: 多模型测试生成（Codex 后端测试 + Gemini 前端测试）
+description: '多模型测试生成：智能路由 Codex 后端测试 / Gemini 前端测试'
 ---

-## 用法
-`/test <测试目标>`
+# Test - 多模型测试生成
+
+根据代码类型智能路由，生成高质量测试用例。
+
+## 多模型调用语法
+
+**必须使用 heredoc 语法调用 codeagent-wrapper**：
+
+```bash
+~/.claude/bin/codeagent-wrapper --backend <codex|gemini> - [工作目录] <<'EOF'
+<任务内容>
+EOF
+```
+
+## 使用方法
+
+```bash
+/test <测试目标>
+```

 ## 上下文
- 测试目标: $ARGUMENTS
- Codex 生成后端测试，Gemini 生成前端测试

-## 流程
+- 测试目标：$ARGUMENTS
+- 智能路由：后端 → Codex，前端 → Gemini，全栈 → 并行
+- 遵循项目现有测试框架和风格

-### Phase 1: 测试分析
-1. 调用 `mcp__ace-tool__search_context` 检索:
-   - `project_root_path`: 项目根目录绝对路径
-   - `query`: 需要测试的代码/功能描述
-   - 目标代码的完整实现
-   - 现有测试文件和测试框架
-   - 项目测试配置（jest.config, pytest.ini 等）
-2. 识别代码类型：前端组件 / 后端逻辑 / 全栈
-3. 评估当前测试覆盖率和缺口
+## 你的角色
+
+你是**测试工程师**，编排测试生成流程：
+- **Codex** – 后端测试生成（**后端权威**）
+- **Gemini** – 前端测试生成（**前端权威**）
+- **Claude (自己)** – 整合测试、验证运行
+
+---
+
+## 执行工作流
+
+**测试目标**：$ARGUMENTS
+
+### 🔍 阶段 1：测试分析
+
+`[模式：研究]`
+
+1. 检索目标代码的完整实现
+2. 查找现有测试文件和测试框架配置
+3. 识别代码类型：[后端/前端/全栈]
+4. 评估当前测试覆盖率和缺口
+
+### 🔬 阶段 2：智能路由测试生成
+
+`[模式：生成]`

-### Phase 2: 智能路由测试生成
 | 代码类型 | 路由 | 角色 |
 |---------|------|------|
-| 后端 | Codex | `tester` |
-| 前端 | Gemini | `tester` |
+| 后端 | Codex | `tester.md` |
+| 前端 | Gemini | `tester.md` |
 | 全栈 | 并行执行 | 两者 |

-**调用方式**: 使用 `Bash` 工具调用 `codeagent-wrapper`
+**全栈代码并行调用**：

+**执行步骤**：
+1. 在**同一个 Bash 调用**中启动两个后台进程（不加 wait，立即返回）：
 ```bash
-# Codex 后端测试生成
-codeagent-wrapper --backend {{BACKEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/tester.md
+# Codex 后端测试调用
+~/.claude/bin/codeagent-wrapper --backend codex - $PWD <<'EOF' &
+你是后端测试专家，角色提示词见 ~/.claude/.ccg/prompts/codex/tester.md

-<TASK>
-生成测试: {{需要测试的代码}}
-Context: {{现有测试和测试框架配置}}
-</TASK>
+任务：为以下代码生成单元测试
+<代码内容>

-OUTPUT: Unified Diff Patch for test files ONLY.
+要求：
+1. 使用项目现有测试框架
+2. 覆盖正常路径、边界条件、异常处理
+3. 输出完整测试代码
+EOF
+
+# Gemini 前端测试调用
+~/.claude/bin/codeagent-wrapper --backend gemini - $PWD <<'EOF' &
+你是前端测试专家，角色提示词见 ~/.claude/.ccg/prompts/gemini/tester.md
+
+任务：为以下组件生成测试
+<组件代码>
+
+要求：
+1. 使用项目现有测试框架
+2. 测试渲染、交互、状态变化
+3. 输出完整测试代码
 EOF
 ```
+2. 使用 `TaskOutput` 监控并获取 2 个模型的测试代码。

-```bash
-# Gemini 前端测试生成
-codeagent-wrapper --backend {{FRONTEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{FRONTEND_PRIMARY}}/tester.md
+**⚠️ 强制规则：必须等待 TaskOutput 返回两个模型的完整结果后才能进入下一阶段，禁止跳过或提前继续！**

-<TASK>
-生成测试: {{需要测试的代码}}
-Context: {{现有测试和测试框架配置}}
-</TASK>
+### 🔀 阶段 3：测试整合

-OUTPUT: Unified Diff Patch for test files ONLY.
-EOF
-```
+`[模式：计划]`

-根据代码类型选择调用对应模型，全栈代码则并行调用（`run_in_background: true`）。
-
-### Phase 3: 测试整合
-1. 收集模型输出（`TaskOutput`）
+1. 收集模型输出
 2. Claude 重构：统一风格、确保命名一致、优化结构、移除冗余

-### Phase 4: 测试验证
-1. 运行生成的测试
-2. 检查通过率
+### ✅ 阶段 4：测试验证
+
+`[模式：执行]`
+
+1. 创建测试文件
+2. 运行生成的测试
 3. 如有失败，分析原因并修复

+---
+
+## 输出格式
+
+```markdown
+## 🧪 测试生成：<测试目标>
+
+### 分析结果
+- 代码类型：[后端/前端/全栈]
+- 测试框架：<检测到的框架>
+
+### 生成的测试
+- 测试文件：<文件路径>
+- 测试用例数：<数量>
+
+### 运行结果
+- 通过：X / Y
+- 失败：<如有，列出原因>
+```
+
 ## 测试策略金字塔
+
 ```
    /\      E2E (10%)
   /--\     Integration (20%)
  /----\    Unit (70%)
 ```

-## 关键原则
-1. **测试行为，不测试实现** - 关注输入输出
-2. **智能路由** - 后端测试用 Codex，前端测试用 Gemini
-3. **复用现有模式** - 遵循项目已有的测试风格
-4. **覆盖优先级** - 先覆盖关键路径和高风险代码
+---
+
+## 关键规则
+
+1. **测试行为，不测试实现** – 关注输入输出
+2. **智能路由** – 后端测试用 Codex，前端测试用 Gemini
+3. **复用现有模式** – 遵循项目已有的测试风格
+4. **必须等待所有模型返回** – 禁止提前进入下一步
@@ -1,102 +0,0 @@
---
-description: UltraThink 深度分析（双模型并行分析 + 综合见解）
---
-
-## 用法
-`/think <分析主题>`
-
-## 上下文
- 分析主题: $ARGUMENTS
- 使用双模型进行多角度深度分析
- 适用于复杂架构决策、技术选型、问题探索
-
-## 流程
-
-### Phase 1: 上下文收集
-1. 调用 `mcp__ace-tool__search_context` 检索相关代码:
-   - `project_root_path`: 项目根目录绝对路径
-   - `query`: 需要深度分析的问题描述
-2. 识别分析范围和关键组件
-3. 列出已知约束和假设
-
-### Phase 2: 并行深度分析
-**同时调用**（`run_in_background: true`）:
-
-**调用方式**: 使用 `Bash` 工具调用 `codeagent-wrapper`
-
-```bash
-# Codex 后端/系统视角分析
-codeagent-wrapper --backend {{BACKEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/analyzer.md
-
-<TASK>
-深度分析: {{问题或场景}}
-Context: {{从 ace-tool 获取的相关代码}}
-</TASK>
-
-OUTPUT: Structured analysis report with clear reasoning.
-EOF
-```
-
-```bash
-# Gemini 前端/用户视角分析
-codeagent-wrapper --backend {{FRONTEND_PRIMARY}} - $PROJECT_DIR <<'EOF'
-ROLE_FILE: ~/.claude/.ccg/prompts/{{FRONTEND_PRIMARY}}/analyzer.md
-
-<TASK>
-深度分析: {{问题或场景}}
-Context: {{从 ace-tool 获取的相关代码}}
-</TASK>
-
-OUTPUT: Structured analysis report with clear reasoning.
-EOF
-```
-
- **Codex** + `analyzer` 角色 → 后端/系统视角
- **Gemini** + `analyzer` 角色 → 前端/用户视角
-
-### Phase 3: UltraThink 综合
-1. 收集双模型分析报告（`TaskOutput`）
-2. **交叉验证**：
-   - 一致观点（强信号）
-   - 分歧点（需要权衡）
-   - 互补见解
-3. **综合推理**：整合技术和用户视角，形成统一分析框架
-
-### Phase 4: 输出结论
-```
-## 🧠 深度分析: <主题>
-
-### 一致观点（强信号）
-1. <双方都认同的点>
-
-### 分歧点（需权衡）
-| 议题 | Codex 观点 | Gemini 观点 | 建议 |
-|------|------------|-------------|------|
-
-### 核心结论
-<1-2 句话总结>
-
-### 推荐方案
-**首选**: <方案>
- 理由 / 风险 / 缓解措施
-
-### 行动计划
-1. [ ] <短期>
-2. [ ] <中期>
-3. [ ] <长期>
-```
-
-## 适用场景
-| 场景 | 示例 |
-|------|------|
-| 架构决策 | "评估微服务拆分方案" |
-| 技术选型 | "比较 Redux vs Zustand" |
-| 性能分析 | "分析页面加载慢的原因" |
-| 重构评估 | "评估重构遗留模块的风险" |
-
-## 关键原则
-1. **不急于结论** - 充分收集和分析后再下结论
-2. **多视角思考** - 技术 + 用户 + 业务
-3. **量化权衡** - 尽可能用数据支撑判断
-4. **可执行导向** - 分析结果要能指导行动
@@ -0,0 +1,198 @@
+---
+description: '多模型协作开发工作流（研究→构思→计划→执行→优化→评审），智能路由前端→Gemini、后端→Codex'
+---
+
+# Workflow - 多模型协作开发
+
+使用质量把关、MCP 服务和多模型协作执行结构化开发工作流。
+
+## 使用方法
+
+```bash
+/workflow <任务描述>
+```
+
+## 上下文
+
+- 要开发的任务：$ARGUMENTS
+- 带质量把关的结构化 6 阶段工作流
+- 多模型协作：Codex（后端）+ Gemini（前端）+ Claude（编排）
+- MCP 服务集成（ace-tool）以增强功能
+
+## 你的角色
+
+你是**编排者**，协调多模型协作系统（研究 → 构思 → 计划 → 执行 → 优化 → 评审），用中文协助用户，面向专业程序员，交互应简洁专业，避免不必要解释。
+
+**协作模型**：
+- **ace-tool MCP** – 代码检索 + Prompt 增强
+- **Codex** – 后端逻辑、算法、调试（**后端权威，可信赖**）
+- **Gemini** – 前端 UI/UX、视觉设计（**前端高手，后端意见仅供参考**）
+- **Claude (自己)** – 编排、计划、执行、交付
+
+---
+
+---
+
+## 沟通守则
+
+1. 响应以模式标签 `[模式：X]` 开始，初始为 `[模式：研究]`。
+2. 核心工作流严格按 `研究 → 构思 → 计划 → 执行 → 优化 → 评审` 顺序流转。
+3. 每个阶段完成后必须请求用户确认。
+4. 评分低于 7 分或用户未批准时强制停止。
+
+---
+
+## 执行工作流
+
+**任务描述**：$ARGUMENTS
+
+### 🔍 阶段 1：研究与分析
+
+`[模式：研究]` - 理解需求并收集上下文：
+
+1. **Prompt 增强**：调用 `mcp__ace-tool__enhance_prompt`
+2. **上下文检索**：调用 `mcp__ace-tool__search_context`
+3. **需求完整性评分**（0-10 分）：
+   - 目标明确性（0-3）、预期结果（0-3）、边界范围（0-2）、约束条件（0-2）
+   - ≥7 分：继续 | <7 分：⛔ 停止，提出补充问题
+
+### 💡 阶段 2：方案构思
+
+`[模式：构思]` - 多模型并行分析：
+
+**并行调用 Codex 和 Gemini 进行分析**：
+
+1. **Codex 分析**：`~/.claude/.ccg/prompts/codex/analyzer.md`
+2. **Gemini 分析**：`~/.claude/.ccg/prompts/gemini/analyzer.md`
+
+**执行步骤**：
+1. 在**同一个 Bash 调用**中启动两个后台进程（不加 wait，立即返回）：
+```bash
+codeagent-wrapper --backend codex - $PWD <<'EOF' &
+ROLE_FILE: ~/.claude/.ccg/prompts/codex/analyzer.md
+<TASK>
+分析需求: <任务描述>
+Context: <项目上下文>
+</TASK>
+OUTPUT: 技术可行性、推荐方案、风险点
+EOF
+
+codeagent-wrapper --backend gemini - $PWD <<'EOF' &
+ROLE_FILE: ~/.claude/.ccg/prompts/gemini/analyzer.md
+<TASK>
+分析需求: <任务描述>
+Context: <项目上下文>
+</TASK>
+OUTPUT: UI可行性、推荐方案、用户体验
+EOF
+```
+2. 使用 `TaskOutput` 监控并获取 2 个后台进程的输出结果
+
+**⚠️ 强制规则：必须等待 TaskOutput 返回两个模型的完整结果后才能进入下一阶段，禁止跳过或提前继续！**
+
+**注意**：Gemini 可能不会在输出中直接显示 SESSION_ID。如需复用上下文，请查看输出中的 log 文件路径，运行 `grep "SESSION_ID" <log文件>` 获取。
+
+综合两方分析，输出方案对比（至少 2 个方案），等待用户选择。
+
+### 📋 阶段 3：详细规划
+
+`[模式：计划]` - 多模型协作规划：
+
+**并行调用 Codex 和 Gemini 进行架构规划**（使用后台进程 `&`）：
+
+1. **Codex 规划**：`~/.claude/.ccg/prompts/codex/architect.md`
+2. **Gemini 规划**：`~/.claude/.ccg/prompts/gemini/architect.md`
+
+调用示例：
+```bash
+codeagent-wrapper --backend codex - $PWD <<'EOF' &
+ROLE_FILE: ~/.claude/.ccg/prompts/codex/architect.md
+<TASK>
+规划需求: <任务描述>
+Context: <项目上下文>
+</TASK>
+OUTPUT: 后端架构规划
+EOF
+
+codeagent-wrapper --backend gemini - $PWD <<'EOF' &
+ROLE_FILE: ~/.claude/.ccg/prompts/gemini/architect.md
+<TASK>
+规划需求: <任务描述>
+Context: <项目上下文>
+</TASK>
+OUTPUT: 前端架构规划
+EOF
+```
+
+使用 `TaskOutput` 获取 2 个模型的规划结果。
+
+**⚠️ 强制规则：必须等待 Codex 和 Gemini 两个进程都返回完整结果后才能进入下一阶段，禁止跳过或提前继续！**
+
+**Claude 综合规划**：
+- 采纳 Codex 的后端规划（**可信赖**）
+- 采纳 Gemini 的前端规划（**可信赖**）
+- Gemini 的后端建议**仅供参考，以 Codex 为准**
+- 请求用户批准后存入 `.claude/plan/任务名.md`
+
+### ⚡ 阶段 4：实施
+
+`[模式：执行]` - 代码开发：
+
+- 严格按批准的计划实施
+- 遵循项目现有代码规范
+- 在关键里程碑请求反馈
+
+### 🚀 阶段 5：代码优化
+
+`[模式：优化]` - 多模型并行审查：
+
+**并行调用 Codex 和 Gemini 进行代码审查**（使用后台进程 `&`）：
+
+1. **Codex 审查**：`~/.claude/.ccg/prompts/codex/reviewer.md`
+2. **Gemini 审查**：`~/.claude/.ccg/prompts/gemini/reviewer.md`
+
+调用示例：
+```bash
+codeagent-wrapper --backend codex - $PWD <<'EOF' &
+ROLE_FILE: ~/.claude/.ccg/prompts/codex/reviewer.md
+<TASK>
+审查代码: <实施的代码变更>
+关注点: 安全性、性能、错误处理
+</TASK>
+OUTPUT: 审查意见
+EOF
+
+codeagent-wrapper --backend gemini - $PWD <<'EOF' &
+ROLE_FILE: ~/.claude/.ccg/prompts/gemini/reviewer.md
+<TASK>
+审查代码: <实施的代码变更>
+关注点: 可访问性、设计一致性、用户体验
+</TASK>
+OUTPUT: 审查意见
+EOF
+```
+
+使用 `TaskOutput` 获取 2 个模型的审查结果。
+
+**⚠️ 强制规则：必须等待 Codex 和 Gemini 两个进程都返回完整结果后才能进入下一阶段，禁止跳过或提前继续！**
+
+整合审查意见，提出优化建议，用户确认后执行。
+
+### ✅ 阶段 6：质量审查
+
+`[模式：评审]` - 最终评估：
+
+- 对照计划检查完成情况
+- 运行测试验证功能
+- 报告问题与建议
+- 请求最终用户确认
+
+---
+
+## 关键规则
+
+1. 阶段顺序不可跳过（除非用户明确指令）
+2. **多模型调用必须使用后台进程 `&` + `TaskOutput` 获取结果**
+3. **必须等待所有模型返回完整结果后才能进入下一阶段**，禁止跳过或提前继续
+4. 外部模型对文件系统**零写入权限**，所有修改由 Claude 执行
+5. 评分 <7 分或用户未批准时**强制停止**
@@ -1,276 +1,128 @@
 ---
-description: 管理 Git worktree，在项目平级的 ../.ccg/项目名/ 目录下创建，支持智能默认、IDE 集成和内容迁移
-allowed-tools: Read(**), Exec(git worktree add, git worktree list, git worktree remove, git worktree prune, git branch, git checkout, git rev-parse, git stash, git cp, detect-ide, open-ide, which, command, basename, dirname)
-argument-hint: <add|list|remove|prune|migrate> [path] [-b <branch>] [-o|--open] [--track] [--guess-remote] [--detach] [--checkout] [--lock] [--migrate-from <source-path>] [--migrate-stash]
-# examples:
-#   - /git-worktree add feature-ui                     # 从 main/master 创建新分支 'feature-ui'
-#   - /git-worktree add feature-ui -o                  # 创建 worktree 并直接用 IDE 打开
-#   - /git-worktree add hotfix -b fix/login -o         # 创建新分支 'fix/login'，路径为 'hotfix'
-#   - /git-worktree migrate feature-ui --from main     # 将主分支未提交内容迁移到 feature-ui
-#   - /git-worktree migrate feature-ui --stash         # 将当前 stash 迁移到 feature-ui
+description: '管理 Git Worktree：在 ../.ccg/项目名/ 目录创建，支持 IDE 集成和内容迁移'
 ---

-# Claude Command: Git Worktree
+# Worktree - Git Worktree 管理

-管理 Git worktree，支持智能默认、IDE 集成和内容迁移，使用结构化的 `../.ccg/项目名/` 路径。
+在结构化目录管理 Git worktree，支持智能默认和 IDE 集成。

-直接执行命令并提供简洁结果。
-
---
-
-## Usage
+## 使用方法

 ```bash
-# 基本操作
-/git-worktree add <path>                           # 从 main/master 创建名为 <path> 的新分支
-/git-worktree add <path> -b <branch>               # 创建指定名称的新分支
-/git-worktree add <path> -o                        # 创建并直接用 IDE 打开
-/git-worktree list                                 # 显示所有 worktree 状态
-/git-worktree remove <path>                        # 删除指定的 worktree
-/git-worktree prune                                # 清理无效 worktree 记录
-
-# 内容迁移
-/git-worktree migrate <target> --from <source>     # 迁移未提交内容
-/git-worktree migrate <target> --stash             # 迁移 stash 内容
+/worktree <add|list|remove|prune|migrate> [options]
 ```

-### Options
+## 子命令

-| 选项               | 说明                                         |
-| ------------------ | -------------------------------------------- |
-| `add [<path>]`     | 在 `../.ccg/项目名/<path>` 添加新的 worktree |
-| `migrate <target>` | 迁移内容到指定 worktree                      |
-| `list`             | 列出所有 worktree 及其状态                   |
-| `remove <path>`    | 删除指定路径的 worktree                      |
-| `prune`            | 清理无效的 worktree 引用                     |
-| `-b <branch>`      | 创建新分支并检出到 worktree                  |
-| `-o, --open`       | 创建成功后直接用 IDE 打开（跳过询问）        |
-| `--from <source>`  | 指定迁移源路径（migrate 专用）               |
-| `--stash`          | 迁移当前 stash 内容（migrate 专用）          |
-| `--track`          | 设置新分支跟踪对应的远程分支                 |
-| `--guess-remote`   | 自动猜测远程分支进行跟踪                     |
-| `--detach`         | 创建分离 HEAD 的 worktree                    |
-| `--checkout`       | 创建后立即检出（默认行为）                   |
-| `--lock`           | 创建后锁定 worktree                          |
+| 命令 | 说明 |
+|------|------|
+| `add <path>` | 创建新 worktree |
+| `list` | 列出所有 worktree |
+| `remove <path>` | 删除指定 worktree |
+| `prune` | 清理无效引用 |
+| `migrate <target>` | 迁移内容到目标 worktree |
+
+## 选项
+
+| 选项 | 说明 |
+|------|------|
+| `-b <branch>` | 创建新分支 |
+| `-o, --open` | 创建后用 IDE 打开 |
+| `--from <source>` | 迁移源路径 |
+| `--stash` | 迁移 stash 内容 |
+| `--track` | 跟踪远程分支 |
+| `--detach` | 分离 HEAD |
+| `--lock` | 锁定 worktree |

 ---

-## What This Command Does
+## 目录结构

-1. **环境检查**
-   - 通过 `git rev-parse --is-inside-work-tree` 验证 Git 仓库
-   - 检测是否在主仓库或现有 worktree 中，进行智能路径计算
-
-2. **智能路径管理**
-   - 使用 worktree 检测自动从主仓库路径计算项目名
-   - 在结构化的 `../.ccg/项目名/<path>` 目录创建 worktree
-   - 正确处理主仓库和 worktree 执行上下文
-
-```bash
-# worktree 检测的核心路径计算逻辑
-get_main_repo_path() {
-  local git_common_dir=$(git rev-parse --git-common-dir 2>/dev/null)
-  local current_toplevel=$(git rev-parse --show-toplevel 2>/dev/null)
-
-  # 检测是否在 worktree 中
-  if [[ "$git_common_dir" != "$current_toplevel/.git" ]]; then
-    # 在 worktree 中，从 git-common-dir 推导主仓库路径
-    dirname "$git_common_dir"
-  else
-    # 在主仓库中
-    echo "$current_toplevel"
-  fi
-}
-
-MAIN_REPO_PATH=$(get_main_repo_path)
-PROJECT_NAME=$(basename "$MAIN_REPO_PATH")
-WORKTREE_BASE="$MAIN_REPO_PATH/../.ccg/$PROJECT_NAME"
-
-# 始终使用绝对路径防止嵌套问题
-ABSOLUTE_WORKTREE_PATH="$WORKTREE_BASE/<path>"
 ```
-
-**关键修复**: 在现有 worktree 内创建新 worktree 时，始终使用绝对路径以防止出现类似 `../.ccg/project/.ccg/project/path` 的路径嵌套问题。
-
-3. **Worktree 操作**
-   - **add**: 使用智能分支/路径默认创建新 worktree
-   - **list**: 显示所有 worktree 的分支和状态
-   - **remove**: 安全删除 worktree 并清理引用
-   - **prune**: 清理孤立的 worktree 记录
-
-4. **智能默认**
-   - **分支创建**: 未指定 `-b` 时，使用路径名创建新分支
-   - **基础分支**: 新分支从 main/master 分支创建
-   - **路径解析**: 未指定路径时使用分支名作为路径
-   - **IDE 集成**: 自动检测并提示 IDE 打开
-
-5. **内容迁移**
-   - 在 worktree 之间迁移未提交改动
-   - 将 stash 内容应用到目标 worktree
-   - 安全检查防止冲突
-
-6. **安全特性**
-   - **路径冲突防护**: 创建前检查目录是否已存在
-   - **分支检出验证**: 确保分支未被其他地方使用
-   - **绝对路径强制**: 防止在 worktree 内创建嵌套的 `.ccg` 目录
-   - **删除时自动清理**: 同时清理目录和 git 引用
-   - **清晰的状态报告**: 显示 worktree 位置和分支状态
-
-7. **环境文件处理**
-   - **自动检测**: 扫描 `.gitignore` 文件中的环境变量文件模式
-   - **智能复制**: 复制 `.gitignore` 中列出的 `.env` 和 `.env.*` 文件
-   - **排除逻辑**: 跳过 `.env.example` 等模板文件
-   - **权限保护**: 保持原始文件权限和时间戳
-   - **用户反馈**: 提供已复制环境文件的清晰状态信息
-
-```bash
-# 环境文件复制实现
-copy_environment_files() {
-    local main_repo="$MAIN_REPO_PATH"
-    local target_worktree="$ABSOLUTE_WORKTREE_PATH"
-    local gitignore_file="$main_repo/.gitignore"
-    
-    # 检查 .gitignore 是否存在
-    if [[ ! -f "$gitignore_file" ]]; then
-        return 0
-    fi
-    
-    local copied_count=0
-    
-    # 检测 .env 文件
-    if [[ -f "$main_repo/.env" ]] && grep -q "^\.env$" "$gitignore_file"; then
-        cp "$main_repo/.env" "$target_worktree/.env"
-        echo "✅ 已复制 .env"
-        ((copied_count++))
-    fi
-    
-    # 检测 .env.* 模式文件（排除 .env.example）
-    for env_file in "$main_repo"/.env.*; do
-        if [[ -f "$env_file" ]] && [[ "$(basename "$env_file")" != ".env.example" ]]; then
-            local filename=$(basename "$env_file")
-            if grep -q "^\.env\.\*$" "$gitignore_file"; then
-                cp "$env_file" "$target_worktree/$filename"
-                echo "✅ 已复制 $filename"
-                ((copied_count++))
-            fi
-        fi
-    done
-    
-    if [[ $copied_count -gt 0 ]]; then
-        echo "📋 已从 .gitignore 复制 $copied_count 个环境文件"
-    fi
-}
+parent-directory/
+├── your-project/           # 主项目
+│   ├── .git/
+│   └── src/
+└── .ccg/                   # worktree 管理目录
+    └── your-project/
+        ├── feature-ui/     # 功能分支
+        ├── hotfix/         # 修复分支
+        └── debug/          # 调试 worktree
 ```

 ---

-## Enhanced Features
+## 执行工作流

-### IDE 集成
+### Add - 创建 Worktree

- **自动检测**: VS Code → Cursor → WebStorm → Sublime Text → Vim
- **智能提示**: 创建 worktree 后询问是否在 IDE 中打开
- **直接打开**: 使用 `-o` 标志跳过提示直接打开
- **自定义配置**: 通过 git config 配置
+`[模式：创建]`

-### 内容迁移系统
+1. 验证 Git 仓库
+2. 计算路径：`../.ccg/项目名/<path>`
+3. 创建 worktree
+4. 自动复制环境文件（`.env` 等）
+5. 可选：用 IDE 打开

-```bash
-# 迁移未提交改动
-/git-worktree migrate feature-ui --from main
-/git-worktree migrate hotfix --from ../other-worktree
+### Migrate - 迁移内容

-# 迁移 stash 内容
-/git-worktree migrate feature-ui --stash
-```
-
-**迁移流程**:
+`[模式：迁移]`

 1. 验证源有未提交内容
-2. 确保目标 worktree 干净
+2. 确保目标干净
 3. 显示即将迁移的改动
-4. 使用 git 命令安全迁移
-5. 确认结果并建议后续步骤
+4. 安全迁移
+5. 确认结果

 ---

-## Examples
+## 示例

 ```bash
-# 基本用法
-/git-worktree add feature-ui                       # 从 main/master 创建新分支 'feature-ui'
-/git-worktree add feature-ui -b my-feature         # 创建新分支 'my-feature'，路径为 'feature-ui'
-/git-worktree add feature-ui -o                    # 创建并直接用 IDE 打开
+# 基本创建
+/worktree add feature-ui

-# 内容迁移场景
-/git-worktree add feature-ui -b feature/new-ui     # 创建新功能 worktree
-/git-worktree migrate feature-ui --from main       # 迁移未提交改动
-/git-worktree migrate hotfix --stash               # 迁移 stash 内容
+# 创建并用 IDE 打开
+/worktree add feature-ui -o
+
+# 创建指定分支
+/worktree add hotfix -b fix/login -o
+
+# 迁移未提交内容
+/worktree migrate feature-ui --from main
+
+# 迁移 stash 内容
+/worktree migrate feature-ui --stash

 # 管理操作
-/git-worktree list                                 # 查看所有 worktree
-/git-worktree remove feature-ui                    # 删除不需要的 worktree
-/git-worktree prune                                # 清理无效引用
+/worktree list
+/worktree remove feature-ui
+/worktree prune
 ```

-**示例输出**:
+## 输出示例

 ```
 ✅ Worktree created at ../.ccg/项目名/feature-ui
 ✅ 已复制 .env
 ✅ 已复制 .env.local
 📋 已从 .gitignore 复制 2 个环境文件
-🖥️ 是否在 IDE 中打开 ../.ccg/项目名/feature-ui？[y/n]: y
-🚀 正在用 VS Code 打开 ../.ccg/项目名/feature-ui...
+🖥️ 是否在 IDE 中打开？[y/n]: y
+🚀 正在用 VS Code 打开...
 ```

 ---

-## Directory Structure
+## 智能特性

-```
-parent-directory/
-├── your-project/            # 主项目
-│   ├── .git/
-│   └── src/
-└── .ccg/                    # worktree 管理
-    └── your-project/        # 项目 worktree
-        ├── feature-ui/      # 功能分支
-        ├── hotfix/          # 修复分支
-        └── debug/           # 调试 worktree
-```
+1. **智能默认** – 未指定分支时使用路径名
+2. **IDE 集成** – 自动检测 VS Code / Cursor / WebStorm
+3. **环境文件** – 自动复制 `.gitignore` 中的 `.env` 文件
+4. **路径安全** – 始终使用绝对路径防止嵌套问题
+5. **分支保护** – 验证分支未被其他地方使用

---
+## 注意事项

-## Configuration
-
-### IDE 配置
-
- 支持 VS Code、Cursor、WebStorm、Sublime Text、Vim
- 通过 git config 配置自定义 IDE
- 基于优先级的自动检测选择
-
-### 自定义 IDE 设置
-
-```bash
-# 配置自定义 IDE
-git config worktree.ide.custom.sublime "subl %s"
-git config worktree.ide.preferred "sublime"
-
-# 控制自动检测
-git config worktree.ide.autodetect true  # 默认
-```
-
---
-
-## Notes
-
- **性能**: worktree 共享 `.git` 目录，节省磁盘空间
- **安全**: 路径冲突防护和分支检出验证
- **迁移**: 仅限未提交改动；已提交内容需使用 `git cherry-pick`
- **IDE 要求**: 命令行工具必须在 PATH 中
- **跨平台**: 支持 Windows、macOS、Linux
- **环境文件**: 自动复制 `.gitignore` 中列出的环境文件到新 worktree
- **文件排除**: 模板文件如 `.env.example` 仅保留在主仓库中
-
---
+- Worktree 共享 `.git` 目录，节省磁盘空间
+- 迁移仅限未提交改动，已提交内容用 `git cherry-pick`
+- 支持 Windows、macOS、Linux