feat: 增强 command-guide skill 支持深度命令分析和 CLI 辅助查询

新增 Mode 6: 深度命令分析 - 创建 reference 备份目录（80个文档：11 agents + 69 commands） - 支持简单查询（直接文件查找）和复杂查询（CLI 辅助分析） - 集成 gemini/qwen 进行跨命令对比、最佳实践、工作流分析 - 添加查询复杂度自动分类和降级策略更新文档 - SKILL.md: 添加 Mode 6 说明和 Reference Documentation 章节 - implementation-details.md: 添加完整的 Mode 6 实现逻辑 - 版本更新至 v1.3.0 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
2026-02-12 02:37:45 +08:00 · 2025-11-06 16:27:58 +08:00
parent 0ab3d0e1af
commit 1897ba4e82
85 changed files with 30439 additions and 199 deletions
--- a/.claude/skills/command-guide/guides/cli-tools-guide.md
+++ b/.claude/skills/command-guide/guides/cli-tools-guide.md
@@ -1,64 +1,488 @@
-# CLI 智能工具指南
+# CLI 工具使用指南

-Gemini CLI 能够集成多种智能工具（如大型语言模型 LLM），以增强您的开发工作流。本指南将帮助您理解这些智能工具如何工作，以及如何有效地利用它们。
+> 从用户视角理解和使用 Gemini、Qwen、Codex 三大 CLI 工具

-## 1. 什么是智能工具？
+## 🎯 快速理解：CLI 工具是什么？

-智能工具是集成到 Gemini CLI 中的高级 AI 模型，它们能够理解自然语言、分析代码、生成文本和代码，并协助完成复杂的开发任务。它们就像您的智能助手，可以自动化重复性工作，提供洞察，并帮助您做出更好的决策。
+CLI 工具是集成在 Claude DMS3 中的**智能分析和执行助手**。你不需要记忆复杂的命令格式，只需用自然语言描述你想做什么，工具会自动完成。

-## 2. 核心工作原理
+**核心理念**：用自然语言描述需求 → CLI 工具理解并执行 → 返回结果

-Gemini CLI 中的智能工具遵循以下核心原则：
+---

-   **上下文感知**: 工具会理解您当前的项目状态、代码内容和开发意图，从而提供更相关的建议和操作。这意味着它们不会“凭空”回答问题，而是基于您的实际工作环境提供帮助。
-   **模块化**: 智能工具被设计为可互换的后端。您可以根据任务需求选择或组合不同的 LLM。例如，某些模型可能擅长代码生成，而另一些则擅长复杂推理。
-   **自动化与增强**: 智能工具可以自动化重复或复杂的任务（如生成样板代码、基础重构、测试脚手架），并通过提供智能建议、解释和问题解决协助来增强您的开发能力。
-   **用户控制与透明**: 您始终对工具的操作拥有最终控制权。工具会清晰地解释其建议的更改，并允许您轻松审查和修改。工具的选择和执行过程也是透明的。
+## 📋 三大工具能力对比

-详情可参考 `../../workflows/intelligent-tools-strategy.md`。
+| 工具 | 擅长领域 | 典型场景 | 何时使用 |
+|------|----------|----------|----------|
+| **Gemini** | 分析、理解、规划 | 代码分析、架构设计、问题诊断 | 需要深入理解代码或系统 |
+| **Qwen** | 分析、备选方案 | 代码审查、模式识别 | Gemini 不可用时的备选 |
+| **Codex** | 实现、测试、执行 | 功能开发、测试生成、自动化任务 | 需要生成代码或自动执行 |

-## 3. 智能工具的应用场景
+**简单记忆**：
+- 想**理解**什么 → Gemini / Qwen
+- 想**实现**什么 → Codex

-智能工具被集成到 CLI 工作流的多个关键点，以提供全面的帮助：
+---

-   **提示增强**: 优化您的输入提示，使智能工具更好地理解您的需求。
-    -   **命令**: `enhance-prompt`
-   **代码分析与审查**: 快速洞察代码，识别潜在问题，并提出改进建议。
-    -   **命令**: `analyze`, `chat`, `code-analysis`, `bug-diagnosis`
-   **规划与任务分解**: 协助将复杂问题分解为可管理的小任务，并生成实施计划。
-    -   **命令**: `plan`, `discuss-plan`, `breakdown`
-   **代码生成与实现**: 根据您的规范生成代码片段、函数、测试甚至整个模块。
-    -   **命令**: `execute`, `create`, `codex-execute`
-   **测试与调试**: 生成测试用例，诊断错误，并建议修复方案。
-    -   **命令**: `test-gen`, `test-fix-gen`, `tdd-plan`, `tdd-verify`
-   **文档生成**: 自动化代码、API 和项目模块的文档创建。
-    -   **命令**: `docs`, `skill-memory`, `update-full`, `update-related`
-   **工作流编排**: 智能选择和协调工具与代理来执行复杂的工作流。
-    -   **命令**: `workflow:status`, `resume`, `plan`, `execute` (工作流级别)
+## 🚀 如何调用：两种方式

-## 4. 如何选择和使用工具
+### 方式 1：语义调用（推荐，最优雅）

-Gemini CLI 允许您使用 `--tool` 标志来指定用于特定操作的智能工具。这为您提供了灵活性，可以根据任务的性质选择最合适的模型。
-
-   `--tool codex`: 优先使用 Codex（或兼容的专注于代码的 LLM）。非常适合精确的代码生成、重构和类似 linting 的任务。
-    -   **何时使用**: 当您需要生成高质量代码、进行代码审查或修复代码错误时。
-   `--tool gemini`: 优先使用 Gemini（或兼容的通用 LLM）。擅长复杂的推理、更广泛的分析、规划和自然语言理解任务。
-    -   **何时使用**: 当您需要进行高层次的规划、理解复杂概念或进行广泛的代码库分析时。
-   `--tool qwen`: 优先使用 Qwen（或兼容的特定领域/语言 LLM）。适用于需要专业知识或特定语言支持的任务。
-    -   **何时使用**: 当您的项目涉及特定技术栈或需要特定语言的专业知识时。
-   **(默认/自动)**: 如果未指定工具，CLI 会根据任务上下文和可用配置智能地选择最合适的工具。
-
-**示例**:
+**通过 workflow 命令**，用自然语言描述需求，系统自动选择合适的 CLI 工具：

 ```bash
-# 使用 Gemini 进行项目规划
-gemini plan --tool gemini "设计一个新的微服务架构"
+# 自动规划和分析
+/workflow:plan "实现用户认证功能"

-# 使用 Codex 生成代码
-gemini execute --tool codex "task-id-for-code-generation"
+# 自动执行实现
+/workflow:execute

-# 使用 Qwen 分析特定领域的代码
-gemini analyze --tool qwen "分析医疗数据处理模块"
+# 自动生成测试
+/workflow:test-gen WFS-xxx
 ```

-通过理解这些智能工具及其用法，您可以更有效地利用 Gemini CLI，加速您的开发过程。
+**优点**：
+- ✅ 无需指定工具，系统自动选择
+- ✅ 自然语言描述，无需记忆格式
+- ✅ 集成完整工作流
+
+**适用场景**：日常开发任务、标准工作流
+
+---
+
+### 方式 2：直接命令调用（精确控制）
+
+**直接调用特定 CLI 工具**，适合需要精确控制的场景：
+
+#### Gemini/Qwen（分析类）
+
+```bash
+# 基础格式
+/cli:analyze --tool gemini "分析认证模块的安全性"
+
+# 带增强模式
+/cli:analyze --tool gemini --enhance "代码执行流程追踪"
+
+# 指定工作目录
+/cli:analyze --tool gemini --cd src/auth "分析当前模块"
+```
+
+#### Codex（实现类）
+
+```bash
+# 基础执行
+/cli:execute --tool codex "实现 JWT 令牌刷新机制"
+
+# 自动化执行（YOLO 模式）
+/cli:codex-execute "实现用户登录功能"
+
+# 使用 agent 模式
+/cli:execute --agent --tool codex "重构认证服务"
+```
+
+**优点**：
+- ✅ 精确指定工具和模式
+- ✅ 灵活的参数控制
+- ✅ 适合高级用户
+
+**适用场景**：特定工具需求、自定义参数、高级控制
+
+---
+
+## 💡 能力特性清单
+
+### Gemini 能力
+
+**🔍 深度分析**
+- 执行流程追踪
+- 依赖关系分析
+- 代码模式识别
+- 架构评审
+
+**🎯 规划设计**
+- 架构设计
+- 技术方案评估
+- 任务分解
+- 迁移策略
+
+**📚 文档生成**
+- API 文档
+- 模块说明
+- 使用指南
+
+**使用示例**：
+```bash
+# 追踪代码执行流程
+/cli:analyze --tool gemini "追踪用户登录的完整流程"
+
+# 架构设计
+/cli:mode:plan --tool gemini "设计微服务通信架构"
+
+# 代码模式分析
+/cli:analyze --tool gemini "识别项目中的设计模式"
+```
+
+---
+
+### Qwen 能力
+
+**作为 Gemini 的备选方案**，能力基本相同：
+- 代码分析
+- 模式识别
+- 架构评审
+
+**何时使用**：
+- Gemini 不可用
+- 需要第二意见
+- 特定领域分析
+
+**使用示例**：
+```bash
+# Gemini 不可用时的备选
+/cli:analyze --tool qwen "分析数据处理模块"
+
+# 并行使用获取多角度分析
+/cli:analyze --tool gemini "分析认证模块" &
+/cli:analyze --tool qwen "分析认证模块"
+```
+
+---
+
+### Codex 能力
+
+**⚡ 代码实现**
+- 功能开发
+- 组件实现
+- API 创建
+- UI 组件
+
+**🧪 测试生成**
+- 单元测试
+- 集成测试
+- 测试用例
+- TDD 支持
+
+**🔧 代码重构**
+- 结构优化
+- 性能改进
+- 代码清理
+
+**🤖 自动化执行**
+- 完整功能实现
+- Bug 修复
+- 批量操作
+
+**使用示例**：
+```bash
+# 功能实现
+/cli:execute --tool codex "实现用户注册功能，包含邮箱验证"
+
+# 测试生成
+/workflow:test-gen WFS-session-id
+
+# 自动化执行（YOLO 模式）
+/cli:codex-execute --verify-git "重构认证服务，使用依赖注入"
+
+# Bug 修复
+/cli:mode:bug-diagnosis --tool codex "修复登录超时问题"
+```
+
+---
+
+## 🎓 使用场景决策树
+
+```mermaid
+graph TD
+    A[我想...] --> B{是分析还是实现?}
+    B -->|分析理解| C[使用 Gemini/Qwen]
+    B -->|实现开发| D[使用 Codex]
+
+    C --> C1{具体需求?}
+    C1 -->|理解代码流程| C2[/cli:mode:code-analysis]
+    C1 -->|诊断bug| C3[/cli:mode:bug-diagnosis]
+    C1 -->|设计架构| C4[/cli:mode:plan]
+    C1 -->|一般分析| C5[/cli:analyze]
+
+    D --> D1{具体需求?}
+    D1 -->|完整功能| D2[/cli:codex-execute]
+    D1 -->|精确控制| D3[/cli:execute]
+    D1 -->|生成测试| D4[/workflow:test-gen]
+    D1 -->|标准流程| D5[/workflow:execute]
+```
+
+---
+
+## 🔄 典型使用场景
+
+### 场景 1：理解陌生代码库
+
+**需求**：接手新项目，需要快速理解代码结构
+
+**推荐方式**：
+```bash
+# 1. 整体架构分析
+/cli:analyze --tool gemini "分析整个项目的架构设计和模块关系"
+
+# 2. 关键流程追踪
+/cli:mode:code-analysis --tool gemini "追踪用户注册的完整流程"
+
+# 3. 识别技术栈
+/cli:analyze --tool gemini "识别项目使用的技术栈和设计模式"
+```
+
+---
+
+### 场景 2：实现新功能
+
+**需求**：实现用户认证功能
+
+**推荐方式**（语义调用）：
+```bash
+# 完整工作流
+/workflow:plan --agent "实现用户认证功能，包括注册、登录、JWT 令牌"
+/workflow:execute
+/workflow:test-gen WFS-xxx
+```
+
+**或直接调用**（精确控制）：
+```bash
+# 直接实现
+/cli:codex-execute "实现用户认证功能：
+- 用户注册（邮箱+密码）
+- 登录验证
+- JWT 令牌生成和刷新
+- 密码加密存储
+"
+```
+
+---
+
+### 场景 3：诊断 Bug
+
+**需求**：登录功能偶尔超时
+
+**推荐方式**：
+```bash
+# 1. 诊断问题
+/cli:mode:bug-diagnosis --tool gemini "诊断登录超时问题"
+
+# 2. 分析执行流程
+/cli:mode:code-analysis --tool gemini "追踪登录请求的完整执行路径"
+
+# 3. 修复问题（如果需要）
+/cli:execute --tool codex "修复登录超时问题，基于上述分析结果"
+```
+
+---
+
+### 场景 4：代码重构
+
+**需求**：重构认证模块，提高可维护性
+
+**推荐方式**：
+```bash
+# 1. 分析现状
+/cli:analyze --tool gemini "评估当前认证模块的代码质量和可维护性"
+
+# 2. 制定计划
+/cli:mode:plan --tool gemini "制定认证模块重构方案"
+
+# 3. 执行重构
+/cli:execute --tool codex "重构认证模块，按照上述计划执行"
+
+# 4. 生成测试
+/workflow:test-gen WFS-xxx
+```
+
+---
+
+### 场景 5：生成文档
+
+**需求**：为 API 模块生成文档
+
+**推荐方式**：
+```bash
+# 自动生成文档
+/memory:docs src/api --tool gemini --mode full
+```
+
+---
+
+## 🎯 最佳实践
+
+### ✅ 推荐做法
+
+1. **默认使用语义调用**
+   - 通过 `/workflow:*` 命令描述需求
+   - 让系统自动选择合适的工具
+
+2. **分析用 Gemini，实现用 Codex**
+   - 理解问题 → Gemini
+   - 解决问题 → Codex
+
+3. **善用 --enhance 参数**
+   - 让提示自动优化，提高结果质量
+   ```bash
+   /cli:analyze --enhance "分析认证模块"
+   ```
+
+4. **指定工作目录减少噪音**
+   ```bash
+   /cli:analyze --cd src/auth "分析当前模块"
+   ```
+
+5. **并行使用获得多角度**
+   ```bash
+   /cli:analyze --tool gemini "分析方案A"
+   /cli:analyze --tool qwen "分析方案A"  # 对比结果
+   ```
+
+---
+
+### ❌ 避免做法
+
+1. **不要混淆工具职责**
+   - ❌ 用 Gemini 实现功能
+   - ❌ 用 Codex 做架构分析
+
+2. **不要忽略工作目录**
+   - ❌ 在项目根目录分析单个模块
+   - ✅ 使用 `--cd` 切换到目标目录
+
+3. **不要直接编写技术规范**
+   - ❌ 手动构造复杂的 RULES 模板
+   - ✅ 使用 `--enhance` 让系统优化
+
+---
+
+## 🔍 进阶技巧
+
+### 技巧 1：链式分析
+
+```bash
+# 步骤 1：理解现状
+/cli:analyze --tool gemini "分析当前认证实现" > analysis.md
+
+# 步骤 2：基于分析结果制定计划
+/cli:mode:plan --tool gemini "基于 analysis.md，制定改进方案"
+
+# 步骤 3：执行改进
+/cli:execute --tool codex "按照改进方案执行"
+```
+
+---
+
+### 技巧 2：使用 Agent 模式
+
+Agent 模式让 CLI 工具更自主地执行任务：
+
+```bash
+# 标准模式（需要明确指令）
+/cli:execute --tool codex "实现用户登录"
+
+# Agent 模式（更自主，可自行决策）
+/cli:execute --agent --tool codex "实现用户认证系统"
+```
+
+**何时使用 Agent**：
+- 任务复杂，需要多步决策
+- 需要工具自主探索代码库
+- 信任工具的判断
+
+---
+
+### 技巧 3：自定义提示增强
+
+```bash
+# 使用预定义模板增强
+/cli:analyze --enhance "分析认证模块安全性"
+
+# 系统会自动：
+# 1. 识别任务类型（安全分析）
+# 2. 选择合适模板
+# 3. 优化提示词
+# 4. 执行分析
+```
+
+---
+
+## 📚 快速参考
+
+### 常用命令速查
+
+| 需求 | 命令 | 示例 |
+|------|------|------|
+| 代码分析 | `/cli:analyze` | `/cli:analyze --tool gemini "分析auth模块"` |
+| Bug 诊断 | `/cli:mode:bug-diagnosis` | `/cli:mode:bug-diagnosis "登录超时"` |
+| 功能实现 | `/cli:codex-execute` | `/cli:codex-execute "实现用户注册"` |
+| 架构规划 | `/cli:mode:plan` | `/cli:mode:plan "设计微服务架构"` |
+| 生成测试 | `/workflow:test-gen` | `/workflow:test-gen WFS-xxx` |
+| 完整工作流 | `/workflow:plan` + `/workflow:execute` | 最推荐的标准流程 |
+
+---
+
+### 参数速查
+
+| 参数 | 作用 | 示例 |
+|------|------|------|
+| `--tool <gemini\|qwen\|codex>` | 指定CLI工具 | `--tool gemini` |
+| `--enhance` | 自动优化提示 | `--enhance` |
+| `--agent` | 启用Agent模式 | `--agent` |
+| `--cd <路径>` | 切换工作目录 | `--cd src/auth` |
+| `--verify-git` | Git状态验证 | `--verify-git` |
+
+---
+
+## 🆘 常见问题
+
+### Q: 我该用哪个工具？
+
+**A**: 记住简单规则：
+- 想**理解/分析/规划** → Gemini
+- 想**实现/测试/执行** → Codex
+- 不确定 → 用 `/workflow:*` 让系统选
+
+---
+
+### Q: 语义调用和命令调用有什么区别？
+
+**A**:
+- **语义调用**（`/workflow:*`）：自然语言描述，系统自动选工具，适合日常
+- **命令调用**（`/cli:*`）：手动指定工具和参数，适合高级控制
+
+---
+
+### Q: 什么时候用 Agent 模式？
+
+**A**: Agent 模式更自主，适合：
+- 复杂任务需要多步决策
+- 信任工具的判断
+- 想让工具自主探索
+
+**不适合**：
+- 精确控制每一步
+- 不确定工具行为
+- 简单任务
+
+---
+
+### Q: 如何提高结果质量？
+
+**A**:
+1. 使用 `--enhance` 自动优化提示
+2. 明确描述需求和期望
+3. 指定工作目录减少噪音（`--cd`）
+4. 提供上下文（已有的分析、相关代码）
+
+---
+
+## 📖 相关文档
+
+- [Intelligent Tools Strategy](../../workflows/intelligent-tools-strategy.md) - 技术规范和高级配置
+- [Workflow Patterns](workflow-patterns.md) - 标准工作流模式
+- [Getting Started](getting-started.md) - 快速入门指南
+- [Troubleshooting](troubleshooting.md) - 问题排查
+
+---
+
+**最后更新**: 2025-11-06
--- a/.claude/skills/command-guide/guides/getting-started.md
+++ b/.claude/skills/command-guide/guides/getting-started.md
@@ -1,95 +1,242 @@
 # 5分钟快速上手指南

-欢迎来到 Gemini CLI！本指南将帮助您快速了解核心命令，并通过一个简单的工作流示例，让您在5分钟内开始使用。
+> 欢迎使用 Claude DMS3！本指南将帮助您快速上手，5分钟内开始第一个工作流。

-## 1. Gemini CLI 简介
+## 🎯 Claude DMS3 是什么？

-Gemini CLI 是一个强大的命令行工具，旨在通过智能代理和自动化工作流，提升您的开发效率。它能够帮助您进行代码分析、任务规划、代码生成、测试以及文档编写等。
+Claude DMS3 是一个**智能开发管理系统**，集成了 69 个命令，帮助您：
+- 📋 规划和分解复杂任务
+- ⚡ 自动化代码实现
+- 🧪 生成和执行测试
+- 📚 生成项目文档
+- 🤖 使用 AI 工具（Gemini、Qwen、Codex）加速开发

-## 2. 核心命令速览
+**核心理念**：用自然语言描述需求 → 系统自动规划和执行 → 获得结果

-以下是一些您将频繁使用的核心命令：
+---

-### `version` - 查看版本信息
- **用途**: 检查当前 CLI 版本并获取更新信息。
- **示例**:
-  ```bash
-  gemini version
-  ```
+## 🚀 最常用的14个命令

-### `enhance-prompt` - 智能提示增强
- **用途**: 根据当前会话记忆和代码库分析，智能地优化您的输入提示，让代理更好地理解您的意图。
- **示例**:
-  ```bash
-  gemini enhance-prompt "如何修复这个bug？"
-  ```
+### 工作流类（必会）

-### `analyze` - 快速代码分析
- **用途**: 使用 CLI 工具（如 Codex, Gemini, Qwen）对代码库进行快速分析，获取洞察。
- **示例**:
-  ```bash
-  gemini analyze "分析 src/main.py 中的性能瓶颈"
-  ```
+| 命令 | 用途 | 何时使用 |
+|------|------|----------|
+| `/workflow:plan` | 规划任务 | 开始新功能、新项目 |
+| `/workflow:execute` | 执行任务 | plan 之后，实现功能 |
+| `/workflow:test-gen` | 生成测试 | 实现完成后，生成测试 |
+| `/workflow:status` | 查看进度 | 查看工作流状态 |
+| `/workflow:resume` | 恢复任务 | 继续之前的工作流 |

-### `chat` - 交互式对话
- **用途**: 与 CLI 进行简单的交互式对话，直接进行代码分析或提问。
- **示例**:
-  ```bash
-  gemini chat "解释一下 UserService.java 的主要功能"
-  ```
+### CLI 工具类（常用）

-### `plan` - 项目规划与架构分析
- **用途**: 启动项目规划和架构分析工作流，帮助您将复杂问题分解为可执行的任务。
- **示例**:
-  ```bash
-  gemini plan "实现用户认证模块"
-  ```
+| 命令 | 用途 | 何时使用 |
+|------|------|----------|
+| `/cli:analyze` | 代码分析 | 理解代码、分析架构 |
+| `/cli:execute` | 执行实现 | 精确控制实现过程 |
+| `/cli:codex-execute` | 自动化实现 | 快速实现功能 |
+| `/cli:chat` | 问答交互 | 询问代码库问题 |

-### `create` - 创建实现任务
- **用途**: 根据上下文创建具体的实现任务。
- **示例**:
-  ```bash
-  gemini create "编写用户注册接口"
-  ```
+### Memory 类（知识管理）

-### `execute` - 自动执行任务
- **用途**: 自动执行实现任务，智能地推断上下文并协调代理完成工作。
- **示例**:
-  ```bash
-  gemini execute "task-id-123"
-  ```
+| 命令 | 用途 | 何时使用 |
+|------|------|----------|
+| `/memory:docs` | 生成文档 | 生成模块文档 |
+| `/memory:load` | 加载上下文 | 获取任务相关上下文 |

-## 3. 第一个工作流示例：规划与执行一个简单任务
+### Task 类（任务管理）

-让我们通过一个简单的例子来体验 Gemini CLI 的工作流：**规划并实现一个“Hello World”函数**。
+| 命令 | 用途 | 何时使用 |
+|------|------|----------|
+| `/task:create` | 创建任务 | 手动创建单个任务 |
+| `/task:execute` | 执行任务 | 执行特定任务 |

-1.  **规划任务**:
-    首先，我们使用 `plan` 命令来规划我们的“Hello World”功能。
-    ```bash
-    gemini plan "实现一个打印 'Hello World!' 的 Python 函数"
-    ```
-    CLI 将会启动一个规划工作流，可能会询问您一些问题，并最终生成一个或多个任务。
+---

-2.  **创建具体任务**:
-    假设 `plan` 命令为您生成了一个任务 ID，或者您想手动创建一个任务。
-    ```bash
-    gemini create "编写 Python 函数 `say_hello` 打印 'Hello World!'"
-    ```
-    这个命令会创建一个新的任务，并返回一个任务 ID。
+## 📝 第一个工作流：实现一个新功能

-3.  **执行任务**:
-    现在，我们使用 `execute` 命令来让 CLI 自动完成这个任务。请将 `your-task-id` 替换为上一步中获得的实际任务 ID。
-    ```bash
-    gemini execute "your-task-id"
-    ```
-    CLI 将会调用智能代理，根据任务描述生成代码，并尝试将其写入文件。
+让我们通过一个实际例子来体验完整的工作流：**实现用户登录功能**

-通过这三个简单的步骤，您就完成了一个从规划到执行的完整工作流。
+### 步骤 1：规划任务

-## 4. 接下来做什么？
+```bash
+/workflow:plan --agent "实现用户登录功能，包括邮箱密码验证和JWT令牌"
+```

- 探索更多命令：使用 `gemini help` 查看所有可用命令。
- 查阅其他指南：深入了解工作流模式、CLI 工具使用和故障排除。
- 尝试更复杂的任务：挑战自己，使用 Gemini CLI 解决实际项目中的问题。
+**发生什么**：
+- 系统分析需求
+- 自动生成任务计划（IMPL_PLAN.md）
+- 创建多个子任务（task JSON 文件）
+- 返回 workflow session ID（如 WFS-20251106-xxx）

-祝您使用愉快！
+**你会看到**：
+- ✅ 规划完成
+- 📋 任务列表（如：task-001-user-model, task-002-login-api 等）
+- 📁 Session 目录创建
+
+---
+
+### 步骤 2：执行实现
+
+```bash
+/workflow:execute
+```
+
+**发生什么**：
+- 系统自动发现最新的 workflow session
+- 按顺序执行所有任务
+- 使用 Codex 自动生成代码
+- 实时显示进度
+
+**你会看到**：
+- ⏳ Task 1 执行中...
+- ✅ Task 1 完成
+- ⏳ Task 2 执行中...
+- （依次执行所有任务）
+
+---
+
+### 步骤 3：生成测试
+
+```bash
+/workflow:test-gen WFS-20251106-xxx
+```
+
+**发生什么**：
+- 分析实现的代码
+- 生成测试策略
+- 创建测试任务
+
+---
+
+### 步骤 4：查看状态
+
+```bash
+/workflow:status
+```
+
+**发生什么**：
+- 显示当前工作流状态
+- 列出所有任务及其状态
+- 显示已完成/进行中/待执行任务
+
+---
+
+## 🎓 其他常用场景
+
+### 场景 1：快速代码分析
+
+**需求**：理解陌生代码
+
+```bash
+# 分析整体架构
+/cli:analyze --tool gemini "分析项目架构和模块关系"
+
+# 追踪执行流程
+/cli:mode:code-analysis --tool gemini "追踪用户注册的执行流程"
+```
+
+---
+
+### 场景 2：快速实现功能
+
+**需求**：实现一个简单功能
+
+```bash
+# 方式 1：完整工作流（推荐）
+/workflow:plan "添加用户头像上传功能"
+/workflow:execute
+
+# 方式 2：直接实现（快速）
+/cli:codex-execute "添加用户头像上传功能，支持图片裁剪和压缩"
+```
+
+---
+
+### 场景 3：恢复之前的工作
+
+**需求**：继续上次的任务
+
+```bash
+# 查看可恢复的 session
+/workflow:status
+
+# 恢复特定 session
+/workflow:resume WFS-20251106-xxx
+```
+
+---
+
+### 场景 4：生成文档
+
+**需求**：为模块生成文档
+
+```bash
+/memory:docs src/auth --tool gemini --mode full
+```
+
+---
+
+## 💡 快速记忆法
+
+记住这个流程，就能完成大部分任务：
+
+```
+规划 → 执行 → 测试 → 完成
+  ↓      ↓      ↓
+plan → execute → test-gen
+```
+
+**扩展场景**：
+- 需要分析理解 → 使用 `/cli:analyze`
+- 需要精确控制 → 使用 `/cli:execute`
+- 需要快速实现 → 使用 `/cli:codex-execute`
+
+---
+
+## 🆘 遇到问题？
+
+### 命令记不住？
+
+使用 Command Guide SKILL：
+```bash
+ccw  # 或 ccw-help
+```
+
+然后说：
+- "搜索 planning 命令"
+- "执行完 /workflow:plan 后做什么"
+- "我是新手，如何开始"
+
+---
+
+### 执行失败？
+
+1. **查看错误信息**：仔细阅读错误提示
+2. **使用诊断模板**：`ccw-issue` → 选择 "诊断模板"
+3. **查看排查指南**：[Troubleshooting Guide](troubleshooting.md)
+
+---
+
+### 想深入学习？
+
+- **工作流模式**：[Workflow Patterns](workflow-patterns.md) - 学习更多工作流组合
+- **CLI 工具使用**：[CLI Tools Guide](cli-tools-guide.md) - 了解 Gemini/Qwen/Codex 的高级用法
+- **完整命令列表**：查看 `index/essential-commands.json`
+
+---
+
+## 🎯 下一步
+
+现在你已经掌握了基础！尝试：
+
+1. **实践基础工作流**：选择一个小功能，走一遍 plan → execute → test-gen 流程
+2. **探索 CLI 工具**：尝试用 `/cli:analyze` 分析你的代码库
+3. **学习工作流模式**：阅读 [Workflow Patterns](workflow-patterns.md) 了解更多高级用法
+
+**记住**：Claude DMS3 的设计理念是让你用自然语言描述需求，系统自动完成繁琐的工作。不要担心命令记不住，随时可以使用 `ccw` 获取帮助！
+
+---
+
+**祝你使用愉快！** 🎉
+
+有任何问题，使用 `ccw-issue` 提交问题或查询帮助。
--- a/.claude/skills/command-guide/guides/implementation-details.md
+++ b/.claude/skills/command-guide/guides/implementation-details.md
@@ -9,9 +9,11 @@ User Query
    ↓
 Intent Recognition
    ↓
-Mode Selection (1 of 5)
+Mode Selection (1 of 6)
    ↓
-Index/File Query
+Index/File/Reference Query
+    ↓
+Optional CLI Analysis (Mode 6)
    ↓
 Response Formation
    ↓
@@ -51,6 +53,15 @@ function recognizeIntent(userQuery) {
  // Mode 3: Documentation
  if (query.includes('参数') || query.includes('怎么用') ||
      query.includes('如何使用') || query.match(/\/\w+:\w+.*详情/)) {
+
+    // Special case: CLI tools usage guide
+    if (query.match(/cli.*工具/) || query.match(/如何.*使用.*cli/) ||
+        query.match(/gemini|qwen|codex.*使用/) || query.match(/优雅.*使用/) ||
+        query.includes('cli能力') || query.includes('cli特性') ||
+        query.includes('语义调用') || query.includes('命令调用')) {
+      return 'CLI_TOOLS_GUIDE';
+    }
+
    return 'DOCUMENTATION';
  }

@@ -60,6 +71,17 @@ function recognizeIntent(userQuery) {
    return 'ONBOARDING';
  }

+  // Mode 6: Deep Command Analysis
+  // Triggered by specific command/agent names or complexity indicators
+  if (query.match(/\/\w+:\w+/) || // Contains command name pattern
+      query.match(/agent.*工作|实现.*原理|命令.*细节/) || // Asks about internals
+      query.includes('详细说明') || query.includes('实现细节') ||
+      query.match(/对比.*命令|workflow.*对比/) || // Comparison queries
+      query.match(/\w+-agent/) || // Agent name pattern
+      query.includes('最佳实践') && query.match(/\w+:\w+/)) { // Best practices for specific command
+    return 'DEEP_ANALYSIS';
+  }
+
  // Default: Ask for clarification
  return 'CLARIFY';
 }
@@ -225,6 +247,15 @@ async function getRecommendations(currentCommand) {
 - "如何使用 /cli:execute？"
 - "task:create 详细文档"

+**Special Case - CLI Tools Guide**:
+**Keywords**: cli工具, 如何使用cli, gemini/qwen/codex使用, 优雅使用, cli能力, cli特性, 语义调用, 命令调用
+
+**Examples**:
+- "如何优雅的使用cli工具"
+- "cli工具能做什么"
+- "gemini和codex的区别"
+- "语义调用是什么"
+
 ### Processing Flow

 ```
@@ -253,7 +284,32 @@ async function getRecommendations(currentCommand) {
 ### Implementation

 ```javascript
-async function getDocumentation(commandName) {
+async function getDocumentation(commandName, queryType = 'DOCUMENTATION') {
+  // Special case: CLI tools usage guide
+  if (queryType === 'CLI_TOOLS_GUIDE') {
+    const guideContent = await readFile('guides/cli-tools-guide.md');
+    return {
+      type: 'CLI_TOOLS_GUIDE',
+      title: 'CLI 工具使用指南',
+      content: guideContent,
+      sections: {
+        introduction: extractSection(guideContent, '## 🎯 快速理解'),
+        comparison: extractSection(guideContent, '## 📋 三大工具能力对比'),
+        how_to_use: extractSection(guideContent, '## 🚀 如何调用'),
+        capabilities: extractSection(guideContent, '## 💡 能力特性清单'),
+        scenarios: extractSection(guideContent, '## 🔄 典型使用场景'),
+        quick_reference: extractSection(guideContent, '## 📚 快速参考'),
+        faq: extractSection(guideContent, '## 🆘 常见问题')
+      },
+      related_docs: [
+        'intelligent-tools-strategy.md',
+        'workflow-patterns.md',
+        'getting-started.md'
+      ]
+    };
+  }
+
+  // Normal command documentation
  // Normalize command name
  const normalized = normalizeCommandName(commandName);

@@ -460,6 +516,419 @@ async function reportIssue(issueType) {

 ---

+## Mode 6: Deep Command Analysis 🔬
+
+### Trigger Analysis
+
+**Keywords**: 详细说明, 命令原理, agent 如何工作, 实现细节, 对比命令, 最佳实践
+
+**Examples**:
+- "action-planning-agent 如何工作？"
+- "/workflow:plan 的实现原理是什么？"
+- "对比 workflow:plan 和 workflow:tdd-plan"
+- "ui-design-agent 详细说明"
+
+### Processing Flow
+
+```
+1. Parse Query
+   ├─ Identify target command(s)/agent(s)
+   ├─ Determine query complexity
+   └─ Extract specific questions
+   ↓
+2. Classify Query Type
+   ├─ Simple: Single entity, basic explanation
+   └─ Complex: Multi-entity comparison, best practices, workflows
+   ↓
+3. Simple Query Path
+   ├─ Locate file in reference/
+   ├─ Read markdown content
+   ├─ Extract relevant sections
+   └─ Format response
+   ↓
+4. Complex Query Path
+   ├─ Identify all relevant files
+   ├─ Construct CLI analysis prompt
+   ├─ Execute gemini/qwen analysis
+   └─ Return comprehensive results
+   ↓
+5. Response Enhancement
+   ├─ Add usage examples
+   ├─ Link to related docs
+   └─ Suggest next steps
+```
+
+### Query Classification Logic
+
+```javascript
+function classifyDeepAnalysisQuery(query) {
+  const complexityIndicators = {
+    multiEntity: query.match(/对比|比较|区别/) && query.match(/(\/\w+:\w+.*){2,}/),
+    bestPractices: query.includes('最佳实践') || query.includes('推荐用法'),
+    workflowAnalysis: query.match(/工作流.*分析|流程.*说明/),
+    architecturalDepth: query.includes('架构') || query.includes('设计思路'),
+    crossReference: query.match(/和.*一起用|配合.*使用/)
+  };
+
+  const isComplex = Object.values(complexityIndicators).some(v => v);
+
+  return {
+    isComplex,
+    indicators: complexityIndicators,
+    requiresCLI: isComplex
+  };
+}
+```
+
+### Simple Query Implementation
+
+```javascript
+async function handleSimpleQuery(query) {
+  // Extract entity name (command or agent)
+  const entityName = extractEntityName(query); // e.g., "action-planning-agent" or "workflow:plan"
+
+  // Determine if command or agent
+  const isAgent = entityName.includes('-agent') || entityName.includes('agent');
+  const isCommand = entityName.includes(':') || entityName.startsWith('/');
+
+  let filePath;
+  if (isAgent) {
+    // Agent query
+    const agentFileName = entityName.replace(/^\//, '').replace(/-agent$/, '-agent');
+    filePath = `reference/agents/${agentFileName}.md`;
+  } else if (isCommand) {
+    // Command query - need to find in command hierarchy
+    const cmdName = entityName.replace(/^\//, '');
+    filePath = await locateCommandFile(cmdName);
+  }
+
+  // Read documentation
+  const docContent = await readFile(filePath);
+
+  // Extract relevant sections based on query keywords
+  const sections = extractRelevantSections(docContent, query);
+
+  // Format response
+  return {
+    entity: entityName,
+    type: isAgent ? 'agent' : 'command',
+    documentation: sections,
+    full_path: filePath,
+    related: await findRelatedEntities(entityName)
+  };
+}
+
+async function locateCommandFile(commandName) {
+  // Parse command category from name
+  // e.g., "workflow:plan" → "reference/commands/workflow/plan.md"
+  const [category, name] = commandName.split(':');
+
+  // Search in reference/commands hierarchy
+  const possiblePaths = [
+    `reference/commands/${category}/${name}.md`,
+    `reference/commands/${category}/${name}/*.md`,
+    `reference/commands/${name}.md`
+  ];
+
+  for (const path of possiblePaths) {
+    if (await fileExists(path)) {
+      return path;
+    }
+  }
+
+  throw new Error(`Command file not found: ${commandName}`);
+}
+
+function extractRelevantSections(markdown, query) {
+  // Parse markdown into sections
+  const sections = parseMarkdownSections(markdown);
+
+  // Determine which sections are relevant
+  const keywords = extractKeywords(query);
+  const relevantSections = {};
+
+  // Always include overview/description
+  if (sections['## Overview'] || sections['## Description']) {
+    relevantSections.overview = sections['## Overview'] || sections['## Description'];
+  }
+
+  // Include specific sections based on keywords
+  if (keywords.includes('参数') || keywords.includes('参数说明')) {
+    relevantSections.parameters = sections['## Parameters'] || sections['## Arguments'];
+  }
+
+  if (keywords.includes('例子') || keywords.includes('示例') || keywords.includes('example')) {
+    relevantSections.examples = sections['## Examples'] || sections['## Usage'];
+  }
+
+  if (keywords.includes('工作流') || keywords.includes('流程')) {
+    relevantSections.workflow = sections['## Workflow'] || sections['## Process Flow'];
+  }
+
+  if (keywords.includes('最佳实践') || keywords.includes('建议')) {
+    relevantSections.best_practices = sections['## Best Practices'] || sections['## Recommendations'];
+  }
+
+  return relevantSections;
+}
+```
+
+### Complex Query Implementation (CLI-Assisted)
+
+```javascript
+async function handleComplexQuery(query, classification) {
+  // Identify all entities mentioned in query
+  const entities = extractAllEntities(query); // Returns array of command/agent names
+
+  // Build file context for CLI analysis
+  const contextPaths = [];
+  for (const entity of entities) {
+    const path = await resolveEntityPath(entity);
+    contextPaths.push(path);
+  }
+
+  // Construct CLI prompt based on query type
+  const prompt = buildCLIPrompt(query, classification, contextPaths);
+
+  // Execute CLI analysis
+  const cliResult = await executeCLIAnalysis(prompt);
+
+  return {
+    query_type: 'complex',
+    analysis_method: 'CLI-assisted (gemini)',
+    entities_analyzed: entities,
+    result: cliResult,
+    source_files: contextPaths
+  };
+}
+
+function buildCLIPrompt(userQuery, classification, contextPaths) {
+  // Extract key question
+  const question = extractCoreQuestion(userQuery);
+
+  // Build context reference
+  const contextRef = contextPaths.map(p => `@${p}`).join(' ');
+
+  // Determine analysis focus based on classification
+  let taskDescription = '';
+  if (classification.indicators.multiEntity) {
+    taskDescription = `• Compare the entities mentioned in terms of:
+  - Use cases and scenarios
+  - Capabilities and features
+  - When to use each
+  - Workflow integration
+• Provide side-by-side comparison
+• Recommend usage guidelines`;
+  } else if (classification.indicators.bestPractices) {
+    taskDescription = `• Analyze best practices for the mentioned entities
+• Provide practical usage recommendations
+• Include common pitfalls to avoid
+• Show example workflows`;
+  } else if (classification.indicators.workflowAnalysis) {
+    taskDescription = `• Trace the workflow execution
+• Explain process flow and dependencies
+• Identify key integration points
+• Provide usage examples`;
+  } else {
+    taskDescription = `• Provide comprehensive analysis
+• Explain implementation details
+• Show practical examples
+• Include related concepts`;
+  }
+
+  // Construct full prompt using Standard Template
+  return `PURPOSE: Analyze command/agent documentation to provide comprehensive answer to user query
+TASK:
+${taskDescription}
+MODE: analysis
+CONTEXT: ${contextRef}
+EXPECTED: Comprehensive answer with examples, comparisons, and recommendations in markdown format
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt) | Focus on practical usage and real-world scenarios | analysis=READ-ONLY
+
+User Question: ${question}`;
+}
+
+async function executeCLIAnalysis(prompt) {
+  // Change to reference directory for correct file context
+  const cwd = 'reference';
+
+  // Execute gemini with analysis prompt
+  const command = `cd ${cwd} && gemini -p "${escapePrompt(prompt)}" -m gemini-3-pro-preview-11-2025`;
+
+  try {
+    const result = await execBash(command, { timeout: 120000 }); // 2 min timeout
+    return parseAnalysisResult(result.stdout);
+  } catch (error) {
+    // Fallback to qwen if gemini fails
+    console.warn('Gemini failed, falling back to qwen');
+    const fallbackCmd = `cd ${cwd} && qwen -p "${escapePrompt(prompt)}" -m coder-model`;
+    const result = await execBash(fallbackCmd, { timeout: 120000 });
+    return parseAnalysisResult(result.stdout);
+  }
+}
+
+function parseAnalysisResult(rawOutput) {
+  // Extract main content from CLI output
+  // Remove CLI wrapper/metadata, keep analysis content
+  const lines = rawOutput.split('\n');
+  const contentStart = lines.findIndex(l => l.trim().startsWith('#') || l.length > 50);
+  const content = lines.slice(contentStart).join('\n');
+
+  return {
+    raw: rawOutput,
+    parsed: content,
+    format: 'markdown'
+  };
+}
+```
+
+### Helper Functions
+
+```javascript
+function extractEntityName(query) {
+  // Extract command name pattern: /workflow:plan or workflow:plan
+  const cmdMatch = query.match(/\/?(\w+:\w+)/);
+  if (cmdMatch) return cmdMatch[1];
+
+  // Extract agent name pattern: action-planning-agent or action planning agent
+  const agentMatch = query.match(/(\w+(?:-\w+)*-agent|\w+\s+agent)/);
+  if (agentMatch) return agentMatch[1].replace(/\s+/g, '-');
+
+  return null;
+}
+
+function extractAllEntities(query) {
+  const entities = [];
+
+  // Find all command patterns
+  const commands = query.match(/\/?(\w+:\w+)/g);
+  if (commands) {
+    entities.push(...commands.map(c => c.replace('/', '')));
+  }
+
+  // Find all agent patterns
+  const agents = query.match(/(\w+(?:-\w+)*-agent)/g);
+  if (agents) {
+    entities.push(...agents);
+  }
+
+  return [...new Set(entities)]; // Deduplicate
+}
+
+async function resolveEntityPath(entityName) {
+  const isAgent = entityName.includes('-agent');
+
+  if (isAgent) {
+    return `agents/${entityName}.md`;
+  } else {
+    // Command - need to find in hierarchy
+    const [category] = entityName.split(':');
+    // Use glob to find the file
+    const matches = await glob(`commands/${category}/**/${entityName.split(':')[1]}.md`);
+    if (matches.length > 0) {
+      return matches[0];
+    }
+    throw new Error(`Entity file not found: ${entityName}`);
+  }
+}
+
+function extractCoreQuestion(query) {
+  // Remove common prefixes
+  const cleaned = query
+    .replace(/^(请|帮我|能否|可以)/g, '')
+    .replace(/^(ccw|CCW)[:\s]*/gi, '')
+    .trim();
+
+  // Ensure it ends with question mark if it's interrogative
+  if (cleaned.match(/什么|如何|为什么|怎么|哪个/) && !cleaned.endsWith('?') && !cleaned.endsWith('？')) {
+    return cleaned + '？';
+  }
+
+  return cleaned;
+}
+
+function escapePrompt(prompt) {
+  // Escape special characters for bash
+  return prompt
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, '\\$')
+    .replace(/`/g, '\\`');
+}
+```
+
+### Example Outputs
+
+**Simple Query Example**:
+```javascript
+// Input: "action-planning-agent 如何工作？"
+{
+  entity: "action-planning-agent",
+  type: "agent",
+  documentation: {
+    overview: "# Action Planning Agent\n\nGenerates structured task plans...",
+    workflow: "## Workflow\n1. Analyze requirements\n2. Break down into tasks...",
+    examples: "## Examples\n```bash\n/workflow:plan --agent \"feature\"\n```"
+  },
+  full_path: "reference/agents/action-planning-agent.md",
+  related: ["workflow:plan", "task:create", "conceptual-planning-agent"]
+}
+```
+
+**Complex Query Example**:
+```javascript
+// Input: "对比 workflow:plan 和 workflow:tdd-plan 的使用场景和最佳实践"
+{
+  query_type: "complex",
+  analysis_method: "CLI-assisted (gemini)",
+  entities_analyzed: ["workflow:plan", "workflow:tdd-plan"],
+  result: {
+    parsed: `# 对比分析: workflow:plan vs workflow:tdd-plan
+
+## 使用场景对比
+
+### workflow:plan
+- **适用场景**: 通用功能开发，无特殊测试要求
+- **特点**: 灵活的任务分解，focus on implementation
+...
+
+### workflow:tdd-plan
+- **适用场景**: 测试驱动开发，需要严格测试覆盖
+- **特点**: Red-Green-Refactor 循环，test-first
+...
+
+## 最佳实践
+
+### workflow:plan 最佳实践
+1. 先分析需求，明确目标
+2. 合理分解任务，避免过大或过小
+...
+
+### workflow:tdd-plan 最佳实践
+1. 先写测试，明确预期行为
+2. 保持 Red-Green-Refactor 节奏
+...
+
+## 选择建议
+
+| 情况 | 推荐命令 |
+|------|----------|
+| 新功能开发，无特殊测试要求 | workflow:plan |
+| 核心模块，需要高测试覆盖 | workflow:tdd-plan |
+| 快速原型，验证想法 | workflow:plan |
+| 关键业务逻辑 | workflow:tdd-plan |
+`,
+    format: "markdown"
+  },
+  source_files: [
+    "commands/workflow/plan.md",
+    "commands/workflow/tdd-plan.md"
+  ]
+}
+```
+
+---
+
 ## Error Handling

 ### Not Found
@@ -523,4 +992,6 @@ async function readIndex(filename) {

 ---

-**Last Updated**: 2025-01-06
+**Last Updated**: 2025-11-06
+
+**Version**: 1.3.0 - Added Mode 6: Deep Command Analysis with reference documentation backup and CLI-assisted complex queries
--- a/.claude/skills/command-guide/guides/workflow-patterns.md
+++ b/.claude/skills/command-guide/guides/workflow-patterns.md
@@ -1,100 +1,475 @@
 # 常见工作流模式

-Gemini CLI 不仅提供单个命令，更能通过智能编排将一系列命令组合成强大的工作流，帮助您高效完成复杂任务。本指南将介绍几种常见的工作流模式。
+> 学习如何组合命令完成复杂任务，提升开发效率

-## 1. 工作流核心概念
+## 🎯 什么是工作流？

-在深入了解具体模式之前，理解工作流的架构至关重要。Gemini CLI 的工作流管理系统旨在提供一个灵活、可扩展的框架，用于定义、执行和协调复杂的开发任务。
+工作流是**一系列命令的组合**，用于完成特定的开发目标。Claude DMS3 提供了多种工作流模式，覆盖从规划到测试的完整开发周期。

- **工作流 (Workflows)**：一系列任务的组合，旨在实现特定的开发目标。
- **任务 (Tasks)**：工作流中的独立工作单元，可以简单也可以复杂，有状态、输入和输出。
- **智能体 (Agents)**：通常由大型语言模型驱动，负责执行任务或在工作流中做出决策。
- **上下文 (Context)**：当前工作流的相关动态信息，包括项目状态、代码片段、文档、用户输入等，是智能决策的关键。
- **记忆 (Memory)**：持久存储上下文、工作流历史和学习模式，支持工作流的恢复、适应和改进。
+**核心概念**：
+- **工作流（Workflow）**：一组相关任务的集合
+- **任务（Task）**：独立的工作单元，有明确的输入和输出
+- **Session**：工作流的执行实例，记录所有任务状态
+- **上下文（Context）**：任务执行所需的代码、文档、配置等信息

-详情可参考 `../../workflows/workflow-architecture.md`。
+---

-## 2. 规划 -> 执行 (Plan -> Execute) 模式
+## 📋 Pattern 1: 规划→执行（最常用）

-这是最基础也是最常用的工作流模式，它将一个大的目标分解为可执行的步骤，并逐步实现。
+**适用场景**：实现新功能、新模块

-**场景**: 您有一个需要从头开始实现的新功能或模块。
+**流程**：规划 → 执行 → 查看状态

-**主要命令**: 
- `plan`: 启动高级规划过程，分解目标。
- `breakdown`: 进一步细化和分解 `plan` 生成的任务。
- `create`: 创建具体的实施任务。
- `execute`: 执行创建好的任务以实现代码或解决方案。
+### 完整示例

-**工作流示例**:
-1.  **启动规划**: `gemini plan "开发一个用户认证服务"`
-    - CLI 会与您互动，明确需求，并生成一个初步的规划（可能包含多个子任务）。
-2.  **任务分解** (可选，如果规划足够细致可跳过):
-    - 假设 `plan` 产生了一个任务 ID `task-auth-service`。
-    - `gemini breakdown task-auth-service`
-    - 可能进一步分解为 `task-register`, `task-login`, `task-password-reset`等。
-3.  **创建具体实现任务**:
-    - `gemini create "实现用户注册 API 接口"`
-    - 这会生成一个专门针对此任务的 ID，例如 `task-id-register-api`。
-4.  **执行实现任务**:
-    - `gemini execute task-id-register-api`
-    - CLI 将调用智能体自动编写和集成代码。
+```bash
+# 步骤 1：规划任务
+/workflow:plan --agent "实现用户认证模块"

-## 3. 测试驱动开发 (TDD) 模式
+# 系统输出：
+# ✅ 规划完成
+# 📁 Session: WFS-20251106-123456
+# 📋 生成 5 个任务

-TDD 模式强调先编写测试，再编写满足测试的代码，然后重构。Gemini CLI 通过自动化 TDD 流程来支持这一模式。
+# 步骤 2：执行任务
+/workflow:execute

-**场景**: 您正在开发一个新功能，并希望通过 TDD 确保代码质量和正确性。
+# 系统输出：
+# ⏳ 执行 task-001-user-model...
+# ✅ task-001 完成
+# ⏳ 执行 task-002-login-api...
+# ...

-**主要命令**:
- `tdd-plan`: 规划 TDD 工作流，生成红-绿-重构任务链。
- `test-gen`: 根据功能描述生成测试用例。
- `execute`: 执行代码生成和测试。
- `tdd-verify`: 验证 TDD 工作流的合规性并生成质量报告。
+# 步骤 3：查看状态
+/workflow:status

-**工作流示例**:
-1.  **TDD 规划**: `gemini tdd-plan "实现一个购物车功能"`
-    - CLI 将为您创建一个 TDD 任务链，包括测试生成、代码实现和验证。
-2.  **生成测试**: (通常包含在 `tdd-plan` 的早期阶段，或可以单独调用)
-    - `gemini test-gen source-session-id` (如果已有一个实现会话)
-    - 这会产生失败的测试（红）。
-3.  **执行代码实现和测试**: 
-    - `gemini execute task-id-for-code-implementation`
-    - 智能体会编写代码以通过测试，并将执行测试（变为绿）。
-4.  **TDD 验证**: `gemini tdd-verify`
-    - 验证整个 TDD 周期是否规范执行，以及生成测试覆盖率等报告。
+# 系统输出：
+# Session: WFS-20251106-123456
+# Total: 5 | Completed: 5 | Pending: 0
+```

-## 4. UI 设计与实现工作流
+**关键点**：
+- `--agent` 参数使用 AI 生成更详细的计划
+- 系统自动发现最新 session，无需手动指定
+- 所有任务按依赖顺序自动执行

-Gemini CLI 可以辅助您进行 UI 的设计、提取和代码生成，加速前端开发。
+---

-**场景**: 您需要基于一些设计稿或现有网站来快速构建 UI 原型或实现页面。
+## 🧪 Pattern 2: TDD测试驱动开发

-**主要命令**:
- `ui-designer`: 启动 UI 设计分析。
- `layout-extract`: 从参考图像或 URL 提取布局信息。
- `style-extract`: 从参考图像或 URL 提取设计风格。
- `generate`: 组合布局和设计令牌生成 UI 原型。
- `update`: 使用最终设计系统参考更新设计产物。
+**适用场景**：需要高质量代码和测试覆盖

-**工作流示例**:
-1.  **启动 UI 设计分析**: `gemini ui-designer`
-    - 开始一个引导式的流程，定义您的 UI 设计目标。
-2.  **提取布局**: `gemini layout-extract --urls "https://example.com/some-page"`
-    - 从给定 URL 提取页面布局结构。
-3.  **提取样式**: `gemini style-extract --images "./design-mockup.png"`
-    - 从设计图中提取颜色、字体等视觉风格。
-4.  **生成 UI 原型**: `gemini generate --base-path ./my-ui-project`
-    - 结合提取的布局和样式，生成可工作的 UI 代码或原型。
-5.  **更新与迭代**: `gemini update --session ui-design-session-id --selected-prototypes "proto-01,proto-03"`
-    - 根据反馈和最终设计系统，迭代并更新生成的 UI 产物。
+**流程**：TDD规划 → 执行（红→绿→重构）→ 验证

-## 5. 上下文搜索策略
+### 完整示例

-所有这些工作流都依赖于高效的上下文管理。Gemini CLI 采用多层次的上下文搜索策略，以确保智能代理获得最相关的信息。
+```bash
+# 步骤 1：TDD 规划
+/workflow:tdd-plan --agent "实现购物车功能"

- **相关性优先**: 优先收集与当前任务直接相关的上下文，而非大量数据。
- **分层搜索**: 从最直接的来源（如当前打开文件）开始，逐步扩展到项目文件、记忆库和外部资源。
- **语义理解**: 利用智能搜索理解查询的意图，而非仅仅是关键词匹配。
+# 系统输出：
+# ✅ TDD 任务链生成
+# 📋 Red-Green-Refactor 周期：
+#   - task-001-cart-tests (RED)
+#   - task-002-cart-implement (GREEN)
+#   - task-003-cart-refactor (REFACTOR)

-更多细节请查阅 `../../workflows/context-search-strategy.md`。
+# 步骤 2：执行 TDD 周期
+/workflow:execute
+
+# 系统会自动：
+# 1. 生成失败的测试（RED）
+# 2. 实现代码让测试通过（GREEN）
+# 3. 重构代码（REFACTOR）
+
+# 步骤 3：验证 TDD 合规性
+/workflow:tdd-verify
+
+# 系统输出：
+# ✅ TDD 周期完整
+# ✅ 测试覆盖率: 95%
+# ✅ Red-Green-Refactor 合规
+```
+
+**关键点**：
+- TDD 模式自动生成测试优先的任务链
+- 每个任务有依赖关系，确保正确的顺序
+- 验证命令检查 TDD 合规性
+
+---
+
+## 🔄 Pattern 3: 测试生成
+
+**适用场景**：已有代码，需要生成测试
+
+**流程**：分析代码 → 生成测试策略 → 执行测试生成
+
+### 完整示例
+
+```bash
+# 步骤 1：实现功能（已完成）
+# 假设已经完成实现，session 为 WFS-20251106-123456
+
+# 步骤 2：生成测试
+/workflow:test-gen WFS-20251106-123456
+
+# 系统输出：
+# ✅ 分析实现代码
+# ✅ 生成测试策略
+# 📋 创建测试任务：WFS-test-20251106-789
+
+# 步骤 3：执行测试生成
+/workflow:test-cycle-execute --resume-session WFS-test-20251106-789
+
+# 系统输出：
+# ⏳ 生成测试用例...
+# ⏳ 执行测试...
+# ❌ 3 tests failed
+# ⏳ 修复失败测试...
+# ✅ All tests passed
+```
+
+**关键点**：
+- `test-gen` 分析现有代码生成测试
+- `test-cycle-execute` 自动生成→测试→修复循环
+- 最多迭代 N 次直到所有测试通过
+
+---
+
+## 🎨 Pattern 4: UI 设计工作流
+
+**适用场景**：基于设计稿或现有网站实现 UI
+
+**流程**：提取样式 → 提取布局 → 生成原型 → 更新
+
+### 完整示例
+
+```bash
+# 步骤 1：提取设计样式
+/workflow:ui-design:style-extract \
+  --images "design/*.png" \
+  --mode imitate \
+  --variants 3
+
+# 系统输出：
+# ✅ 提取颜色系统
+# ✅ 提取字体系统
+# ✅ 生成 3 个样式变体
+
+# 步骤 2：提取页面布局
+/workflow:ui-design:layout-extract \
+  --urls "https://example.com/dashboard" \
+  --device-type responsive
+
+# 系统输出：
+# ✅ 提取布局结构
+# ✅ 识别组件层次
+# ✅ 生成响应式布局
+
+# 步骤 3：生成 UI 原型
+/workflow:ui-design:generate \
+  --style-variants 2 \
+  --layout-variants 2
+
+# 系统输出：
+# ✅ 生成 4 个原型组合
+# 📁 输出：.workflow/ui-design/prototypes/
+
+# 步骤 4：更新最终版本
+/workflow:ui-design:update \
+  --session ui-session-id \
+  --selected-prototypes "proto-1,proto-3"
+
+# 系统输出：
+# ✅ 应用最终设计系统
+# ✅ 更新所有原型
+```
+
+**关键点**：
+- 支持从图片或 URL 提取设计
+- 可生成多个变体供选择
+- 最终更新使用确定的设计系统
+
+---
+
+## 🔍 Pattern 5: 代码分析→重构
+
+**适用场景**：优化现有代码，提高可维护性
+
+**流程**：分析现状 → 制定计划 → 执行重构 → 生成测试
+
+### 完整示例
+
+```bash
+# 步骤 1：分析代码质量
+/cli:analyze --tool gemini --cd src/auth \
+  "评估认证模块的代码质量、可维护性和潜在问题"
+
+# 系统输出：
+# ✅ 识别 3 个设计问题
+# ✅ 发现 5 个性能瓶颈
+# ✅ 建议 7 项改进
+
+# 步骤 2：制定重构计划
+/cli:mode:plan --tool gemini --cd src/auth \
+  "基于上述分析，制定认证模块重构方案"
+
+# 系统输出：
+# ✅ 重构计划生成
+# 📋 包含 8 个重构任务
+
+# 步骤 3：执行重构
+/cli:execute --tool codex \
+  "按照重构计划执行认证模块重构"
+
+# 步骤 4：生成测试确保正确性
+/workflow:test-gen WFS-refactor-session-id
+```
+
+**关键点**：
+- Gemini 用于分析和规划（理解）
+- Codex 用于执行实现（重构）
+- 重构后必须生成测试验证
+
+---
+
+## 📚 Pattern 6: 文档生成
+
+**适用场景**：为项目或模块生成文档
+
+**流程**：分析代码 → 生成文档 → 更新索引
+
+### 完整示例
+
+```bash
+# 方式 1：为单个模块生成文档
+/memory:docs src/auth --tool gemini --mode full
+
+# 系统输出：
+# ✅ 分析模块结构
+# ✅ 生成 CLAUDE.md
+# ✅ 生成 API 文档
+# ✅ 生成使用指南
+
+# 方式 2：更新所有模块文档
+/memory:update-full --tool gemini
+
+# 系统输出：
+# ⏳ 按层级更新文档...
+# ✅ Layer 3: 12 modules updated
+# ✅ Layer 2: 5 modules updated
+# ✅ Layer 1: 2 modules updated
+
+# 方式 3：只更新修改过的模块
+/memory:update-related --tool gemini
+
+# 系统输出：
+# ✅ 检测 git 变更
+# ✅ 更新 3 个相关模块
+```
+
+**关键点**：
+- `--mode full` 生成完整文档
+- `update-full` 适用于初始化或大规模更新
+- `update-related` 适用于日常增量更新
+
+---
+
+## 🔄 Pattern 7: 恢复和继续
+
+**适用场景**：中断后继续工作，或修复失败的任务
+
+**流程**：查看状态 → 恢复 session → 继续执行
+
+### 完整示例
+
+```bash
+# 步骤 1：查看所有 session
+/workflow:status
+
+# 系统输出：
+# Session: WFS-20251106-123456 (5/10 completed)
+# Session: WFS-20251105-234567 (10/10 completed)
+
+# 步骤 2：恢复特定 session
+/workflow:resume WFS-20251106-123456
+
+# 系统输出：
+# ✅ Session 恢复
+# 📋 5/10 tasks completed
+# ⏳ 待执行: task-006, task-007, ...
+
+# 步骤 3：继续执行
+/workflow:execute --resume-session WFS-20251106-123456
+
+# 系统输出：
+# ⏳ 继续执行 task-006...
+# ✅ task-006 完成
+# ...
+```
+
+**关键点**：
+- 所有 session 状态都被保存
+- 可以随时恢复中断的工作流
+- 恢复时自动分析进度和待办任务
+
+---
+
+## 🎯 Pattern 8: 快速实现（Codex YOLO）
+
+**适用场景**：快速实现简单功能，跳过规划
+
+**流程**：直接执行 → 完成
+
+### 完整示例
+
+```bash
+# 一键实现功能
+/cli:codex-execute --verify-git \
+  "实现用户头像上传功能：
+  - 支持 jpg/png 格式
+  - 自动裁剪为 200x200
+  - 压缩到 100KB 以下
+  - 上传到 OSS
+  "
+
+# 系统输出：
+# ⏳ 分析需求...
+# ⏳ 生成代码...
+# ⏳ 集成现有代码...
+# ✅ 功能实现完成
+# 📁 修改文件:
+#   - src/api/upload.ts
+#   - src/utils/image.ts
+```
+
+**关键点**：
+- 适合简单、独立的功能
+- `--verify-git` 确保 git 状态干净
+- 自动分析需求并完整实现
+
+---
+
+## 🤝 Pattern 9: 多工具协作
+
+**适用场景**：复杂任务需要多个 AI 工具配合
+
+**流程**：Gemini 分析 → Gemini/Qwen 规划 → Codex 实现
+
+### 完整示例
+
+```bash
+# 步骤 1：Gemini 深度分析
+/cli:analyze --tool gemini \
+  "分析支付模块的安全性和性能问题"
+
+# 步骤 2：多工具讨论方案
+/cli:discuss-plan --topic "支付模块重构方案" --rounds 3
+
+# 系统输出：
+# Round 1:
+#   Gemini: 建议方案 A（关注安全）
+#   Codex: 建议方案 B（关注性能）
+# Round 2:
+#   Gemini: 综合分析...
+#   Codex: 技术实现评估...
+# Round 3:
+#   最终方案: 方案 C（安全+性能）
+
+# 步骤 3：Codex 执行实现
+/cli:execute --tool codex "按照方案 C 重构支付模块"
+```
+
+**关键点**：
+- `discuss-plan` 让多个 AI 讨论方案
+- 每个工具贡献自己的专长
+- 最终选择综合最优方案
+
+---
+
+## 📊 工作流选择指南
+
+```mermaid
+graph TD
+    A[我要做什么?] --> B{任务类型?}
+
+    B -->|新功能| C[规划→执行]
+    B -->|需要测试| D{代码是否存在?}
+    B -->|UI开发| E[UI设计工作流]
+    B -->|代码优化| F[分析→重构]
+    B -->|生成文档| G[文档生成]
+    B -->|快速实现| H[Codex YOLO]
+
+    D -->|不存在| I[TDD工作流]
+    D -->|已存在| J[测试生成]
+
+    C --> K[/workflow:plan<br/>↓<br/>/workflow:execute]
+    I --> L[/workflow:tdd-plan<br/>↓<br/>/workflow:execute]
+    J --> M[/workflow:test-gen<br/>↓<br/>/workflow:test-cycle-execute]
+    E --> N[/workflow:ui-design:*]
+    F --> O[/cli:analyze<br/>↓<br/>/cli:mode:plan<br/>↓<br/>/cli:execute]
+    G --> P[/memory:docs]
+    H --> Q[/cli:codex-execute]
+```
+
+---
+
+## 💡 最佳实践
+
+### ✅ 推荐做法
+
+1. **复杂任务使用完整工作流**
+   ```bash
+   /workflow:plan → /workflow:execute → /workflow:test-gen
+   ```
+
+2. **简单任务使用 Codex YOLO**
+   ```bash
+   /cli:codex-execute "快速实现xxx"
+   ```
+
+3. **重要代码使用 TDD**
+   ```bash
+   /workflow:tdd-plan → /workflow:execute → /workflow:tdd-verify
+   ```
+
+4. **定期更新文档**
+   ```bash
+   /memory:update-related  # 每次提交前
+   ```
+
+5. **善用恢复功能**
+   ```bash
+   /workflow:status → /workflow:resume
+   ```
+
+---
+
+### ❌ 避免做法
+
+1. **不要跳过规划直接执行复杂任务**
+   - ❌ 直接 `/cli:execute` 实现复杂功能
+   - ✅ 先 `/workflow:plan` 再 `/workflow:execute`
+
+2. **不要忽略测试**
+   - ❌ 实现完成后不生成测试
+   - ✅ 使用 `/workflow:test-gen` 生成测试
+
+3. **不要遗忘文档**
+   - ❌ 代码实现后忘记更新文档
+   - ✅ 使用 `/memory:update-related` 自动更新
+
+---
+
+## 🔗 相关资源
+
+- **快速入门**：[Getting Started](getting-started.md) - 5分钟上手
+- **CLI 工具**：[CLI Tools Guide](cli-tools-guide.md) - Gemini/Qwen/Codex 详解
+- **问题排查**：[Troubleshooting](troubleshooting.md) - 常见问题解决
+- **完整命令列表**：查看 `index/all-commands.json`
+
+---
+
+**最后更新**: 2025-11-06
+
+记住：选择合适的工作流模式，事半功倍！不确定用哪个？使用 `ccw` 询问 Command Guide！