agy-superpowers 5.0.5 → 5.0.6

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.6",
   "description": "Superpowers skills library for Google Antigravity agent — scaffold .agent/ with one command",
   "type": "module",
   "bin": {

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/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

@@ -14,7 +14,11 @@ This workflow has two phases:
    - If clone fails → **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
+2. Run the Antigravity patch script (breaks symlinks → real files, removes non-Antigravity tool refs):
+   `node scripts/patch-agent-skills.js`
+
+3. **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,7 +28,7 @@ This workflow has two phases:
 
    If no skills were added or removed → skip, note "rules: no changes needed".
 
-3. **Phase 2 — New skills check**
+4. **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.
@@ -32,11 +36,11 @@ This workflow has two phases:
    - Do NOT auto-create. Let the user decide.
 
 // turbo
-4. Commit all changes from Phase 2:
+5. 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:
+6. 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 |