agy-superpowers 5.2.1 → 5.2.2

package/package.json

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

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

@@ -116,3 +116,26 @@ Option 2: push, Option 4: branch delete), add an explicit `auto_commit` check:
   - If `true` (or absent): `git add .gitignore && git commit -m "chore: ignore worktree directory"`
 - Step 3 (proceed with worktree creation): always runs
 
+---
+
+## Patch: temp directory — all skills
+
+**Files:**
+- `brainstorming/scripts/server.cjs`
+- `brainstorming/scripts/start-server.sh`
+- `brainstorming/scripts/stop-server.sh`
+- `brainstorming/visual-companion.md`
+- `writing-skills/testing-skills-with-subagents.md`
+- `rust-developer/references/rust-rules/test-fixture-raii.md`
+- `rust-developer/references/rust-rules/opt-pgo-profile.md`
+
+**Intent:** Replace all `/tmp/` paths with `.agent/tmp/` equivalents. Temp data should stay
+within the project's `.agent/tmp/` directory instead of polluting the system `/tmp/`.
+
+Specific changes:
+- `server.cjs`: fallback `SESSION_DIR` should resolve to `.agent/tmp/brainstorm` via `path.resolve(__dirname, '..', '..', '..', 'tmp', 'brainstorm')`
+- `start-server.sh`: compute `AGENT_DIR` from `SCRIPT_DIR` (walk up 3 levels to `.agent/`), use `${AGENT_DIR}/tmp/brainstorm-${SESSION_ID}` as fallback
+- `stop-server.sh`: cleanup condition should match both `/tmp/*` and `*/.agent/tmp/*`
+- `visual-companion.md`: documentation references to `/tmp` → `.agent/tmp/`
+- `testing-skills-with-subagents.md`: example path `/tmp/payment-system` → `.agent/tmp/payment-system`
+- Rust reference docs: all `/tmp/` example paths → `.agent/tmp/` equivalents

package/template/agent/rules/superpowers.md

@@ -46,6 +46,9 @@ All skills are symlinked into `.agent/skills/` and are automatically available.
 | `saas-architect` | Multi-tenant SaaS architecture, tenant isolation |
 | `devops-engineer` | CI/CD, infrastructure, deployment, monitoring |
 | `security-engineer` | App security, auth, GDPR, security audits |
+| `frontend-design` | Web components, pages, artifacts — high design quality, avoids generic AI aesthetics |
+| `mobile-uiux-promax` | Mobile app UI for iOS, Android, React Native, Flutter, SwiftUI, Compose |
+| `rust-developer` | Rust code, ownership/borrow errors, async patterns, idiomatic Rust |
 
 ### Business & Growth
 

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

@@ -111,9 +111,10 @@ 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** — 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."
+- Commit the design document to git (if `auto_commit` is enabled):
+  - Read `.agent/config.yml` — check `auto_commit` setting
+  - If `auto_commit: true` (default when absent): `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 Self-Review:**
 After writing the spec document, look at it with fresh eyes:

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

@@ -47,15 +47,14 @@ Save `screen_dir` and `state_dir` from the response. Tell user to open the URL.
 
 **Note:** Pass the project root as `--project-dir` so mockups persist in `.superpowers/brainstorm/` and survive server restarts. Without it, files go to `.agent/tmp/` and get cleaned up on server stop. Remind the user to add `.superpowers/` to `.gitignore` if it's not already there.
 
-**Launching the server by platform:**
+**Launching the server:**
 
-**Antigravity:**
 ```bash
 # Launch the server normally
 scripts/start-server.sh --project-dir /path/to/project
 ```
 
-**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.
+The script backgrounds the server itself. 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/finishing-a-development-branch/SKILL.md

@@ -67,24 +67,22 @@ Which option?
 
 #### Option 1: Merge Locally
 
-**Before git write steps:** Check `.agent/config.yml` for `auto_commit`.
-- If `auto_commit: false`: skip all git write operations below, print "Skipping git operation (auto_commit: false)."
-- If `auto_commit: true` (or absent): proceed normally.
+Read `.agent/config.yml` — check `auto_commit` setting. If `auto_commit: false`: skip the merge, print "Skipping git operation (auto_commit: false)." and go to Step 5. If `auto_commit: true` (or absent): proceed.
 
 ```bash
 # Switch to base branch
 git checkout <base-branch>
 
-# Pull latest (blocked if auto_commit: false)
+# Pull latest
 git pull
 
-# Merge feature branch (blocked if auto_commit: false)
+# Merge feature branch
 git merge <feature-branch>
 
 # Verify tests on merged result
 <test command>
 
-# If tests pass (blocked if auto_commit: false)
+# If tests pass
 git branch -d <feature-branch>
 ```
 
@@ -92,15 +90,13 @@ Then: Cleanup worktree (Step 5)
 
 #### Option 2: Push and Create PR
 
-**Before git write steps:** Check `.agent/config.yml` for `auto_commit`.
-- If `auto_commit: false`: skip all git write operations below, print "Skipping git operation (auto_commit: false)."
-- If `auto_commit: true` (or absent): proceed normally.
+Read `.agent/config.yml` — check `auto_commit` setting. If `auto_commit: false`: skip the push, print "Skipping git operation (auto_commit: false)." If `auto_commit: true` (or absent): proceed.
 
 ```bash
-# Push branch (blocked if auto_commit: false)
+# Push branch
 git push -u origin <feature-branch>
 
-# Create PR (blocked if auto_commit: false)
+# Create PR
 gh pr create --title "<title>" --body "$(cat <<'EOF'
 ## Summary
 <2-3 bullets of what changed>
@@ -133,14 +129,13 @@ Type 'discard' to confirm.
 
 Wait for exact confirmation.
 
-**Before git write steps:** Check `.agent/config.yml` for `auto_commit`.
-- If `auto_commit: false`: skip all git write operations below, print "Skipping git operation (auto_commit: false)."
-- If `auto_commit: true` (or absent): proceed normally.
-
 If confirmed:
+
+Read `.agent/config.yml` — check `auto_commit` setting. If `auto_commit: false`: skip the branch delete, print "Skipping git operation (auto_commit: false)." If `auto_commit: true` (or absent): proceed.
+
 ```bash
 git checkout <base-branch>
-git branch -D <feature-branch>  # blocked if auto_commit: false
+git branch -D <feature-branch>
 ```
 
 Then: Cleanup worktree (Step 5)

package/template/agent/skills/rust-developer/references/rust-rules/opt-pgo-profile.md

@@ -16,7 +16,7 @@ PGO uses real runtime behavior to guide compiler optimization decisions. By prof
 
 ```bash
 # Step 1: Build instrumented binary
-RUSTFLAGS="-Cprofile-generate=/tmp/pgo-data" \
+RUSTFLAGS="-Cprofile-generate=.agent/tmp/pgo-data" \
     cargo build --release
 
 # Step 2: Run representative workloads
@@ -25,10 +25,10 @@ RUSTFLAGS="-Cprofile-generate=/tmp/pgo-data" \
 ./target/release/my_app < typical_workload.txt
 
 # Step 3: Merge profile data
-llvm-profdata merge -o /tmp/pgo-data/merged.profdata /tmp/pgo-data
+llvm-profdata merge -o .agent/tmp/pgo-data/merged.profdata .agent/tmp/pgo-data
 
 # Step 4: Build optimized binary using profile
-RUSTFLAGS="-Cprofile-use=/tmp/pgo-data/merged.profdata" \
+RUSTFLAGS="-Cprofile-use=.agent/tmp/pgo-data/merged.profdata" \
     cargo build --release
 ```
 
@@ -50,7 +50,7 @@ opt-level = 3
 #!/bin/bash
 set -e
 
-PGO_DIR=/tmp/pgo-$(date +%s)
+PGO_DIR=.agent/tmp/pgo-$(date +%s)
 
 # Clean
 cargo clean
@@ -133,16 +133,16 @@ jobs:
         run: sudo apt-get install llvm
       
       - name: Instrumented build
-        run: RUSTFLAGS="-Cprofile-generate=/tmp/pgo" cargo build --release
+        run: RUSTFLAGS="-Cprofile-generate=.agent/tmp/pgo" cargo build --release
       
       - name: Run profiling workloads
         run: ./scripts/run_profiling_workloads.sh
       
       - name: Merge profiles
-        run: llvm-profdata merge -o /tmp/pgo/merged.profdata /tmp/pgo
+        run: llvm-profdata merge -o .agent/tmp/pgo/merged.profdata .agent/tmp/pgo
       
       - name: Optimized build
-        run: RUSTFLAGS="-Cprofile-use=/tmp/pgo/merged.profdata" cargo build --release
+        run: RUSTFLAGS="-Cprofile-use=.agent/tmp/pgo/merged.profdata" cargo build --release
       
       - name: Upload artifact
         uses: actions/upload-artifact@v4

package/template/agent/skills/rust-developer/references/rust-rules/test-fixture-raii.md

@@ -11,7 +11,7 @@ Tests often need setup and teardown—creating temp files, starting servers, set
 ```rust
 #[test]
 fn test_with_temp_file() {
-    let path = "/tmp/test_file.txt";
+    let path = ".agent/tmp/test_file.txt";
     std::fs::write(path, "test data").unwrap();
     
     let result = process_file(path);
@@ -132,7 +132,7 @@ use scopeguard::defer;
 
 #[test]
 fn test_with_defer() {
-    let path = "/tmp/test_file.txt";
+    let path = ".agent/tmp/test_file.txt";
     std::fs::write(path, "data").unwrap();
     
     defer! {

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

@@ -32,6 +32,7 @@ digraph when_to_use {
 ```
 
 **vs. Executing Plans (parallel session):**
+
 - Same session (no context switch)
 - Fresh subagent per task (no context pollution)
 - Two-stage review after each task: spec compliance first, then code quality
@@ -95,6 +96,7 @@ Use the least powerful model that can handle each role to conserve cost and incr
 **Architecture, design, and review tasks**: use the most capable available model.
 
 **Task complexity signals:**
+
 - Touches 1-2 files with a complete spec → cheap model
 - Touches multiple files with integration concerns → standard model
 - Requires design judgment or broad codebase understanding → most capable model
@@ -110,6 +112,7 @@ Implementer subagents report one of four statuses. Handle each appropriately:
 **NEEDS_CONTEXT:** The implementer needs information that wasn't provided. Provide the missing context and re-dispatch.
 
 **BLOCKED:** The implementer cannot complete the task. Assess the blocker:
+
 1. If it's a context problem, provide more context and re-dispatch with the same model
 2. If the task requires more reasoning, re-dispatch with a more capable model
 3. If the task is too large, break it into smaller pieces
@@ -202,23 +205,27 @@ Done!
 ## Advantages
 
 **vs. Manual execution:**
+
 - Subagents follow TDD naturally
 - Fresh context per task (no confusion)
 - Parallel-safe (subagents don't interfere)
 - Subagent can ask questions (before AND during work)
 
 **vs. Executing Plans:**
+
 - Same session (no handoff)
 - Continuous progress (no waiting)
 - Review checkpoints automatic
 
 **Efficiency gains:**
+
 - No file reading overhead (controller provides full text)
 - Controller curates exactly what context is needed
 - Subagent gets complete information upfront
 - Questions surfaced before work begins (not after)
 
 **Quality gates:**
+
 - Self-review catches issues before handoff
 - Two-stage review: spec compliance, then code quality
 - Review loops ensure fixes actually work
@@ -226,6 +233,7 @@ Done!
 - Code quality ensures implementation is well-built
 
 **Cost:**
+
 - More subagent invocations (implementer + 2 reviewers per task)
 - Controller does more prep work (extracting all tasks upfront)
 - Review loops add iterations
@@ -234,6 +242,7 @@ Done!
 ## Red Flags
 
 **Never:**
+
 - Start implementation on main/master branch without explicit user consent
 - Skip reviews (spec compliance OR code quality)
 - Proceed with unfixed issues
@@ -248,35 +257,42 @@ Done!
 - 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
 - Don't rush them into implementation
 
 **If reviewer finds issues:**
+
 - Implementer (same subagent) fixes them
 - Reviewer reviews again
 - Repeat until approved
 - Don't skip the re-review
 
 **If subagent fails task:**
+
 - Dispatch fix subagent with specific instructions
 - Don't try to fix manually (context pollution)
 
 ## Integration
 
 **Required workflow skills:**
+
 - **superpowers:using-git-worktrees** - REQUIRED: Set up isolated workspace before starting
 - **superpowers:writing-plans** - Creates the plan this skill executes
 - **superpowers:requesting-code-review** - Code review template for reviewer subagents
 - **superpowers:finishing-a-development-branch** - Complete development after all tasks
 
 **Subagents should use:**
+
 - **superpowers:test-driven-development** - Subagents follow TDD for each task
 - **Domain skills matching the task context** - e.g. `mobile-developer` for React Native work, `backend-developer` for API work, `frontend-developer` for web UI. Include only the relevant SKILL.md in the implementer prompt context; load specific references on demand as the task requires them.
 
 **Alternative workflow:**
+
 - **superpowers:executing-plans** - Use for parallel session instead of same-session execution

package/template/agent/skills/subagent-driven-development/implementer-prompt.md

@@ -28,13 +28,14 @@ Task tool (general-purpose):
 
     ## Your Job
 
+    Once you're clear on requirements:
     1. Implement exactly what the task specifies
     2. Write tests (following TDD if task says to)
     3. Verify implementation works
     4. Commit your work (if auto_commit is enabled)
-       - Read `.agent/config.yml` to check the `auto_commit` setting
-       - If `auto_commit: true` (or not set): `git add` changed files + `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."
+       - Read `.agent/config.yml` — check `auto_commit` setting
+       - If `auto_commit: true` (or not set): `git add` + `git commit`
+       - If `auto_commit: false`: skip commit and staging entirely, print "Skipping commit (auto_commit: false)."
     5. Self-review (see below)
     6. Report back
 

package/template/agent/skills/using-git-worktrees/SKILL.md

@@ -63,9 +63,10 @@ git check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/d
 
 Per Jesse's rule "Fix broken things immediately":
 1. Add appropriate line to .gitignore
-2. Commit the change (if auto_commit enabled)
-   - Read `.agent/config.yml` — if `auto_commit: false`: skip commit, print "Skipping git operation (auto_commit: false)."
+2. Commit the change (if `auto_commit` is enabled):
+   - Read `.agent/config.yml` — check `auto_commit` setting
    - If `auto_commit: true` (or absent): `git add .gitignore && git commit -m "chore: ignore worktree directory"`
+   - If `auto_commit: false`: skip commit, print "Skipping git operation (auto_commit: false)."
 3. Proceed with worktree creation
 
 **Why critical:** Prevents accidentally committing worktree contents to repository.

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

@@ -19,21 +19,23 @@ 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** (GEMINI.md, AGENTS.md, direct requests) — highest priority
+1. **User's explicit instructions** (direct requests, project config) — highest priority
 2. **Superpowers skills** — override default system behavior where they conflict
 3. **Default system prompt** — lowest priority
 
-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.
+If the user 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 Antigravity:** Use `view_file` on `.agent/skills/<skill-name>/SKILL.md` to read a skill. Skills are detected automatically from their `description` field.
+Use `view_file` on the skill's `SKILL.md`:
+```
+.agent/skills/<skill-name>/SKILL.md
+```
+Example: `.agent/skills/brainstorming/SKILL.md`
 
 ## Platform Adaptation
 
-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`.
+This package is configured for **Google Antigravity**. Tool name equivalents are documented in `references/antigravity-tools.md`.
 
 # Using Skills
 

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

@@ -0,0 +1,52 @@
+# Copilot CLI Tool Mapping
+
+Skills use Claude Code tool names. When you encounter these in a skill, use your platform equivalent:
+
+| Skill references | Copilot CLI equivalent |
+|-----------------|----------------------|
+| `Read` (file reading) | `view` |
+| `Write` (file creation) | `create` |
+| `Edit` (file editing) | `edit` |
+| `Bash` (run commands) | `bash` |
+| `Grep` (search file content) | `grep` |
+| `Glob` (search files by name) | `glob` |
+| `Skill` tool (invoke a skill) | `skill` |
+| `WebFetch` | `web_fetch` |
+| `Task` tool (dispatch subagent) | `task` (see [Agent types](#agent-types)) |
+| Multiple `Task` calls (parallel) | Multiple `task` calls |
+| Task status/output | `read_agent`, `list_agents` |
+| `TodoWrite` (task tracking) | `sql` with built-in `todos` table |
+| `WebSearch` | No equivalent — use `web_fetch` with a search engine URL |
+| `EnterPlanMode` / `ExitPlanMode` | No equivalent — stay in the main session |
+
+## Agent types
+
+Copilot CLI's `task` tool accepts an `agent_type` parameter:
+
+| Claude Code agent | Copilot CLI equivalent |
+|-------------------|----------------------|
+| `general-purpose` | `"general-purpose"` |
+| `Explore` | `"explore"` |
+| Named plugin agents (e.g. `superpowers:code-reviewer`) | Discovered automatically from installed plugins |
+
+## Async shell sessions
+
+Copilot CLI supports persistent async shell sessions, which have no direct Claude Code equivalent:
+
+| Tool | Purpose |
+|------|---------|
+| `bash` with `async: true` | Start a long-running command in the background |
+| `write_bash` | Send input to a running async session |
+| `read_bash` | Read output from an async session |
+| `stop_bash` | Terminate an async session |
+| `list_bash` | List all active shell sessions |
+
+## Additional Copilot CLI tools
+
+| Tool | Purpose |
+|------|---------|
+| `store_memory` | Persist facts about the codebase for future sessions |
+| `report_intent` | Update the UI status line with current intent |
+| `sql` | Query the session's SQLite database (todos, metadata) |
+| `fetch_copilot_cli_documentation` | Look up Copilot CLI documentation |
+| GitHub MCP tools (`github-mcp-server-*`) | Native GitHub API access (issues, PRs, code search) |

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

@@ -97,13 +97,15 @@ Expected: PASS
 
 - [ ] **Step 5: Commit (if auto_commit enabled)**
 
-Check `.agent/config.yml` for `auto_commit` setting:
-- If `auto_commit: true` (default):
+Check `.agent/config.yml` for `auto_commit` setting.
+
+If `auto_commit: true` (default when absent):
 ```bash
 git add tests/path/test.py src/path/file.py
 git commit -m "feat: add specific feature"
 ```
-- If `auto_commit: false`: skip commit and staging. Print: "Skipping commit (auto_commit: false)."
+
+If `auto_commit: false`: skip commit and staging. Print: "Skipping commit (auto_commit: false)."
 ````
 
 ## No Placeholders

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 (`~/.agent/skills` for Antigravity)** 
+**Personal skills live in `~/.agent/skills`** 
 
 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/superpowers-version.json

@@ -1,5 +1,5 @@
 {
-  "tag": "v5.0.6",
-  "updated_at": "2026-03-28T11:32:19Z",
+  "tag": "v5.0.7",
+  "updated_at": "2026-04-02T12:29:10Z",
   "source": "https://github.com/obra/superpowers"
 }

package/template/agent/tmp/agent-config-backup.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