@drunkcoding/agents-and-skills 0.0.25 → 0.0.27

package/.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "name": "tech-graph",
       "source": "./plugins/tech-graph",
       "description": "6-step wizard for technical diagrams (SVG/PNG) via fireworks-tech-graph",
-      "version": "0.0.25",
+      "version": "0.0.27",
       "category": "diagram",
       "keywords": [
         "diagram",
@@ -26,7 +26,7 @@
       "name": "html-effectiveness",
       "source": "./plugins/html-effectiveness",
       "description": "Generate self-contained interactive HTML reports from 20 upstream templates via a conversational agent.",
-      "version": "0.0.25",
+      "version": "0.0.27",
       "category": "reports",
       "keywords": [
         "html",
@@ -37,30 +37,11 @@
         "decision-matrix"
       ]
     },
-    {
-      "name": "team-superpower",
-      "source": "./plugins/team-superpower",
-      "description": "Shape-adaptive engineering team that runs the Superpowers skill chain across up to 8 roles — designer, planner, software-architect, security-engineer, backend-developer, frontend-developer, qa-engineer, reviewer — driven by a `team-superpower` block in CLAUDE.md. Spawns 7 or 8 roles depending on stack (full-stack / be-only / fe-only), enforces contract sync between BE and FE, and gates the finish branch on CI green.",
-      "version": "0.0.25",
-      "category": "workflow",
-      "keywords": [
-        "agent-teams",
-        "superpowers",
-        "tdd",
-        "orchestration",
-        "workflow",
-        "brainstorming",
-        "code-review",
-        "architecture",
-        "security",
-        "qa"
-      ]
-    },
     {
       "name": "plugin-validator",
       "source": "./plugins/plugin-validator",
       "description": "Orchestrated validator for Claude Code plugins — validates skills, agents, commands, and hooks across every plugin under plugins/**.",
-      "version": "0.0.25",
+      "version": "0.0.27",
       "category": "tooling",
       "keywords": [
         "validation",
@@ -73,18 +54,18 @@
       ]
     },
     {
-      "name": "auto-power",
-      "source": "./plugins/auto-power",
-      "description": "Single-command hands-off pipeline wrapping obra/superpowers. Auto-answers safe clarifying questions during spec, then runs plan → arch+sec → impl → verify → review → ff-merge with no further touchpoints. Checkpointed and resumable; escalates only on substantive failures.",
-      "version": "0.0.25",
-      "category": "workflow",
+      "name": "team-share",
+      "source": "./plugins/team-share",
+      "description": "Share Claude plugin settings with a team, scaffold CLAUDE.md when needed, refresh the Understand-Anything graph, and stage the onboarding artifacts for review.",
+      "version": "0.0.27",
+      "category": "tooling",
       "keywords": [
-        "superpowers",
-        "automation",
-        "pipeline",
-        "tdd",
-        "auto-merge",
-        "checkpoint"
+        "onboarding",
+        "team",
+        "claude",
+        "settings",
+        "understand-anything",
+        "git-lfs"
       ]
     }
   ]

package/README.md

@@ -12,6 +12,7 @@ Published on npm as [`@drunkcoding/agents-and-skills`](https://www.npmjs.com/pac
 | [`html-effectiveness`](plugins/html-effectiveness) | Conversational agent that generates self-contained interactive HTML reports from 20 templates. |
 | [`team-superpower`](plugins/team-superpower) | Shape-adaptive engineering team running the Superpowers skill chain — up to 8 roles (designer, planner, software-architect, security-engineer, backend-developer, frontend-developer, qa-engineer, reviewer); spawns 7 or 8 depending on stack (`full-stack` / `be-only` / `fe-only`) declared in `CLAUDE.md`. Test/build commands, contract publish + sync, security checklist, and CI gate before merge are all driven by the project's `CLAUDE.md` `team-superpower` block. |
 | [`plugin-validator`](plugins/plugin-validator) | Orchestrated validator that checks every plugin's skills, agents, commands, and hooks for spec compliance — runs in parallel and proposes batched fixes. |
+| [`team-share`](plugins/team-share) | Onboarding helper that shares Claude plugin settings, scaffolds `CLAUDE.md` when missing, refreshes the Understand-Anything graph, and stages the resulting repo artifacts for review. |
 | [`auto-power`](plugins/auto-power) | Single-command hands-off pipeline that wraps `obra/superpowers`. Auto-answers safe clarifying questions during spec, then runs plan → arch+sec → impl → verify → review → ff-merge with no further touchpoints. Checkpointed and resumable. Escalates on substantive failures. |
 
 ## team-superpower v3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drunkcoding/agents-and-skills",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "description": "Personal collection of Claude Code skills and agents, installable via `npx skills`.",
   "keywords": [
     "claude-code",

package/plugins/html-effectiveness/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "html-effectiveness",
   "displayName": "HTML Effectiveness Reports",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "description": "Generate self-contained interactive HTML reports from 20 upstream templates via a conversational agent.",
   "author": {
     "name": "Steven Hoang"

package/plugins/plugin-validator/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "plugin-validator",
   "displayName": "Plugin Validator",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "description": "Orchestrated validator for Claude Code plugins — validates skills, agents, commands, and hooks across every plugin under plugins/**.",
   "author": {
     "name": "Steven Hoang"

package/plugins/team-share/.claude-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "team-share",
+  "displayName": "Team Share",
+  "version": "0.0.27",
+  "description": "Share Claude plugin settings with a team, scaffold CLAUDE.md when needed, refresh the Understand-Anything graph, and stage the onboarding artifacts for review.",
+  "author": {
+    "name": "Steven Hoang"
+  },
+  "keywords": [
+    "onboarding",
+    "team",
+    "claude",
+    "settings",
+    "understand-anything",
+    "git-lfs"
+  ]
+}

package/plugins/team-share/README.md

@@ -0,0 +1,30 @@
+# team-share
+
+Share repo-level Claude Code onboarding artifacts with your team in one pass.
+
+## What it does
+
+The `team-share` agent prepares a repository for teammates by:
+
+1. Writing a shareable `.claude/settings.json` from the maintainer's enabled plugins and marketplaces.
+2. Ensuring `CLAUDE.md` exists when the project does not already have one.
+3. Refreshing the Understand-Anything knowledge graph with auto-update enabled.
+4. Tracking the graph with `git-lfs` and staging the resulting onboarding files for human review.
+
+It is designed to be idempotent and intentionally stops short of committing or pushing.
+
+## Usage
+
+Run:
+
+```text
+/team-share [--force] [--language <lang>]
+```
+
+Arguments are passed through to `/understand` alongside the default `--auto-update` behavior.
+
+## Notes
+
+- The command expects `git-lfs` and `jq` to be installed.
+- It stages files for review but does not create commits.
+- The knowledge graph flow depends on the `understand-anything` plugin being available to teammates.

package/plugins/team-share/agents/team-share.md

@@ -0,0 +1,206 @@
+---
+name: team-share
+description: Share Claude plugin settings with the team, build or refresh the Understand-Anything knowledge graph with auto-update, and git-lfs track it before staging everything for review.
+argument-hint: "[--force] [--language <lang>] (passed through to /understand)"
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, Skill
+---
+
+# /team-share
+
+Make this repo onboarding-ready for the team in one pass:
+
+1. Generate a **shareable `.claude/settings.json`** (plugins + marketplaces) from the maintainer's live setup.
+2. Build/refresh the **Understand-Anything knowledge graph** with auto-update enabled.
+3. **git-lfs track** the graph and **stage** everything — leaving the commit to a human.
+
+This command is **idempotent** — safe to re-run. It **never commits or pushes**; it only stages.
+`$ARGUMENTS` (e.g. `--force`, `--language zh`) is forwarded to `/understand`.
+
+Plugin source: Understand-Anything (Egonex fork) — <https://github.com/Egonex-AI/Understand-Anything>
+
+---
+
+## Step 0 — Preconditions (stop on any failure, fail loud)
+
+```bash
+git rev-parse --is-inside-work-tree                 # must be a git repo
+git rev-parse --abbrev-ref HEAD                      # report branch; warn if it is the default/protected branch
+command -v git-lfs || echo "MISSING: git-lfs — install it (brew install git-lfs) before continuing"
+command -v jq      || echo "MISSING: jq — install it (brew install jq) before continuing"
+```
+
+- If not a git repo, or `git-lfs`/`jq` are missing → **report and STOP**. Do not partially apply.
+- If on a protected branch (e.g. `develop`/`main`), warn and ask the user to switch to a feature branch first.
+
+---
+
+## Step 1 — Generate the shareable `.claude/settings.json` **and ensure `CLAUDE.md` exists**
+
+Goal: teammates who clone the repo get the **same plugins + marketplaces** the maintainer uses, with **no machine-specific data leaked** — *and* a project-level `CLAUDE.md` is scaffolded if it is missing.
+
+### 1a — Merge plugin + marketplace settings
+
+Copy **only** `enabledPlugins` and `extraKnownMarketplaces` from the maintainer's user settings into the repo settings. Do **NOT** copy `hooks`, `permissions`, `env`, or any key holding absolute paths or local tooling (those are per-machine and may expose private paths).
+
+```bash
+USER_SETTINGS="$HOME/.claude/settings.json"
+REPO_SETTINGS=".claude/settings.json"
+
+mkdir -p .claude
+[ -f "$REPO_SETTINGS" ] || echo '{}' > "$REPO_SETTINGS"
+
+# Merge: repo settings win on scalar keys; the two plugin maps are unioned
+# (user entries layered on top of any existing repo entries). Only these two
+# keys are taken from user settings — nothing else crosses over.
+jq -s '
+  .[0] as $repo | .[1] as $user
+  | $repo
+  + { enabledPlugins:        (($repo.enabledPlugins        // {}) + ($user.enabledPlugins        // {})) }
+  + { extraKnownMarketplaces: (($repo.extraKnownMarketplaces // {}) + ($user.extraKnownMarketplaces // {})) }
+' "$REPO_SETTINGS" "$USER_SETTINGS" > "$REPO_SETTINGS.tmp" && mv "$REPO_SETTINGS.tmp" "$REPO_SETTINGS"
+
+jq '{enabledPlugins, extraKnownMarketplaces}' "$REPO_SETTINGS"   # show the result for review
+```
+
+Notes:
+- This shares **currently-enabled** plugins (the in-use set). It does not pull disabled-but-installed plugins.
+- Some marketplaces may be **private** (require repo/org access). Flag any private marketplace so the user can confirm teammates can reach it.
+- Confirm `understand-anything@understand-anything` is present in `enabledPlugins` (needed for Step 2's auto-update hook to work on teammates' machines). If absent, tell the user to install it:
+  `/plugin marketplace add Egonex-AI/Understand-Anything` then `/plugin install understand-anything`.
+
+### 1b — Scaffold `CLAUDE.md` if missing
+
+The `claude-code-setup` plugin (from the `claude-plugins-official` marketplace) generates a project-savvy `CLAUDE.md` when one does not yet exist. Running the install command is **idempotent** — if `CLAUDE.md` is already present it will **not** be overwritten.
+
+```bash
+# Only create CLAUDE.md when it does not already exist.
+if [ -f CLAUDE.md ]; then
+  echo "✅ CLAUDE.md already exists — skipping plugin install."
+else
+  echo "📝 CLAUDE.md not found — installing claude-code-setup plugin to scaffold it…"
+  claude plugin install claude-code-setup@claude-plugins-official
+  if [ -f CLAUDE.md ]; then
+    echo "✅ CLAUDE.md created by claude-code-setup."
+  else
+    echo "⚠️  claude-code-setup did not produce CLAUDE.md — you may need to run it manually or create the file yourself."
+  fi
+fi
+```
+
+Notes:
+- The plugin must already be available in the `claude-plugins-official` marketplace (it is already listed in `enabledPlugins` in the repo settings).
+- If the team prefers a custom `CLAUDE.md` template, commit one *before* running this command so the guard `[ -f CLAUDE.md ]` skips the plugin step.
+
+### 1c — Inject the Understand-Anything code-research section into `CLAUDE.md`
+
+Goal: every teammate's AI assistant knows to use the Understand-Anything commands when doing code research, without duplicating the section on re-runs.
+
+```bash
+# Only append when the section marker is not already present (idempotent).
+if grep -qF '## Code research with Understand-Anything' CLAUDE.md 2>/dev/null; then
+  echo "✅ Understand-Anything section already in CLAUDE.md — skipping."
+else
+  cat >> CLAUDE.md << 'EOF'
+
+## Code research with Understand-Anything
+
+This project uses the [Understand-Anything](https://github.com/Egonex-AI/Understand-Anything) plugin to maintain an interactive knowledge graph of the codebase. **Always prefer these commands over raw grep/glob when researching code structure, relationships, or logic:**
+
+| Goal | Command |
+|------|---------|
+| Explore the full codebase graph | `/understand` |
+| Ask a free-form question about the code | `/understand-chat <question>` |
+| Deep-dive into a specific file or function | `/understand-explain <path/symbol>` |
+| See impact of your current changes before committing | `/understand-diff` |
+| Open the interactive visual dashboard | `/understand-dashboard` |
+| Extract business-domain knowledge (domains, flows, steps) | `/understand-domain` |
+| Generate an onboarding guide for new teammates | `/understand-onboard` |
+
+The knowledge graph lives in `.understand-anything/knowledge-graph.json` and is kept up-to-date automatically on every commit (auto-update is enabled). Re-run `/understand` after large refactors to force a full rebuild, or pass `--force` to rebuild from scratch.
+EOF
+  echo "✅ Understand-Anything code-research section appended to CLAUDE.md."
+fi
+```
+
+Notes:
+- The section is appended at the end of `CLAUDE.md` so it does not disturb existing content.
+- The marker string `## Code research with Understand-Anything` is used as the idempotency guard — do not rename the heading without updating the guard.
+- If `MIRRORS.md` / `AGENTS.md` or other agent-config files exist alongside `CLAUDE.md` (e.g. for non-Claude runtimes), apply the same append to them so all agent runtimes get the guidance. The loop below covers `AGENTS.md` and `MIRRORS.md` — add more filenames to the `for` list if the project uses additional agent-config files.
+
+```bash
+# Mirror to AGENTS.md / MIRRORS.md if they exist (non-Claude runtimes).
+for f in AGENTS.md MIRRORS.md; do
+  if [ -f "$f" ] && ! grep -qF '## Code research with Understand-Anything' "$f" 2>/dev/null; then
+    cat >> "$f" << 'EOF'
+
+## Code research with Understand-Anything
+
+This project uses the [Understand-Anything](https://github.com/Egonex-AI/Understand-Anything) plugin to maintain an interactive knowledge graph of the codebase. **Always prefer these commands over raw grep/glob when researching code structure, relationships, or logic:**
+
+| Goal | Command |
+|------|---------|
+| Explore the full codebase graph | `/understand` |
+| Ask a free-form question about the code | `/understand-chat <question>` |
+| Deep-dive into a specific file or function | `/understand-explain <path/symbol>` |
+| See impact of your current changes before committing | `/understand-diff` |
+| Open the interactive visual dashboard | `/understand-dashboard` |
+| Extract business-domain knowledge (domains, flows, steps) | `/understand-domain` |
+| Generate an onboarding guide for new teammates | `/understand-onboard` |
+
+The knowledge graph lives in `.understand-anything/knowledge-graph.json` and is kept up-to-date automatically on every commit (auto-update is enabled). Re-run `/understand` after large refactors to force a full rebuild, or pass `--force` to rebuild from scratch.
+EOF
+    echo "✅ Understand-Anything section also appended to $f."
+  fi
+done
+```
+
+---
+
+## Step 2 — Build / refresh the knowledge graph (auto-update on)
+
+Run the skill **in the main thread** (it dispatches its own analyzer subagents — do not wrap it in a subagent):
+
+```
+/understand --auto-update $ARGUMENTS
+```
+
+- `--auto-update` writes `{"autoUpdate": true}` to `.understand-anything/config.json`. The plugin's bundled hook then incrementally patches the graph whenever a `git commit` is made (and on stale SessionStart), so each commit lands with a matching graph.
+- If a graph already exists, `/understand` runs incrementally. Pass `--force` (via `$ARGUMENTS`) to rebuild from scratch.
+- After it finishes, confirm these exist: `.understand-anything/knowledge-graph.json`, `.understand-anything/meta.json`, `.understand-anything/config.json` (with `autoUpdate: true`).
+
+---
+
+## Step 3 — Ignore scratch, git-lfs track the graph, and stage
+
+Scratch outputs must stay local (never committed):
+
+```bash
+# .gitignore — append only if missing (idempotent)
+for p in ".understand-anything/intermediate/" ".understand-anything/tmp/" ".understand-anything/diff-overlay.json"; do
+  grep -qxF "$p" .gitignore 2>/dev/null || echo "$p" >> .gitignore
+done
+
+# Large graphs (10 MB+) belong in LFS; tracking is harmless for small ones too.
+git lfs install
+git lfs track ".understand-anything/*.json"
+
+# Stage — but DO NOT commit. A human reviews and commits.
+git add .gitattributes .gitignore .claude/settings.json .understand-anything/ CLAUDE.md
+# Also stage AGENTS.md / MIRRORS.md if they were modified.
+for f in AGENTS.md MIRRORS.md; do [ -f "$f" ] && git add "$f"; done
+
+git status
+git lfs ls-files          # confirm the graph json is LFS-tracked
+```
+
+---
+
+## Done — report, do not commit
+
+Summarize for the user:
+- Which plugins/marketplaces were written into `.claude/settings.json` (call out any private ones).
+- `CLAUDE.md` status: already existed vs created by `claude-code-setup`; Understand-Anything section added vs already present.
+- `AGENTS.md` status (if applicable): Understand-Anything section added vs already present / not found.
+- Graph status: created vs incrementally updated; `autoUpdate` on/off.
+- What is staged and confirmed LFS-tracked.
+- Remind them: **review, then commit yourself** (e.g. `git commit -m "chore: share team onboarding (claude settings + CLAUDE.md + understand graph)"`). The auto-update hook keeps the graph fresh on every future commit.

package/plugins/team-share/commands/team-share.md

@@ -0,0 +1,4 @@
+---
+description: Launch team-share agent.
+agent: team-share
+---

package/plugins/tech-graph/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tech-graph",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "description": "Step-by-step wizard for generating technical diagrams as SVG+PNG.",
   "author": {
     "name": "steven"

package/plugins/auto-power/.claude-plugin/plugin.json

@@ -1,17 +0,0 @@
-{
-  "name": "auto-power",
-  "displayName": "Auto Power",
-  "version": "0.0.25",
-  "description": "Single-command, hands-off pipeline that wraps obra/superpowers: auto-answers safe clarifying questions during spec, then runs plan → arch+sec → impl → verify → review → ff-merge with no further touchpoints. Checkpointed and resumable; escalates only on substantive failures (security, architecture, repeated QA fail, semantic conflict).",
-  "author": {
-    "name": "Steven Hoang"
-  },
-  "keywords": [
-    "superpowers",
-    "automation",
-    "pipeline",
-    "tdd",
-    "auto-merge",
-    "checkpoint"
-  ]
-}

package/plugins/auto-power/README.md

@@ -1,80 +0,0 @@
-# auto-power
-
-Single-command, hands-off pipeline that wraps [`obra/superpowers`](https://github.com/obra/superpowers). Auto-answers safe clarifying questions during the spec phase, then runs plan → arch+sec → impl → verify → review → ff-merge with no further owner touchpoints. Checkpointed and resumable. Escalates only on substantive failures.
-
-## Install
-
-After installing this marketplace:
-
-```
-/plugin install auto-power@drunkcoding
-```
-
-## Commands
-
-| Command | Purpose |
-|---|---|
-| `/auto-power <idea>` | Start a fresh pipeline for `<idea>` |
-| `/auto-power-resume <slug>` | Resume an interrupted or blocked pipeline |
-
-## Lifecycle
-
-1. **Brainstorming** — `superpowers:brainstorming` runs. Clarifying questions that match a deterministic whitelist (test framework, lint command, naming convention, etc.) are auto-answered from repo signals. Unsafe or ambiguous questions surface to you.
-2. **Spec approval** — once the spec doc is written and self-reviewed, you are asked to approve. **This is the only owner touchpoint by design.**
-3. **Plan** — `superpowers:writing-plans` produces the implementation plan.
-4. **Arch+Sec self-review** — inline checklist; any ❌ escalates immediately.
-5. **Worktree** — if you ran `/auto-power` from inside an existing worktree, that worktree is reused (the pipeline does not remove it on finish). If you ran from the main repo, a new worktree is created at `../<repo>-<slug>/`.
-6. **Implementation** — `superpowers:subagent-driven-development` (preferred) or `executing-plans`. Mid-impl touchpoints ("continue?", "commit?", "run tests?") are auto-approved. Destructive git operations are never auto-approved — they escalate.
-7. **Verify** — `superpowers:verification-before-completion`.
-8. **Review** — `superpowers:requesting-code-review` self-review pass.
-9. **Finish** — CI gate (polled up to `--ci-wait`), then `git merge --ff-only` to `main`, push, branch delete. If we created the worktree, it is removed.
-
-## Artifacts
-
-The pipeline writes everything next to your existing superpowers artifacts:
-
-- `docs/superpowers/specs/<date>-<slug>-design.md` — spec
-- `docs/superpowers/specs/<date>-<slug>-plan.md` — plan
-- `docs/superpowers/specs/<slug>-auto-decisions.md` — append-only log of every auto-answer and auto-approve, with category and signal source
-- `docs/superpowers/specs/<slug>-checkpoint.json` — pipeline state
-- `docs/superpowers/specs/<slug>-ESCALATION.md` — only written when the pipeline halts on a substantive failure
-
-## Escalation handling
-
-If the runtime halts, it writes an escalation file with: phase, signal, retry history, last error logs, suggested fixes, and the exact resume command. Substantive failures (security ❌, architecture ❌, semantic merge conflict, repeated QA failure, persistent CI red, non-ff merge required, missing test suite, missing plan-referenced file) never auto-retry — you decide.
-
-After fixing the underlying issue:
-
-```
-/auto-power-resume <slug> --cleared
-```
-
-To abandon the work:
-
-```bash
-rm docs/superpowers/specs/<slug>-checkpoint.json
-git worktree remove <worktree-path>   # only if the pipeline created it
-git branch -D <branch>                # only after confirming no work to keep
-```
-
-## Flags reference
-
-| Flag | Default | Notes |
-|---|---|---|
-| `--branch=<name>` | `auto-power/<slug>` | Override branch name |
-| `--no-worktree` | off | In-place work on current branch |
-| `--worktree` | off | Force new worktree even if already in one |
-| `--max-retries=N` | 3 | Override transient-failure retry budget |
-| `--ci-wait=MIN` | 30 | Override CI polling timeout |
-
-## What it does NOT do (v1)
-
-- No multi-agent fan-out (single Claude session, serial). Use `team-superpower` if you want parallel teammates.
-- No PR mode — finish is always `git merge --ff-only` to `main`.
-- No cross-repo orchestration.
-- No web UI or TUI; status lives in stdout and the checkpoint file.
-
-## Relationship to other plugins
-
-- `obra/superpowers` — the skill chain `auto-power` drives. Not forked or duplicated.
-- `team-superpower` — sibling plugin for multi-agent parallel runs with explicit owner touchpoints. Pick this when you want oversight per phase, not hands-off automation.

package/plugins/auto-power/assets/CHECKPOINT_SCHEMA.md

@@ -1,69 +0,0 @@
-# Auto-Power Checkpoint Schema
-
-Location: `docs/superpowers/specs/<slug>-checkpoint.json` (next to the spec/plan files for the same `<slug>`).
-
-Format: plain JSON. Users may inspect or edit by hand.
-
-## Schema
-
-```json
-{
-  "slug": "add-foo-widget",
-  "started_at": "2026-05-14T08:30:00Z",
-  "updated_at": "2026-05-14T09:12:00Z",
-  "status": "running | blocked | done",
-  "phase": "spec | plan | arch_sec | worktree | impl | verify | review | finish",
-  "branch": "auto-power/add-foo-widget",
-  "worktree_path": "/abs/path/to/worktree-or-null",
-  "worktree_created_by_us": true,
-  "spec_path": "docs/superpowers/specs/2026-05-14-add-foo-widget-design.md",
-  "plan_path": "docs/superpowers/specs/2026-05-14-add-foo-widget-plan.md",
-  "auto_decisions_path": "docs/superpowers/specs/2026-05-14-add-foo-widget-auto-decisions.md",
-  "current_task_id": "task-3",
-  "tasks_done": ["task-1", "task-2"],
-  "retries": { "impl": 1, "verify": 0, "ci": 0 },
-  "last_error": null,
-  "finish_mode": "ff-merge",
-  "limits": { "max_retries": 3, "ci_wait_minutes": 30, "phase_stall_minutes": 30 }
-}
-```
-
-## Field reference
-
-| Field | Type | Required | Notes |
-|---|---|---|---|
-| `slug` | string | yes | Kebab-case identifier; appears in every artifact filename |
-| `started_at` | ISO-8601 UTC | yes | Set once at pipeline start; never overwritten |
-| `updated_at` | ISO-8601 UTC | yes | Bumped on every write |
-| `status` | enum | yes | `running` during pipeline, `blocked` after escalation, `done` after successful merge |
-| `phase` | enum | yes | One of: `spec`, `plan`, `arch_sec`, `worktree`, `impl`, `verify`, `review`, `finish` |
-| `branch` | string | yes | Git branch holding the work |
-| `worktree_path` | string \| null | yes | Absolute worktree path; `null` when running in main repo |
-| `worktree_created_by_us` | bool | yes | `true` only when the pipeline itself created the worktree. Drives cleanup behavior on finish |
-| `spec_path` | string | yes | Relative path to the approved design doc |
-| `plan_path` | string | yes | Set after plan phase completes |
-| `auto_decisions_path` | string | yes | Append-only log of auto-answers and auto-approves |
-| `current_task_id` | string \| null | yes | Plan task currently in flight; null outside `impl` phase |
-| `tasks_done` | string[] | yes | Completed plan task IDs |
-| `retries` | object | yes | Keys: any of `plan`, `arch_sec`, `impl`, `verify`, `review`, `finish`, `ci`. Counters reset on phase advance |
-| `last_error` | object \| null | yes | `{ phase, signal, message, at }` populated on retry or escalation |
-| `finish_mode` | enum | yes | Always `ff-merge` in v1 |
-| `limits` | object | yes | `max_retries` (default 3), `ci_wait_minutes` (default 30), `phase_stall_minutes` (default 30) |
-
-## Write triggers
-
-The runtime writes the checkpoint:
-
-1. At pipeline start (initial creation).
-2. Before every phase transition.
-3. After every retry counter increment.
-4. After every task completion (`tasks_done` append + `current_task_id` advance).
-5. Before any escalation file write.
-6. On successful merge (`status: done`).
-
-## Hard rules
-
-- Never overwrite the checkpoint without bumping `updated_at`.
-- Never resume into a branch different from the one recorded.
-- Never advance `phase` without first writing the checkpoint.
-- Never remove a worktree where `worktree_created_by_us: false`.

package/plugins/auto-power/assets/ESCALATION_TEMPLATE.md

@@ -1,67 +0,0 @@
-# Auto-Power Escalation Template
-
-The runtime writes one of these files to `docs/superpowers/specs/<slug>-ESCALATION.md` whenever a substantive failure halts the pipeline. Use the structure below verbatim — replace bracketed placeholders.
-
-```markdown
-# Escalation: <slug>
-
-**Halted at:** <ISO-8601 UTC>
-**Phase:** <plan | arch_sec | worktree | impl | verify | review | finish>
-**Signal:** <SEC_BLOCKED | ARCH_BLOCKED | QA_FAIL_EXHAUSTED | SEMANTIC_CONFLICT | CI_RED_PERSISTENT | FINISH_BLOCKED | TEST_SUITE_MISSING | PLAN_FILE_MISSING | OTHER:<short>>
-**Branch:** <branch>
-**Worktree:** <path or "in-repo">
-**Checkpoint:** docs/superpowers/specs/<slug>-checkpoint.json
-
-## What failed
-
-<One paragraph: the immediate symptom and the gate that caught it.>
-
-## Retry history
-
-| # | Attempt | Outcome |
-|---|---|---|
-| 1 | <action taken> | <result> |
-| 2 | <action taken> | <result> |
-| 3 | <action taken> | <result> |
-
-## Last error logs
-
-```
-<verbatim last error block; truncate at 2 KB if longer>
-```
-
-## Suggested fixes
-
-- <fix 1: concrete, file-level>
-- <fix 2>
-- <fix 3>
-
-## Resume command
-
-After applying a fix:
-
-```bash
-/auto-power-resume <slug> --cleared
-```
-
-If you decide to abandon the work:
-
-```bash
-# Delete the checkpoint and (if we created it) the worktree:
-rm docs/superpowers/specs/<slug>-checkpoint.json
-git worktree remove <worktree-path>   # only if worktree_created_by_us=true
-git branch -D <branch>                # only after confirming no work to keep
-```
-
-## Signal reference
-
-| Signal | Origin | Auto-retry? |
-|---|---|---|
-| `SEC_BLOCKED` | security self-review ❌ | No — escalate immediately |
-| `ARCH_BLOCKED` | architecture self-review ❌ | No — escalate immediately |
-| `QA_FAIL_EXHAUSTED` | `verification-before-completion` red after `max_retries` | No — escalate after retries used |
-| `SEMANTIC_CONFLICT` | merge conflict touching overlapping logic | No |
-| `CI_RED_PERSISTENT` | same CI failure signature after `max_retries` | No |
-| `FINISH_BLOCKED` | non-ff, push rejected, dirty worktree | No |
-| `TEST_SUITE_MISSING` | no test runner detected, can't verify | No |
-| `PLAN_FILE_MISSING` | plan task references a non-existent file | No |

package/plugins/auto-power/commands/auto-power-resume.md

@@ -1,32 +0,0 @@
----
-description: Resume an auto-power pipeline from its checkpoint. Re-enters the recorded phase with retry counters preserved. Use --cleared after fixing the issue described in an ESCALATION.md file.
----
-
-# /auto-power-resume
-
-**Usage:** `/auto-power-resume <slug-or-checkpoint-path> [--cleared]`
-
-**Arguments:**
-
-| Flag | Default | Effect |
-|---|---|---|
-| `<slug-or-checkpoint-path>` (required, positional) | — | Either the slug (resolves to `docs/superpowers/specs/<slug>-checkpoint.json`) or an explicit path |
-| `--cleared` | off | Required when the checkpoint `status` is `blocked`. Asserts you have fixed the issue described in the ESCALATION file. Clears `last_error` and resumes from the recorded phase |
-
-## Procedure
-
-1. Resolve the checkpoint path from the positional argument.
-2. Invoke the `auto-power-runtime` skill with intent `resume`. The skill executes §8 of its own rules:
-   - Verify branch and (if recorded) worktree path exist.
-   - Reject if HEAD has uncommitted churn the pipeline did not write.
-   - `status: done` ⇒ no-op, print summary, exit.
-   - `status: blocked` without `--cleared` ⇒ re-print escalation summary, exit.
-   - `status: blocked` with `--cleared` ⇒ clear `last_error`, set `status: running`, re-enter the recorded `phase`.
-   - `status: running` ⇒ re-enter the recorded `phase`.
-3. Continue the pipeline from that phase until the next escalation or successful finish.
-
-## Hard guarantees
-
-- The resume never changes the recorded `branch`.
-- Retry counters survive resume — if `retries.impl` is `2` on a 3-retry budget, only one retry remains.
-- The auto-decisions log is appended to, never rewritten.