ccg-workflow 1.7.48 → 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（前端）
 

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.e4y82GtN.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.e4y82GtN.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.e4y82GtN.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.48";
+const version = "1.7.49";
 
 function isWindows() {
   return process.platform === "win32";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccg-workflow",
-  "version": "1.7.48",
+  "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 -->