@drunkcoding/agents-and-skills 0.0.18 → 0.0.23

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.18",
+      "version": "0.0.23",
       "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.18",
+      "version": "0.0.23",
       "category": "reports",
       "keywords": [
         "html",
@@ -41,7 +41,7 @@
       "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.18",
+      "version": "0.0.23",
       "category": "workflow",
       "keywords": [
         "agent-teams",
@@ -60,7 +60,7 @@
       "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.18",
+      "version": "0.0.23",
       "category": "tooling",
       "keywords": [
         "validation",
@@ -76,7 +76,7 @@
       "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.18",
+      "version": "0.0.23",
       "category": "workflow",
       "keywords": [
         "superpowers",

package/README.md

@@ -14,6 +14,29 @@ Published on npm as [`@drunkcoding/agents-and-skills`](https://www.npmjs.com/pac
 | [`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. |
 | [`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
+
+The `team-superpower` plugin shipped a v3 amendment in 2026-05. Three additions on top of v2:
+
+1. **Autonomous complexity assessment (phase 0.5).** The lead picks mode (`solo` / `single-agent` / `team`) and size (`minimal` / `standard` / `full`) from launch-message heuristics. No extra owner touchpoint; the 3-touchpoint promise is preserved. Override per feature with `/team-feature --mode=<mode> --size=<size>`; preview with `--explain`.
+
+2. **Dependency-grouped parallel waves (phase 4).** The planner emits a `## Waves` section. Independent tasks within a wave run concurrently across up to **2 BE + 2 FE implementers** at peak. Collisions on shared files hard-fail and force a planner re-plan; cap is 3 retries before owner escalation.
+
+3. **Per-role model and effort configuration.** Each agent file pins `model:` (alias) and `effort:`:
+   - **Opus** for orchestration / design / architecture / security / final review (lead + designer + software-architect + security-engineer + reviewer).
+   - **Sonnet** for planning / implementation / QA (planner + backend-developer + frontend-developer + qa-engineer).
+
+   For production teams, pin specific versions via env vars:
+
+   ```bash
+   export ANTHROPIC_DEFAULT_OPUS_MODEL="claude-opus-4-7"
+   export ANTHROPIC_DEFAULT_SONNET_MODEL="claude-sonnet-4-6"
+   ```
+
+   Agent files use aliases so version bumps are intentional.
+
+A typical full-stack `team-standard` feature runs ~3 Opus sessions (lead, designer, reviewer) and ~5–7 Sonnet sessions (planner, BE×1–2, FE×1–2, QA). See `plugins/team-superpower/docs/superpowers/team-superpower-v3-spec.md` for the full spec and `plugins/team-superpower/assets/SESSION_README.md` for owner-facing operational notes.
+
 ## Install
 
 ### Claude Code marketplace

package/package.json

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

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

@@ -1,7 +1,7 @@
 {
   "name": "auto-power",
   "displayName": "Auto Power",
-  "version": "0.0.18",
+  "version": "0.0.23",
   "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"

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

@@ -1,7 +1,7 @@
 {
   "name": "html-effectiveness",
   "displayName": "HTML Effectiveness Reports",
-  "version": "0.0.18",
+  "version": "0.0.23",
   "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.18",
+  "version": "0.0.23",
   "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-superpower/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "team-superpower",
   "displayName": "Team Superpower",
-  "version": "0.0.18",
+  "version": "0.0.23",
   "description": "Shape-adaptive coordination layer that runs the obra/superpowers skill chain across a Claude Code agent team — one /team-feature command takes an idea through design, plan, pre-impl architecture+security gate, BE/FE implementation, QA gate, code review, CI gate, and finish with at most 3 owner touchpoints. Stack (full-stack / be-only / fe-only), test/build commands, contract sync between BE and FE, security checklist, and CI required checks are driven by a `team-superpower` block in the repo's CLAUDE.md.",
   "author": {
     "name": "Steven Hoang"

package/plugins/team-superpower/README.md

@@ -1,58 +1,127 @@
 # team-superpower
 
-Coordination layer that runs the [obra/superpowers](https://github.com/obra/superpowers) skill chain across a Claude Code **agent team**. One `/team-feature` command takes an idea through design → plan → architecture + security gate → BE/FE implementation → QA gate → code review → finish, with at most **3 owner touchpoints**.
+Coordination layer that runs the [obra/superpowers](https://github.com/obra/superpowers)
+skill chain on top of **Claude Code Agent Teams**. One `/team-feature` command
+takes an idea through analysis → planning → implementation → end-of-plan QC →
+finish, with at most **3 owner touchpoints**.
 
-This plugin is *not* a fork of Superpowers. It consumes Superpowers skills as-installed and adds the orchestration: who runs which skill, when, and how teammates talk without bothering the owner.
+This plugin is *not* a fork of Superpowers. It consumes Superpowers skills
+as-installed and adds the orchestration: who runs which skill, when, and how
+teammates talk without bothering the owner.
 
-## v2 — shape-adaptive, project-aware
+## Overview (v5)
 
-The plugin reads a `team-superpower` YAML block from your repo-root `CLAUDE.md` to drive every stack decision: BE-only repos do not spawn a frontend teammate, FE-only repos do not spawn a backend teammate, full-stack repos get both plus a contract-publish gate. Test/build/format commands come from `CLAUDE.md` — no more hard-coded `dotnet test`. CI green is required before the finish-branch menu (when a CI provider is configured). The security engineer's checklist is project-aware (no SQL items if no SQL, no XSS items if no HTML). The Superpowers version is pinned at session start so mid-feature skill drift can't corrupt recovery. See `assets/CLAUDE.md.template` for the schema and `docs/superpowers/README.md` (seeded on first run) for the operating manual.
+team-superpower runs **one Agent Teams team** per feature across all phases.
+The lead (orchestrator) is the sole spawner; a coordinating teammate
+(team-leader) requests spawns via `SPAWN_REQUEST`.
+
+**Modes:**
+
+- **Solo** (1 touchpoint, no team) — bug fixes, typos, single-file changes.
+- **Single-agent** (1 touchpoint, 1 team) — small enhancements.
+- **Team** (2 phase-A touchpoints + 1 phase-H finish touchpoint, 1 team
+  across phases A–H) — full features.
+
+**Pipeline (team mode):**
+Phase A (solution-architect + feature-planner [+ security-engineer]) →
+handover → Phases B–F (team-leader + implementers, per-plan-phase wave
+dispatch + phase-end SOLID/DRY review) → Phase G (qc-engineer, end-of-plan
+QC, max 3 rounds) → Phase H (lead push + finish-branch decision + cleanup).
+
+**Restart-on-stuck:** mid-implementation architectural questions trigger a
+full cycle restart (max 2). No architect standby — phase-A roles shut down
+at handover.
+
+See `docs/superpowers/team-superpower-v5-spec.md` for the canonical spec,
+`docs/superpowers/agent-team-flows-v5.md` for diagrams, and
+`docs/superpowers/agent-team-checklist.md` for acceptance criteria.
+
+## Project-aware via CLAUDE.md
+
+The plugin reads a `team-superpower` YAML block from your repo-root `CLAUDE.md`
+to drive every stack decision: BE-only repos do not spawn a frontend
+teammate, FE-only repos do not spawn a backend teammate, full-stack repos
+get both plus a contract-publish gate. Test/build/lint/typecheck/format
+commands come from `CLAUDE.md` — no hard-coded toolchain. The
+security-engineer is only spawned when `security.domain ∈
+{payments, healthcare}` or `security.pii: yes`. See
+`assets/CLAUDE.md.template` for the schema.
 
 ## What you get
 
-- Three slash commands: `/team-feature`, `/team-feature-resume`, `/team-cleanup`.
-- **Eight agent roles**, each with a tightly-scoped system prompt mapping it to specific Superpowers skills or gate behaviour:
-  - `designer` — runs `brainstorming` (phase 1).
-  - `planner` — runs `using-git-worktrees` then `writing-plans` (phase 2). Routes implementation by `impl:be-` / `impl:fe-` prefix.
-  - `software-architect` — phase-3 pre-impl architecture gate. Reviews design + plan. Posts `ARCH_PASSED` / `ARCH_BLOCKED`.
-  - `security-engineer` — phase-3 pre-impl security gate, parallel with `software-architect`. Threat-models design + plan. Posts `SEC_PASSED` / `SEC_BLOCKED`.
-  - `backend-developer` — phase-4 implementer for `impl:be-` tasks (server, data, infra, CI). Runs `subagent-driven-development` + `test-driven-development` per task.
-  - `frontend-developer` — phase-4 implementer for `impl:fe-` tasks. Same skill chain.
-  - `qa-engineer` — phase-5 post-impl QA gate. Verifies acceptance criteria + regression coverage. Posts `QA_PASSED` / `QA_BLOCKED`.
-  - `reviewer` — phase-6 runs `requesting-code-review`; phase-7 runs `finishing-a-development-branch`.
-- Three guardrail hooks (registered automatically via `hooks/hooks.json`):
-  - `TeammateIdle` — refuses idle while peer mail is unanswered.
-  - `TaskCreated` — enforces `impl:` / `review:` / `meta:` / `block:` task title prefixes.
-  - `TaskCompleted` — gates `impl:` completions on `plan_approved_at` and validates escalation entries.
-- `scripts/team-state.sh` — inspection + cleanup helper. Called by the slash commands; also runnable directly.
+- Two slash commands: `/team-feature` and `/team-cleanup`. There is **no
+  separate resume command in v5** — `/team-feature` auto-detects in-progress
+  features.
+- **Eight agent roles**, each with a tightly-scoped system prompt:
+
+## Agents
+
+| Agent | Lifetime | Role |
+|---|---|---|
+| `orchestrator` | Whole feature | Lead session; sole spawner; SPAWN_REQUEST + RESTART_REQUEST handler; cleanup + push. |
+| `solution-architect` | Phase A only | Spec + arch-map. |
+| `feature-planner` | Phase A only | Plan (plan-phase grouped, waves). |
+| `security-engineer` | Phase A only (regulated domains only) | Regulatory + threat-model review. |
+| `team-leader` | Phases B–F | Coordinator; composes spawn briefs; runs phase-end SOLID/DRY/domain review. |
+| `backend-developer` / `frontend-developer` | Per wave | TDD implementation, static-check log capture, commit. |
+| `qc-engineer` | Phase G only | End-of-plan 5-step QC; rework dispatch if blocking. |
+
+- **Three guardrail hooks** (registered automatically via `hooks/hooks.json`):
+  - `TeammateIdle` — role-aware idle routing (refuses idle when the role's
+    outstanding obligation is open).
+  - `TaskCreated` — enforces `impl:` / `review:` / `meta:` / `block:` task
+    title prefixes, v5 wave shape, and shape-marker scope.
+  - `TaskCompleted` — gates `impl:` completions on the static-check log
+    (`.team-superpower/static-check-<task-id>.log`) and rework-reference
+    (`Reworks: <orig-id>` for `impl:rework-*`).
+- `scripts/team-state.sh` — inspection + cleanup helper; new `members <slug>`
+  subcommand lists role / id / status per teammate.
 - Robustness primitives baked into the workflow:
-  - **Preflight scan** in `/team-feature` and `/team-feature-resume` — detects orphaned team config, stale task lists, and in-flight runs before doing anything destructive.
-  - **Two gate phases** (pre-impl arch+security, post-impl QA) — block forward progress until findings resolve, so the reviewer at phase 6 sees clean code-quality issues only, not architectural or security regressions.
-  - **Heartbeat file** at `docs/superpowers/sessions/<slug>.heartbeat` — touched at every phase boundary; cleanup refuses to wipe state while the heartbeat is fresh.
-  - **Atomic checkpoint writes** (tmp + rename) — half-written checkpoints can't corrupt recovery.
-  - **Automatic cleanup after `FINISH_DONE`** — the lead verifies all phases complete, all commits in place, teammates idle, then runs the canonical "clean up the team" primitive followed by a verification scan. No manual `rm -rf` required.
-  - **`/team-cleanup [slug]`** for the case where a previous lead crashed and the canonical cleanup path is no longer available.
-- Templates seeded into your project on first use: `docs/superpowers/ESCALATION.md` (escalation template + 2 worked examples) and `docs/superpowers/README.md` (onboarding + troubleshooting).
+  - **Preflight scan** in `/team-feature` — detects orphaned team config and
+    in-flight runs before doing anything destructive.
+  - **Auto-resume** in `/team-feature` — detects in-progress handovers
+    without a matching qc-report and offers to continue.
+  - **Phase-end leader review** — team-leader scans every plan-phase's diff
+    against the arch-map for SOLID/DRY/domain violations and dispatches
+    `impl:rework-*` tasks.
+  - **End-of-plan QC** — qc-engineer runs once after `PLAN_COMPLETE`; up to 3
+    rework rounds.
+  - **Heartbeat file** at `docs/superpowers/sessions/<slug>.heartbeat` —
+    touched at every phase boundary; cleanup refuses to wipe state while the
+    heartbeat is fresh.
+  - **Automatic cleanup after `FINISH_DONE`** — the lead verifies all phases
+    complete, all commits in place, teammates idle, then runs the canonical
+    "clean up the team" primitive followed by a verification scan.
+  - **`/team-cleanup [slug]`** for the case where a previous lead crashed.
+- Templates seeded into your project on first use:
+  `docs/superpowers/ESCALATION.md` (template + three worked examples),
+  `docs/superpowers/README.md` (onboarding + troubleshooting), and
+  `docs/superpowers/handovers/README.md` (handover artefact contract).
 
 ## Phase chain at a glance
 
 | Phase | Role(s) | Output | Gate? |
 |---|---|---|---|
-| 1 Design | `designer` | Design doc → `docs/superpowers/specs/` | Owner approval |
-| 2 Plan | `planner` | Worktree + plan with `impl:be-` / `impl:fe-` tasks → `docs/superpowers/plans/` | Owner approval |
-| 3 Pre-impl review (parallel) | `software-architect` + `security-engineer` | ARCH + SEC reports → `docs/superpowers/reviews/` | Both must post PASSED |
-| 4 Implementation (parallel) | `backend-developer` + `frontend-developer` | TDD commits on feature branch | All `impl:` tasks complete |
-| 5 QA | `qa-engineer` | QA report → `docs/superpowers/reviews/` | `QA_PASSED` |
-| 6 Code review | `reviewer` | Review report → `docs/superpowers/reviews/` | `REVIEW_PASSED` |
-| 7 Finish | `reviewer` | Merge / PR / keep / discard | Owner decision |
+| A — Analysis | `solution-architect` + `feature-planner` [+ `security-engineer`] | Spec, arch-map, plan, handover | Spec sign-off + plan approval (2 touchpoints) |
+| B–F — Implementation (one per plan-phase) | `team-leader` + `backend-developer` / `frontend-developer` | TDD commits per wave + phase-end leader review | `PHASE_COMPLETE` per plan-phase |
+| G — End-of-plan QC | `qc-engineer` | `<date>-<slug>-qc-report.md` | `QC_PASS` (max 3 rework rounds) |
+| H — Finish | `orchestrator` | Push + merge/PR/keep/discard | Owner decision (finish touchpoint) |
 
 ## Requirements
 
 - Claude Code `2.1.32` or later.
-- `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in your environment (the slash command halts if absent).
-- The Superpowers plugin installed: `/plugin install superpowers@claude-plugins-official`.
-- `jq` on `$PATH` (the hooks degrade to log-only when missing, but you want them enforcing).
-- **Run the lead session on Opus.** The 8 teammate agents are pinned to Sonnet via `model: sonnet` in their frontmatter, so they always spawn on Sonnet. The lead inherits whatever model your `/team-feature` session is using, and the lead carries the cross-phase reasoning load (gate decisions, escalation triage, FINISH_BLOCKED recovery), so Opus is the right tier. The command performs a self-attestation check at preflight and halts if the lead reports it is running on Sonnet/Haiku.
+- `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in your environment (the slash
+  command halts if absent).
+- The Superpowers plugin installed:
+  `/plugin install superpowers@claude-plugins-official`.
+- `jq` on `$PATH` (hooks degrade to log-only when missing, but you want them
+  enforcing).
+- **Run the lead session on Opus.** Teammates are pinned via their agent
+  frontmatter, so they always spawn on their pinned model. The lead carries
+  the cross-phase reasoning load (gate decisions, SPAWN_REQUEST handling,
+  RESTART_REQUEST approval, FINISH_BLOCKED recovery), so Opus is the right
+  tier. The command performs a self-attestation check at preflight and halts
+  if the lead reports it is running on Sonnet/Haiku.
 
 ## Install
 
@@ -76,37 +145,43 @@ Then make sure the agent-teams env flag is set in `~/.claude/settings.json`:
 /team-feature add a /healthcheck endpoint that returns 200 OK
 ```
 
-You will be interrupted at most three times:
+You will be interrupted at most three times in team mode:
 
-1. Design sign-off (after phase 1).
-2. Plan approval (after phase 2).
-3. Finish-branch decision — merge / PR / keep / discard (in phase 7).
+1. Spec sign-off (mid phase A).
+2. Plan approval (end phase A).
+3. Finish-branch decision — merge / PR / keep / discard (phase H).
 
-Anything else that reaches you uses the escalation template in `docs/superpowers/ESCALATION.md`. If a teammate pings you without using the template, that's a bug — file it.
+Anything else that reaches you uses the escalation template in
+`docs/superpowers/ESCALATION.md`. If a teammate pings you without using the
+template, that's a bug — file it.
 
 ## Task prefix routing
 
-The planner assigns every `impl:` task one of two sub-prefixes; the lead routes by prefix:
+The planner assigns every `impl:` task one of these sub-prefixes; the lead
+routes by prefix:
 
 | Prefix | Routed to | Scope |
 |---|---|---|
-| `impl:be-` | `backend-developer` | Server-side code, APIs, data, schemas, migrations, infra / CI scripts, Docker, IaC |
-| `impl:fe-` | `frontend-developer` | UI components, pages, client-side state, styles, browser assets |
+| `impl:be-*` | `backend-developer` | Server-side code, APIs, data, schemas, infra |
+| `impl:be-migration-*` | `backend-developer` | Schema migrations (serialised by hook) |
+| `impl:be-contract-publish-*` | `backend-developer` | Publishes contract; gates FE tasks |
+| `impl:fe-*` | `frontend-developer` | UI components, pages, client-side state, styles |
+| `impl:contract-update-*` | `backend-developer` | Contract drift fix (scope-neutral) |
+| `impl:rework-*` | inherits originating task's role | Phase-end leader review or QC rework |
 
-Defect-fix tasks filed mid-flight inherit the routing prefix:
-
-| Prefix | Filed by | Routed to |
-|---|---|---|
-| `impl:qa-fix-be-` / `impl:qa-fix-fe-` | `qa-engineer` (phase 5) | matching BE / FE implementer |
-| `impl:review-fix-be-` / `impl:review-fix-fe-` | `reviewer` (phase 6) | matching BE / FE implementer |
+Wave metadata must be one of: `<plan-phase>.<wave>` (e.g. `1.1`),
+`<plan-phase>.rework`, or `qc-rework`.
 
 ## Resume after `/resume` drops the team
 
-```text
-/team-feature-resume YYYY-MM-DD-<slug>.md
-```
+Re-run `/team-feature` from the same worktree. The lead detects:
 
-The lead reads the committed checkpoint in `docs/superpowers/sessions/`, scans `~/.claude/teams/superpower-<slug>/` for orphaned platform state, runs cleanup if the heartbeat indicates the previous lead is dead, then respawns the right teammates and continues from the next unchecked phase. Completed phases are not redone.
+1. Existing `~/.claude/teams/superpower-<slug>/` directory.
+2. In-progress feature artefacts (handover without matching qc-report).
+3. Partial commits ahead of the base branch.
+
+…and presents a single resume prompt. On continue, completed phases are not
+redone.
 
 ## Clean up after a crashed lead
 
@@ -115,47 +190,29 @@ The lead reads the committed checkpoint in `docs/superpowers/sessions/`, scans `
 /team-cleanup --all
 ```
 
-Use this when a previous lead died (terminal closed, `/resume` lost the team, OS killed the process) and left `~/.claude/teams/superpower-<slug>/` behind. Project-side artefacts under `docs/superpowers/{specs,plans,reviews}` are preserved; only platform-side state is removed.
+Use this when a previous lead died (terminal closed, `/resume` lost the team,
+OS killed the process) and left `~/.claude/teams/superpower-<slug>/` behind.
+Project-side artefacts under `docs/superpowers/{specs,plans,handovers,reviews}`
+are preserved; only platform-side state plus per-feature scratch
+(`.team-superpower/spawn-briefs/`, `.team-superpower/static-check-*.log`) is
+removed.
 
-The slash command dry-runs first, prints what would be removed, and asks for confirmation. The heartbeat file at `docs/superpowers/sessions/<slug>.heartbeat` is checked — if it was touched in the last 10 minutes, cleanup refuses unless the owner explicitly confirms with `--ignore-heartbeat` that the previous lead is dead.
+The slash command dry-runs first, prints what would be removed, and asks for
+confirmation. The heartbeat file at
+`docs/superpowers/sessions/<slug>.heartbeat` is checked — if it was touched
+in the last 10 minutes, cleanup refuses unless the owner explicitly confirms
+with `--ignore-heartbeat` that the previous lead is dead.
 
 The helper script is also runnable directly:
 
 ```bash
 bash plugins/team-superpower/scripts/team-state.sh scan          # list all teams
 bash plugins/team-superpower/scripts/team-state.sh scan <slug>   # inspect one
+bash plugins/team-superpower/scripts/team-state.sh members <slug>     # list role/id/status
 bash plugins/team-superpower/scripts/team-state.sh cleanup <slug>          # dry-run
 bash plugins/team-superpower/scripts/team-state.sh cleanup <slug> --force  # apply
 ```
 
-## Automatic cleanup after the feature ships
-
-`/team-feature` runs cleanup automatically the instant the reviewer reports `FINISH_DONE` (merge / PR / keep / discard). Before wiping anything, the lead verifies:
-
-- every phase from design through finish is complete in the checkpoint
-- the shared task list has zero in-progress tasks
-- the expected commits exist on the worktree (design, plan, ARCH+SEC reports, TDD pairs of test + code, QA report, code-review report, and any merge / PR-prep commit per the finish decision)
-- all teammates are idle and shut down
-
-Only then does it invoke the canonical "clean up the team" primitive, verify with a scan that `~/.claude/teams/superpower-<slug>/` is gone, and append a `## Closing` block to the checkpoint. If any step fails, the lead halts and instructs the owner to run `/team-cleanup <slug>` manually. **No `rm -rf` runs on a half-finished feature.**
-
-### Worktree removal on merge
-
-When (and only when) the finish decision is `merged` AND the platform-cleanup scan shows everything `absent`, the lead now runs a Step D.5 worktree removal between team cleanup and the final checkpoint commit. `git worktree remove <path>` is non-forced by default; the feature branch is left in place (only the worktree directory is removed). If `git worktree remove` fails (untracked files, locked worktree, in-progress git operation), the lead presents a 4-option menu:
-
-| | Option | Behaviour |
-|---|---|---|
-| A | Show files + retry | Lists blocking files via `git status --short` + `git diff --stat`, then retries (cap 3). |
-| B | Force remove | Discards uncommitted work in the worktree (requires typed `yes` confirmation). |
-| C | Keep worktree | Leaves the directory on disk; owner removes manually. |
-| D | Escalate | §7 escalation with verbatim stderr. |
-
-Other finish decisions (`pr_opened`, `kept`, `discarded`) skip Step D.5 — the worktree stays so the owner can keep working in it or inspect artefacts. The Closing block records the outcome with a `worktree:` field.
-
-### Merge-failure menu
-
-If the reviewer's merge step in phase 7 fails (`conflict` / `non-ff` / `dirty-worktree` / `push-rejected`), it posts `FINISH_BLOCKED <reason>` instead of `FINISH_DONE`. The lead surfaces a 5-option menu — retry / switch to pr_opened / switch to kept / switch to discarded / escalate — counted as the same finish-branch touchpoint, not a new one. Retries cap at 3; after the 3rd `FINISH_BLOCKED`, option A drops. The cap persists across `/team-feature-resume` via the checkpoint.
-
 ## Layout
 
 ```
@@ -163,60 +220,74 @@ plugins/team-superpower/
 ├── .claude-plugin/plugin.json
 ├── README.md
 ├── agents/
-│   ├── designer.md
-│   ├── planner.md
-│   ├── software-architect.md
+│   ├── orchestrator.md
+│   ├── solution-architect.md
+│   ├── feature-planner.md
 │   ├── security-engineer.md
+│   ├── team-leader.md
 │   ├── backend-developer.md
 │   ├── frontend-developer.md
-│   ├── qa-engineer.md
-│   └── reviewer.md
+│   └── qc-engineer.md
 ├── commands/
-│   ├── team-feature.md
-│   ├── team-feature-resume.md
+│   ├── team-feature.md          # v5 single-team lifecycle + auto-resume
 │   └── team-cleanup.md
 ├── hooks/
 │   ├── hooks.json
-│   ├── teammate-idle.sh
-│   ├── task-created.sh       → recognises v2 sub-prefixes and the shape marker
-│   └── task-completed.sh     → migration serialization + contract-publish verification
+│   ├── teammate-idle.sh         # role-aware idle routing
+│   ├── task-created.sh          # impl:/review:/meta:/block: + v5 wave shape
+│   └── task-completed.sh        # static-check log + rework reference gate
 ├── scripts/
-│   ├── team-state.sh         → inspection + cleanup helper
-│   ├── detect-stack.sh       → filesystem-based stack detection (BE / FE / contracts / CI)
-│   └── parse-claudemd.sh     → extract the team-superpower block from CLAUDE.md
+│   ├── team-state.sh            # inspection + cleanup helper + members subcommand
+│   ├── detect-stack.sh
+│   └── parse-claudemd.sh
 └── assets/
-    ├── ESCALATION.md         → seeded to docs/superpowers/ESCALATION.md on first run
-    ├── SESSION_README.md     → seeded to docs/superpowers/README.md on first run
-    └── CLAUDE.md.template    → copy to repo root if no CLAUDE.md exists
+    ├── ESCALATION.md            # seeded to docs/superpowers/ESCALATION.md on first run
+    ├── SESSION_README.md        # seeded to docs/superpowers/README.md on first run
+    └── CLAUDE.md.template       # copy to repo root if no CLAUDE.md exists
 ```
 
 ## Clarification routing
 
-Teammates resolve as many clarifications as possible without involving the owner. Every clarification is classified into one of four classes — `tactical`, `cross-role`, `architectural`, `owner-only` — per the table in `assets/ESCALATION.md` § Decision classes.
+Teammates resolve as many clarifications as possible without involving the
+owner. Every clarification is classified into one of three classes —
+`tactical`, `cross-role`, `architectural` — per `assets/ESCALATION.md`.
 
-- **Tactical** questions (naming, wording, thresholds in range) are decided by the originator and logged in the session checkpoint's `## Assumptions` block. No mailbox, no escalation.
-- **Cross-role** questions go to the relevant peer; consensus on first reply → log + proceed; after 2 round-trips with no consensus → escalate citing the attempts.
-- **Architectural** questions go to `software-architect`; sign-off → log; dissent → escalate.
-- **Owner-only** questions (scope, design-vs-plan contradiction, security-blocking) escalate immediately.
+- **Tactical** (naming, wording, thresholds in range) — decided by the
+  originator and logged in the checkpoint's `## Assumptions` block. No
+  SendMessage, no escalation.
+- **Cross-role** — to the relevant peer via SendMessage; consensus on first
+  reply → log + proceed; no consensus → escalate citing attempts.
+- **Architectural** — implementers send `ESCALATE class=architectural` to
+  team-leader. If team-leader cannot resolve from arch-map, team-leader posts
+  `RESTART_REQUEST` to the orchestrator (recovery touchpoint, not counted
+  against the 3-budget).
 
-Every escalation carries a `Peer attempts:` field. The `TaskCompleted` hook warns when missing (warn-only). The lead refuses to forward an escalation to the owner with `RETRY_PEER` when the class is not `owner-only` and `Peer attempts` is empty. Per-role rubrics live in each agent file under `agents/<role>.md` § Clarification routing.
+Per-role rubrics live in each agent file under `agents/<role>.md`.
 
 ## Design
 
-See the project's `docs/superpowers/README.md` after first run for the operating manual. The short version:
-
 - The **lead** is a conductor. It never runs a Superpowers skill itself.
-- Teammates run **canonical, unmodified** Superpowers skills. They are forbidden from paraphrasing or replacing them.
-- TDD is enforced by `subagent-driven-development` + `test-driven-development` per implementer task. The `TaskCompleted` hook is a backstop, not the primary control.
-- **Two gate phases** keep the reviewer's job small. Architecture and security issues are caught at phase 3 (pre-impl) so implementers don't waste cycles on plans that fail review. QA defects are caught at phase 5 (post-impl) so the reviewer at phase 6 only deals with code-quality findings.
-- All cross-team chatter that needs an owner decision goes through the §7 escalation template. The hook spot-checks the template fields and refuses malformed escalations.
-- Every phase boundary writes a checkpoint to `docs/superpowers/sessions/<slug>.md`. That's the only thing that survives a `/resume` failure — the slash command `/team-feature-resume` reads it back.
+- Teammates run **canonical, unmodified** Superpowers skills. They are
+  forbidden from paraphrasing or replacing them.
+- TDD is enforced by `subagent-driven-development` +
+  `test-driven-development` per implementer task. Static checks (lint +
+  format + typecheck) are captured to a log and gated by the `TaskCompleted`
+  hook.
+- **Phase-end leader review** + **end-of-plan QC** keep architectural drift
+  in check without a per-task QA loop.
+- All cross-team chatter that needs an owner decision goes through the §7
+  escalation template.
+- Every phase boundary writes a checkpoint to
+  `docs/superpowers/sessions/<slug>.md`.
 
 ## Out of scope
 
 - Token-usage metrics per teammate per phase.
 - Per-role permission allowlists.
-- Standalone devops, technical-writer, or minimal-change-engineer roles — infra/CI folds into `backend-developer`; documentation lands in PR descriptions and inline; minimal-change patterns are scoped per task by the planner.
+- Standalone devops, technical-writer, or minimal-change-engineer roles —
+  infra/CI folds into `backend-developer`; documentation lands in PR
+  descriptions and inline; minimal-change patterns are scoped per task by
+  the planner.
 
 ## License