@nst173/superpowers-ccg 1.3.0

package/.agent/skills/brainstorming/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: brainstorming
+description: Explore requirements, tradeoffs, and routing before implementation starts. Use when the request is open-ended, ambiguous, or likely to require multiple bounded tasks.
+---
+
+# Brainstorming
+
+## Goals
+
+1. Clarify the real user goal and any hidden constraints.
+2. Identify the smallest useful outcome.
+3. Split likely work into backend, frontend, and coordination slices.
+4. Decide whether the task needs a plan or can go straight to a bounded execution step.
+
+## Output
+
+- A short problem statement
+- Key constraints and risks
+- A proposed task split
+- A recommended next command or skill
+
+## Guardrails
+
+- Do not implement during brainstorming.
+- Do not generate multi-page plans when a few bounded tasks will do.
+- Prefer narrowing scope over escalating to multiple workers.

package/.agent/skills/coordinating-multi-model-work/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: coordinating-multi-model-work
+description: Route bounded implementation tasks to Codex or Gemini while keeping Cursor out of the implementation hot path. Use for coding, refactors, debugging, UI work, APIs, databases, scripts, and CI/CD changes.
+---
+
+# Coordinating Multi-Model Work
+
+## Routing
+
+- `codex`: backend APIs, databases, auth, scripts, CI/CD, Docker, infrastructure, repo tooling
+- `gemini`: UI components, layouts, styling, interaction polish
+- `cross-validation`: architectural disputes or genuinely ambiguous ownership
+
+## Rules
+
+1. Reduce the current work to one bounded task.
+2. Assign exactly one worker unless architecture uncertainty makes that unsafe.
+3. Include the file set, acceptance criteria, and verification command.
+4. Require one of two outputs only:
+   - a patch-ready diff
+   - blocking questions
+5. Reuse the same worker context for fixes on the same task.
+
+## Anti-patterns
+
+- Do not ask for a prototype and then rewrite it yourself.
+- Do not route the same bounded task to multiple workers by default.
+- Do not let review steps replay the entire execution history.
+- Do not keep long planning and execution narration in the main Cursor thread.

package/.agent/skills/executing-plans/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: executing-plans
+description: Execute a short plan one bounded task at a time with explicit worker ownership and verification. Use after planning is complete and implementation is ready to begin.
+---
+
+# Executing Plans
+
+## Execution loop
+
+1. Pick the next bounded task.
+2. Emit a compact CP1 assessment if implementation is beginning.
+3. Route the task to the correct worker or keep it local if it is truly trivial.
+4. Integrate the returned diff or resolve the blocking questions.
+5. Run the verification command for that task.
+6. Move to the next bounded task only after the current one is stable.
+
+## Reporting
+
+- Keep progress updates short.
+- Track only the active task, owner, and verification state.
+- Do not duplicate the full plan in every update.
+
+## Completion
+
+- Run final verification.
+- Emit a compact CP3 assessment.
+- Report remaining risks or gaps if verification is partial.

package/.agent/skills/using-superpowers/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: using-superpowers
+description: Establish how to operate Superpowers CCG inside Cursor. Use when starting work, deciding which skill to apply, or setting the orchestration model for a task.
+---
+
+# Using Superpowers In Cursor
+
+## Core behavior
+
+1. If there is even a small chance that a skill applies, use the skill before proceeding.
+2. Keep Cursor in the orchestrator role for anything beyond trivial local edits or documentation.
+3. Break work into bounded tasks with a file set and a verification command.
+4. Route implementation to one worker at a time:
+   - `codex` for backend and systems
+   - `gemini` for frontend and styling
+5. Only use cross-validation when a single worker cannot safely own the decision.
+
+## Standard flow
+
+1. Use `brainstorming` before open-ended feature design.
+2. Use `writing-plans` to produce bounded execution tasks.
+3. Use `executing-plans` to run the work one task at a time.
+4. Use `verifying-before-completion` before reporting completion.
+
+## Commands
+
+- `/brainstorm` for discovery and design
+- `/write-plan` for turning scope into bounded tasks
+- `/execute-plan` for worker-driven execution

package/.agent/skills/verifying-before-completion/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: verifying-before-completion
+description: Validate that the implemented work is actually complete before reporting success. Use before final handoff, after risky edits, or after external worker output is integrated.
+---
+
+# Verifying Before Completion
+
+## Checklist
+
+1. Run the stated verification commands.
+2. Confirm the changed files match the intended scope.
+3. Check for obvious regressions, broken docs, or stale instructions.
+4. Summarize what was verified and what was not.
+
+## Output
+
+- Verification commands run
+- Result of each command
+- Remaining gaps or risks
+- Compact CP3 assessment

package/.agent/skills/writing-plans/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: writing-plans
+description: Turn a request into a short ordered plan of bounded tasks. Use when implementation spans multiple files, decisions, or verification steps.
+---
+
+# Writing Plans
+
+## Requirements
+
+1. Keep the plan short and execution-oriented.
+2. Each task must name its likely files or subsystem.
+3. Each task must have one owner:
+   - Cursor
+   - Codex
+   - Gemini
+4. Each task should include a verification command or validation method.
+
+## Preferred format
+
+1. Goal
+2. Constraints
+3. Ordered bounded tasks
+4. First task to execute now
+
+## Avoid
+
+- vague “investigate everything” steps
+- mixing backend and frontend implementation in one bounded task
+- plans that require the orchestrator to restate the same context repeatedly

package/.cursor/agents/code-reviewer.md

@@ -0,0 +1,22 @@
+---
+name: code-reviewer
+description: Review completed work for regressions, missing verification, and workflow drift. Use after a meaningful bounded task or before final handoff.
+---
+
+# Code Reviewer
+
+Review with a findings-first mindset.
+
+## Priorities
+
+1. Behavioral regressions
+2. Missing or weak verification
+3. Routing mistakes that pushed Cursor into implementation unnecessarily
+4. Documentation or instruction drift
+5. Maintainability and clarity issues
+
+## Output format
+
+1. Findings ordered by severity
+2. Open questions or assumptions
+3. Brief summary of acceptable risk, if no blocking issues remain

package/.cursor/commands/brainstorm.md

@@ -0,0 +1,11 @@
+---
+name: brainstorm
+description: Clarify requirements, task split, and routing before implementation.
+---
+
+# Brainstorm
+
+1. Use the `using-superpowers` skill.
+2. Use the `brainstorming` skill.
+3. Clarify the goal, constraints, and likely routing split.
+4. Do not implement yet.

package/.cursor/commands/execute-plan.md

@@ -0,0 +1,12 @@
+---
+name: execute-plan
+description: Execute the current plan with bounded-task routing and verification.
+---
+
+# Execute Plan
+
+1. Use the `using-superpowers` skill.
+2. Use the `executing-plans` skill.
+3. Use `coordinating-multi-model-work` for routed implementation.
+4. Keep Cursor as the orchestrator unless the task is trivial.
+5. Verify each bounded task before moving on.

package/.cursor/commands/write-plan.md

@@ -0,0 +1,11 @@
+---
+name: write-plan
+description: Convert the current request into a short plan of bounded tasks.
+---
+
+# Write Plan
+
+1. Use the `using-superpowers` skill.
+2. Use the `writing-plans` skill.
+3. Produce a short ordered plan with explicit owners and verification commands.
+4. Keep the plan small enough to execute without token sprawl.

package/.cursor/hook-scripts/after-file-edit.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+console.log("[superpowers-ccg] After edit: keep the active task bounded and run task-level verification before moving on.");

package/.cursor/hook-scripts/before-shell-execution.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+console.error("[superpowers-ccg] Shell guard: confirm the command is necessary, scoped, and does not bypass the bounded-task workflow.");

package/.cursor/hook-scripts/session-end.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+console.log("[superpowers-ccg] Session end: report verification results, remaining risks, and a compact CP3 assessment.");

package/.cursor/hooks.json

@@ -0,0 +1,21 @@
+{
+  "version": 1,
+  "hooks": {
+    "afterFileEdit": [
+      {
+        "command": "node ./.cursor/hook-scripts/after-file-edit.mjs"
+      }
+    ],
+    "beforeShellExecution": [
+      {
+        "command": "node ./.cursor/hook-scripts/before-shell-execution.mjs",
+        "matcher": "rm|curl|wget|git reset --hard|git checkout --"
+      }
+    ],
+    "sessionEnd": [
+      {
+        "command": "node ./.cursor/hook-scripts/session-end.mjs"
+      }
+    ]
+  }
+}

package/.cursor/mcp.json

@@ -0,0 +1,20 @@
+{
+  "mcpServers": {
+    "codex": {
+      "command": "uvx",
+      "args": [
+        "--from",
+        "C:\Users\ngosi\.mcp-servers\codexmcp",
+        "codexmcp"
+      ]
+    },
+    "gemini": {
+      "command": "uvx",
+      "args": [
+        "--from",
+        "C:\Users\ngosi\.mcp-servers\geminimcp",
+        "geminimcp"
+      ]
+    }
+  }
+}

package/.cursor/rules/checkpoint-protocol.mdc

@@ -0,0 +1,11 @@
+---
+description: Apply CP1 before execution starts and CP3 before claiming completion.
+alwaysApply: true
+---
+
+checkpoint-protocol:
+
+- Before the first substantial implementation step, emit a short CP1 routing assessment.
+- Before claiming completion, emit a short CP3 verification assessment.
+- Keep checkpoint blocks minimal and factual.
+- Include task type, routing choice, and evidence for the final verification state.

package/.cursor/rules/orchestrator-routing.mdc

@@ -0,0 +1,12 @@
+---
+description: Route work through the Superpowers CCG orchestrator instead of treating Cursor as the implementation worker.
+alwaysApply: true
+---
+
+orchestrator-routing:
+
+- Reduce work to one bounded task with a clear goal, file set, and verification command.
+- Route backend and systems work to the `codex` MCP server.
+- Route frontend and styling work to the `gemini` MCP server.
+- Keep Cursor in the orchestrator role unless the task is trivial coordination or documentation.
+- Use cross-validation only when there is real architectural uncertainty, not by default.

package/.cursor/rules/token-discipline.mdc

@@ -0,0 +1,12 @@
+---
+description: Keep orchestration compact so the main Cursor thread does not become the token hot path.
+alwaysApply: true
+---
+
+token-discipline:
+
+- Do not ask one worker for a prototype and then rewrite the same task yourself.
+- Require `diff or blocking questions` from implementation workers.
+- Reuse the same worker context for follow-up fixes on the same bounded task.
+- Summarize decisions once and avoid restating the same project context in every turn.
+- Keep reviews artifact-focused instead of replaying the full task narrative.

package/.cursor/skills/brainstorming/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: brainstorming
+description: Explore requirements, tradeoffs, and routing before implementation starts. Use when the request is open-ended, ambiguous, or likely to require multiple bounded tasks.
+---
+
+# Brainstorming
+
+## Goals
+
+1. Clarify the real user goal and any hidden constraints.
+2. Identify the smallest useful outcome.
+3. Split likely work into backend, frontend, and coordination slices.
+4. Decide whether the task needs a plan or can go straight to a bounded execution step.
+
+## Output
+
+- A short problem statement
+- Key constraints and risks
+- A proposed task split
+- A recommended next command or skill
+
+## Guardrails
+
+- Do not implement during brainstorming.
+- Do not generate multi-page plans when a few bounded tasks will do.
+- Prefer narrowing scope over escalating to multiple workers.

package/.cursor/skills/coordinating-multi-model-work/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: coordinating-multi-model-work
+description: Route bounded implementation tasks to Codex or Gemini while keeping Cursor out of the implementation hot path. Use for coding, refactors, debugging, UI work, APIs, databases, scripts, and CI/CD changes.
+---
+
+# Coordinating Multi-Model Work
+
+## Routing
+
+- `codex`: backend APIs, databases, auth, scripts, CI/CD, Docker, infrastructure, repo tooling
+- `gemini`: UI components, layouts, styling, interaction polish
+- `cross-validation`: architectural disputes or genuinely ambiguous ownership
+
+## Rules
+
+1. Reduce the current work to one bounded task.
+2. Assign exactly one worker unless architecture uncertainty makes that unsafe.
+3. Include the file set, acceptance criteria, and verification command.
+4. Require one of two outputs only:
+   - a patch-ready diff
+   - blocking questions
+5. Reuse the same worker context for fixes on the same task.
+
+## Anti-patterns
+
+- Do not ask for a prototype and then rewrite it yourself.
+- Do not route the same bounded task to multiple workers by default.
+- Do not let review steps replay the entire execution history.
+- Do not keep long planning and execution narration in the main Cursor thread.

package/.cursor/skills/executing-plans/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: executing-plans
+description: Execute a short plan one bounded task at a time with explicit worker ownership and verification. Use after planning is complete and implementation is ready to begin.
+---
+
+# Executing Plans
+
+## Execution loop
+
+1. Pick the next bounded task.
+2. Emit a compact CP1 assessment if implementation is beginning.
+3. Route the task to the correct worker or keep it local if it is truly trivial.
+4. Integrate the returned diff or resolve the blocking questions.
+5. Run the verification command for that task.
+6. Move to the next bounded task only after the current one is stable.
+
+## Reporting
+
+- Keep progress updates short.
+- Track only the active task, owner, and verification state.
+- Do not duplicate the full plan in every update.
+
+## Completion
+
+- Run final verification.
+- Emit a compact CP3 assessment.
+- Report remaining risks or gaps if verification is partial.

package/.cursor/skills/using-superpowers/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: using-superpowers
+description: Establish how to operate Superpowers CCG inside Cursor. Use when starting work, deciding which skill to apply, or setting the orchestration model for a task.
+---
+
+# Using Superpowers In Cursor
+
+## Core behavior
+
+1. If there is even a small chance that a skill applies, use the skill before proceeding.
+2. Keep Cursor in the orchestrator role for anything beyond trivial local edits or documentation.
+3. Break work into bounded tasks with a file set and a verification command.
+4. Route implementation to one worker at a time:
+   - `codex` for backend and systems
+   - `gemini` for frontend and styling
+5. Only use cross-validation when a single worker cannot safely own the decision.
+
+## Standard flow
+
+1. Use `brainstorming` before open-ended feature design.
+2. Use `writing-plans` to produce bounded execution tasks.
+3. Use `executing-plans` to run the work one task at a time.
+4. Use `verifying-before-completion` before reporting completion.
+
+## Commands
+
+- `/brainstorm` for discovery and design
+- `/write-plan` for turning scope into bounded tasks
+- `/execute-plan` for worker-driven execution

package/.cursor/skills/verifying-before-completion/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: verifying-before-completion
+description: Validate that the implemented work is actually complete before reporting success. Use before final handoff, after risky edits, or after external worker output is integrated.
+---
+
+# Verifying Before Completion
+
+## Checklist
+
+1. Run the stated verification commands.
+2. Confirm the changed files match the intended scope.
+3. Check for obvious regressions, broken docs, or stale instructions.
+4. Summarize what was verified and what was not.
+
+## Output
+
+- Verification commands run
+- Result of each command
+- Remaining gaps or risks
+- Compact CP3 assessment

package/.cursor/skills/writing-plans/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: writing-plans
+description: Turn a request into a short ordered plan of bounded tasks. Use when implementation spans multiple files, decisions, or verification steps.
+---
+
+# Writing Plans
+
+## Requirements
+
+1. Keep the plan short and execution-oriented.
+2. Each task must name its likely files or subsystem.
+3. Each task must have one owner:
+   - Cursor
+   - Codex
+   - Gemini
+4. Each task should include a verification command or validation method.
+
+## Preferred format
+
+1. Goal
+2. Constraints
+3. Ordered bounded tasks
+4. First task to execute now
+
+## Avoid
+
+- vague “investigate everything” steps
+- mixing backend and frontend implementation in one bounded task
+- plans that require the orchestrator to restate the same context repeatedly

package/AGENTS.md

@@ -0,0 +1,23 @@
+# Superpowers CCG
+
+Use Cursor as the orchestrator, not the primary implementation worker.
+
+## Operating model
+
+- Reduce work to one bounded task at a time.
+- Keep the active task tied to a clear file set and verification command.
+- Route backend and systems work to Codex via MCP.
+- Route frontend and styling work to Gemini via MCP.
+- Use cross-validation only for true architectural uncertainty.
+
+## Anti-patterns
+
+- Do not ask one worker for a prototype and then rewrite it yourself.
+- Do not route the same bounded task to multiple workers unless necessary.
+- Do not keep long execution narration in the main thread.
+
+## Verification
+
+- Before implementation starts, emit a compact CP1 routing assessment.
+- Before claiming completion, emit a compact CP3 verification assessment.
+- Report what was verified and what remains unverified.

package/CLAUDE.md

@@ -0,0 +1,78 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code when working in this repository.
+
+## What This Project Is
+
+**Superpowers-CCG** is a Claude Code plugin that adds a skills-driven development workflow with multi-model orchestration (Claude + Codex + Gemini). Claude acts as pure orchestrator and routes all implementation code to external models. It is a fork of [obra/superpowers](https://github.com/obra/superpowers).
+
+This repository is a **plugin/skills framework** written mostly as Markdown and Bash, with a small Node.js utility. There is no build step.
+
+The authoritative agent rules are in `superpowers-ccg.md`.
+
+## Running Tests
+
+```bash
+./tests/claude-code/run-skill-tests.sh
+./tests/claude-code/run-skill-tests.sh --integration
+./tests/claude-code/run-skill-tests.sh --test <test-file>.sh
+./tests/claude-code/run-skill-tests.sh --verbose
+./tests/claude-code/run-skill-tests.sh --timeout 1800
+```
+
+## Architecture
+
+### Skills (`skills/`)
+
+Each skill lives in a subdirectory with `SKILL.md` (YAML frontmatter + instructions). Skills are discovered and resolved via `lib/skills-core.js`. All skills are exposed under the `superpowers-ccg:` namespace.
+
+Key skills:
+- `coordinating-multi-model-work/` — Routes tasks to Codex/Gemini MCP and defines the CP checkpoint protocol
+- `developing-with-subagents/` — Routes tasks to external models with spec review via Opus, then Opus quality review
+- `executing-plans/` — Batch plan execution with review checkpoints
+
+### Hooks (`hooks/`)
+
+Three hooks regulate Claude behavior at runtime:
+
+| Hook | Trigger | Purpose |
+|------|---------|---------|
+| `session-start.sh` | startup/resume/clear | Session initialization |
+| `user-prompt-submit.sh` | every user message | Inject CP1/CP3 checkpoint reminders |
+| `pre-tool-use-task.sh` | before Task tool | Remind about model selection |
+
+### Multi-Model Routing
+
+Claude is the **orchestrator**. It routes tasks, coordinates models, and integrates results, but **never writes implementation code**.
+
+| Routing | When | MCP Tool |
+|---------|------|----------|
+| `CODEX` | Backend and systems: API, DB, auth, scripts, CI/CD, Dockerfiles, infrastructure | `mcp__codex__codex` |
+| `GEMINI` | Frontend: UI, components, styles | `mcp__gemini__gemini` |
+| `CROSS_VALIDATION` | Full-stack, architectural, uncertain | Multiple |
+| `CLAUDE` | Orchestration only: docs, coordination (no code) | None |
+
+Opus reviews all code-changing paths directly.
+
+### Shared Context Layer (Serena HTTP)
+
+All agents (Claude, Codex, Gemini) connect to a single Serena instance via Streamable HTTP (port 9121). This provides shared project memories and the `global/response_protocol` memory for token-efficient agent output.
+
+### Supplementary Tools
+
+Supplementary MCP tools can enhance orchestration, but they are optional. See `skills/shared/supplementary-tools.md`.
+
+### Checkpoint Protocol
+
+- **CP1**: Before first Task call
+- **CP2**: Mid-execution when uncertainty or stalls appear
+- **CP3**: Before claiming completion
+
+### Plugin Metadata (`.claude-plugin/`)
+
+- `plugin.json` — name, version, description
+- `marketplace.json` — marketplace registration
+
+## Skill Authoring
+
+When creating or editing skills, use `superpowers-ccg:writing-skills`. Skills require a failing test before implementation.

package/GEMINI.md

@@ -0,0 +1,27 @@
+# Superpowers CCG For Antigravity
+
+Antigravity is the orchestrator. Keep the main agent focused on planning, delegation, integration, and verification rather than hand-writing implementation in the main thread.
+
+## Operating model
+
+- Reduce work to one bounded task at a time.
+- Prefer small swarms over one giant agent session.
+- Keep each task tied to a file set and a verification command.
+- Reuse the same agent context for follow-up fixes on the same task.
+
+## Routing
+
+- Backend and systems: prefer Codex MCP
+- Frontend and styling: prefer Gemini-oriented execution
+- Architecture disputes: use a short review pass, not duplicate full implementations
+
+## Anti-patterns
+
+- Do not prototype in one agent and rewrite the same task in another.
+- Do not restate the full project context in every task.
+- Do not let review replay the full execution story.
+
+## Completion
+
+- Require evidence for verification before marking work done.
+- Summarize risks or remaining gaps explicitly.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jesse Vincent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.