ccg-ros2-workflow 2.2.1 → 3.0.0

package/templates/commands/spec-research.md

@@ -9,34 +9,32 @@ description: '需求 → 约束集（并行探索 + OPSX 提案）'
 - Strictly adhere to OPSX rules when writing spec-structured documents.
 
 **Guardrails**
-- **STOP! BEFORE ANY OTHER ACTION**: You MUST call `mcp__ace-tool__enhance_prompt` FIRST. This is NON-NEGOTIABLE.
+- **STOP! BEFORE ANY OTHER ACTION**: You MUST perform Prompt Enhancement FIRST. This is NON-NEGOTIABLE.
 - **NEVER** divide subagent tasks by roles (e.g., "架构师agent", "安全专家agent").
 - **ALWAYS** divide by context boundaries (e.g., "user-related code", "authentication logic").
 - Each subagent context must be self-contained with independent output.
 - Use `{{MCP_SEARCH_TOOL}}` to minimize grep/find operations.
 - Do not make architectural decisions—surface constraints that guide decisions.
+- **USER GUIDANCE RULE**: When suggesting next steps to the user, ALWAYS use CCG commands (`/ccg:spec-research`, `/ccg:spec-plan`, `/ccg:spec-impl`, `/ccg:spec-review`). NEVER suggest `/opsx:*` commands to the user. If OpenSpec CLI returns error messages referencing OPSX skills, translate them to CCG equivalents.
+- **PHASE BOUNDARY**: This phase ONLY generates the OPSX proposal artifact. Do NOT modify any source code. Do NOT proceed to planning or implementation. After the proposal is generated, STOP and inform the user: "Research complete. Run `/ccg:spec-plan` to continue."
 
 **Steps**
 0. **MANDATORY: Enhance Requirement FIRST**
-   - **DO THIS IMMEDIATELY. DO NOT SKIP. DO NOT CALL ANY OTHER TOOL FIRST.**
-   - Call:
-   ```
-   mcp__ace-tool__enhance_prompt({
-     prompt: "$ARGUMENTS",
-     conversation_history: "<recent conversation>",
-     project_root_path: "{{WORKDIR}}"
-   })
-   ```
-   - Wait for enhanced prompt result.
+   - **DO THIS IMMEDIATELY. DO NOT SKIP.**
+   - **Prompt 增强**（按 `/ccg:enhance` 的逻辑执行）：分析 $ARGUMENTS 的意图、缺失信息、隐含假设，补全为结构化需求（明确目标、技术约束、范围边界、验收标准）。
    - Use enhanced prompt for ALL subsequent steps.
 
 1. **Generate OPSX Change**
-   - Create a new change using OPSX command:
+   - Check if change already exists:
      ```bash
-     /opsx:new "<brief-descriptive-name>"
+     openspec list --json
+     ```
+   - If change doesn't exist, create it:
+     ```bash
+     openspec new change "<brief-descriptive-name>"
      ```
    - This scaffolds `openspec/changes/<name>/` with proposal.md.
-   - If change already exists, use `/opsx:list` to find it and continue.
+   - If change already exists, continue with existing change.
 
 2. **Initial Codebase Assessment**
    - Use `{{MCP_SEARCH_TOOL}}` to scan codebase.
@@ -51,7 +49,11 @@ description: '需求 → 约束集（并行探索 + OPSX 提案）'
    - Each boundary should be self-contained: no cross-communication needed.
 
 4. **Parallel Multi-Model Exploration**
-   - Dispatch Explore subagents with unified output template:
+   - **CRITICAL**: You MUST launch BOTH {{BACKEND_PRIMARY}} AND {{FRONTEND_PRIMARY}} in a SINGLE message with TWO Bash tool calls.
+   - **DO NOT** call one model first and wait. Launch BOTH simultaneously with `run_in_background: true`.
+   - **工作目录**：`{{WORKDIR}}` **必须通过 Bash 执行 `pwd`（Unix）或 `cd`（Windows CMD）获取当前工作目录的绝对路径**，禁止从 `$HOME` 或环境变量推断。如果用户通过 `/add-dir` 添加了多个工作区，先确定任务相关的工作区。
+
+   **Output Template** (instruct both models to use this format):
    ```json
    {
      "module_name": "context boundary explored",
@@ -64,7 +66,37 @@ description: '需求 → 约束集（并行探索 + OPSX 提案）'
      "success_criteria_hints": ["observable success behaviors"]
    }
    ```
-   - Run Codex for backend boundaries, Gemini for frontend boundaries.
+
+   **Step 4.1**: In ONE message, make TWO parallel Bash calls:
+
+   **FIRST Bash call ({{BACKEND_PRIMARY}} — backend boundaries)**:
+   ```
+   Bash({
+     command: "~/.claude/bin/codeagent-wrapper --progress --backend {{BACKEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}- \"{{WORKDIR}}\" <<'EOF'\nExplore backend context boundaries for <change description>:\n- Existing structures and patterns\n- Conventions in use\n- Hard constraints limiting solution space\n- Dependencies and risks\nOUTPUT: JSON using the output template above\nEOF",
+     run_in_background: true,
+     timeout: 300000,
+     description: "{{BACKEND_PRIMARY}}: backend boundary exploration"
+   })
+   ```
+
+   **SECOND Bash call ({{FRONTEND_PRIMARY}} — frontend boundaries) - IN THE SAME MESSAGE**:
+   ```
+   Bash({
+     command: "~/.claude/bin/codeagent-wrapper --progress --backend {{FRONTEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}- \"{{WORKDIR}}\" <<'EOF'\nExplore frontend context boundaries for <change description>:\n- Existing structures and patterns\n- Conventions in use\n- Hard constraints limiting solution space\n- Dependencies and risks\nOUTPUT: JSON using the output template above\nEOF",
+     run_in_background: true,
+     timeout: 300000,
+     description: "{{FRONTEND_PRIMARY}}: frontend boundary exploration"
+   })
+   ```
+
+   **Step 4.2**: After BOTH Bash calls return task IDs, wait for results with TWO TaskOutput calls:
+   ```
+   TaskOutput({ task_id: "<codex_task_id>", block: true, timeout: 600000 })
+   TaskOutput({ task_id: "<gemini_task_id>", block: true, timeout: 600000 })
+   ```
+
+   ⛔ **上层应用模型失败必须重试**：若上层应用模型调用失败，最多重试 2 次（间隔 5 秒）。3 次全败才跳过。
+   ⛔ **底层控制模型结果必须等待**：底层控制模型执行 5-15 分钟属正常，超时后继续轮询，禁止跳过。
 
 5. **Aggregate and Synthesize**
    - Collect all subagent outputs.
@@ -83,22 +115,42 @@ description: '需求 → 约束集（并行探索 + OPSX 提案）'
    - Capture responses as additional constraints.
 
 7. **Finalize OPSX Proposal**
-   - Transform constraint sets into OPSX format:
-     * **Context**: User need + discovered constraints
-     * **Requirements**: Each constraint becomes requirement with scenario
-     * **Success Criteria**: Derived from hints and user confirmations
-   - Ensure proposal includes:
-     * All discovered constraints as requirements
-     * Verifiable scenarios for each requirement
-     * Clear dependencies and sequencing
-     * Risk mitigation strategies
+   - **BEFORE calling `/opsx:continue`** (internal skill call — do NOT expose this command to user), output a structured summary for OPSX context:
+     ```markdown
+     ## Research Summary for OPSX
+
+     **Discovered Constraints**:
+     - [List all hard and soft constraints from Step 5]
+
+     **Dependencies**:
+     - [List cross-module dependencies]
+
+     **Risks & Mitigations**:
+     - [List identified risks and mitigation strategies]
+
+     **Success Criteria**:
+     - [List verifiable success behaviors]
+
+     **User Confirmations**:
+     - [List all user decisions from Step 6]
+     ```
+
+   - Then call `/opsx:continue` internally to generate proposal artifact:
+     ```
+     /opsx:continue
+     ```
+   - The OPSX skill will use the above summary to write proposal.md.
+   - **Note**: This is an internal call. If this step fails, guide the user to re-run `/ccg:spec-research`.
+   - **STOP**: After proposal is generated, verify it exists and inform user:
+     "Research phase complete. Proposal generated. Run `/ccg:spec-plan` to continue planning."
+     Do NOT proceed to planning or implementation.
 
 8. **Context Checkpoint**
    - Report current context usage.
    - If approaching 80K tokens, suggest: "Run `/clear` and continue with `/ccg:spec-plan`"
 
 **Reference**
-- OPSX CLI: `/opsx:status`, `/opsx:show`
+- OPSX CLI: `openspec status --change "<id>" --json`, `openspec list --json`
 - Check prior research: `ls openspec/changes/*/`
 - Use `AskUserQuestion` for ANY ambiguity—never assume or guess
 <!-- CCG:SPEC:RESEARCH:END -->

package/templates/commands/spec-review.md

@@ -9,44 +9,45 @@ description: '双模型交叉审查（独立工具，随时可用）'
 - This is an independent review tool—can be used anytime, not tied to archive workflow.
 
 **Guardrails**
-- **MANDATORY**: Both Codex AND Gemini must complete review before synthesis.
+- **MANDATORY**: Both {{BACKEND_PRIMARY}} AND {{FRONTEND_PRIMARY}} must complete review before synthesis.
 - Review scope is strictly limited to the proposal's changes—no scope creep.
-- Refer to `openspec/AGENTS.md` for spec conventions if reviewing OpenSpec proposals.
+- Refer to `openspec/config.yaml` for project conventions when reviewing OpenSpec proposals.
 
 **Steps**
 1. **Select Proposal**
-   - Run `/opsx:list` to display Active Changes.
+   - Run `openspec list --json` to display Active Changes.
    - Confirm with user which proposal ID to review.
-   - Run `/opsx:show <proposal_id>` to load spec and tasks.
+   - Run `openspec status --change "<proposal_id>" --json` to load spec and tasks.
 
 2. **Collect Implementation Artifacts**
    - Identify all files modified by this proposal.
-   - Use `git diff` or `/opsx:diff <proposal_id>` to get change summary.
+   - Use `git diff` to get change summary.
    - Load relevant spec constraints and PBT properties from `openspec/changes/<id>/specs/`.
 
 3. **Multi-Model Review (PARALLEL)**
-   - **CRITICAL**: You MUST launch BOTH Codex AND Gemini in a SINGLE message with TWO Bash tool calls.
+   - **CRITICAL**: You MUST launch BOTH {{BACKEND_PRIMARY}} AND {{FRONTEND_PRIMARY}} in a SINGLE message with TWO Bash tool calls.
    - **DO NOT** call one model first and wait. Launch BOTH simultaneously with `run_in_background: true`.
+   - **工作目录**：`{{WORKDIR}}` **必须通过 Bash 执行 `pwd`（Unix）或 `cd`（Windows CMD）获取当前工作目录的绝对路径**，禁止从 `$HOME` 或环境变量推断。如果用户通过 `/add-dir` 添加了多个工作区，先确定任务相关的工作区。
 
    **Step 3.1**: In ONE message, make TWO parallel Bash calls:
 
-   **FIRST Bash call (Codex)**:
+   **FIRST Bash call ({{BACKEND_PRIMARY}})**:
    ```
    Bash({
-     command: "~/.claude/bin/codeagent-wrapper --backend codex - \"{{WORKDIR}}\" <<'EOF'\nReview proposal <proposal_id> implementation:\n\n## Codex Review Dimensions\n1. **Spec Compliance**: Verify ALL constraints from spec are satisfied\n2. **PBT Properties**: Check invariants, idempotency, bounds are correctly implemented\n3. **Logic Correctness**: Edge cases, error handling, algorithm correctness\n4. **Backend Security**: Injection vulnerabilities, auth checks, input validation\n5. **Regression Risk**: Interface compatibility, type safety, breaking changes\n\n## Output Format (JSON)\n{\n  \"findings\": [\n    {\n      \"severity\": \"Critical|Warning|Info\",\n      \"dimension\": \"spec_compliance|pbt|logic|security|regression\",\n      \"file\": \"path/to/file.ts\",\n      \"line\": 42,\n      \"description\": \"What is wrong\",\n      \"constraint_violated\": \"Constraint ID from spec (if applicable)\",\n      \"fix_suggestion\": \"How to fix\"\n    }\n  ],\n  \"passed_checks\": [\"List of verified constraints/properties\"],\n  \"summary\": \"Overall assessment\"\n}\nEOF",
+     command: "~/.claude/bin/codeagent-wrapper --progress --backend {{BACKEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}- \"{{WORKDIR}}\" <<'EOF'\nReview proposal <proposal_id> implementation:\n\n## {{BACKEND_PRIMARY}} Review Dimensions\n1. **Spec Compliance**: Verify ALL constraints from spec are satisfied\n2. **PBT Properties**: Check invariants, idempotency, bounds are correctly implemented\n3. **Logic Correctness**: Edge cases, error handling, algorithm correctness\n4. **Backend Security**: Injection vulnerabilities, auth checks, input validation\n5. **Regression Risk**: Interface compatibility, type safety, breaking changes\n\n## Output Format (JSON)\n{\n  \"findings\": [\n    {\n      \"severity\": \"Critical|Warning|Info\",\n      \"dimension\": \"spec_compliance|pbt|logic|security|regression\",\n      \"file\": \"path/to/file.ts\",\n      \"line\": 42,\n      \"description\": \"What is wrong\",\n      \"constraint_violated\": \"Constraint ID from spec (if applicable)\",\n      \"fix_suggestion\": \"How to fix\"\n    }\n  ],\n  \"passed_checks\": [\"List of verified constraints/properties\"],\n  \"summary\": \"Overall assessment\"\n}\nEOF",
      run_in_background: true,
      timeout: 300000,
-     description: "Codex: backend/logic review"
+     description: "{{BACKEND_PRIMARY}}: backend/logic review"
    })
    ```
 
-   **SECOND Bash call (Gemini) - IN THE SAME MESSAGE**:
+   **SECOND Bash call ({{FRONTEND_PRIMARY}}) - IN THE SAME MESSAGE**:
    ```
    Bash({
-     command: "~/.claude/bin/codeagent-wrapper --backend gemini {{GEMINI_MODEL_FLAG}}- \"{{WORKDIR}}\" <<'EOF'\nReview proposal <proposal_id> implementation:\n\n## Gemini Review Dimensions\n1. **Pattern Consistency**: Naming conventions, code style, project patterns\n2. **Maintainability**: Readability, complexity, documentation adequacy\n3. **Integration Risk**: Dependency changes, cross-module impacts\n4. **Frontend Security**: XSS, CSRF, sensitive data exposure\n5. **Spec Alignment**: Implementation matches spec intent (not just letter)\n\n## Output Format (JSON)\n{\n  \"findings\": [\n    {\n      \"severity\": \"Critical|Warning|Info\",\n      \"dimension\": \"patterns|maintainability|integration|security|alignment\",\n      \"file\": \"path/to/file.ts\",\n      \"line\": 42,\n      \"description\": \"What is wrong\",\n      \"spec_reference\": \"Spec section (if applicable)\",\n      \"fix_suggestion\": \"How to fix\"\n    }\n  ],\n  \"passed_checks\": [\"List of verified aspects\"],\n  \"summary\": \"Overall assessment\"\n}\nEOF",
+     command: "~/.claude/bin/codeagent-wrapper --progress --backend {{FRONTEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}- \"{{WORKDIR}}\" <<'EOF'\nReview proposal <proposal_id> implementation:\n\n## {{FRONTEND_PRIMARY}} Review Dimensions\n1. **Pattern Consistency**: Naming conventions, code style, project patterns\n2. **Maintainability**: Readability, complexity, documentation adequacy\n3. **Integration Risk**: Dependency changes, cross-module impacts\n4. **Frontend Security**: XSS, CSRF, sensitive data exposure\n5. **Spec Alignment**: Implementation matches spec intent (not just letter)\n\n## Output Format (JSON)\n{\n  \"findings\": [\n    {\n      \"severity\": \"Critical|Warning|Info\",\n      \"dimension\": \"patterns|maintainability|integration|security|alignment\",\n      \"file\": \"path/to/file.ts\",\n      \"line\": 42,\n      \"description\": \"What is wrong\",\n      \"spec_reference\": \"Spec section (if applicable)\",\n      \"fix_suggestion\": \"How to fix\"\n    }\n  ],\n  \"passed_checks\": [\"List of verified aspects\"],\n  \"summary\": \"Overall assessment\"\n}\nEOF",
      run_in_background: true,
      timeout: 300000,
-     description: "Gemini: patterns/integration review"
+     description: "{{FRONTEND_PRIMARY}}: patterns/integration review"
    })
    ```
 
@@ -56,6 +57,9 @@ description: '双模型交叉审查（独立工具，随时可用）'
    TaskOutput({ task_id: "<gemini_task_id>", block: true, timeout: 600000 })
    ```
 
+   ⛔ **上层应用模型失败必须重试**：若上层应用模型调用失败，最多重试 2 次（间隔 5 秒）。3 次全败才跳过。
+   ⛔ **底层控制模型结果必须等待**：底层控制模型执行 5-15 分钟属正常，超时后继续轮询，禁止跳过。
+
 4. **Synthesize Findings**
    - Merge findings from both models.
    - Deduplicate overlapping issues.
@@ -96,7 +100,7 @@ description: '双模型交叉审查（独立工具，随时可用）'
 
 7. **Optional: Inline Fix Mode**
    - If user chooses "Fix now" for Critical issues:
-     * Route each fix to appropriate model (backend→Codex, frontend→Gemini).
+     * Route each fix to appropriate model (backend→{{BACKEND_PRIMARY}}, frontend→{{FRONTEND_PRIMARY}}).
      * Apply fix using unified diff patch pattern.
      * Re-run affected review dimension.
      * Repeat until Critical = 0.
@@ -107,14 +111,14 @@ description: '双模型交叉审查（独立工具，随时可用）'
 
 **Exit Criteria**
 Review is complete when:
-- [ ] Both Codex and Gemini reviews completed
+- [ ] Both {{BACKEND_PRIMARY}} and {{FRONTEND_PRIMARY}} reviews completed
 - [ ] All findings synthesized and classified
 - [ ] Zero Critical issues remain (fixed or user-acknowledged)
 - [ ] User decision captured (archive / return to impl / defer)
 
 **Reference**
-- View proposal: `/opsx:show <id>`
+- View proposal: `openspec status --change "<id>" --json`
 - Check spec constraints: `rg -n "CONSTRAINT:|MUST|INVARIANT:" openspec/changes/<id>/specs/`
-- View implementation diff: `/opsx:diff <id>` or `git diff`
+- View implementation diff: `git diff`
 - Archive (after passing): `/ccg:spec-impl` → Step 10
 <!-- CCG:SPEC:REVIEW:END -->

package/templates/{commands → commands-legacy}/analyze.md

@@ -79,7 +79,7 @@ TaskOutput({ task_id: "<task_id>", block: true, timeout: 600000 })
 
 ### 🔍 阶段 0：Prompt 增强（可选）
 
-`[模式：准备]` - 如 ace-tool MCP 可用，调用 `mcp__ace-tool__enhance_prompt`，**用增强结果替代原始 $ARGUMENTS，后续调用 Codex/Gemini 时传入增强后的需求**
+`[模式：准备]` - 直接将 $ARGUMENTS 作为后续多模型调用的输入。
 
 ### 🔍 阶段 1：上下文检索
 

package/templates/commands-legacy/backend.md

@@ -0,0 +1,224 @@
+---
+description: 'ROS2 底层控制专项工作流（研究→构思→计划→执行→优化→评审），{{BACKEND_PRIMARY}} 主导'
+---
+
+# Backend - ROS2 底层控制专项开发
+
+## 使用方法
+
+```bash
+/backend <底层控制任务描述>
+```
+
+## 上下文
+
+- 底层控制任务：$ARGUMENTS
+- {{BACKEND_PRIMARY}} 主导，{{FRONTEND_PRIMARY}} 辅助参考
+- 适用：C++ 节点、硬件驱动、实时控制算法、消息定义、控制器实现
+- 目标平台：ROS2 Humble
+
+## 你的角色
+
+你是**ROS2 底层控制编排者**，协调多模型完成 C++/驱动/实时控制任务（研究 → 构思 → 计划 → 执行 → 优化 → 评审），用中文协助用户。
+
+**协作模型**：
+- **{{BACKEND_PRIMARY}}** – 底层控制：C++、硬件驱动、实时算法（**底层权威，可信赖**）
+- **{{FRONTEND_PRIMARY}}** – 上层视角（**底层意见仅供参考**）
+- **Claude (自己)** – 编排、计划、执行、交付
+
+---
+
+## 多模型调用规范
+
+**工作目录**：
+- `{{WORKDIR}}`：**必须通过 Bash 执行 `pwd`（Unix）或 `cd`（Windows CMD）获取当前工作目录的绝对路径**，禁止从 `$HOME` 或环境变量推断
+- 如果用户通过 `/add-dir` 添加了多个工作区，先用 Glob/Grep 确定任务相关的工作区
+- 如果无法确定，用 `AskUserQuestion` 询问用户选择目标工作区
+
+**调用语法**：
+
+```
+# 新会话调用
+Bash({
+  command: "~/.claude/bin/codeagent-wrapper {{LITE_MODE_FLAG}}--progress --backend {{BACKEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}- \"{{WORKDIR}}\" <<'EOF'
+ROLE_FILE: <角色提示词路径>
+<TASK>
+需求：<增强后的需求（如未增强则用 $ARGUMENTS）>
+上下文：<前序阶段收集的项目上下文、分析结果等>
+ROS2上下文：<colcon工作空间、package.xml、现有C++节点、消息定义、硬件接口等>
+</TASK>
+OUTPUT: 期望输出格式
+EOF",
+  run_in_background: false,
+  timeout: 3600000,
+  description: "简短描述"
+})
+
+# 复用会话调用
+Bash({
+  command: "~/.claude/bin/codeagent-wrapper {{LITE_MODE_FLAG}}--progress --backend {{BACKEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}resume <BACKEND_SESSION> - \"{{WORKDIR}}\" <<'EOF'
+ROLE_FILE: <角色提示词路径>
+<TASK>
+需求：<增强后的需求（如未增强则用 $ARGUMENTS）>
+上下文：<前序阶段收集的项目上下文、分析结果等>
+ROS2上下文：<colcon工作空间、package.xml、现有C++节点、消息定义、硬件接口等>
+</TASK>
+OUTPUT: 期望输出格式
+EOF",
+  run_in_background: false,
+  timeout: 3600000,
+  description: "简短描述"
+})
+```
+
+**角色提示词**：
+
+| 阶段 | 底层控制 |
+|------|----------|
+| 分析 | `~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/analyzer.md` |
+| 规划 | `~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/architect.md` |
+| 审查 | `~/.claude/.ccg/prompts/{{BACKEND_PRIMARY}}/reviewer.md` |
+
+**会话复用**：每次调用返回 `SESSION_ID: xxx`，后续阶段用 `resume xxx` 复用上下文。阶段 2 保存 `BACKEND_SESSION`，阶段 3 和 5 使用 `resume` 复用。
+
+---
+
+## 执行工作流
+
+**任务描述**：$ARGUMENTS
+
+### 🔍 阶段 1：研究与分析
+
+`[模式：研究]` - 理解底层控制需求并收集 ROS2 上下文：
+
+1. **ROS2 环境检测**：
+   - 检查 colcon 工作空间结构
+   - 扫描现有 C++ 节点和消息定义
+   - 识别硬件接口（CAN/串口/传感器）
+2. **上下文检索**：调用 `{{MCP_SEARCH_TOOL}}`，重点检索 C++ 节点、消息定义、控制算法
+3. **需求完整性评分**（0-10 分）：
+   - 目标明确性（0-3）、预期结果（0-3）、边界范围（0-2）、约束条件（0-2）
+   - ≥7 分：继续 | <7 分：⛔ 停止，提出补充问题
+
+### 💡 阶段 2：方案构思
+
+`[模式：构思]` - 底层控制模型分析：
+
+调用底层控制模型，使用分析提示词，输出：
+- C++ 节点架构设计
+- 控制算法选型（PID/MPC/LQR 等）
+- 消息定义方案
+- 硬件驱动接口设计
+- 实时性保证策略
+- 线程安全考虑
+
+**📌 保存 SESSION_ID**（`BACKEND_SESSION`）。
+
+综合分析，输出方案对比（至少 2 个方案），等待用户选择。
+
+### 📋 阶段 3：详细规划
+
+`[模式：计划]` - 底层控制详细规划：
+
+调用底层控制模型（复用会话 `resume $BACKEND_SESSION`），使用规划提示词，输出：
+- **C++ 节点清单**：每个节点的职责、订阅/发布的 Topic、提供的 Service
+- **消息定义清单**：自定义消息的 .msg/.srv/.action 文件内容
+- **控制算法清单**：算法实现细节、参数配置、性能指标
+- **硬件驱动清单**：驱动接口、通信协议、错误处理
+- **CMakeLists.txt 配置**：依赖库、编译选项、链接设置
+- **文件清单**：需要创建/修改的文件列表
+
+**⛔ HARD STOP**：展示计划，等待用户批准。未批准禁止进入执行阶段。
+
+### ⚙️ 阶段 4：代码执行
+
+`[模式：执行]` - Claude 主导实施：
+
+根据批准的计划，按以下顺序实施：
+
+1. **消息定义**（如需）：
+   - 创建 `msg/`、`srv/`、`action/` 目录和文件
+   - 更新 `CMakeLists.txt` 和 `package.xml`
+2. **C++ 节点实现**：
+   - 创建节点源文件（`src/`）和头文件（`include/`）
+   - 实现订阅/发布/服务/动作
+   - 实现控制算法
+   - 配置生命周期节点（如需）
+3. **硬件驱动实现**（如需）：
+   - 实现硬件通信接口（CAN/串口/I2C/SPI）
+   - 实现传感器数据解析
+   - 实现执行器控制
+   - 添加错误处理和重连逻辑
+4. **CMakeLists.txt 配置**：
+   - 添加依赖库（rclcpp、sensor_msgs、geometry_msgs 等）
+   - 配置编译选项（C++17、优化级别）
+   - 添加可执行文件和库
+5. **单元测试**（如需）：
+   - 创建测试文件（`test/`）
+   - 使用 gtest 编写单元测试
+   - 配置 CMakeLists.txt 测试目标
+
+每完成一个模块，运行 `colcon build` 验证编译。
+
+### 🔧 阶段 5：优化审查
+
+`[模式：优化]` - 底层控制模型审查：
+
+调用底层控制模型（复用会话 `resume $BACKEND_SESSION`），使用审查提示词，审查：
+- C++ 代码质量（内存管理、异常处理、RAII）
+- 控制算法正确性和性能
+- 消息定义合理性
+- 硬件驱动稳定性
+- 实时性保证（线程优先级、锁策略）
+- 线程安全（互斥锁、原子操作）
+
+综合审查意见，Claude 整合修复：
+- **Critical 问题**：必须修复（内存泄漏、死锁、数据竞争、实时性违反）
+- **Warning 问题**：建议修复（命名不规范、注释不足、异常处理缺失）
+- **Info 建议**：可选优化（性能优化、代码风格）
+
+### ✅ 阶段 6：最终评审
+
+`[模式：评审]` - 质量把关：
+
+1. **编译测试**：
+   ```bash
+   colcon build --packages-select <package_name>
+   colcon test --packages-select <package_name>
+   ```
+2. **静态检查**：
+   - `cpplint` / `cppcheck`
+   - `clang-tidy`
+3. **性能测试**：
+   - CPU 使用率
+   - 内存占用
+   - 消息延迟
+   - 控制周期稳定性
+4. **硬件测试**（如有）：
+   - 硬件连接测试
+   - 传感器数据验证
+   - 执行器响应测试
+5. **文档完整性**：
+   - 代码注释充分
+   - README.md 包含使用说明
+   - 控制算法有文档说明
+
+输出评审报告，等待用户确认。
+
+---
+
+## 完成标准
+
+所有 6 个阶段完成后，输出最终交付清单：
+
+- ✅ C++ 节点实现完成
+- ✅ 消息定义正确（如有）
+- ✅ 控制算法实现并验证
+- ✅ 硬件驱动稳定（如有）
+- ✅ 编译测试通过
+- ✅ 单元测试通过（如有）
+- ✅ 性能指标达标
+- ✅ 代码审查通过
+- ✅ 文档完整
+
+**🎉 ROS2 底层控制开发完成！**