agy-superpowers 5.0.5 → 5.0.7

package/README.md

@@ -130,6 +130,29 @@ This workflow will:
 
 ---
 
+## Configuration
+
+Per-project settings live in `.agent/config.yml`. Create or edit this file in your project's `.agent/` folder:
+
+```yaml
+# .agent/config.yml
+
+# auto_commit: true | false
+# When true (default), Superpowers skills automatically commit after completing
+# tasks and writing design docs.
+# When false, all git commits and staging are skipped — files are left as
+# modified for you to commit manually.
+auto_commit: true
+```
+
+| Setting | Default | Description |
+|---|---|---|
+| `auto_commit` | `true` | AI auto-commits after tasks and design docs. Set to `false` to skip all commits. |
+
+This file is preserved across `/update-superpowers` runs.
+
+---
+
 ## Installation
 
 ### Using This Repo in Your Project

package/bin/init.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // bin/init.js
-// Usage: npx antigravity-superpowers init
+// Usage: npx agy-superpowers init
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
@@ -15,8 +15,8 @@ const command = args[0];
 if (command !== 'init') {
   console.error(`❌ Unknown command: ${command || '(none)'}`);
   console.error('');
-  console.error('Usage: npx antigravity-superpowers init');
-  console.error('       npx antigravity-superpowers init --force   # overwrite existing .agent/');
+  console.error('Usage: npx agy-superpowers init');
+  console.error('       npx agy-superpowers init --force   # overwrite existing .agent/');
   process.exit(1);
 }
 
@@ -38,7 +38,7 @@ if (fs.existsSync(TARGET_DIR)) {
   console.warn('⚠️  .agent/ already exists in this directory.');
   console.warn('   Delete it first or re-run with --force to overwrite:');
   console.warn('');
-  console.warn('   npx antigravity-superpowers init --force');
+  console.warn('   npx agy-superpowers init --force');
   console.warn('');
   if (!args.includes('--force')) {
     process.exit(1);
@@ -47,7 +47,7 @@ if (fs.existsSync(TARGET_DIR)) {
   console.log('🗑  Removed existing .agent/');
 }
 
-console.log('🚀 Initialising antigravity-superpowers…');
+console.log('🚀 Initialising agy-superpowers…');
 copyDir(TEMPLATE_DIR, TARGET_DIR);
 console.log('✅ .agent/ created successfully!\n');
 console.log('📖 Next steps:');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-superpowers",
-  "version": "5.0.5",
+  "version": "5.0.7",
   "description": "Superpowers skills library for Google Antigravity agent — scaffold .agent/ with one command",
   "type": "module",
   "bin": {

package/template/agent/config.yml

@@ -0,0 +1,9 @@
+# Antigravity Superpowers — Project Config
+#
+# Configure per-project behavior by editing this file.
+# Skills read this file to determine how to behave in this project.
+
+# auto_commit: true | false
+# When true (default), AI automatically commits after completing tasks and writing design docs.
+# When false, all git commits and staging are skipped; files are left as modified for manual commit.
+auto_commit: false

package/template/agent/patches/skills-patches.md

@@ -0,0 +1,74 @@
+# Skill Patches
+
+Patches applied by AI during the `update-superpowers` workflow (Phase 2, Step 7).
+Each patch describes the *intent* of the change — AI finds the relevant section and rewrites it.
+Do not match text literally. Understand intent and adapt to current upstream wording.
+
+---
+
+## Patch: Platform Adaptation — using-superpowers
+
+**File:** `using-superpowers/SKILL.md`
+**Intent:** Remove all references to Claude Code, Gemini CLI, and Codex. Replace with a single
+Antigravity block: skills are read using `view_file` on `.agent/skills/<name>/SKILL.md`.
+Reference `references/antigravity-tools.md` for tool name mappings.
+The Platform Adaptation section should say this package is configured for Google Antigravity,
+with tool name equivalents in `references/antigravity-tools.md`.
+
+---
+
+## Patch: Platform mentions — executing-plans
+
+**File:** `executing-plans/SKILL.md`
+**Intent:** Replace any mentions of "Claude Code", "Codex", or other non-Antigravity platforms
+with "Antigravity". Example: "(such as Claude Code or Codex)" → "(such as Antigravity)".
+
+---
+
+## Patch: Skills path — writing-skills
+
+**File:** `writing-skills/SKILL.md`
+**Intent:** Replace platform-specific personal skill paths (`~/.claude/skills` for Claude Code,
+`~/.agents/skills/` for Codex) with the Antigravity path: `~/.agent/skills`.
+
+---
+
+## Patch: Visual companion platform blocks — brainstorming
+
+**File:** `brainstorming/visual-companion.md`
+**Intent:** Remove the Codex-specific server block. Replace Claude Code and Gemini CLI
+server startup blocks with a single Antigravity block:
+```bash
+# Launch the server normally
+scripts/start-server.sh --project-dir /path/to/project
+```
+
+---
+
+## Patch: Platform comment — dispatching-parallel-agents
+
+**File:** `dispatching-parallel-agents/SKILL.md`
+**Intent:** Remove the comment `// In Claude Code / AI environment` (or similar platform-specific
+inline comments). The code should work without platform-specific annotations.
+
+---
+
+## Patch: auto_commit flag — brainstorming
+
+**File:** `brainstorming/SKILL.md`
+**Intent:** Make the step that commits the design document to git conditional on `.agent/config.yml`:
+- Read `.agent/config.yml` before committing
+- If `auto_commit: true` (default): commit normally with `git add <path> && git commit -m "docs: add <topic> design spec"`
+- If `auto_commit: false`: skip commit and staging entirely. Print: "Skipping commit (auto_commit: false in .agent/config.yml). File is ready for manual commit."
+
+---
+
+## Patch: auto_commit flag — subagent-driven-development
+
+**File:** `subagent-driven-development/SKILL.md`
+**Intent:** Make the implementer subagent commit step conditional on `.agent/config.yml`:
+- Read `.agent/config.yml` before committing
+- If `auto_commit: true` (default): commit normally with `git add` + `git commit`
+- If `auto_commit: false`: skip commit and staging entirely. Print: "Skipping commit (auto_commit: false in .agent/config.yml). Files left as modified for manual commit."
+Update any diagram labels that mention "commits" to reflect this conditionality
+(e.g. "commits (if auto_commit: true)").

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

@@ -114,7 +114,9 @@ digraph brainstorming {
 - Write the validated design (spec) to `docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md`
   - (User preferences for spec location override this default)
 - Use elements-of-style:writing-clearly-and-concisely skill if available
-- Commit the design document to git
+- **Commit the design document to git** — but first check `.agent/config.yml`:
+    - If `auto_commit: true` (default): run `git add <path> && git commit -m "docs: add <topic> design spec"`
+    - If `auto_commit: false`: skip commit and staging entirely. Print: "Skipping commit (auto_commit: false in .agent/config.yml). File is ready for manual commit."
 
 **Spec Review Loop:**
 After writing the spec document:

package/template/agent/skills/brainstorming/visual-companion.md

@@ -48,35 +48,12 @@ Save `screen_dir` from the response. Tell user to open the URL.
 
 **Launching the server by platform:**
 
-**Claude Code (macOS / Linux):**
+**Antigravity:**
 ```bash
-# Default mode works — the script backgrounds the server itself
+# Launch the server normally
 scripts/start-server.sh --project-dir /path/to/project
 ```
 
-**Claude Code (Windows):**
-```bash
-# Windows auto-detects and uses foreground mode, which blocks the tool call.
-# Use run_in_background: true on the Bash tool call so the server survives
-# across conversation turns.
-scripts/start-server.sh --project-dir /path/to/project
-```
-When calling this via the Bash tool, set `run_in_background: true`. Then read `$SCREEN_DIR/.server-info` on the next turn to get the URL and port.
-
-**Codex:**
-```bash
-# Codex reaps background processes. The script auto-detects CODEX_CI and
-# switches to foreground mode. Run it normally — no extra flags needed.
-scripts/start-server.sh --project-dir /path/to/project
-```
-
-**Gemini CLI:**
-```bash
-# Use --foreground and set is_background: true on your shell tool call
-# so the process survives across turns
-scripts/start-server.sh --project-dir /path/to/project --foreground
-```
-
 **Other environments:** The server must keep running in the background across conversation turns. If your environment reaps detached processes, use `--foreground` and launch the command with your platform's background execution mechanism.
 
 If the URL is unreachable from your browser (common in remote/containerized setups), bind a non-loopback host:

package/template/agent/skills/dispatching-parallel-agents/SKILL.md

@@ -66,7 +66,6 @@ Each agent gets:
 ### 3. Dispatch in Parallel
 
 ```typescript
-// In Claude Code / AI environment
 Task("Fix agent-tool-abort.test.ts failures")
 Task("Fix batch-completion-behavior.test.ts failures")
 Task("Fix tool-approval-race-conditions.test.ts failures")

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

@@ -11,7 +11,7 @@ Load plan, review critically, execute all tasks, report when complete.
 
 **Announce at start:** "I'm using the executing-plans skill to implement this plan."
 
-**Note:** Tell your human partner that Superpowers works much better with access to subagents. The quality of its work will be significantly higher if run on a platform with subagent support (such as Claude Code or Codex). If subagents are available, use superpowers:subagent-driven-development instead of this skill.
+**Note:** Tell your human partner that Superpowers works much better with access to subagents. The quality of its work will be significantly higher if run on a platform with subagent support (such as Antigravity). If subagents are available, use superpowers:subagent-driven-development instead of this skill.
 
 ## The Process
 

package/template/agent/skills/subagent-driven-development/SKILL.md

@@ -48,7 +48,7 @@ digraph process {
         "Dispatch implementer subagent (./implementer-prompt.md)" [shape=box];
         "Implementer subagent asks questions?" [shape=diamond];
         "Answer questions, provide context" [shape=box];
-        "Implementer subagent implements, tests, commits, self-reviews" [shape=box];
+        "Implementer subagent implements, tests, commits (if auto_commit: true), self-reviews" [shape=box];
         "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)" [shape=box];
         "Spec reviewer subagent confirms code matches spec?" [shape=diamond];
         "Implementer subagent fixes spec gaps" [shape=box];
@@ -67,8 +67,8 @@ digraph process {
     "Dispatch implementer subagent (./implementer-prompt.md)" -> "Implementer subagent asks questions?";
     "Implementer subagent asks questions?" -> "Answer questions, provide context" [label="yes"];
     "Answer questions, provide context" -> "Dispatch implementer subagent (./implementer-prompt.md)";
-    "Implementer subagent asks questions?" -> "Implementer subagent implements, tests, commits, self-reviews" [label="no"];
-    "Implementer subagent implements, tests, commits, self-reviews" -> "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)";
+    "Implementer subagent asks questions?" -> "Implementer subagent implements, tests, commits (if auto_commit: true), self-reviews" [label="no"];
+    "Implementer subagent implements, tests, commits (if auto_commit: true), self-reviews" -> "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)";
     "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)" -> "Spec reviewer subagent confirms code matches spec?";
     "Spec reviewer subagent confirms code matches spec?" -> "Implementer subagent fixes spec gaps" [label="no"];
     "Implementer subagent fixes spec gaps" -> "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)" [label="re-review"];
@@ -247,6 +247,10 @@ Done!
 - **Start code quality review before spec compliance is ✅** (wrong order)
 - Move to next task while either review has open issues
 
+**Before implementer commits:** Check `.agent/config.yml` for `auto_commit` setting.
+- If `auto_commit: true` (default): commit normally with `git add` + `git commit`
+- If `auto_commit: false`: skip commit and staging entirely. Print: "Skipping commit (auto_commit: false in .agent/config.yml). Files left as modified for manual commit."
+
 **If subagent asks questions:**
 - Answer clearly and completely
 - Provide additional context if needed

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

@@ -19,23 +19,21 @@ This is not negotiable. This is not optional. You cannot rationalize your way ou
 
 Superpowers skills override default system prompt behavior, but **user instructions always take precedence**:
 
-1. **User's explicit instructions** (CLAUDE.md, GEMINI.md, AGENTS.md, direct requests) — highest priority
+1. **User's explicit instructions** (GEMINI.md, AGENTS.md, direct requests) — highest priority
 2. **Superpowers skills** — override default system behavior where they conflict
 3. **Default system prompt** — lowest priority
 
-If CLAUDE.md, GEMINI.md, or AGENTS.md says "don't use TDD" and a skill says "always use TDD," follow the user's instructions. The user is in control.
+If GEMINI.md or AGENTS.md says "don't use TDD" and a skill says "always use TDD," follow the user's instructions. The user is in control.
 
 ## How to Access Skills
 
-**In Claude Code:** Use the `Skill` tool. When you invoke a skill, its content is loaded and presented to you—follow it directly. Never use the Read tool on skill files.
-
-**In Gemini CLI:** Skills activate via the `activate_skill` tool. Gemini loads skill metadata at session start and activates the full content on demand.
-
-**In other environments:** Check your platform's documentation for how skills are loaded.
+**In Antigravity:** Use `view_file` on `.agent/skills/<skill-name>/SKILL.md` to read a skill. Skills are detected automatically from their `description` field.
 
 ## Platform Adaptation
 
-Skills use Claude Code tool names. Non-CC platforms: see `references/codex-tools.md` (Codex) for tool equivalents. Gemini CLI users get the tool mapping loaded automatically via GEMINI.md.
+This package is configured for **Google Antigravity**. Tool name mappings are handled automatically via `GEMINI.md` in your workspace.
+
+For tool name equivalents, see `references/antigravity-tools.md`.
 
 # Using Skills
 

package/template/agent/skills/using-superpowers/references/antigravity-tools.md

@@ -0,0 +1,43 @@
+# Antigravity Tool Mapping
+
+Some skills reference tool names from other platforms. Use the Antigravity equivalents below:
+
+| Skill references | Antigravity equivalent |
+|---|---|
+| `Read` (file reading) | `view_file` |
+| `Write` (file creation) | `write_to_file` |
+| `Edit` (file editing, single block) | `replace_file_content` |
+| `Edit` (file editing, multiple blocks) | `multi_replace_file_content` |
+| `Bash` (run commands) | `run_command` |
+| `Grep` (search file content) | `grep_search` |
+| `Glob` / `LS` (search files by name/pattern) | `find_by_name` |
+| `LS` (list directory) | `list_dir` |
+| `WebSearch` | `search_web` |
+| `WebFetch` | `read_url_content` |
+| `Skill` tool (invoke a skill) | `view_file` on `.agent/skills/<name>/SKILL.md` |
+| `TodoWrite` (task tracking) | ❌ No direct equivalent — track progress in responses |
+| `Task` tool (dispatch subagent) | `browser_subagent` (browser only, not general-purpose) |
+
+## Subagent support
+
+Antigravity does not support general-purpose subagent dispatch (`Task` tool). Skills that rely on `subagent-driven-development` or `dispatching-parallel-agents` should fall back to single-session execution via `executing-plans`.
+
+## Background commands
+
+Antigravity supports long-running background commands:
+
+| Tool | Purpose |
+|---|---|
+| `run_command` with `WaitMsBeforeAsync` | Start a command, optionally wait for output |
+| `command_status` | Poll status and output of a background command |
+| `send_command_input` | Send stdin to a running command |
+
+## Additional Antigravity tools
+
+These tools are available in Antigravity with no equivalent in other platforms:
+
+| Tool | Purpose |
+|---|---|
+| `generate_image` | Generate or edit images via AI |
+| `browser_subagent` | Automate browser interactions |
+| `list_resources` / `read_resource` | MCP resource access |

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

@@ -9,7 +9,7 @@ description: Use when creating new skills, editing existing skills, or verifying
 
 **Writing skills IS Test-Driven Development applied to process documentation.**
 
-**Personal skills live in agent-specific directories (`~/.claude/skills` for Claude Code, `~/.agents/skills/` for Codex)** 
+**Personal skills live in agent-specific directories (`~/.agent/skills` for Antigravity)** 
 
 You write test cases (pressure scenarios with subagents), watch them fail (baseline behavior), write the skill (documentation), watch tests pass (agents comply), and refactor (close loopholes).
 

package/template/agent/workflows/publish.md

@@ -0,0 +1,45 @@
+---
+description: Publish agy-superpowers to npm with version bump, git tag, and push
+---
+
+Publish `agy-superpowers` to npm.
+
+**Current version:** check `package.json` → `"version"`
+**npm page:** https://www.npmjs.com/package/agy-superpowers
+
+---
+
+## Usage
+
+// turbo
+1. Run the publish script with the desired version bump:
+
+```bash
+# patch bump: 5.0.5 → 5.0.6 (default, use after minor fixes)
+./scripts/publish.sh
+
+# minor bump: 5.0.5 → 5.1.0 (new features)
+./scripts/publish.sh minor
+
+# exact version: match upstream superpowers tag (use after /update-superpowers)
+./scripts/publish.sh 5.1.0
+```
+
+2. Script will automatically:
+   - Bump `package.json` version
+   - Run `npm run build` (via `prepublishOnly`)
+   - Publish to npm registry
+   - `git commit` + `git tag` + `git push`
+
+---
+
+## After running `/update-superpowers`
+
+When superpowers upstream releases a new version, sync and publish:
+
+1. Run `/update-superpowers` (updates `superpowers/` and `.agent/`)
+2. Check new version: `cat .agent/superpowers-version.json`
+3. Publish with matching version:
+   ```bash
+   ./scripts/publish.sh 5.1.0   # replace with actual new version
+   ```

package/template/agent/workflows/update-superpowers.md

@@ -7,14 +7,26 @@ This workflow has two phases:
 - **Phase 2 (AI):** update the skill list in rules only — no content rewriting
 
 // turbo
-1. Run the update script:
+1. Preserve user config (if exists):
+   `[ -f .agent/config.yml ] && cp .agent/config.yml /tmp/agent-config-backup.yml && echo "Config backed up" || echo "No config to backup"`
+
+// turbo
+2. Run the update script:
    `bash .agent/.shared/update-superpowers.sh`
 
-   - If output ends with "Already up to date" → **STOP**. Nothing to do.
-   - If clone fails → **STOP**. Report the error to the user.
+   - If output ends with "Already up to date" → restore config if backed up (`[ -f /tmp/agent-config-backup.yml ] && cp /tmp/agent-config-backup.yml .agent/config.yml`), then **STOP**. Nothing to do.
+   - If clone fails → restore config if backed up, then **STOP**. Report the error to the user.
    - On success the script prints `SCRIPT_DONE:<new-tag>` — note the new tag and continue.
 
-2. **Phase 2 — Update skill list in rules**
+// turbo
+3. Run the Antigravity patch script (breaks symlinks → real files, removes non-Antigravity tool refs):
+   `node scripts/patch-agent-skills.js`
+
+// turbo
+4. Restore user config:
+   `[ -f /tmp/agent-config-backup.yml ] && cp /tmp/agent-config-backup.yml .agent/config.yml && echo "Config restored" || echo "No config to restore"`
+
+5. **Phase 2 — Update skill list in rules**
 
    List all skill folders now present in `.agent/skills/`.
    Open `.agent/rules/superpowers.md` and update **only the skills table**:
@@ -24,19 +36,30 @@ This workflow has two phases:
 
    If no skills were added or removed → skip, note "rules: no changes needed".
 
-3. **Phase 2 — New skills check**
+6. **Phase 2 — New skills check**
 
    For any skill in `.agent/skills/` that has no corresponding workflow in `.agent/workflows/`:
    - Read its `SKILL.md` `description` field.
    - Report it to the user: "New skill available: `<name>` — `<description>`. Create a workflow?"
    - Do NOT auto-create. Let the user decide.
 
+7. **Phase 2 — Apply skill patches from `.agent/patches/skills-patches.md`**
+
+   Read `.agent/patches/skills-patches.md`. For each patch entry:
+   - Open the target SKILL.md (path relative to `.agent/skills/`)
+   - Understand the *intent* described — do not match text literally
+   - Find the relevant section in the current file content
+   - Rewrite that section to match the intent, adapting to any upstream wording changes
+   - If the patch is already applied → skip, note "already applied"
+
+   Apply all patches before moving to the next step.
+
 // turbo
-4. Commit all changes from Phase 2:
+8. Commit all changes from Phase 2:
    `git add .agent/ && git commit -m "chore: sync .agent/ with superpowers <new-tag>"`
    (Skip commit if nothing changed.)
 
-5. Print summary:
+8. Print summary:
    ```
    ✅ Superpowers updated: <old-tag> → <new-tag>
    📦 Skills: <old-count> → <new-count>  (+new_skill / -removed_skill)

package/template/agent/skills/systematic-debugging/CREATION-LOG.md

@@ -1,119 +0,0 @@
-# Creation Log: Systematic Debugging Skill
-
-Reference example of extracting, structuring, and bulletproofing a critical skill.
-
-## Source Material
-
-Extracted debugging framework from `/Users/jesse/.claude/CLAUDE.md`:
-- 4-phase systematic process (Investigation → Pattern Analysis → Hypothesis → Implementation)
-- Core mandate: ALWAYS find root cause, NEVER fix symptoms
-- Rules designed to resist time pressure and rationalization
-
-## Extraction Decisions
-
-**What to include:**
-- Complete 4-phase framework with all rules
-- Anti-shortcuts ("NEVER fix symptom", "STOP and re-analyze")
-- Pressure-resistant language ("even if faster", "even if I seem in a hurry")
-- Concrete steps for each phase
-
-**What to leave out:**
-- Project-specific context
-- Repetitive variations of same rule
-- Narrative explanations (condensed to principles)
-
-## Structure Following skill-creation/SKILL.md
-
-1. **Rich when_to_use** - Included symptoms and anti-patterns
-2. **Type: technique** - Concrete process with steps
-3. **Keywords** - "root cause", "symptom", "workaround", "debugging", "investigation"
-4. **Flowchart** - Decision point for "fix failed" → re-analyze vs add more fixes
-5. **Phase-by-phase breakdown** - Scannable checklist format
-6. **Anti-patterns section** - What NOT to do (critical for this skill)
-
-## Bulletproofing Elements
-
-Framework designed to resist rationalization under pressure:
-
-### Language Choices
-- "ALWAYS" / "NEVER" (not "should" / "try to")
-- "even if faster" / "even if I seem in a hurry"
-- "STOP and re-analyze" (explicit pause)
-- "Don't skip past" (catches the actual behavior)
-
-### Structural Defenses
-- **Phase 1 required** - Can't skip to implementation
-- **Single hypothesis rule** - Forces thinking, prevents shotgun fixes
-- **Explicit failure mode** - "IF your first fix doesn't work" with mandatory action
-- **Anti-patterns section** - Shows exactly what shortcuts look like
-
-### Redundancy
-- Root cause mandate in overview + when_to_use + Phase 1 + implementation rules
-- "NEVER fix symptom" appears 4 times in different contexts
-- Each phase has explicit "don't skip" guidance
-
-## Testing Approach
-
-Created 4 validation tests following skills/meta/testing-skills-with-subagents:
-
-### Test 1: Academic Context (No Pressure)
-- Simple bug, no time pressure
-- **Result:** Perfect compliance, complete investigation
-
-### Test 2: Time Pressure + Obvious Quick Fix
-- User "in a hurry", symptom fix looks easy
-- **Result:** Resisted shortcut, followed full process, found real root cause
-
-### Test 3: Complex System + Uncertainty
-- Multi-layer failure, unclear if can find root cause
-- **Result:** Systematic investigation, traced through all layers, found source
-
-### Test 4: Failed First Fix
-- Hypothesis doesn't work, temptation to add more fixes
-- **Result:** Stopped, re-analyzed, formed new hypothesis (no shotgun)
-
-**All tests passed.** No rationalizations found.
-
-## Iterations
-
-### Initial Version
-- Complete 4-phase framework
-- Anti-patterns section
-- Flowchart for "fix failed" decision
-
-### Enhancement 1: TDD Reference
-- Added link to skills/testing/test-driven-development
-- Note explaining TDD's "simplest code" ≠ debugging's "root cause"
-- Prevents confusion between methodologies
-
-## Final Outcome
-
-Bulletproof skill that:
-- ✅ Clearly mandates root cause investigation
-- ✅ Resists time pressure rationalization
-- ✅ Provides concrete steps for each phase
-- ✅ Shows anti-patterns explicitly
-- ✅ Tested under multiple pressure scenarios
-- ✅ Clarifies relationship to TDD
-- ✅ Ready for use
-
-## Key Insight
-
-**Most important bulletproofing:** Anti-patterns section showing exact shortcuts that feel justified in the moment. When Claude thinks "I'll just add this one quick fix", seeing that exact pattern listed as wrong creates cognitive friction.
-
-## Usage Example
-
-When encountering a bug:
-1. Load skill: skills/debugging/systematic-debugging
-2. Read overview (10 sec) - reminded of mandate
-3. Follow Phase 1 checklist - forced investigation
-4. If tempted to skip - see anti-pattern, stop
-5. Complete all phases - root cause found
-
-**Time investment:** 5-10 minutes
-**Time saved:** Hours of symptom-whack-a-mole
-
----
-
-*Created: 2025-10-03*
-*Purpose: Reference example for skill extraction and bulletproofing*

package/template/agent/skills/using-superpowers/references/codex-tools.md

@@ -1,25 +0,0 @@
-# Codex Tool Mapping
-
-Skills use Claude Code tool names. When you encounter these in a skill, use your platform equivalent:
-
-| Skill references | Codex equivalent |
-|-----------------|------------------|
-| `Task` tool (dispatch subagent) | `spawn_agent` |
-| Multiple `Task` calls (parallel) | Multiple `spawn_agent` calls |
-| Task returns result | `wait` |
-| Task completes automatically | `close_agent` to free slot |
-| `TodoWrite` (task tracking) | `update_plan` |
-| `Skill` tool (invoke a skill) | Skills load natively — just follow the instructions |
-| `Read`, `Write`, `Edit` (files) | Use your native file tools |
-| `Bash` (run commands) | Use your native shell tools |
-
-## Subagent dispatch requires multi-agent support
-
-Add to your Codex config (`~/.codex/config.toml`):
-
-```toml
-[features]
-multi_agent = true
-```
-
-This enables `spawn_agent`, `wait`, and `close_agent` for skills like `dispatching-parallel-agents` and `subagent-driven-development`.

package/template/agent/skills/using-superpowers/references/gemini-tools.md

@@ -1,33 +0,0 @@
-# Gemini CLI Tool Mapping
-
-Skills use Claude Code tool names. When you encounter these in a skill, use your platform equivalent:
-
-| Skill references | Gemini CLI equivalent |
-|-----------------|----------------------|
-| `Read` (file reading) | `read_file` |
-| `Write` (file creation) | `write_file` |
-| `Edit` (file editing) | `replace` |
-| `Bash` (run commands) | `run_shell_command` |
-| `Grep` (search file content) | `grep_search` |
-| `Glob` (search files by name) | `glob` |
-| `TodoWrite` (task tracking) | `write_todos` |
-| `Skill` tool (invoke a skill) | `activate_skill` |
-| `WebSearch` | `google_web_search` |
-| `WebFetch` | `web_fetch` |
-| `Task` tool (dispatch subagent) | No equivalent — Gemini CLI does not support subagents |
-
-## No subagent support
-
-Gemini CLI has no equivalent to Claude Code's `Task` tool. Skills that rely on subagent dispatch (`subagent-driven-development`, `dispatching-parallel-agents`) will fall back to single-session execution via `executing-plans`.
-
-## Additional Gemini CLI tools
-
-These tools are available in Gemini CLI but have no Claude Code equivalent:
-
-| Tool | Purpose |
-|------|---------|
-| `list_directory` | List files and subdirectories |
-| `save_memory` | Persist facts to GEMINI.md across sessions |
-| `ask_user` | Request structured input from the user |
-| `tracker_create_task` | Rich task management (create, update, list, visualize) |
-| `enter_plan_mode` / `exit_plan_mode` | Switch to read-only research mode before making changes |