ccg-ros2-workflow 2.2.2 → 3.0.0

package/templates/commands/go.md

@@ -0,0 +1,206 @@
+---
+description: 'CCG 智能入口 — 描述你要做什么，AI 自动选择最佳策略执行'
+---
+
+# /ccg:go — CCG 智能入口
+
+$ARGUMENTS
+
+---
+
+## 你的角色
+
+你是 **CCG Engine**，一个智能编排器。你的职责是：分析用户的自然语言意图，自动选择最优的开发策略，然后严格按策略执行。用户不需要记住任何命令，只需要描述他们想做什么。
+
+语言：中文交流，技术术语保留英文。
+
+---
+
+## Phase 0: 逃生舱检测
+
+在开始分析之前，先检查 `$ARGUMENTS` 是否命中逃生舱：
+
+**直接执行短语**（跳过所有分析，Claude 直接处理）：
+- "直接做" / "just do it" / "skip" / "不用分析" / "别分析了" / "小修一下"
+
+**快捷路由**（跳过意图分析，直接加载对应策略）：
+- 以 `commit` 开头 → 加载 `git-action` 策略
+- 以 `rollback` / `回滚` 开头 → 加载 `git-action` 策略
+- 以 `review` / `审查` 开头 → 加载 `review-audit` 策略
+- 以 `clean` 开头且含 `branch` → 加载 `git-action` 策略
+
+如果命中逃生舱或快捷路由，跳到 Phase 3。否则继续 Phase 1。
+
+---
+
+## Phase 1: 意图分析 [required]
+
+### 1.1 获取项目上下文 [required · 不可跳过]
+
+**先行动，再判断**。必须执行以下操作获取上下文：
+
+1. `git status` — 当前变更状态、分支信息
+2. 读取项目配置文件（`package.json` / `go.mod` / `pyproject.toml` / `Cargo.toml` 等，取存在的第一个）— 技术栈
+3. 快速浏览目录结构（`ls` 或 `find . -maxdepth 2 -type f | head -30`）— 项目规模
+
+### 1.2 任务类型分类
+
+根据 `$ARGUMENTS` 中的关键词和语义判断：
+
+| 类型 | 信号词（中/英） |
+|------|----------------|
+| **bug-fix** | fix, bug, error, 500, crash, 报错, 修复, broken, 坏了, 失败, failed |
+| **feature** | add, implement, create, 新增, 添加, 开发, build, 做一个, 加一个 |
+| **refactor** | refactor, restructure, 重构, extract, simplify, clean up, 整理 |
+| **research** | what, how, compare, 分析, 研究, 方案, 调研, 评估, 对比, 怎么做 |
+| **optimize** | performance, optimize, speed, slow, 优化, 性能, latency, 慢 |
+| **review** | review, audit, check quality, 审查, 审计, 看看代码 |
+| **git** | commit, rollback, branch, merge, push, clean, worktree, 提交, 回滚 |
+
+如果多个类型匹配，选择最核心的那个（动词决定类型，形容词/名词决定领域）。
+
+### 1.3 复杂度评估
+
+**基于 Phase 1.1 获取的项目上下文**评估，不是凭空猜测：
+
+| 级别 | 判定标准 |
+|------|---------|
+| **S** | 单文件变更，范围清晰，预估 <30 行 |
+| **M** | 2-5 文件，单模块内，路径明确 |
+| **L** | 5+ 文件，跨模块，需要规划和协调 |
+| **XL** | 架构级变更，API/Schema 变动，多模块协作 |
+
+**不确定时默认选高一级**。
+
+### 1.4 风险评估
+
+| 级别 | 判定标准 |
+|------|---------|
+| **low** | 无生产影响，可逆，有测试覆盖 |
+| **medium** | 修改现有行为，需要测试验证 |
+| **high** | API 契约变更，数据库迁移，认证/加密逻辑 |
+
+### 1.5 领域检测
+
+从 `$ARGUMENTS` + 项目上下文推断：
+- **frontend** — UI, component, CSS, React, Vue, Angular, style, layout, 页面, 组件
+- **backend** — API, database, server, endpoint, auth, queue, 接口, 数据库
+- **fullstack** — 同时涉及前底层控制
+- **security** — vulnerability, auth, injection, encryption, 漏洞, 认证
+- **devops** — CI/CD, Docker, deploy, infrastructure, 部署, 运维
+
+---
+
+## Phase 2: 策略选择
+
+展示分析结果，用户可纠正：
+
+```
+📋 CCG 分析
+  任务: [type]  复杂度: [S/M/L/XL]  领域: [domain]  风险: [level]
+  策略: [strategy] — [一句话说明]
+  📍 Next: 加载策略并开始执行
+```
+
+### 决策矩阵
+
+| 类型 \ 复杂度 | S | M | L / XL |
+|--------------|---|---|--------|
+| **bug-fix** | direct-fix | debug-investigate | debug-investigate |
+| **feature** | quick-implement | guided-develop | full-collaborate |
+| **refactor** | direct-fix | refactor-safely | refactor-safely |
+| **research** | deep-research | deep-research | deep-research |
+| **optimize** | optimize-measure | optimize-measure | optimize-measure |
+| **review** | review-audit | review-audit | review-audit |
+| **git** | git-action | git-action | git-action |
+
+**风险修正**：如果风险为 high 且策略不含外部模型审查，升级一档（如 direct-fix → debug-investigate）。
+
+### ⛔ 创建任务 [required · 策略加载前必须完成]
+
+如果复杂度 ≥ M **且策略不是 git-action**，**必须先创建任务目录再加载策略**：
+
+**Step 1**: 生成任务名 — 用户请求核心词转 kebab-case（如 `add-oauth2-login`、`fix-api-timeout`）
+**Step 2**: 执行命令创建目录和文件：
+
+```bash
+mkdir -p .ccg/tasks/{task-name}
+```
+
+**Step 3**: 获取当前 git 分支名：`git rev-parse --abbrev-ref HEAD`
+
+**Step 4**: 写入 `.ccg/tasks/{task-name}/task.json`：
+
+```json
+{
+  "id": "{task-name}",
+  "title": "{用户请求一句话摘要}",
+  "status": "in_progress",
+  "strategy": "{selected-strategy}",
+  "currentPhase": "1",
+  "nextAction": "{策略第一阶段的描述}",
+  "gate": null,
+  "branch": "{当前 git 分支}",
+  "scope": "{task-name}",
+  "createdAt": "{当前 ISO 日期时间}"
+}
+```
+
+**Step 5**: 创建 `.ccg/tasks/{task-name}/context.jsonl` 种子文件：
+- 第一行写种子示例：`{"_example": "Fill with {\"file\": \"path\", \"reason\": \"why\"}. Seed rows are skipped."}`
+- 如果 `.ccg/spec/` 存在 → 追加 spec 文件条目
+
+**复杂度 S → 跳过任务创建**（保持轻量）。
+
+**确认任务已创建后**，输出：
+```
+✅ Task created: .ccg/tasks/{task-name}/
+```
+
+### 加载策略
+
+```
+Read("~/.claude/.ccg/engine/strategies/{selected-strategy}.md")
+```
+
+如果用户对分析结果提出异议（如"用完整协作模式"），**接受用户覆盖**，加载指定策略。
+
+---
+
+## Phase 3: 执行策略
+
+严格按照加载的策略文件执行。遵守以下原则：
+
+1. 标记为 `[required]` 的阶段**不可跳过**
+2. 标记为 `HARD STOP` 的 Gate **必须等待用户确认**
+3. 策略文件底部的 `## 铁律` 区块必须遵守
+4. 如需调用外部模型，先 `Read("~/.claude/.ccg/engine/model-router.md")` 获取调用模板
+
+---
+
+## 铁律（MUST NOT）
+
+1. **不可在未获取项目上下文的情况下评估复杂度** — Phase 1.1 不可跳过
+2. **不可自行发明逃生舱** — 只有 Phase 0 明确列出的短语才能跳过分析
+3. **不可在用户未确认的情况下降级策略** — 可升级，不可降级
+4. **M+ 复杂度必须先创建 Task 再加载策略** — 没有 `task.json` 就没有 Hook 面包屑注入，等于丢失状态追踪
+5. **不可跳过策略中 [required] 标记的阶段** — 即使"看起来很简单"
+6. **复杂度有疑问时，默认选高一级** — 宁可多做一步，不可漏掉关键步骤
+7. **⛔ 写代码前必须让用户选择执行模式** — 如果策略包含执行模式选择（Agent Teams / Codex / Claude），你**必须明确向用户展示选项并等待回复**。不可默认选择任何模式，不可跳过选择直接开始写代码。违反此条 = 最严重的流程失控
+
+---
+
+## 附录：策略一览
+
+| 策略 | 适用场景 | 外部模型 |
+|------|---------|---------|
+| `direct-fix` | 简单修复，范围清晰 | 无 |
+| `quick-implement` | 小功能，单文件/组件 | 无 |
+| `guided-develop` | 中等功能，需要规划 | 可选单模型 |
+| `full-collaborate` | 复杂功能，需要多模型协作 | 双模型并行 |
+| `debug-investigate` | 复杂调试，原因不明 | 双模型并行 |
+| `refactor-safely` | 代码重构，需要安全保障 | 可选 |
+| `deep-research` | 技术研究，方案对比 | 双模型探索 |
+| `optimize-measure` | 性能优化，需要度量 | 可选 |
+| `review-audit` | 代码审查 | 双模型交叉 |
+| `git-action` | Git 操作 | 无（委托现有命令） |

package/templates/commands/init.md

@@ -49,7 +49,7 @@ Task({
 ```
 Task({
   subagent_type: "init-architect",
-  prompt: "扫描项目并生成 CLAUDE.md 文档。\n\n项目摘要：$ARGUMENTS\n当前时间戳：$TIMESTAMP\n工作目录：$PWD\n\n请执行：\n1. 阶段 A：全仓清点（文件统计、模块识别）\n2. 阶段 B：模块优先扫描（入口、接口、依赖、测试）\n3. 阶段 C：深度补捞（按需）\n4. 阶段 D：生成文档（根级 + 模块级 CLAUDE.md）\n\n输出覆盖率报告与推荐下一步。",
+  prompt: "扫描项目并生成 CLAUDE.md 文档。\n\n项目摘要：$ARGUMENTS\n当前时间戳：$TIMESTAMP\n工作目录：{{WORKDIR}}\n\n请执行：\n1. 阶段 A：全仓清点（文件统计、模块识别）\n2. 阶段 B：模块优先扫描（入口、接口、依赖、测试）\n3. 阶段 C：深度补捞（按需）\n4. 阶段 D：生成文档（根级 + 模块级 CLAUDE.md）\n\n输出覆盖率报告与推荐下一步。",
   description: "初始化项目文档"
 })
 ```

package/templates/commands/spec-impl.md

@@ -9,20 +9,30 @@ description: '按规范执行 + 多模型协作 + 归档'
 - Minimize documentation—prefer self-explanatory code over comments.
 
 **Guardrails**
-- **NEVER** apply Codex/Gemini prototypes directly—all outputs are reference only.
+- **NEVER** apply 底层控制/上层应用模型 prototypes directly—all outputs are reference only.
 - **MANDATORY**: Request `unified diff patch` format from external models; they have zero write permission.
 - Keep implementation strictly within `tasks.md` scope—no scope creep.
 - Refer to `openspec/config.yaml` for conventions.
+- **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.
+- **TASKS FORMAT RULE**: When generating or modifying `tasks.md`, ALL tasks MUST use checkbox format (`- [ ] X.Y description`). Heading+bullet format will cause OpenSpec CLI to parse 0 tasks and block the workflow.
 
 **Steps**
 1. **Select Change**
-   - Run `/opsx:list` to inspect Active Changes.
+   - Run `openspec list --json` to inspect Active Changes.
    - Confirm with user which change ID to implement.
-   - Run `/opsx:show <change_id>` to review tasks.
-
-2. **Apply OPSX Change**
-   - Use `/ccg:spec-impl` (which uses OpenSpec skills internally) to enter implementation mode.
-   - This skill will guide you through the tasks defined in `tasks.md`.
+   - Run `openspec status --change "<change_id>" --json` to review tasks.
+
+2. **Apply OPSX Change (Pre-flight Check)**
+   - Call `/opsx:apply` internally to enter implementation mode:
+     ```
+     /opsx:apply
+     ```
+   - This will load the change context and guide you through the tasks defined in `tasks.md`.
+   - **Note**: This is an internal call. If this step fails, guide the user to re-run `/ccg:spec-impl`.
+   - **HARD GATE**: Check the returned `state` field:
+     - If `state: "blocked"` → STOP immediately. Inform the user which artifacts are missing and suggest: "Run `/ccg:spec-plan` to generate missing artifacts first."
+     - If `progress.total === 0` → STOP immediately. Inform: "tasks.md has no parseable tasks. Run `/ccg:spec-plan` to regenerate."
+     - Only proceed to Step 3 when `state: "ready"` and `progress.total > 0`.
 
 3. **Identify Minimal Verifiable Phase**
    - Review `tasks.md` and identify the **smallest verifiable phase**.
@@ -30,12 +40,14 @@ description: '按规范执行 + 多模型协作 + 归档'
    - Announce: "Implementing Phase X: [task group name]"
 
 4. **Route Tasks to Appropriate Model**
-   - **Route A: Gemini** — Frontend/UI/styling (CSS, React, Vue, HTML, components)
-   - **Route B: Codex** — Backend/logic/algorithm (API, data processing, business logic)
+   - **Route A: {{FRONTEND_PRIMARY}}** — Frontend/UI/styling (CSS, React, Vue, HTML, components)
+   - **Route B: {{BACKEND_PRIMARY}}** — Backend/logic/algorithm (API, data processing, business logic)
+
+   **工作目录**：`{{WORKDIR}}` **必须通过 Bash 执行 `pwd`（Unix）或 `cd`（Windows CMD）获取当前工作目录的绝对路径**，禁止从 `$HOME` 或环境变量推断。如果用户通过 `/add-dir` 添加了多个工作区，先确定任务相关的工作区。
 
    For each task:
    ```
-   codeagent-wrapper --backend <codex|gemini> - "{{WORKDIR}}" <<'EOF'
+   codeagent-wrapper --progress --backend <{{BACKEND_PRIMARY}}|{{FRONTEND_PRIMARY}}> {{GEMINI_MODEL_FLAG}}- "{{WORKDIR}}" <<'EOF'
    TASK: <task description from tasks.md>
    CONTEXT: <relevant code context>
    CONSTRAINTS: <constraints from spec>
@@ -43,6 +55,8 @@ description: '按规范执行 + 多模型协作 + 归档'
    EOF
    ```
 
+   **会话复用**：保存返回的 `SESSION_ID:`（{{BACKEND_PRIMARY}} → `CODEX_PROTO_SESSION`，{{FRONTEND_PRIMARY}} → `GEMINI_PROTO_SESSION`），Step 7 审查时复用。
+
 5. **Rewrite Prototype to Production Code**
    Upon receiving diff patch, **NEVER apply directly**. Rewrite by:
    - Removing redundancy
@@ -61,28 +75,28 @@ description: '按规范执行 + 多模型协作 + 归档'
    If issues found, make targeted corrections.
 
 7. **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`.
 
    **Step 7.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 the implementation changes:\n- Correctness: logic errors, edge cases\n- Security: injection, auth issues\n- Spec compliance: constraints satisfied\nOUTPUT: JSON with findings\nEOF",
+     command: "~/.claude/bin/codeagent-wrapper --progress --backend {{BACKEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}resume <CODEX_PROTO_SESSION> - \"{{WORKDIR}}\" <<'EOF'\nReview the implementation changes:\n- Correctness: logic errors, edge cases\n- Security: injection, auth issues\n- Spec compliance: constraints satisfied\nOUTPUT: JSON with findings\nEOF",
      run_in_background: true,
      timeout: 300000,
-     description: "Codex: correctness/security review"
+     description: "{{BACKEND_PRIMARY}}: correctness/security 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 the implementation changes:\n- Maintainability: readability, complexity\n- Patterns: consistency with project style\n- Integration: cross-module impacts\nOUTPUT: JSON with findings\nEOF",
+     command: "~/.claude/bin/codeagent-wrapper --progress --backend {{FRONTEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}resume <GEMINI_PROTO_SESSION> - \"{{WORKDIR}}\" <<'EOF'\nReview the implementation changes:\n- Maintainability: readability, complexity\n- Patterns: consistency with project style\n- Integration: cross-module impacts\nOUTPUT: JSON with findings\nEOF",
      run_in_background: true,
      timeout: 300000,
-     description: "Gemini: maintainability/patterns review"
+     description: "{{FRONTEND_PRIMARY}}: maintainability/patterns review"
    })
    ```
 
@@ -92,6 +106,9 @@ description: '按规范执行 + 多模型协作 + 归档'
    TaskOutput({ task_id: "<gemini_task_id>", block: true, timeout: 600000 })
    ```
 
+   ⛔ **上层应用模型失败必须重试**：若上层应用模型调用失败，最多重试 2 次（间隔 5 秒）。3 次全败才跳过。
+   ⛔ **底层控制模型结果必须等待**：底层控制模型执行 5-15 分钟属正常，超时后继续轮询，禁止跳过。
+
    Address any critical findings before proceeding.
 
 8. **Update Task Status**
@@ -105,13 +122,16 @@ description: '按规范执行 + 多模型协作 + 归档'
 
 10. **Archive on Completion**
     - When ALL tasks in `tasks.md` are marked `[x]`:
-    - The agent will use OpenSpec skills to archive the change.
+    - Call `/opsx:archive` internally to archive the change:
+      ```
+      /opsx:archive
+      ```
     - This merges spec deltas to `openspec/specs/` and moves change to archive.
+    - **Note**: This is an internal call. If archiving fails, guide the user to re-run `/ccg:spec-impl`.
 
 **Reference**
-- Check task status: `/opsx:show <id>`
-- Validate before archive: `/opsx:validate <id>`
-- View active changes: `/opsx:list`
+- Check task status: `openspec status --change "<id>" --json`
+- View active changes: `openspec list --json`
 - Search existing patterns: `rg -n "function|class" <file>`
 
 **Exit Criteria**

package/templates/commands/spec-init.md

@@ -1,5 +1,5 @@
 ---
-description: '初始化 OpenSpec (OPSX) 环境 + 验证多模型 MCP 工具（ROS2 版本）'
+description: '初始化 OpenSpec (OPSX) 环境 + 验证多模型 MCP 工具'
 ---
 <!-- CCG:SPEC:INIT:START -->
 **Core Philosophy**
@@ -38,15 +38,20 @@ description: '初始化 OpenSpec (OPSX) 环境 + 验证多模型 MCP 工具（RO
      ```
    - **Note**: Always use `openspec` (not `opsx`) for CLI commands.
 
-3. **Initialize OPSX for Current ROS2 Project**
+3. **Initialize OPSX for Current Project**
+   - **重要**：所有命令必须在当前工作目录下执行，禁止 `cd` 到其他路径。如不确定当前目录，先执行 `pwd` 确认。
    - Check if already initialized:
      ```bash
      ls -la openspec/ .claude/skills/openspec-* 2>/dev/null || echo "Not initialized"
      ```
-   - If not initialized, run:
+   - If not initialized, run interactive setup (v1.2+ auto-detects AI tools):
      ```bash
-     npx @fission-ai/openspec init --tools claude
+     npx @fission-ai/openspec init
      ```
+   - **Profile Selection** (v1.2+):
+     - `core` profile (default): 4 essential workflows (`propose`, `explore`, `apply`, `archive`)
+     - `custom` profile: Pick any subset of workflows
+     - To change profile later: `openspec config profile`
    - Verify initialization:
      - Check `openspec/` directory exists
      - Check `.claude/skills/` contains `openspec-*` skills
@@ -55,27 +60,18 @@ description: '初始化 OpenSpec (OPSX) 环境 + 验证多模型 MCP 工具（RO
 
 4. **Validate Multi-Model MCP Tools**
    - Check `codeagent-wrapper` availability: `~/.claude/bin/codeagent-wrapper --version`
-   - **工作目录**：`{{WORKDIR}}` 替换为目标工作目录的绝对路径。如果用户通过 `/add-dir` 添加了多个工作区，先确定任务相关的工作区。
-   - Test Codex backend（底层控制）:
+   - **工作目录**：`{{WORKDIR}}` **必须通过 Bash 执行 `pwd`（Unix）或 `cd`（Windows CMD）获取当前工作目录的绝对路径**，禁止从 `$HOME` 或环境变量推断。如果用户通过 `/add-dir` 添加了多个工作区，先确定任务相关的工作区。
+   - Test {{BACKEND_PRIMARY}} backend:
      ```bash
-     ~/.claude/bin/codeagent-wrapper --backend codex - "{{WORKDIR}}" <<< "echo test"
+     echo "echo test" | ~/.claude/bin/codeagent-wrapper --backend {{BACKEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}- "{{WORKDIR}}"
      ```
-   - Test Gemini backend（上层应用）:
+   - Test {{FRONTEND_PRIMARY}} backend:
      ```bash
-     ~/.claude/bin/codeagent-wrapper --backend gemini --gemini-model gemini-3.1-pro-preview - "{{WORKDIR}}" <<< "echo test"
+     echo "echo test" | ~/.claude/bin/codeagent-wrapper --backend {{FRONTEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}- "{{WORKDIR}}"
      ```
    - For each unavailable tool, display warning with installation instructions.
 
-5. **Validate Context Retrieval MCP** (Optional)
-   - **Check Active Tool**: Is `{{MCP_SEARCH_TOOL}}` available in the current session?
-   - **Check Configuration**: If tool is missing, check `~/.claude.json` for `"ace-tool"` or `"ace-tool-rs"` in `mcpServers`.
-   - **Diagnosis**:
-     - If tool available: Mark as "✓ Active".
-     - If config exists but tool missing: Mark as "⚠️ Configured but inactive (Try restarting Claude)".
-     - If neither: Mark as "○ Not installed (Optional)".
-   - If not installed/configured, suggest: "Run `npx ccg-ros2-workflow` and select ace-tool MCP option."
-
-6. **Summary Report**
+5. **Summary Report**
    Display status table:
    ```
    Component                 Status
@@ -84,9 +80,8 @@ description: '初始化 OpenSpec (OPSX) 环境 + 验证多模型 MCP 工具（RO
    Project initialized       ✓/✗
    OPSX Skills               ✓/✗
    codeagent-wrapper         ✓/✗
-   Codex backend（底层控制）  ✓/✗
-   Gemini backend（上层应用） ✓/✗
-   ace-tool MCP              ✓/✗ (optional)
+   {{BACKEND_PRIMARY}} backend             ✓/✗
+   {{FRONTEND_PRIMARY}} backend            ✓/✗
    ```
 
    **Next Steps (Use CCG Encapsulated Commands)**
@@ -99,9 +94,8 @@ description: '初始化 OpenSpec (OPSX) 环境 + 验证多模型 MCP 工具（RO
 
 **Reference**
 - OpenSpec (OPSX) CLI: `npx @fission-ai/openspec --help`
-- OPSX Commands: `/opsx:new`, `/opsx:continue`, `/opsx:apply`, etc.
-- CCG ROS2 Workflow: `npx ccg-ros2-workflow`
-- Codex/Gemini MCP: Bundled with codeagent-wrapper
-- Node.js >= 20.x required
-- ROS2 Humble: https://docs.ros.org/en/humble/
+- Profile Management: `openspec config profile`
+- CCG Workflow: `npx ccg-ros2-workflow`
+- 底层控制/上层应用模型 MCP: Bundled with codeagent-wrapper
+- Node.js >= 18.x required for OpenSpec
 <!-- CCG:SPEC:INIT:END -->

package/templates/commands/spec-plan.md

@@ -10,39 +10,43 @@ description: '多模型分析 → 消除歧义 → 零决策可执行计划'
 
 **Guardrails**
 - Do not proceed to implementation until every ambiguity is resolved.
-- Multi-model collaboration is **mandatory**: use both Codex and Gemini.
+- Multi-model collaboration is **mandatory**: use both {{BACKEND_PRIMARY}} and {{FRONTEND_PRIMARY}}.
 - If constraints cannot be fully specified, escalate to user or return to research phase.
 - Refer to `openspec/config.yaml` for project conventions.
+- **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.
+- **TASKS FORMAT RULE**: When generating or modifying `tasks.md`, ALL tasks MUST use checkbox format (`- [ ] X.Y description`). Heading+bullet format will cause OpenSpec CLI to parse 0 tasks and block the workflow.
+- **PHASE BOUNDARY**: This phase ONLY generates OPSX artifacts (specs.md, design.md, tasks.md). Do NOT modify any source code. Do NOT proceed to implementation. After artifacts are generated, STOP and inform the user: "Plan complete. Run `/ccg:spec-impl` to start implementation."
 
 **Steps**
 1. **Select Change**
-   - Run `/opsx:list` to display Active Changes.
+   - Run `openspec list --json` to display Active Changes.
    - Confirm with user which change ID to refine.
-   - Run `/opsx:status <change_id>` to review current state.
+   - Run `openspec status --change "<change_id>" --json` to review current state.
 
 2. **Multi-Model Implementation Analysis (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 2.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'\nAnalyze change <change_id> from backend perspective:\n- Implementation approach\n- Technical risks\n- Alternative architectures\n- Edge cases and failure modes\nOUTPUT: JSON with analysis\nEOF",
+     command: "~/.claude/bin/codeagent-wrapper --progress --backend {{BACKEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}- \"{{WORKDIR}}\" <<'EOF'\nAnalyze change <change_id> from backend perspective:\n- Implementation approach\n- Technical risks\n- Alternative architectures\n- Edge cases and failure modes\nOUTPUT: JSON with analysis\nEOF",
      run_in_background: true,
      timeout: 300000,
-     description: "Codex: backend analysis"
+     description: "{{BACKEND_PRIMARY}}: backend analysis"
    })
    ```
 
-   **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'\nAnalyze change <change_id> from frontend/integration perspective:\n- Maintainability assessment\n- Scalability considerations\n- Integration conflicts\nOUTPUT: JSON with analysis\nEOF",
+     command: "~/.claude/bin/codeagent-wrapper --progress --backend {{FRONTEND_PRIMARY}} {{GEMINI_MODEL_FLAG}}- \"{{WORKDIR}}\" <<'EOF'\nAnalyze change <change_id> from frontend/integration perspective:\n- Maintainability assessment\n- Scalability considerations\n- Integration conflicts\nOUTPUT: JSON with analysis\nEOF",
      run_in_background: true,
      timeout: 300000,
-     description: "Gemini: frontend analysis"
+     description: "{{FRONTEND_PRIMARY}}: frontend analysis"
    })
    ```
 
@@ -52,11 +56,14 @@ description: '多模型分析 → 消除歧义 → 零决策可执行计划'
    TaskOutput({ task_id: "<gemini_task_id>", block: true, timeout: 600000 })
    ```
 
+   ⛔ **上层应用模型失败必须重试**：若上层应用模型调用失败，最多重试 2 次（间隔 5 秒）。3 次全败才跳过。
+   ⛔ **底层控制模型结果必须等待**：底层控制模型执行 5-15 分钟属正常，超时后继续轮询，禁止跳过。
+
    - Synthesize responses and present consolidated options to user.
 
 3. **Uncertainty Elimination Audit**
-   - **Codex**: "Review proposal for unspecified decision points. List each as: [AMBIGUITY] → [REQUIRED CONSTRAINT]"
-   - **Gemini**: "Identify implicit assumptions. Specify: [ASSUMPTION] → [EXPLICIT CONSTRAINT NEEDED]"
+   - **{{BACKEND_PRIMARY}}**: "Review proposal for unspecified decision points. List each as: [AMBIGUITY] → [REQUIRED CONSTRAINT]"
+   - **{{FRONTEND_PRIMARY}}**: "Identify implicit assumptions. Specify: [ASSUMPTION] → [EXPLICIT CONSTRAINT NEEDED]"
 
    **Anti-Pattern Detection** (flag and reject):
    - Information collection without decision boundaries
@@ -71,8 +78,8 @@ description: '多模型分析 → 消除歧义 → 零决策可执行计划'
    Iterate with user until ALL ambiguities resolved.
 
 4. **PBT Property Extraction**
-   - **Codex**: "Extract PBT properties. For each requirement: [INVARIANT] → [FALSIFICATION STRATEGY]"
-   - **Gemini**: "Define system properties: [PROPERTY] | [DEFINITION] | [BOUNDARY CONDITIONS] | [COUNTEREXAMPLE GENERATION]"
+   - **{{BACKEND_PRIMARY}}**: "Extract PBT properties. For each requirement: [INVARIANT] → [FALSIFICATION STRATEGY]"
+   - **{{FRONTEND_PRIMARY}}**: "Define system properties: [PROPERTY] | [DEFINITION] | [BOUNDARY CONDITIONS] | [COUNTEREXAMPLE GENERATION]"
 
    **Property Categories**:
    - **Commutativity/Associativity**: Order-independent operations
@@ -83,11 +90,37 @@ description: '多模型分析 → 消除歧义 → 零决策可执行计划'
    - **Bounds**: Value ranges, size limits, rate constraints
 
 5. **Update OPSX Artifacts**
-   - The agent will use OpenSpec skills to generate/update:
-     * specs (Requirements + PBT)
-     * design (Technical decisions)
-     * tasks (Zero-decision implementation plan)
-   - Ensure all resolved constraints and PBT properties are included in the generated artifacts.
+   - **BEFORE calling `/opsx:continue`** (internal skill call — do NOT expose this command to user), output a structured summary for OPSX context:
+     ```markdown
+     ## Planning Summary for OPSX
+
+     **Multi-Model Analysis Results**:
+     - {{BACKEND_PRIMARY}} (Backend): [Key findings and recommendations]
+     - {{FRONTEND_PRIMARY}} (Frontend): [Key findings and recommendations]
+     - Consolidated Approach: [Selected implementation strategy]
+
+     **Resolved Constraints**:
+     - [All explicit constraints from Step 3]
+
+     **PBT Properties**:
+     - [All extracted properties from Step 4 with falsification strategies]
+
+     **Technical Decisions**:
+     - [All finalized technology choices, algorithms, configurations]
+
+     **Implementation Tasks**:
+     - [High-level task breakdown ready for tasks.md]
+     ```
+
+   - Then call `/opsx:continue` internally to generate next artifacts:
+     ```
+     /opsx:continue
+     ```
+   - The OPSX skill will use the above summary to create specs.md, design.md, and tasks.md.
+   - **Note**: This is an internal call. If this step fails, guide the user to re-run `/ccg:spec-plan`.
+   - **STOP**: After artifacts are generated, verify they exist and inform user:
+     "Plan phase complete. Artifacts generated: specs.md, design.md, tasks.md. Run `/ccg:spec-impl` to start implementation."
+     Do NOT proceed to modify source code.
 
 6. **Context Checkpoint**
    - Report current context usage.
@@ -102,8 +135,8 @@ A change is ready for implementation only when:
 - [ ] User has explicitly approved all constraint decisions
 
 **Reference**
-- Inspect change: `/opsx:status <id>`
-- Check conflicts: `/opsx:schemas`
+- Inspect change: `openspec status --change "<id>" --json`
+- List changes: `openspec list --json`
 - Search patterns: `rg -n "INVARIANT:|PROPERTY:" openspec/`
 - Use `AskUserQuestion` for ANY ambiguity—never assume
 <!-- CCG:SPEC:PLAN:END -->