ccg-workflow 1.7.47 → 1.7.49

package/README.md

@@ -16,7 +16,9 @@ Claude Code 编排 Codex + Gemini 的多模型协作开发系统。前端任务
 npx ccg-workflow
 ```
 
-**要求**：Claude Code CLI、Node.js 18+
+**要求**：Claude Code CLI、Node.js 20+
+
+> **重要**：本项目依赖 `ora@9.x` 和 `string-width@8.x`，这些包要求 Node.js >= 20。使用 Node.js 18 会导致 `SyntaxError: Invalid regular expression flags` 错误。请确保升级到 Node.js 20 或更高版本。
 
 **可选**：Codex CLI（后端）、Gemini CLI（前端）
 
@@ -41,6 +43,34 @@ npx ccg-workflow
 | `/ccg:worktree` | Worktree 管理 |
 | `/ccg:init` | 初始化 CLAUDE.md |
 | `/ccg:enhance` | Prompt 增强 |
+| `/ccg:spec-init` | 初始化 OpenSpec 环境 |
+| `/ccg:spec-research` | 需求 → 约束集 |
+| `/ccg:spec-plan` | 约束 → 零决策计划 |
+| `/ccg:spec-impl` | 按计划执行 + 归档 |
+| `/ccg:spec-review` | 双模型交叉审查 |
+
+### OpenSpec 规范驱动（v1.7.48）
+
+集成 [OpenSpec](https://github.com/fission-ai/openspec)，把需求变成约束，让 AI 没法自由发挥：
+
+```bash
+# 初始化
+/ccg:spec-init
+
+# 研究需求 → 输出约束集
+/ccg:spec-research 实现用户认证
+
+# 并行分析 → 零决策计划
+/ccg:spec-plan
+
+# 按计划执行
+/ccg:spec-impl
+
+# 独立审查（随时可用）
+/ccg:spec-review
+```
+
+每阶段之间可 `/clear`，状态存在 `openspec/` 目录，不怕上下文爆。
 
 ### 规划与执行分离
 
@@ -157,4 +187,4 @@ MIT
 
 ---
 
-v1.7.47 | [Issues](https://github.com/fengshao1227/ccg-workflow/issues)
+v1.7.48 | [Issues](https://github.com/fengshao1227/ccg-workflow/issues)

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import cac from 'cac';
 import ansis from 'ansis';
-import { z as diagnoseMcpConfig, A as isWindows, B as readClaudeCodeConfig, C as fixWindowsMcpConfig, D as writeClaudeCodeConfig, r as readCcgConfig, b as initI18n, s as showMainMenu, i as init, E as configMcp, F as version, a as i18n } from './shared/ccg-workflow.DrIczHh4.mjs';
+import { z as diagnoseMcpConfig, A as isWindows, B as readClaudeCodeConfig, C as fixWindowsMcpConfig, D as writeClaudeCodeConfig, r as readCcgConfig, b as initI18n, s as showMainMenu, i as init, E as configMcp, F as version, a as i18n } from './shared/ccg-workflow.zPy2yt7f.mjs';
 import 'inquirer';
 import 'node:child_process';
 import 'node:util';

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { c as changeLanguage, x as checkForUpdates, y as compareVersions, d as createDefaultConfig, e as createDefaultRouting, g as getCcgDir, f as getConfigPath, t as getCurrentVersion, v as getLatestVersion, j as getWorkflowById, h as getWorkflowConfigs, a as i18n, i as init, b as initI18n, l as installAceTool, m as installAceToolRs, k as installWorkflows, p as migrateToV1_4_0, q as needsMigration, r as readCcgConfig, s as showMainMenu, o as uninstallAceTool, n as uninstallWorkflows, u as update, w as writeCcgConfig } from './shared/ccg-workflow.DrIczHh4.mjs';
+export { c as changeLanguage, x as checkForUpdates, y as compareVersions, d as createDefaultConfig, e as createDefaultRouting, g as getCcgDir, f as getConfigPath, t as getCurrentVersion, v as getLatestVersion, j as getWorkflowById, h as getWorkflowConfigs, a as i18n, i as init, b as initI18n, l as installAceTool, m as installAceToolRs, k as installWorkflows, p as migrateToV1_4_0, q as needsMigration, r as readCcgConfig, s as showMainMenu, o as uninstallAceTool, n as uninstallWorkflows, u as update, w as writeCcgConfig } from './shared/ccg-workflow.zPy2yt7f.mjs';
 import 'ansis';
 import 'inquirer';
 import 'node:child_process';

package/dist/shared/{ccg-workflow.DrIczHh4.mjs → ccg-workflow.zPy2yt7f.mjs}

@@ -10,7 +10,7 @@ import i18next from 'i18next';
 import ora from 'ora';
 import { parse, stringify } from 'smol-toml';
 
-const version = "1.7.47";
+const version = "1.7.49";
 
 function isWindows() {
   return process.platform === "win32";
@@ -356,6 +356,61 @@ const WORKFLOW_CONFIGS = [
     order: 23,
     description: "\u7BA1\u7406 Git worktree",
     descriptionEn: "Manage Git worktree"
+  },
+  {
+    id: "spec-init",
+    name: "OpenSpec \u521D\u59CB\u5316",
+    nameEn: "OpenSpec Init",
+    category: "spec",
+    commands: ["spec-init"],
+    defaultSelected: true,
+    order: 30,
+    description: "\u521D\u59CB\u5316 OpenSpec \u73AF\u5883 + \u9A8C\u8BC1\u591A\u6A21\u578B MCP \u5DE5\u5177",
+    descriptionEn: "Initialize OpenSpec environment with multi-model MCP validation"
+  },
+  {
+    id: "spec-research",
+    name: "\u9700\u6C42\u7814\u7A76",
+    nameEn: "Spec Research",
+    category: "spec",
+    commands: ["spec-research"],
+    defaultSelected: true,
+    order: 31,
+    description: "\u9700\u6C42 \u2192 \u7EA6\u675F\u96C6\uFF08\u5E76\u884C\u63A2\u7D22 + OpenSpec \u63D0\u6848\uFF09",
+    descriptionEn: "Transform requirements into constraint sets via parallel exploration"
+  },
+  {
+    id: "spec-plan",
+    name: "\u96F6\u51B3\u7B56\u89C4\u5212",
+    nameEn: "Spec Plan",
+    category: "spec",
+    commands: ["spec-plan"],
+    defaultSelected: true,
+    order: 32,
+    description: "\u591A\u6A21\u578B\u5206\u6790 \u2192 \u6D88\u9664\u6B67\u4E49 \u2192 \u96F6\u51B3\u7B56\u53EF\u6267\u884C\u8BA1\u5212",
+    descriptionEn: "Refine proposals into zero-decision executable plans"
+  },
+  {
+    id: "spec-impl",
+    name: "\u89C4\u8303\u9A71\u52A8\u5B9E\u73B0",
+    nameEn: "Spec Implementation",
+    category: "spec",
+    commands: ["spec-impl"],
+    defaultSelected: true,
+    order: 33,
+    description: "\u6309\u89C4\u8303\u6267\u884C + \u591A\u6A21\u578B\u534F\u4F5C + \u5F52\u6863",
+    descriptionEn: "Execute changes via multi-model collaboration with spec compliance"
+  },
+  {
+    id: "spec-review",
+    name: "\u5F52\u6863\u524D\u5BA1\u67E5",
+    nameEn: "Spec Review",
+    category: "spec",
+    commands: ["spec-review"],
+    defaultSelected: true,
+    order: 34,
+    description: "\u53CC\u6A21\u578B\u4EA4\u53C9\u5BA1\u67E5 \u2192 Critical \u5FC5\u987B\u4FEE\u590D \u2192 \u5141\u8BB8\u5F52\u6863",
+    descriptionEn: "Multi-model compliance review before archiving"
   }
 ];
 function getWorkflowConfigs() {
@@ -1987,56 +2042,85 @@ async function performUpdate(fromVersion, toVersion, isNewVersion) {
 
 const execAsync = promisify(exec);
 async function showMainMenu() {
-  console.log();
-  console.log(ansis.cyan.bold(`  CCG - Claude + Codex + Gemini`));
-  console.log(ansis.gray("  Multi-Model Collaboration System"));
-  console.log();
-  const { action } = await inquirer.prompt([{
-    type: "list",
-    name: "action",
-    message: i18n.t("menu:title"),
-    choices: [
-      { name: `${ansis.green("\u279C")} ${i18n.t("menu:options.init")}`, value: "init" },
-      { name: `${ansis.blue("\u279C")} ${i18n.t("menu:options.update")}`, value: "update" },
-      { name: `${ansis.cyan("\u2699")} \u914D\u7F6E MCP`, value: "config-mcp" },
-      { name: `${ansis.magenta("\u279C")} ${i18n.t("menu:options.uninstall")}`, value: "uninstall" },
-      { name: `${ansis.yellow("?")} ${i18n.t("menu:options.help")}`, value: "help" },
-      new inquirer.Separator(),
-      { name: `${ansis.red("\u2715")} ${i18n.t("menu:options.exit")}`, value: "exit" }
-    ]
-  }]);
-  switch (action) {
-    case "init":
-      await init();
-      break;
-    case "update":
-      await update();
-      break;
-    case "config-mcp":
-      await configMcp();
-      break;
-    case "uninstall":
-      await uninstall();
-      break;
-    case "help":
-      showHelp();
-      break;
-    case "exit":
-      console.log(ansis.gray("Goodbye!"));
-      break;
+  while (true) {
+    console.log();
+    console.log(ansis.cyan.bold(`  CCG - Claude + Codex + Gemini`));
+    console.log(ansis.gray("  Multi-Model Collaboration System"));
+    console.log();
+    const { action } = await inquirer.prompt([{
+      type: "list",
+      name: "action",
+      message: i18n.t("menu:title"),
+      choices: [
+        { name: `${ansis.green("\u279C")} ${i18n.t("menu:options.init")}`, value: "init" },
+        { name: `${ansis.blue("\u279C")} ${i18n.t("menu:options.update")}`, value: "update" },
+        { name: `${ansis.cyan("\u2699")} \u914D\u7F6E MCP`, value: "config-mcp" },
+        { name: `${ansis.magenta("\u279C")} ${i18n.t("menu:options.uninstall")}`, value: "uninstall" },
+        { name: `${ansis.yellow("?")} ${i18n.t("menu:options.help")}`, value: "help" },
+        new inquirer.Separator(),
+        { name: `${ansis.red("\u2715")} ${i18n.t("menu:options.exit")}`, value: "exit" }
+      ]
+    }]);
+    switch (action) {
+      case "init":
+        await init();
+        break;
+      case "update":
+        await update();
+        break;
+      case "config-mcp":
+        await configMcp();
+        break;
+      case "uninstall":
+        await uninstall();
+        break;
+      case "help":
+        showHelp();
+        break;
+      case "exit":
+        console.log(ansis.gray("Goodbye!"));
+        return;
+    }
+    console.log();
+    await inquirer.prompt([{
+      type: "input",
+      name: "continue",
+      message: ansis.gray("\u6309 Enter \u8FD4\u56DE\u4E3B\u83DC\u5355...")
+    }]);
   }
 }
 function showHelp() {
   console.log();
   console.log(ansis.cyan.bold(i18n.t("menu:help.title")));
   console.log();
-  console.log(`  ${ansis.green("/ccg:dev")}         ${i18n.t("menu:help.descriptions.dev")}`);
+  console.log(ansis.yellow.bold("  \u5F00\u53D1\u5DE5\u4F5C\u6D41:"));
+  console.log(`  ${ansis.green("/ccg:workflow")}    \u5B8C\u65746\u9636\u6BB5\u5F00\u53D1\u5DE5\u4F5C\u6D41`);
+  console.log(`  ${ansis.green("/ccg:plan")}        \u591A\u6A21\u578B\u534F\u4F5C\u89C4\u5212\uFF08Phase 1-2\uFF09`);
+  console.log(`  ${ansis.green("/ccg:execute")}     \u591A\u6A21\u578B\u534F\u4F5C\u6267\u884C\uFF08Phase 3-5\uFF09`);
   console.log(`  ${ansis.green("/ccg:frontend")}    ${i18n.t("menu:help.descriptions.frontend")}`);
   console.log(`  ${ansis.green("/ccg:backend")}     ${i18n.t("menu:help.descriptions.backend")}`);
-  console.log(`  ${ansis.green("/ccg:review")}      ${i18n.t("menu:help.descriptions.review")}`);
+  console.log(`  ${ansis.green("/ccg:feat")}        \u667A\u80FD\u529F\u80FD\u5F00\u53D1`);
   console.log(`  ${ansis.green("/ccg:analyze")}     ${i18n.t("menu:help.descriptions.analyze")}`);
+  console.log(`  ${ansis.green("/ccg:debug")}       \u95EE\u9898\u8BCA\u65AD + \u4FEE\u590D`);
+  console.log(`  ${ansis.green("/ccg:optimize")}    \u6027\u80FD\u4F18\u5316`);
+  console.log(`  ${ansis.green("/ccg:test")}        \u6D4B\u8BD5\u751F\u6210`);
+  console.log(`  ${ansis.green("/ccg:review")}      ${i18n.t("menu:help.descriptions.review")}`);
+  console.log();
+  console.log(ansis.yellow.bold("  OpenSpec \u89C4\u8303\u9A71\u52A8:"));
+  console.log(`  ${ansis.green("/ccg:spec-init")}      \u521D\u59CB\u5316 OpenSpec \u73AF\u5883`);
+  console.log(`  ${ansis.green("/ccg:spec-research")} \u9700\u6C42\u7814\u7A76 \u2192 \u7EA6\u675F\u96C6`);
+  console.log(`  ${ansis.green("/ccg:spec-plan")}     \u591A\u6A21\u578B\u5206\u6790 \u2192 \u96F6\u51B3\u7B56\u8BA1\u5212`);
+  console.log(`  ${ansis.green("/ccg:spec-impl")}     \u89C4\u8303\u9A71\u52A8\u5B9E\u73B0`);
+  console.log(`  ${ansis.green("/ccg:spec-review")}   \u5F52\u6863\u524D\u53CC\u6A21\u578B\u5BA1\u67E5`);
+  console.log();
+  console.log(ansis.yellow.bold("  Git \u5DE5\u5177:"));
   console.log(`  ${ansis.green("/ccg:commit")}      ${i18n.t("menu:help.descriptions.commit")}`);
   console.log(`  ${ansis.green("/ccg:rollback")}    ${i18n.t("menu:help.descriptions.rollback")}`);
+  console.log(`  ${ansis.green("/ccg:clean-branches")} \u6E05\u7406\u5DF2\u5408\u5E76\u5206\u652F`);
+  console.log(`  ${ansis.green("/ccg:worktree")}    Git Worktree \u7BA1\u7406`);
+  console.log();
+  console.log(ansis.yellow.bold("  \u9879\u76EE\u7BA1\u7406:"));
+  console.log(`  ${ansis.green("/ccg:init")}        \u521D\u59CB\u5316\u9879\u76EE CLAUDE.md`);
   console.log();
   console.log(ansis.gray(i18n.t("menu:help.hint")));
   console.log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccg-workflow",
-  "version": "1.7.47",
+  "version": "1.7.49",
   "description": "Claude-Codex-Gemini 多模型协作系统 - 智能路由多模型开发工作流",
   "type": "module",
   "packageManager": "pnpm@10.17.1",
@@ -44,6 +44,11 @@
     "templates/commands/test.md",
     "templates/commands/workflow.md",
     "templates/commands/worktree.md",
+    "templates/commands/spec-init.md",
+    "templates/commands/spec-research.md",
+    "templates/commands/spec-plan.md",
+    "templates/commands/spec-impl.md",
+    "templates/commands/spec-review.md",
     "templates/commands/agents/",
     "templates/prompts/codex/",
     "templates/prompts/gemini/analyzer.md",

package/templates/commands/spec-impl.md

@@ -0,0 +1,123 @@
+---
+description: '按规范执行 + 多模型协作 + 归档'
+---
+<!-- CCG:SPEC:IMPL:START -->
+**Core Philosophy**
+- Implementation is pure mechanical execution—all decisions were made in Plan phase.
+- External model outputs are prototypes only; must be rewritten to production-grade code.
+- Keep changes tightly scoped; enforce side-effect review before any modification.
+- Minimize documentation—prefer self-explanatory code over comments.
+
+**Guardrails**
+- **NEVER** apply Codex/Gemini 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/AGENTS.md` for conventions.
+
+**Steps**
+1. **Select Proposal**
+   - Run `openspec list` to inspect Active Changes.
+   - Confirm with user which proposal ID to implement.
+   - Run `openspec show <proposal_id>` to review tasks.
+
+2. **Apply OpenSpec Change**
+   - Run `/openspec:apply <proposal_id>` to enter implementation mode.
+
+3. **Identify Minimal Verifiable Phase**
+   - Review `tasks.md` and identify the **smallest verifiable phase**.
+   - Do NOT complete all tasks at once—control context window.
+   - 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)
+
+   For each task:
+   ```
+   codeagent-wrapper --backend <codex|gemini> - "$PWD" <<'EOF'
+   TASK: <task description from tasks.md>
+   CONTEXT: <relevant code context>
+   CONSTRAINTS: <constraints from spec>
+   OUTPUT: Unified Diff Patch format ONLY
+   EOF
+   ```
+
+5. **Rewrite Prototype to Production Code**
+   Upon receiving diff patch, **NEVER apply directly**. Rewrite by:
+   - Removing redundancy
+   - Ensuring clear naming and simple structure
+   - Aligning with project style
+   - Eliminating unnecessary comments
+   - Verifying no new dependencies introduced
+
+6. **Side-Effect Review** (Mandatory before apply)
+   Verify the change:
+   - [ ] Does not exceed `tasks.md` scope
+   - [ ] Does not affect unrelated modules
+   - [ ] Does not introduce new dependencies
+   - [ ] Does not break existing interfaces
+
+   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.
+   - **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)**:
+   ```
+   Bash({
+     command: "~/.claude/bin/codeagent-wrapper --backend codex - \"$PWD\" <<'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"
+   })
+   ```
+
+   **SECOND Bash call (Gemini) - IN THE SAME MESSAGE**:
+   ```
+   Bash({
+     command: "~/.claude/bin/codeagent-wrapper --backend gemini - \"$PWD\" <<'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"
+   })
+   ```
+
+   **Step 7.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 })
+   ```
+
+   Address any critical findings before proceeding.
+
+8. **Update Task Status**
+   - Mark completed task in `tasks.md`: `- [x] Task description`
+   - Commit changes if appropriate.
+
+9. **Context Checkpoint**
+   - After completing a phase, report context usage.
+   - If below 80K: Ask user "Continue to next phase?"
+   - If approaching 80K: Suggest "Run `/clear` and resume with `/ccg:spec:impl`"
+
+10. **Archive on Completion**
+    - When ALL tasks in `tasks.md` are marked `[x]`:
+    - Run `/openspec:archive <proposal_id>`
+    - This merges spec deltas to `openspec/specs/` and moves change to archive.
+
+**Reference**
+- Check task status: `openspec show <id>`
+- Validate before archive: `openspec validate <id>`
+- View active changes: `openspec list`
+- Search existing patterns: `rg -n "function|class" <file>`
+
+**Exit Criteria**
+Implementation is complete when:
+- [ ] All tasks in `tasks.md` marked `[x]`
+- [ ] All multi-model reviews passed
+- [ ] Side-effect review confirmed no regressions
+- [ ] `openspec validate <id>` returns zero issues
+- [ ] Change archived successfully
+<!-- CCG:SPEC:IMPL:END -->

package/templates/commands/spec-init.md

@@ -0,0 +1,72 @@
+---
+description: '初始化 OpenSpec 环境 + 验证多模型 MCP 工具'
+---
+<!-- CCG:SPEC:INIT:START -->
+**Core Philosophy**
+- OpenSpec provides the specification framework; CCG adds multi-model collaboration.
+- This phase ensures all tools are ready before any development work begins.
+- Fail fast: detect missing dependencies early rather than mid-workflow.
+
+**Guardrails**
+- Detect OS (Linux/macOS/Windows) and adapt commands accordingly.
+- Do not proceed to next step until current step completes successfully.
+- Provide clear, actionable error messages when a step fails.
+- Respect user's existing configurations; avoid overwriting without confirmation.
+
+**Steps**
+1. **Detect Operating System**
+   - Identify OS using `uname -s` (Unix) or environment variables (Windows).
+   - Inform user which OS was detected.
+
+2. **Check and Install OpenSpec**
+   - Verify if `openspec` CLI is installed: `openspec --version`
+   - If not installed:
+     ```bash
+     npm install -g @fission-ai/openspec@latest
+     ```
+   - Confirm installation success.
+
+3. **Initialize OpenSpec for Current Project**
+   - Run:
+     ```bash
+     openspec init --tools claude
+     ```
+   - Verify `openspec/` directory structure is created.
+   - Report any errors with remediation steps.
+
+4. **Validate Multi-Model MCP Tools**
+   - Check `codeagent-wrapper` availability: `~/.claude/bin/codeagent-wrapper --version`
+   - Test Codex backend:
+     ```bash
+     ~/.claude/bin/codeagent-wrapper --backend codex - "$PWD" <<< "echo test"
+     ```
+   - Test Gemini backend:
+     ```bash
+     ~/.claude/bin/codeagent-wrapper --backend gemini - "$PWD" <<< "echo test"
+     ```
+   - For each unavailable tool, display warning with installation instructions.
+
+5. **Validate Context Retrieval MCP** (Optional)
+   - Check if `mcp__ace-tool__search_context` is available.
+   - If not, suggest: "Run `npx ccg-workflow` and select ace-tool MCP option."
+
+6. **Summary Report**
+   Display status table:
+   ```
+   Component                 Status
+   ─────────────────────────────────
+   OpenSpec CLI              ✓/✗
+   Project initialized       ✓/✗
+   codeagent-wrapper         ✓/✗
+   Codex backend             ✓/✗
+   Gemini backend            ✓/✗
+   ace-tool MCP              ✓/✗ (optional)
+   ```
+   If any required components missing, list actions before proceeding.
+
+**Reference**
+- OpenSpec CLI: `openspec --help`
+- CCG Workflow: `npx ccg-workflow`
+- Codex/Gemini MCP: Bundled with codeagent-wrapper
+- Node.js >= 18.x required for OpenSpec
+<!-- CCG:SPEC:INIT:END -->

package/templates/commands/spec-plan.md

@@ -0,0 +1,109 @@
+---
+description: '多模型分析 → 消除歧义 → 零决策可执行计划'
+---
+<!-- CCG:SPEC:PLAN:START -->
+**Core Philosophy**
+- The goal is to eliminate ALL decision points—implementation should be pure mechanical execution.
+- Every ambiguity must be resolved into explicit constraints before proceeding.
+- Multi-model collaboration surfaces blind spots and conflicting assumptions.
+- Every requirement must have Property-Based Testing (PBT) properties—focus on invariants.
+
+**Guardrails**
+- Do not proceed to implementation until every ambiguity is resolved.
+- Multi-model collaboration is **mandatory**: use both Codex and Gemini.
+- If constraints cannot be fully specified, escalate to user or return to research phase.
+- Refer to `openspec/AGENTS.md` for conventions; run `openspec update` if missing.
+
+**Steps**
+1. **Select Proposal**
+   - Run `openspec list` to display Active Changes.
+   - Confirm with user which proposal ID to refine.
+   - Run `openspec show <proposal_id>` 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.
+   - **DO NOT** call one model first and wait. Launch BOTH simultaneously with `run_in_background: true`.
+
+   **Step 2.1**: In ONE message, make TWO parallel Bash calls:
+
+   **FIRST Bash call (Codex)**:
+   ```
+   Bash({
+     command: "~/.claude/bin/codeagent-wrapper --backend codex - \"$PWD\" <<'EOF'\nAnalyze proposal <proposal_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"
+   })
+   ```
+
+   **SECOND Bash call (Gemini) - IN THE SAME MESSAGE**:
+   ```
+   Bash({
+     command: "~/.claude/bin/codeagent-wrapper --backend gemini - \"$PWD\" <<'EOF'\nAnalyze proposal <proposal_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"
+   })
+   ```
+
+   **Step 2.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 })
+   ```
+
+   - 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]"
+
+   **Anti-Pattern Detection** (flag and reject):
+   - Information collection without decision boundaries
+   - Technical comparisons without selection criteria
+   - Deferred decisions marked "to be determined during implementation"
+
+   **Target Pattern** (required for approval):
+   - Explicit technology choices with parameters (e.g., "JWT with TTL=15min")
+   - Concrete algorithm selections with configs (e.g., "bcrypt cost=12")
+   - Precise behavioral rules (e.g., "Lock account 30min after 5 failed attempts")
+
+   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]"
+
+   **Property Categories**:
+   - **Commutativity/Associativity**: Order-independent operations
+   - **Idempotency**: Repeated operations yield same result
+   - **Round-trip**: Encode→Decode returns original
+   - **Invariant Preservation**: State constraints maintained
+   - **Monotonicity**: Ordering guarantees (e.g., timestamps increase)
+   - **Bounds**: Value ranges, size limits, rate constraints
+
+5. **Update OpenSpec Documents**
+   - Run `/openspec:proposal <proposal_id>` to update specs with:
+     * All resolved constraints
+     * PBT properties in spec format
+     * Zero-decision task sequence
+   - Run `openspec validate <proposal_id>` to verify format.
+
+6. **Context Checkpoint**
+   - Report current context usage.
+   - If approaching 80K tokens, suggest: "Run `/clear` and continue with `/ccg:spec:impl`"
+
+**Exit Criteria**
+A proposal is ready for implementation only when:
+- [ ] All multi-model analyses completed and synthesized
+- [ ] Zero ambiguities remain (verified by step 3 audit)
+- [ ] All PBT properties documented with falsification strategies
+- [ ] `openspec validate <id>` returns zero issues
+- [ ] User has explicitly approved all constraint decisions
+
+**Reference**
+- Inspect proposal: `openspec show <id> --json`
+- Check conflicts: `openspec list --specs`
+- Search patterns: `rg -n "INVARIANT:|PROPERTY:" openspec/`
+- Use `AskUserQuestion` for ANY ambiguity—never assume
+<!-- CCG:SPEC:PLAN:END -->

package/templates/commands/spec-research.md

@@ -0,0 +1,101 @@
+---
+description: '需求 → 约束集（并行探索 + OpenSpec 提案）'
+---
+<!-- CCG:SPEC:RESEARCH:START -->
+**Core Philosophy**
+- Research produces **constraint sets**, not information dumps. Each constraint narrows the solution space.
+- Constraints tell subsequent stages "don't consider this direction," enabling mechanical execution without decisions.
+- Output: 约束集合 + 可验证的成功判据 (constraint sets + verifiable success criteria).
+- Strictly adhere to OpenSpec 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.
+- **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__ace-tool__search_context` to minimize grep/find operations.
+- Do not make architectural decisions—surface constraints that guide decisions.
+
+**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: "$PWD"
+   })
+   ```
+   - Wait for enhanced prompt result.
+   - Use enhanced prompt for ALL subsequent steps.
+
+1. **Generate OpenSpec Proposal**
+   - Run: `/openspec:proposal $ARGUMENTS`
+   - This scaffolds `openspec/changes/<name>/` with proposal.md, tasks.md, specs/.
+
+2. **Initial Codebase Assessment**
+   - Use `mcp__ace-tool__search_context` to scan codebase.
+   - Determine project scale: single vs multi-directory structure.
+   - **Decision**: If multi-directory → enable parallel Explore subagents.
+
+3. **Define Exploration Boundaries (Context-Based)**
+   - Identify natural context boundaries (NOT functional roles):
+     * Subagent 1: User domain code (models, services, UI)
+     * Subagent 2: Auth & authorization (middleware, session, tokens)
+     * Subagent 3: Infrastructure (configs, deployments, builds)
+   - Each boundary should be self-contained: no cross-communication needed.
+
+4. **Parallel Multi-Model Exploration**
+   - Dispatch Explore subagents with unified output template:
+   ```json
+   {
+     "module_name": "context boundary explored",
+     "existing_structures": ["key patterns found"],
+     "existing_conventions": ["standards in use"],
+     "constraints_discovered": ["hard constraints limiting solution space"],
+     "open_questions": ["ambiguities requiring user input"],
+     "dependencies": ["cross-module dependencies"],
+     "risks": ["potential blockers"],
+     "success_criteria_hints": ["observable success behaviors"]
+   }
+   ```
+   - Run Codex for backend boundaries, Gemini for frontend boundaries.
+
+5. **Aggregate and Synthesize**
+   - Collect all subagent outputs.
+   - Merge into unified constraint sets:
+     * **Hard constraints**: Technical limitations, patterns that cannot be violated
+     * **Soft constraints**: Conventions, preferences, style guides
+     * **Dependencies**: Cross-module relationships affecting implementation order
+     * **Risks**: Blockers needing mitigation
+
+6. **User Interaction for Ambiguity Resolution**
+   - Compile prioritized list of open questions.
+   - Use `AskUserQuestion` tool to present systematically:
+     * Group related questions
+     * Provide context for each
+     * Suggest defaults when applicable
+   - Capture responses as additional constraints.
+
+7. **Finalize OpenSpec Proposal**
+   - Transform constraint sets into OpenSpec 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
+
+8. **Context Checkpoint**
+   - Report current context usage.
+   - If approaching 80K tokens, suggest: "Run `/clear` and continue with `/ccg:spec:plan`"
+
+**Reference**
+- Review constraints: `rg -n "Constraint:|MUST|MUST NOT" openspec/specs`
+- Check prior research: `ls openspec/changes/*/`
+- Use `openspec show <name>` to inspect proposal structure
+- Use `AskUserQuestion` for ANY ambiguity—never assume or guess
+<!-- CCG:SPEC:RESEARCH:END -->

package/templates/commands/spec-review.md

@@ -0,0 +1,120 @@
+---
+description: '双模型交叉审查（独立工具，随时可用）'
+---
+<!-- CCG:SPEC:REVIEW:START -->
+**Core Philosophy**
+- Dual-model cross-validation catches blind spots single-model review would miss.
+- Critical findings SHOULD be addressed before proceeding.
+- Review validates implementation against spec constraints and code quality.
+- 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.
+- 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.
+
+**Steps**
+1. **Select Proposal**
+   - Run `openspec list` to display Active Changes.
+   - Confirm with user which proposal ID to review.
+   - Run `openspec show <proposal_id>` to load spec and tasks.
+
+2. **Collect Implementation Artifacts**
+   - Identify all files modified by this proposal.
+   - Use `git diff` or `openspec diff <proposal_id>` 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.
+   - **DO NOT** call one model first and wait. Launch BOTH simultaneously with `run_in_background: true`.
+
+   **Step 3.1**: In ONE message, make TWO parallel Bash calls:
+
+   **FIRST Bash call (Codex)**:
+   ```
+   Bash({
+     command: "~/.claude/bin/codeagent-wrapper --backend codex - \"$PWD\" <<'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",
+     run_in_background: true,
+     timeout: 300000,
+     description: "Codex: backend/logic review"
+   })
+   ```
+
+   **SECOND Bash call (Gemini) - IN THE SAME MESSAGE**:
+   ```
+   Bash({
+     command: "~/.claude/bin/codeagent-wrapper --backend gemini - \"$PWD\" <<'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",
+     run_in_background: true,
+     timeout: 300000,
+     description: "Gemini: patterns/integration review"
+   })
+   ```
+
+   **Step 3.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 })
+   ```
+
+4. **Synthesize Findings**
+   - Merge findings from both models.
+   - Deduplicate overlapping issues.
+   - Classify by severity:
+     * **Critical**: Spec violation, security vulnerability, breaking change → MUST fix
+     * **Warning**: Pattern deviation, maintainability concern → SHOULD fix
+     * **Info**: Minor improvement suggestion → MAY fix
+
+5. **Present Review Report**
+   - Display findings grouped by severity:
+   ```
+   ## Review Report: <proposal_id>
+
+   ### Critical (X issues) - MUST FIX
+   - [ ] [SPEC] file.ts:42 - Constraint X violated: description
+   - [ ] [SEC] api.ts:15 - SQL injection vulnerability
+
+   ### Warning (Y issues) - SHOULD FIX
+   - [ ] [PATTERN] utils.ts:88 - Inconsistent naming convention
+
+   ### Info (Z issues) - MAY FIX
+   - [ ] [MAINT] helper.ts:20 - Consider extracting to separate function
+
+   ### Passed Checks
+   - ✅ PBT: Idempotency property verified
+   - ✅ Security: No XSS vulnerabilities found
+   ```
+
+6. **Decision Gate**
+   - **If Critical > 0**:
+     * Present findings to user.
+     * Ask: "Fix now or return to `/ccg:spec-impl` to address?"
+     * Do NOT allow archiving.
+
+   - **If Critical = 0**:
+     * Ask user: "All critical checks passed. Proceed to archive?"
+     * If Warning > 0, recommend addressing before archive.
+
+7. **Optional: Inline Fix Mode**
+   - If user chooses "Fix now" for Critical issues:
+     * Route each fix to appropriate model (backend→Codex, frontend→Gemini).
+     * Apply fix using unified diff patch pattern.
+     * Re-run affected review dimension.
+     * Repeat until Critical = 0.
+
+8. **Context Checkpoint**
+   - Report current context usage.
+   - If approaching 80K tokens, suggest: "Run `/clear` and continue with `/ccg:spec-review` or `/ccg:spec-impl`"
+
+**Exit Criteria**
+Review is complete when:
+- [ ] Both Codex and Gemini 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: `openspec show <id>`
+- Check spec constraints: `rg -n "CONSTRAINT:|MUST|INVARIANT:" openspec/changes/<id>/specs/`
+- View implementation diff: `openspec diff <id>` or `git diff`
+- Archive (after passing): `/ccg:spec-impl` → Step 10
+<!-- CCG:SPEC:REVIEW:END -->