docs: codex-efficiency fix-cycle spec and plan (campaign record)

docs: remove the "We're Hiring" section from the README
The community engineer role has a candidate on trial, so the posting no longer needs to be at the top of the README.
2026-08-13 20:23:28 +00:00 · 2026-07-31 10:52:05 -07:00 · 2026-07-27 11:43:14 -07:00 · 2026-07-23 17:28:00 -07:00 · 2026-07-23 16:18:07 -07:00 · 2026-07-23 16:16:32 -07:00
38 changed files with 64 additions and 1624 deletions
--- a/.claude-plugin/marketplace.json
+++ b/.claude-plugin/marketplace.json
@@ -9,7 +9,7 @@
    {
      "name": "superpowers",
      "description": "Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques",
-      "version": "6.3.0",
+      "version": "6.2.0",
      "source": "./",
      "author": {
        "name": "Jesse Vincent",
--- a/.claude-plugin/plugin.json
+++ b/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
  "name": "superpowers",
  "description": "Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques",
-  "version": "6.3.0",
+  "version": "6.2.0",
  "author": {
    "name": "Jesse Vincent",
    "email": "jesse@fsck.com"
--- a/.codex-plugin/plugin.json
+++ b/.codex-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
  "name": "superpowers",
-  "version": "6.3.0",
+  "version": "6.2.0",
  "description": "An agentic skills framework & software development methodology that works: planning, TDD, debugging, and collaboration workflows.",
  "author": {
    "name": "Jesse Vincent",
--- a/.cursor-plugin/plugin.json
+++ b/.cursor-plugin/plugin.json
@@ -2,7 +2,7 @@
  "name": "superpowers",
  "displayName": "Superpowers",
  "description": "Core skills library: TDD, debugging, collaboration patterns, and proven techniques",
-  "version": "6.3.0",
+  "version": "6.2.0",
  "author": {
    "name": "Jesse Vincent",
    "email": "jesse@fsck.com"
--- a/.devin-plugin/plugin.json
+++ b/.devin-plugin/plugin.json
@@ -1,22 +0,0 @@
-{
-  "name": "superpowers",
-  "version": "6.3.0",
-  "description": "An agentic skills framework & software development methodology that works: planning, TDD, debugging, and collaboration workflows.",
-  "author": {
-    "name": "Jesse Vincent",
-    "email": "jesse@fsck.com"
-  },
-  "homepage": "https://github.com/obra/superpowers",
-  "repository": "https://github.com/obra/superpowers",
-  "license": "MIT",
-  "keywords": [
-    "brainstorming",
-    "subagent-driven-development",
-    "skills",
-    "planning",
-    "tdd",
-    "debugging",
-    "code-review",
-    "workflow"
-  ]
-}
--- a/.gitignore
+++ b/.gitignore
@@ -11,9 +11,3 @@ triage/
 # development (see CLAUDE.md / README.md). It is not part of the published
 # plugin, so the whole directory is ignored here.
 evals/
-
-# Python
-__pycache__/
-*.pyc
-*.pyo
-.pytest_cache/
--- a/.hermes-plugin/init.py
+++ b/.hermes-plugin/init.py
@@ -1,104 +0,0 @@
-import os
-import re
-from pathlib import Path
-
-BOOTSTRAP_MARKER = "superpowers:using-superpowers bootstrap for hermes"
-
-
-def _skills_dir() -> str:
-    """Locate the stock skills/ tree for either supported install layout.
-
-    - git-clone install (`hermes plugins install obra/superpowers`): the plugin
-      dir is the repo root, so `.hermes-plugin/` and `skills/` are siblings and
-      this module resolves `../skills`.
-    - flattened install (plugin files copied to the plugin dir root): `skills/`
-      sits next to this module.
-
-    Raises loudly when neither matches — a bootstrap that silently skips is how
-    a broken install masquerades as a working one.
-    """
-    here = os.path.dirname(os.path.realpath(__file__))
-    candidates = (
-        os.path.realpath(os.path.join(here, "..", "skills")),
-        os.path.realpath(os.path.join(here, "skills")),
-    )
-    for cand in candidates:
-        if os.path.isfile(os.path.join(cand, "using-superpowers", "SKILL.md")):
-            return cand
-    raise RuntimeError(
-        "superpowers plugin: cannot find the skills/ tree "
-        f"(looked at {candidates}). Reinstall with "
-        "`hermes plugins install obra/superpowers`."
-    )
-
-
-def _strip_frontmatter(content: str) -> str:
-    match = re.match(r"^---\n[\s\S]*?\n---\n([\s\S]*)$", content)
-    return (match.group(1) if match else content).strip()
-
-
-def _build_bootstrap(skills_dir: str) -> str:
-    with open(
-        os.path.join(skills_dir, "using-superpowers", "SKILL.md"),
-        encoding="utf-8",
-    ) as f:
-        body = _strip_frontmatter(f.read())
-
-    tools_path = os.path.join(
-        skills_dir, "using-superpowers", "references", "hermes-tools.md"
-    )
-    with open(tools_path, encoding="utf-8") as f:
-        tool_mapping = f.read().strip()
-
-    return (
-        f"<EXTREMELY_IMPORTANT>\n"
-        f"{BOOTSTRAP_MARKER}\n\n"
-        f"You have superpowers.\n\n"
-        f"The using-superpowers skill content is included below and is already "
-        f"loaded for this Hermes session. Follow it now. "
-        f"Do not try to load using-superpowers again.\n\n"
-        f"{body}\n\n"
-        f"## Loading Superpowers Skills on Hermes\n\n"
-        f"Superpowers skills are registered with Hermes' native skill loader: "
-        f'invoke one with `skill_view("superpowers:skill-name")` '
-        f'(for example `skill_view("superpowers:brainstorming")`). '
-        f"If a namespaced lookup returns 'not found', read the skill file "
-        f"directly instead:\n"
-        f'`read_file("{skills_dir}/skill-name/SKILL.md")`\n\n'
-        f"The superpowers skills directory is: `{skills_dir}`\n\n"
-        f"{tool_mapping}\n"
-        f"</EXTREMELY_IMPORTANT>"
-    )
-
-
-def register(ctx):
-    skills_dir = _skills_dir()
-    bootstrap = _build_bootstrap(skills_dir)
-
-    # Register every stock skill with Hermes' native loader so skill_view can
-    # load them on demand. Standard markdown; no conversion (plugin guide).
-    # register_skill requires a pathlib.Path — a str raises AttributeError and
-    # hermes silently disables the whole plugin (verified 2026-07-23).
-    for name in sorted(os.listdir(skills_dir)):
-        skill_md = os.path.join(skills_dir, name, "SKILL.md")
-        if os.path.isfile(skill_md):
-            ctx.register_skill(name, Path(skill_md))
-
-    # pre_llm_call returning {"context": ...} is the documented injection path
-    # (on_session_start return values are ignored, and ctx.inject_message
-    # refuses from that hook — verified empirically 2026-07-23). The context is
-    # appended to the first turn's user message.
-    def pre_llm_call(
-        session_id=None,
-        user_message=None,
-        conversation_history=None,
-        is_first_turn=None,
-        model=None,
-        platform=None,
-        **kwargs,
-    ):
-        if is_first_turn:
-            return {"context": bootstrap}
-        return None
-
-    ctx.register_hook("pre_llm_call", pre_llm_call)
--- a/.hermes-plugin/plugin.yaml
+++ b/.hermes-plugin/plugin.yaml
@@ -1,6 +0,0 @@
-name: superpowers
-version: 6.3.0
-description: Superpowers skills and workflow bootstrap for Hermes Agent
-author: obra
-provides_hooks:
-  - pre_llm_call
--- a/.kimi-plugin/plugin.json
+++ b/.kimi-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
  "name": "superpowers",
-  "version": "6.3.0",
+  "version": "6.2.0",
  "description": "An agentic skills framework and software development methodology.",
  "author": {
    "name": "Jesse Vincent",
--- a/.version-bump.json
+++ b/.version-bump.json
@@ -1,11 +1,9 @@
 {
  "files": [
    { "path": "package.json", "field": "version" },
-    { "path": ".hermes-plugin/plugin.yaml", "field": "version" },
    { "path": ".claude-plugin/plugin.json", "field": "version" },
    { "path": ".cursor-plugin/plugin.json", "field": "version" },
    { "path": ".codex-plugin/plugin.json", "field": "version" },
-    { "path": ".devin-plugin/plugin.json", "field": "version" },
    { "path": ".kimi-plugin/plugin.json", "field": "version" },
    { "path": ".claude-plugin/marketplace.json", "field": "plugins.0.version" },
    { "path": "gemini-extension.json", "field": "version" }
--- a/README.md
+++ b/README.md
@@ -2,33 +2,10 @@

 Superpowers is a complete software development methodology for your coding agents, built on top of a set of composable skills and some initial instructions that make sure your agent uses them.

-## Table of Contents

- [How it works](#how-it-works)
- [Commercial Services](#commercial-services)
- [Getting Started](#installation)
-  - [Claude Code](#claude-code)
-  - [Antigravity](#antigravity)
-  - [Codex App](#codex-app)
-  - [Codex CLI](#codex-cli)
-  - [Cursor](#cursor)
-  - [Devin CLI](#devin-cli)
-  - [Factory Droid](#factory-droid)
-  - [Gemini CLI](#gemini-cli)
-  - [GitHub Copilot CLI](#github-copilot-cli)
-  - [Grok Build CLI](#grok-build-cli)
-  - [Kimi Code](#kimi-code)
-  - [OpenCode](#opencode)
-  - [Pi](#pi)
-  - [Hermes Agent](#hermes-agent)
- [The Basic Workflow](#the-basic-workflow)
- [Community](#community)
- [What's Inside](#whats-inside)
- [Philosophy](#philosophy)
- [Contributing](#contributing)
- [Updating](#updating)
- [License](#license)
- [Visual companion telemetry](#visual-companion-telemetry)
+## Quickstart
+
+Give your agent Superpowers: [Claude Code](#claude-code), [Antigravity](#antigravity), [Codex App](#codex-app), [Codex CLI](#codex-cli), [Cursor](#cursor), [Factory Droid](#factory-droid), [Gemini CLI](#gemini-cli), [GitHub Copilot CLI](#github-copilot-cli), [Kimi Code](#kimi-code), [OpenCode](#opencode), [Pi](#pi).

 ## How it works

@@ -125,20 +102,6 @@ Superpowers is available via the [official Codex plugin marketplace](https://git

 - Or search for "superpowers" in the plugin marketplace.

-### Devin CLI
-
- Install the plugin from this repository:
-
-  ```bash
-  devin plugins install obra/superpowers
-  ```
-
- Update to the latest version with:
-
-  ```bash
-  devin plugins update superpowers
-  ```
-
 ### Factory Droid

 - Register the marketplace:
@@ -181,22 +144,6 @@ Superpowers is available via the [official Codex plugin marketplace](https://git
  copilot plugin install superpowers@superpowers-marketplace
  ```

-### Grok Build CLI
-
-Superpowers is available via the [official Grok plugin marketplace](https://github.com/xai-org/plugin-marketplace).
-
- Install the plugin from xAI's official marketplace:
-
-  ```bash
-  grok plugin install superpowers@xai-official --trust
-  ```
-
- Or open the marketplace in the TUI, search for Superpowers, and install it:
-
-  ```text
-  /marketplace
-  ```
-
 ### Kimi Code

 Superpowers is available in Kimi Code's plugin marketplace.
@@ -246,18 +193,6 @@ pi -e /path/to/superpowers

 The Pi package loads the Superpowers skills and a small extension that injects the `using-superpowers` bootstrap at session startup and again after compaction. Pi has native skills, so no compatibility `Skill` tool is required. Subagent and task-list tools remain optional Pi companion packages.

-### Hermes Agent
-
-Install Superpowers as a Hermes plugin from this repository:
-
-```bash
-hermes plugins install obra/superpowers --enable
-```
-
-Restart any active Hermes sessions after installing. Note: Hermes has no
-post-compaction hook, so a very long session that compacts over its first
-turn loses the bootstrap — start a fresh session if skills stop triggering.
-
 ## The Basic Workflow

 1. **brainstorming** - Activates before writing code. Refines rough ideas through questions, explores alternatives, presents design in sections for validation. Saves design document.
@@ -276,14 +211,6 @@ turn loses the bootstrap — start a fresh session if skills stop triggering.

 **The agent checks for relevant skills before any task.** Mandatory workflows, not suggestions.

-## Community
-
-Superpowers is built by [Jesse Vincent](https://blog.fsck.com) and the rest of the folks at [Prime Radiant](https://primeradiant.com).
-
- **Discord**: [Join us](https://discord.gg/35wsABTejz) for community support, questions, and sharing what you're building with Superpowers
- **Issues**: https://github.com/obra/superpowers/issues
- **Release announcements**: [Sign up](https://primeradiant.com/superpowers/) to get notified about new versions
-
 ## What's Inside

 ### Skills Library
@@ -344,3 +271,11 @@ MIT License - see LICENSE file for details
 ## Visual companion telemetry

 Because skills and plugins don't provide any feedback to creators, we have no idea how many of you are using Superpowers. By default, the Prime Radiant logo on brainstorming's optional visual companion feature is loaded from our website. It includes the version of Superpowers in use. It does not include any details about your project, prompt, or coding agent. We don't see your clicks or anything about what you're building. This helps us have a rough idea of how many folks are using Superpowers and which version of Superpowers they're using. It's 100% optional. To disable this, set the environment variable `SUPERPOWERS_DISABLE_TELEMETRY` to any true value. Superpowers also honors Claude Code's `DISABLE_TELEMETRY` and `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` opt-outs.
+
+## Community
+
+Superpowers is built by [Jesse Vincent](https://blog.fsck.com) and the rest of the folks at [Prime Radiant](https://primeradiant.com).
+
+- **Discord**: [Join us](https://discord.gg/35wsABTejz) for community support, questions, and sharing what you're building with Superpowers
+- **Issues**: https://github.com/obra/superpowers/issues
+- **Release announcements**: [Sign up](https://primeradiant.com/superpowers/) to get notified about new versions
--- a/RELEASE-NOTES.md
+++ b/RELEASE-NOTES.md
@@ -1,44 +1,5 @@
 # Superpowers Release Notes

-## v6.3.0 (2026-08-12)
-
-### Harness Support
-
- **Devin CLI**: `devin plugins install obra/superpowers` now works, and skills auto-trigger at session start. (#1995)
- **Hermes Agent**: install from a git clone; skills register with Hermes' native loader and the bootstrap loads on the first turn. (#1922, #2025)
- **Grok Build CLI** added to the install docs. (#1919)
-
-### Brainstorming
-
- **Ceremony now scales to the task.** Requests are classified as spike, bounded, or architectural; small tasks skip the two-document ritual. Every path still stops for your approval before implementation. (#2063)
-
-### Subagent-Driven Development
-
- **Controllers no longer stall on plan conflicts.** Non-catastrophic conflicts and ambiguities get a recorded ruling and work continues; only destructive or irreversible actions still stop for a human. One donated session had sat blocked for almost nine hours on a question the controller could have decided. (#2077)
- **The pre-dispatch conflict scan records its checks in the ledger** instead of just asserting the plan is clean. (#2080)
- **Small same-shape tasks batch into one dispatch**, cutting subagent cost sharply on micro-task plans; batch reviews verify every file in the brief made it into the diff. (#2078)
- **Implementers and reviewers may not spawn their own subagents**, which was producing duplicate reviews. (#2059)
- **Plans carry a `Spec:` pointer** and SDD reads the spec at setup, so plan conflicts get resolved against the design instead of guessed at. (#2086)
- Reviewers re-read evidence they find illegible instead of re-running the test suite (#2089), and circuit-breaker rulings now show up in the Finish report.
-
-### Codex
-
- Subagent waits are event-driven instead of poll-heavy, spawns pin model and reasoning effort explicitly, and the multi-agent reference is corrected against Codex source. (#2060, #2061, #2062)
-
-### Finishing a Development Branch
-
- **Worktree removal no longer destroys untracked files.** When `git worktree remove` refuses because the tree holds uncommitted work, the skill stops, names the files, and asks — instead of reaching for `--force`. (#2016, #1223, #2024)
-
-### Fixes
-
- `render-graphs.js` in writing-skills works on Windows.
- Corrected Copilot CLI backgrounding guidance for Windows. (#1929, #2006)
- `bump-version.sh` covers the Hermes manifest.
-
-### Documentation
-
- README: added a table of contents and reorganized Getting Started.
-
 ## v6.2.0 (2026-07-23)

 ### Subagent-Driven Development
--- a/docs/superpowers/plans/2026-08-06-hermes-version-bump-wiring.md
+++ b/docs/superpowers/plans/2026-08-06-hermes-version-bump-wiring.md
@@ -1,304 +0,0 @@
-# Hermes Version-Bump Wiring Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Keep the Hermes YAML manifest version synchronized with every other declared release manifest.
-
-**Spec:** `docs/superpowers/specs/2026-08-05-hermes-version-bump-wiring-design.md`
-
-**Architecture:** Extend the existing release script with a small extension-based dispatcher: JSON continues through `jq`, while `.yaml` uses Mike Farah `yq` v4. Before the mutating bump loop, read every present manifest through that dispatcher so deterministic format or field failures occur before the first write.
-
-**Tech Stack:** Bash 3.2-compatible shell, `jq`, Mike Farah `yq` v4, existing shell-lint tooling.
-
-## Global Constraints
-
- Support only `.json` and `.yaml`; `.yml` and other extensions remain unsupported.
- YAML fields are present top-level strings; nested YAML fields are out of scope.
- Pass the YAML field and new value through environment data, never interpolate either into a `yq` expression.
- Keep `yq` confined to maintainer release tooling; do not add a plugin runtime dependency.
- Preserve the existing missing-file behavior: `--check` reports missing files and a bump skips them.
- Preflight only the mutating bump path; do not add rollback or transactional writes.
- Do not change audit status behavior, version validation, or the existing JSON field-expression implementation.
-
---
-
-## File Map
-
- Create: `tests/version-bump/test-bump-version.sh`
-  - Exercise the real script in temporary JSON/YAML fixtures and check the real registry.
- Modify: `scripts/bump-version.sh`
-  - Add YAML read/write helpers, format dispatch, and bump-only read preflight.
- Modify: `.version-bump.json`
-  - Register `.hermes-plugin/plugin.yaml` at top-level field `version`.
-
-### Task 1: Wire Hermes Into The Existing Version-Bump Script
-
-**Files:**
- Create: `tests/version-bump/test-bump-version.sh`
- Modify: `scripts/bump-version.sh`
- Modify: `.version-bump.json`
-
-**Interfaces:**
- Consumes: `.version-bump.json` records shaped as `{ "path": string, "field": string }`.
- Produces: `read_manifest_field FILE FIELD`, `write_manifest_field FILE FIELD VALUE`, and `preflight_manifests` Bash helpers.
-
- [ ] **Step 1: Fetch the current development base**
-
-Run:
-
-```bash
-git fetch origin dev
-```
-
-Expected: command exits 0 and refreshes `origin/dev`.
-
- [ ] **Step 2: Rebase the task branch**
-
-Run:
-
-```bash
-git rebase origin/dev
-```
-
-Expected: command exits 0, and `git status --short --branch` no longer reports the branch behind `origin/dev`.
-
- [ ] **Step 3: Add the initial failing behavioral test**
-
-Create `tests/version-bump/test-bump-version.sh` with the happy-path fixture and real registry assertion:
-
-```bash
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-SCRIPT_SOURCE="$REPO_ROOT/scripts/bump-version.sh"
-TEST_ROOT="$(mktemp -d)"
-
-cleanup() {
-  rm -rf "$TEST_ROOT"
-}
-trap cleanup EXIT
-
-fail() {
-  echo "FAIL: $*" >&2
-  exit 1
-}
-
-make_fixture() {
-  local repo="$1"
-  local yaml_body="$2"
-
-  mkdir -p "$repo/scripts" "$repo/.hermes-plugin"
-  cp "$SCRIPT_SOURCE" "$repo/scripts/bump-version.sh"
-  cat >"$repo/.version-bump.json" <<'JSON'
-{
-  "files": [
-    { "path": "package.json", "field": "version" },
-    { "path": ".hermes-plugin/plugin.yaml", "field": "version" }
-  ],
-  "audit": { "exclude": [] }
-}
-JSON
-  cat >"$repo/package.json" <<'JSON'
-{
-  "name": "fixture",
-  "version": "1.2.3"
-}
-JSON
-  printf '%s\n' "$yaml_body" >"$repo/.hermes-plugin/plugin.yaml"
-}
-
-happy_repo="$TEST_ROOT/happy"
-make_fixture "$happy_repo" $'name: superpowers\nversion: 1.2.3'
-
-/bin/bash "$happy_repo/scripts/bump-version.sh" --check >"$TEST_ROOT/check.out"
-/bin/bash "$happy_repo/scripts/bump-version.sh" --audit >"$TEST_ROOT/audit.out"
-/bin/bash "$happy_repo/scripts/bump-version.sh" 2.3.4 >"$TEST_ROOT/bump.out"
-
-[[ "$(jq -r '.version' "$happy_repo/package.json")" == "2.3.4" ]] \
-  || fail "JSON manifest was not bumped"
-[[ "$(yq -r '.version' "$happy_repo/.hermes-plugin/plugin.yaml")" == "2.3.4" ]] \
-  || fail "YAML manifest was not bumped"
-
-jq -e '
-  any(.files[];
-    .path == ".hermes-plugin/plugin.yaml" and .field == "version")
-' "$REPO_ROOT/.version-bump.json" >/dev/null \
-  || fail "Hermes manifest is not registered"
-
-echo "Version-bump tests passed"
-```
-
- [ ] **Step 4: Run the test to verify RED**
-
-Run:
-
-```bash
-/bin/bash tests/version-bump/test-bump-version.sh
-```
-
-Expected: FAIL before `Version-bump tests passed`; the current JSON-only reader cannot process the YAML fixture.
-
- [ ] **Step 5: Add minimal YAML dispatch and register Hermes**
-
-In `scripts/bump-version.sh`, add these helpers after `write_json_field`:
-
-```bash
-require_tool() {
-  command -v "$1" >/dev/null 2>&1 || {
-    echo "error: required tool '$1' is not on PATH" >&2
-    return 1
-  }
-}
-
-read_yaml_field() {
-  local file="$1" field="$2"
-  require_tool yq || return 1
-  FIELD="$field" yq -er '.[strenv(FIELD)] | select(tag == "!!str")' "$file"
-}
-
-write_yaml_field() {
-  local file="$1" field="$2" value="$3"
-  FIELD="$field" VALUE="$value" \
-    yq -i '.[strenv(FIELD)] = strenv(VALUE)' "$file"
-}
-
-read_manifest_field() {
-  local file="$1"
-
-  case "$file" in
-    *.json) read_json_field "$@" ;;
-    *.yaml) read_yaml_field "$@" ;;
-    *)
-      echo "error: unsupported manifest format: $file" >&2
-      return 1
-      ;;
-  esac
-}
-
-write_manifest_field() {
-  local file="$1"
-
-  case "$file" in
-    *.json) write_json_field "$@" ;;
-    *.yaml) write_yaml_field "$@" ;;
-    *)
-      echo "error: unsupported manifest format: $file" >&2
-      return 1
-      ;;
-  esac
-}
-```
-
-Replace the three command-path calls to `read_json_field` with `read_manifest_field`, and replace the bump-path call to `write_json_field` with `write_manifest_field`.
-
-Add this exact entry to `.version-bump.json` immediately after `package.json`:
-
-```json
-{ "path": ".hermes-plugin/plugin.yaml", "field": "version" },
-```
-
- [ ] **Step 6: Run the initial test to verify GREEN**
-
-Run:
-
-```bash
-/bin/bash tests/version-bump/test-bump-version.sh
-```
-
-Expected: PASS with `Version-bump tests passed`.
-
- [ ] **Step 7: Add the failing no-partial-write regression**
-
-Insert this block before the final success message in `tests/version-bump/test-bump-version.sh`:
-
-```bash
-invalid_repo="$TEST_ROOT/invalid"
-make_fixture "$invalid_repo" $'name: superpowers\nversion: 123'
-cp "$invalid_repo/package.json" "$TEST_ROOT/package.before"
-cp "$invalid_repo/.hermes-plugin/plugin.yaml" "$TEST_ROOT/plugin.before"
-
-if /bin/bash "$invalid_repo/scripts/bump-version.sh" 2.3.4 \
-  >"$TEST_ROOT/invalid.out" 2>&1; then
-  fail "bump accepted a non-string YAML version"
-fi
-
-cmp -s "$TEST_ROOT/package.before" "$invalid_repo/package.json" \
-  || fail "JSON manifest changed before YAML validation failed"
-cmp -s "$TEST_ROOT/plugin.before" "$invalid_repo/.hermes-plugin/plugin.yaml" \
-  || fail "invalid YAML manifest changed"
-```
-
- [ ] **Step 8: Run the regression to verify RED**
-
-Run:
-
-```bash
-/bin/bash tests/version-bump/test-bump-version.sh
-```
-
-Expected: FAIL with `JSON manifest changed before YAML validation failed`; without preflight, the JSON manifest is written before the later YAML reader rejects its non-string version.
-
- [ ] **Step 9: Add the bump-only preflight**
-
-Add this helper after `declared_files` in `scripts/bump-version.sh`:
-
-```bash
-preflight_manifests() {
-  local path field fullpath
-
-  require_tool jq || return 1
-  while IFS=$'\t' read -r path field; do
-    fullpath="$REPO_ROOT/$path"
-    [[ -f "$fullpath" ]] || continue
-
-    if ! read_manifest_field "$fullpath" "$field" >/dev/null; then
-      echo "error: cannot read declared manifest: $path ($field)" >&2
-      return 1
-    fi
-  done < <(declared_files)
-}
-```
-
-Call it in `cmd_bump` after version-format validation and before the first bump output or write:
-
-```bash
-  preflight_manifests
-
-  echo "Bumping all declared files to $new_version..."
-```
-
- [ ] **Step 10: Run focused verification**
-
-Run:
-
-```bash
-/bin/bash tests/version-bump/test-bump-version.sh
-scripts/lint-shell.sh scripts/bump-version.sh tests/version-bump/test-bump-version.sh
-scripts/bump-version.sh --check
-git diff --check
-```
-
-Expected:
-
- The behavioral test prints `Version-bump tests passed`.
- Shell lint reports both scripts with no errors.
- `--check` lists eight declared manifests, including `.hermes-plugin/plugin.yaml`, all at `6.2.0`.
- `git diff --check` prints nothing.
-
- [ ] **Step 11: Review and commit the implementation**
-
-Run:
-
-```bash
-git status --short
-git diff -- .version-bump.json scripts/bump-version.sh tests/version-bump/test-bump-version.sh
-git add .version-bump.json scripts/bump-version.sh tests/version-bump/test-bump-version.sh
-git commit \
-  -m "fix(release): wire Hermes into version bumps" \
-  -m "Register the Hermes YAML manifest alongside the existing JSON manifests. Route manifest reads and writes by extension through jq or Mike Farah yq v4, with field names and values passed as data." \
-  -m "Preflight every present manifest before the mutating bump loop so a deterministic YAML read failure cannot leave earlier JSON manifests partially updated. Cover check, audit, bump, registry wiring, and byte-for-byte no-partial-write behavior with one focused fixture test."
-```
-
-Expected: the commit succeeds with only the three implementation paths staged.
--- a/docs/superpowers/specs/2026-08-05-hermes-version-bump-wiring-design.md
+++ b/docs/superpowers/specs/2026-08-05-hermes-version-bump-wiring-design.md
@@ -1,56 +0,0 @@
-# Hermes Version-Bump Wiring Design
-
-**Date:** 2026-08-05
-**Revised:** 2026-08-06
-**Status:** Approved
-
-## Goal
-
-Keep `.hermes-plugin/plugin.yaml` in lockstep with the repository version by
-registering it in `.version-bump.json` and teaching `scripts/bump-version.sh`
-to process YAML without implementing a YAML parser in Bash.
-
-## Design
-
- Add `{ "path": ".hermes-plugin/plugin.yaml", "field": "version" }` to
-  `.version-bump.json`.
- Route `.json` through the existing `jq` helpers and `.yaml` through Mike
-  Farah `yq` v4. The YAML key and value are passed as data, not interpolated
-  into the expression.
- Support only a present top-level YAML string field. Nested fields and `.yml`
-  are out of scope.
- Route `--check`, `--audit`, and version updates through the same small
-  read/write dispatcher.
- Before a version bump writes any manifest, run one read-only preflight that
-  validates the required tools and reads every present declared manifest
-  through the dispatcher. This prevents a deterministic YAML failure from
-  occurring after earlier JSON files have already been updated. Missing-file
-  behavior remains unchanged, and `--help` still works without `jq` or `yq`.
-
-The preflight is the only reliability addition. It does not make the script
-transactional or redesign its existing audit and error-status behavior.
-
-## Tests
-
-Three focused behavioral tests run the real script against an isolated
-temporary fixture and prove:
-
- aligned JSON and YAML pass `--check` and `--audit`, and a bump updates both
-  formats;
- an actual bump with JSON declared first and a later YAML manifest whose
-  top-level `version` is not a string exits nonzero and leaves every manifest
-  byte-for-byte unchanged; and
- the real `.version-bump.json` registers the Hermes manifest.
-
-Verification also runs shell lint and `scripts/bump-version.sh --check` against
-the repository.
-
-## Non-Goals
-
- No hand-written YAML parser.
- No `.yml` or nested-YAML support.
- No Hermes runtime changes.
- No rollback framework, general config-schema layer, audit/status refactor, or
-  exhaustive failure matrix.
- No change to the separate version-validation and JSON-expression issue found
-  during review.
--- a/gemini-extension.json
+++ b/gemini-extension.json
@@ -1,6 +1,6 @@
 {
  "name": "superpowers",
  "description": "Core skills library: TDD, debugging, collaboration patterns, and proven techniques",
-  "version": "6.3.0",
+  "version": "6.2.0",
  "contextFileName": "GEMINI.md"
 }
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "superpowers",
-  "version": "6.3.0",
+  "version": "6.2.0",
  "description": "Superpowers skills and runtime bootstrap for coding agents",
  "type": "module",
  "main": ".opencode/plugins/superpowers.js",
--- a/scripts/bump-version.sh
+++ b/scripts/bump-version.sh
@@ -40,72 +40,12 @@ write_json_field() {
  jq "$jq_path = \"$value\"" "$file" > "$tmp" && mv "$tmp" "$file"
 }

-require_tool() {
-  command -v "$1" >/dev/null 2>&1 || {
-    echo "error: required tool '$1' is not on PATH" >&2
-    return 1
-  }
-}
-
-read_yaml_field() {
-  local file="$1" field="$2"
-  require_tool yq || return 1
-  FIELD="$field" yq -er '.[strenv(FIELD)] | select(tag == "!!str")' "$file"
-}
-
-write_yaml_field() {
-  local file="$1" field="$2" value="$3"
-  FIELD="$field" VALUE="$value" \
-    yq -i '.[strenv(FIELD)] = strenv(VALUE)' "$file"
-}
-
-read_manifest_field() {
-  local file="$1"
-
-  case "$file" in
-    *.json) read_json_field "$@" ;;
-    *.yaml) read_yaml_field "$@" ;;
-    *)
-      echo "error: unsupported manifest format: $file" >&2
-      return 1
-      ;;
-  esac
-}
-
-write_manifest_field() {
-  local file="$1"
-
-  case "$file" in
-    *.json) write_json_field "$@" ;;
-    *.yaml) write_yaml_field "$@" ;;
-    *)
-      echo "error: unsupported manifest format: $file" >&2
-      return 1
-      ;;
-  esac
-}
-
 # Read the list of declared files from config.
 # Outputs lines of "path<TAB>field"
 declared_files() {
  jq -r '.files[] | "\(.path)\t\(.field)"' "$CONFIG"
 }

-preflight_manifests() {
-  local path field fullpath
-
-  require_tool jq || return 1
-  while IFS=$'\t' read -r path field; do
-    fullpath="$REPO_ROOT/$path"
-    [[ -f "$fullpath" ]] || continue
-
-    if ! read_manifest_field "$fullpath" "$field" >/dev/null; then
-      echo "error: cannot read declared manifest: $path ($field)" >&2
-      return 1
-    fi
-  done < <(declared_files)
-}
-
 # Read the audit exclude patterns from config.
 audit_excludes() {
  jq -r '.audit.exclude[]' "$CONFIG" 2>/dev/null
@@ -128,7 +68,7 @@ cmd_check() {
      continue
    fi
    local ver
-    ver=$(read_manifest_field "$fullpath" "$field")
+    ver=$(read_json_field "$fullpath" "$field")
    printf "  %-45s  %s\n" "$path ($field)" "$ver"
    versions+=("$ver")
  done < <(declared_files)
@@ -161,7 +101,7 @@ cmd_audit() {
  current_version=$(
    while IFS=$'\t' read -r path field; do
      local fullpath="$REPO_ROOT/$path"
-      [[ -f "$fullpath" ]] && read_manifest_field "$fullpath" "$field"
+      [[ -f "$fullpath" ]] && read_json_field "$fullpath" "$field"
    done < <(declared_files) | sort | uniq -c | sort -rn | head -1 | awk '{print $2}'
  )

@@ -232,8 +172,6 @@ cmd_bump() {
    exit 1
  fi

-  preflight_manifests
-
  echo "Bumping all declared files to $new_version..."
  echo ""

@@ -244,8 +182,8 @@ cmd_bump() {
      continue
    fi
    local old_ver
-    old_ver=$(read_manifest_field "$fullpath" "$field")
-    write_manifest_field "$fullpath" "$field" "$new_version"
+    old_ver=$(read_json_field "$fullpath" "$field")
+    write_json_field "$fullpath" "$field" "$new_version"
    printf "  %-45s  %s -> %s\n" "$path ($field)" "$old_ver" "$new_version"
  done < <(declared_files)

--- a/scripts/sync-to-codex-plugin.sh
+++ b/scripts/sync-to-codex-plugin.sh
@@ -48,7 +48,6 @@ EXCLUDES=(
  "/.claude-plugin/"
  "/.codex/"
  "/.cursor-plugin/"
-  "/.devin-plugin/"
  "/.git/"
  "/.gitattributes"
  "/.github/"
--- a/skills/brainstorming/SKILL.md
+++ b/skills/brainstorming/SKILL.md
@@ -7,91 +7,20 @@ description: "You MUST use this before any creative work - creating features, bu

 Help turn ideas into fully formed designs and specs through natural collaborative dialogue.

-Start by classifying how much process the request needs, then work
-through your path: understand the context, refine the idea, present a
-design, and get your human partner's approval.
+Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design and get user approval.

 <HARD-GATE>
-Do NOT invoke any implementation skill, write any code, scaffold any
-project, or take any implementation action until you have told your
-human partner what you intend and they have approved it. This applies
-to EVERY task on EVERY path below — the ceremony scales with the task;
-the approval gate never does.
+Do NOT invoke any implementation skill, write any code, scaffold any project, or take any implementation action until you have presented a design and the user has approved it. This applies to EVERY project regardless of perceived simplicity.
 </HARD-GATE>

-## Three Paths
+## Anti-Pattern: "This Is Too Simple To Need A Design"

-Before your first question, classify the request and say the
-classification out loud — "this looks bounded, so I'll present a short
-design here rather than write a spec" — so your human partner can
-override it:
-
- **Spike** — a feasibility question ("can we...", "is it possible...",
-  "quick and dirty is fine") whose output is an answer, not code you
-  keep. Present the question and what you'll try in 2-3 sentences, get
-  a nod, then find out as cheaply as correctness allows. No design
-  doc, no spec file. Report findings as a recommendation; anything you
-  built stays labeled throwaway.
- **Bounded** — a well-scoped change to code that already exists in
-  this repo: a new flag, a small endpoint, a one-file fix.
-  Understanding the kind of app is not enough — bounded means the flow
-  you are changing is already here to read. If there is no existing
-  flow to change, the task is not bounded. Ask the clarifying
-  questions that matter, present a short design IN CHAT (a few
-  sentences to a few short paragraphs), and STOP. Implementation
-  starts only after your human partner says yes to that design — a
-  bounded task's approval is as hard a gate as an architectural
-  one. No spec file, no implementation plan document.
- **Architectural** — new projects, new subsystems, changes that
-  restructure how components fit together or alter interfaces others
-  depend on. Follow the full process: questions, approaches, sectioned
-  design, written spec, then the writing-plans skill.
-
-When in doubt between two paths, take the heavier one. The ratchet is
-one-way: hidden complexity discovered mid-task upgrades the path —
-stop, say so, and step up. Nothing downgrades mid-task.
-
-## Anti-Pattern: "Too Simple To Need Approval"
-
-Every path ends with your human partner approving your intent before
-implementation. A todo list, a single-function utility, a config
-change — the design may be two sentences in chat, but you MUST present
-it and get approval. "Simple" tasks are where unexamined assumptions
-cause the most wasted work. What scales with simplicity is the
-artifact, never the approval.
-
-## Red Flags
-
-| Thought | Reality |
-|---------|---------|
-| "This is too simple to need a design" | Simple means a short design, not no design. Two sentences in chat, then approval. |
-| "I'll call it bounded and skip the spec" | Reaching for a label to skip work IS the doubt — take the heavier path. |
-| "It's bounded and the design is obvious — I'll start while they read it" | The gate is the approval, not the design's length. Present, then stop until you hear yes. |
-| "I understand this kind of app, so it's bounded" | Bounded measures the repo, not your familiarity. A new project has no existing flow — it is architectural. |
-| "The spike works, so I'll keep the code" | A spike's output is an answer. Keeping the code is a new request — classify it. |
-| "It grew, but I'm almost done — no need to re-classify" | Hidden complexity upgrades the path mid-task. Stop and say so. |
-| "They approved the spike, so the follow-up change is approved too" | Each task gets its own classification and its own approval. |
+Every project goes through this process. A todo list, a single-function utility, a config change — all of them. "Simple" projects are where unexamined assumptions cause the most wasted work. The design can be short (a few sentences for truly simple projects), but you MUST present it and get approval.

 ## Checklist

-Classify first, announce the path, then create a task for each item on
-your path and complete them in order.
+You MUST create a task for each of these items and complete them in order:

-**Spike:**
-1. **Explore project context** — enough to frame the probe
-2. **Present question + probe plan** — 2-3 sentences
-3. **Get approval** — a nod is enough
-4. **Investigate** — as cheaply as correctness allows
-5. **Report findings** — a recommendation; label anything built as throwaway
-
-**Bounded:**
-1. **Explore project context** — check files, docs, recent commits
-2. **Ask clarifying questions** — one at a time, the ones that matter
-3. **Present short design in chat** — approach, files touched, testing
-4. **Get approval** — STOP and wait for an explicit yes; presenting the design and starting in the same breath is skipping the gate
-5. **Implement** — proceed with the normal development workflow (TDD applies); no plan document
-
-**Architectural:**
 1. **Explore project context** — check files, docs, recent commits
 2. **Offer the visual companion just-in-time** — NOT upfront. The first time a question would genuinely be clearer shown than described, offer it then (its own message); on approval its browser tab opens for you. If no visual question ever arises, never offer it. See the Visual Companion section below.
 3. **Ask clarifying questions** — one at a time, understand purpose/constraints/success criteria
@@ -106,13 +35,6 @@ your path and complete them in order.

 ```dot
 digraph brainstorming {
-    "Classify: spike / bounded / architectural" [shape=diamond];
-    "Present question + probe (2-3 sentences)" [shape=box];
-    "Ask clarifying questions (bounded)" [shape=box];
-    "Present short design in chat" [shape=box];
-    "Human approves?" [shape=diamond];
-    "Investigate; report recommendation" [shape=doublecircle];
-    "Implement via normal workflow (no plan doc)" [shape=doublecircle];
    "Explore project context" [shape=box];
    "Ask clarifying questions" [shape=box];
    "Propose 2-3 approaches" [shape=box];
@@ -122,17 +44,7 @@ digraph brainstorming {
    "Spec self-review\n(fix inline)" [shape=box];
    "User reviews spec?" [shape=diamond];
    "Invoke writing-plans skill" [shape=doublecircle];
-    "Hidden complexity? Upgrade path" [shape=box];

-    "Classify: spike / bounded / architectural" -> "Present question + probe (2-3 sentences)" [label="spike"];
-    "Classify: spike / bounded / architectural" -> "Ask clarifying questions (bounded)" [label="bounded"];
-    "Classify: spike / bounded / architectural" -> "Explore project context" [label="architectural"];
-    "Present question + probe (2-3 sentences)" -> "Human approves?";
-    "Ask clarifying questions (bounded)" -> "Present short design in chat";
-    "Present short design in chat" -> "Human approves?";
-    "Human approves?" -> "Investigate; report recommendation" [label="spike: yes"];
-    "Human approves?" -> "Implement via normal workflow (no plan doc)" [label="bounded: yes"];
-    "Hidden complexity? Upgrade path" -> "Classify: spike / bounded / architectural";
    "Explore project context" -> "Ask clarifying questions";
    "Ask clarifying questions" -> "Propose 2-3 approaches";
    "Propose 2-3 approaches" -> "Present design sections";
@@ -146,21 +58,10 @@ digraph brainstorming {
 }
 ```

-**Terminal states are path-bound.** Architectural: the ONLY skill you
-invoke after brainstorming is writing-plans — never frontend-design,
-mcp-builder, or any other implementation skill. Bounded: after
-approval, implementation proceeds directly through the normal
-development workflow; no plan document. Spike: the terminal state is a
-reported recommendation.
+**The terminal state is invoking writing-plans.** Do NOT invoke frontend-design, mcp-builder, or any other implementation skill. The ONLY skill you invoke after brainstorming is writing-plans.

 ## The Process

-The subsections below serve the bounded and architectural paths (a
-spike stops at "present the probe, get a nod"). Sections from
-**Exploring approaches** onward are architectural-path depth — for
-bounded work, context plus a few questions plus a short in-chat design
-is the whole process.
-
 **Understanding the idea:**

 - Check out the current project state first (files, docs, recent commits)
@@ -199,7 +100,7 @@ is the whole process.
 - Where existing code has problems that affect the work (e.g., a file that's grown too large, unclear boundaries, tangled responsibilities), include targeted improvements as part of the design - the way a good developer improves code they're working in.
 - Don't propose unrelated refactoring. Stay focused on what serves the current goal.

-## After the Design (architectural path)
+## After the Design

 **Documentation:**

--- a/skills/brainstorming/visual-companion.md
+++ b/skills/brainstorming/visual-companion.md
@@ -83,11 +83,10 @@ scripts/start-server.sh --project-dir /path/to/project --open --foreground

 **Copilot CLI:**
 ```bash
-# Start it with Copilot CLI's non-blocking/background shell mechanism so the
-# server survives across turns. Keep --foreground so the harness, not the
-# script, owns backgrounding. The launcher is a .sh, so invoke it via bash
-# (on Windows, call Git Bash's bash.exe from the PowerShell tool).
-bash scripts/start-server.sh --project-dir /path/to/project --open --foreground
+# Use --foreground and start the server via the bash tool with mode: "async"
+# so the process survives across turns. Capture the returned shellId for
+# read_bash / stop_bash if you need to interact with it later.
+scripts/start-server.sh --project-dir /path/to/project --open --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.
--- a/skills/finishing-a-development-branch/SKILL.md
+++ b/skills/finishing-a-development-branch/SKILL.md
@@ -174,29 +174,6 @@ git worktree remove "$WORKTREE_PATH"
 git worktree prune  # Self-healing: clean up any stale registrations
 ```

-**If removal is refused** (`contains modified or untracked files`): the
-worktree holds files that exist nowhere else — uncommitted plans, notes,
-or scratch work. Never `--force` on your own initiative. Show your human
-partner what is at stake and ask:
-
-```bash
-git -C "$WORKTREE_PATH" status --porcelain -uall
-```
-
-```
-Worktree removal refused — these files were never committed:
-
-<file list>
-
-1. Commit them to <branch> before cleanup
-2. Move them into <main repo root>
-3. Delete them (unrecoverable)
-
-Which?
-```
-
-Carry out the choice, then remove the worktree.
-
 **Otherwise:** The host environment owns this workspace — leave it in
 place. If your platform provides a workspace-exit tool, use it.

@@ -219,7 +196,6 @@ place. If your platform provides a workspace-exit tool, use it.
 | "'Yeah, get rid of it' counts as confirmation" | Only the typed word `discard` authorizes deletion. |
 | "The PR is up, so the worktree is clutter now" | PR feedback gets fixed in that worktree. It stays until the work lands. |
 | "This other worktree looks stale — I'll clean it too" | Clean up only worktrees under `.worktrees/` or `worktrees/`. Everything else belongs to the host. |
-| "Removal refused — `--force` is just finishing the cleanup" | The refusal means files exist only in that worktree. `--force` destroys them permanently. Show your human partner and ask. |
 | "The merged-result failure is probably flaky" | A failing merged result stops everything. Branch and worktree stay put while you investigate. |
 | "The base branch is obviously main" | Confirm the fork point or ask. Merging into the wrong base is expensive to undo. |
 | "The push was rejected — force-push will fix it" | A rejected push means the remote moved. Investigate; force-push only on your human partner's explicit request. |
--- a/skills/requesting-code-review/code-reviewer.md
+++ b/skills/requesting-code-review/code-reviewer.md
@@ -34,15 +34,6 @@ Subagent (general-purpose):

    Your review is read-only on this checkout. Do not mutate the working tree, the index, HEAD, or branch state in any way. Use tools like `git show`, `git diff`, and `git log` to inspect history. If you need a working copy of a different revision, check it out into a separate temporary directory (e.g. `git worktree add /tmp/review-[SHA] [SHA]`) — never move HEAD on this checkout.

-    ## You Do Not Dispatch Subagents
-
-    Do all of this review yourself. Never spawn a subagent to review part
-    of the diff, and never spawn another reviewer for a second opinion.
-    This process already provides every review seat the work gets; a
-    reviewer you spawn duplicates one of them at full cost, and its
-    verdict counts for nothing. If the diff feels too large for one
-    pass, review it in passes yourself and say so in your report.
-
    ## What to Check

    **Plan alignment:**
--- a/skills/subagent-driven-development/SKILL.md
+++ b/skills/subagent-driven-development/SKILL.md
@@ -14,21 +14,7 @@ Execute plan by dispatching a fresh implementer subagent per task, a task review
 **Narration:** between tool calls, narrate at most one short line — the
 ledger and the tool results carry the record.

-**Continuous execution:** Do not pause to check in with your human partner between tasks. Execute all tasks from the plan without stopping. The only reasons to stop are the four named below, or all tasks complete. "Should I continue?" prompts and progress summaries waste their time — they asked you to execute the plan, so execute it.
-
-**Rulings, not stalls.** A running plan does not wait on a human. Conflicts,
-ambiguities, plan defects, a cap you would have asked to exceed — decide
-them. The spec is the binding authority, the plan is its argument, and your
-judgment settles what neither answers. Record every decision in the ledger as
-`Ruling: <what you decided> — <why> — <what it costs if wrong>`, and keep
-going. A wrong ruling costs rework your human partner can see and undo; a
-session parked on a question costs their whole day and buys nothing.
-
-Four things stop you, and only these: an irreversible or destructive
-operation; a security-sensitive action; a side effect outside this worktree
-that norms say you ask about first (a merge, a push to a shared branch, a
-publish); and a plan so broken that every path forward is a guess. For those,
-stop and ask.
+**Continuous execution:** Do not pause to check in with your human partner between tasks. Execute all tasks from the plan without stopping. The only reasons to stop are: BLOCKED status you cannot resolve, ambiguity that genuinely prevents progress, or all tasks complete. "Should I continue?" prompts and progress summaries waste their time — they asked you to execute the plan, so execute it.

 ## When to Use

@@ -71,14 +57,14 @@ digraph process {
        "Generate review package, dispatch task reviewer (./task-reviewer-prompt.md)" [shape=box];
        "Spec ✅ and quality approved?" [shape=diamond];
        "Finding conflicts with plan text?" [shape=diamond];
-        "Rule on the conflict, ledger the ruling" [shape=box];
+        "Ask human partner which governs" [shape=box];
        "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model" [shape=box];
        "Dispatch scoped re-review (./re-review-prompt.md)" [shape=box];
        "All findings addressed?" [shape=diamond];
        "R = 5?" [shape=diamond];
        "Adjudicate each open finding" [shape=box];
        "Any load-bearing finding?" [shape=diamond];
-        "Rule and continue; stop only if every path forward is a guess" [shape=box];
+        "STOP: report BLOCKED to human partner" [shape=box];
        "Park findings in ledger with rulings" [shape=box];
        "Append completion to ledger, mark todo complete" [shape=box];
    }
@@ -99,8 +85,8 @@ digraph process {
    "Generate review package, dispatch task reviewer (./task-reviewer-prompt.md)" -> "Spec ✅ and quality approved?";
    "Spec ✅ and quality approved?" -> "Append completion to ledger, mark todo complete" [label="yes"];
    "Spec ✅ and quality approved?" -> "Finding conflicts with plan text?" [label="no"];
-    "Finding conflicts with plan text?" -> "Rule on the conflict, ledger the ruling" [label="yes"];
-    "Rule on the conflict, ledger the ruling" -> "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model";
+    "Finding conflicts with plan text?" -> "Ask human partner which governs" [label="yes"];
+    "Ask human partner which governs" -> "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model";
    "Finding conflicts with plan text?" -> "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model" [label="no"];
    "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model" -> "Dispatch scoped re-review (./re-review-prompt.md)";
    "Dispatch scoped re-review (./re-review-prompt.md)" -> "All findings addressed?";
@@ -109,7 +95,7 @@ digraph process {
    "R = 5?" -> "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model" [label="no - next round"];
    "R = 5?" -> "Adjudicate each open finding" [label="yes - breaker trips"];
    "Adjudicate each open finding" -> "Any load-bearing finding?";
-    "Any load-bearing finding?" -> "Rule and continue; stop only if every path forward is a guess" [label="yes"];
+    "Any load-bearing finding?" -> "STOP: report BLOCKED to human partner" [label="yes"];
    "Any load-bearing finding?" -> "Park findings in ledger with rulings" [label="no"];
    "Park findings in ledger with rulings" -> "Append completion to ledger, mark todo complete";
    "Append completion to ledger, mark todo complete" -> "More tasks remain?";
@@ -154,32 +140,19 @@ a ledger file, not only in todos.
  that happens, recover from `git log`.

 Read the plan once, note its context and Global Constraints, and create a
-todo per task. If the plan names a Spec, read that too: the spec is the
-authority the plan argues from, and conflicts inside the plan resolve
-against it. A plan with no reachable spec gets a ledger note saying so —
-rulings made without one are provisional.
+todo per task.

-Before dispatching Task 1, scan the plan once for conflicts, writing down
-what you checked as you check it:
+Before dispatching Task 1, scan the plan once for conflicts:

 - tasks that contradict each other or the plan's Global Constraints
 - anything the plan explicitly mandates that the review rubric treats as a
  defect (a test that asserts nothing, verbatim duplication of a logic block)

-The scan's output is a table, not a verdict. One row for every pair of tasks
-that share a file or an interface: the two tasks, what one produces against
-what the other consumes, and what you found. One row for every task: whether
-its own text agrees with itself — the tests it specifies against the code it
-specifies, the files it creates against the files it later touches. "The scan
-is clean" without those rows is not a scan you ran.
-
-Write the table to the ledger. Rule on everything you find before execution
-begins — each finding against the plan text that mandates it — and record
-each ruling in the ledger. If the scan is clean, proceed without comment.
-Rule on each conflict it surfaces — the spec is the binding authority, the
-plan is its argument — record the ruling beside its row, and dispatch
-Task 1. The review loop remains the net for conflicts that only emerge from
-implementation.
+Present everything you find to your human partner as one batched question —
+each finding beside the plan text that mandates it, asking which governs —
+before execution begins, not one interrupt per discovery mid-plan. If the
+scan is clean, proceed without comment. The review loop remains the net for
+conflicts that only emerge from implementation.

 ## Model Selection

@@ -220,29 +193,10 @@ that implementer. Single-file mechanical fixes also take the cheapest tier.

 ## The Task Loop

-**Batch small same-shape work.** When the plan lists several tasks that are
-each a small, independent edit of the same kind — the same one-line fix,
-constant change, or field addition repeated across files — do not dispatch
-one subagent per task. Compose ONE dispatch brief listing every file and
-its change, send the whole batch to a single subagent, and review its diff
-as one unit. Reserve one-dispatch-per-task for work that needs its own
-judgment, its own tests, or its own review surface.
-
 Everything you paste into a dispatch prompt — and everything a subagent
 prints back — stays resident in your context for the rest of the session
 and is re-read on every later turn. Hand artifacts over as files.

-**Waiting on dispatched subagents:** never poll a wait interface with
-short timeouts, and never sit in one silent, open-ended wait either.
-While you have local work — ledger updates, packaging the next review,
-reading reports — keep working; child results arrive on their own.
-When you are genuinely idle, wait in bounded stretches (five to ten
-minutes, where your platform allows), and between stretches post one
-line of status and reconcile your live children: list them, and chase
-any that finished without reporting. A bounded stretch keeps nearly
-all of a long wait's efficiency while guaranteeing a stuck or lost
-child is noticed within minutes, not at the end of the session.
-
 ### 1. Dispatch the implementer

 Record BASE (`git rev-parse HEAD`) before dispatching — the review package
@@ -269,12 +223,6 @@ and fix-round diffs need it.
  later dispatches — a real session's dispatch hit 42k chars of which 99%
  was pasted history. A fresh subagent needs its task, the interfaces it
  touches, and the global constraints. Nothing else.
- The dispatch carries the no-subagents contract (it is in the
-  implementer template): the implementer never dispatches subagents —
-  not helpers, and never a reviewer. Review arrives from you, after the
-  report. In real sessions, every reviewer a worker spawned duplicated
-  the task review the controller dispatched anyway — a full extra
-  review seat per task.
 - If an earlier task parked a finding in the area this task touches, carry
  a pointer to that ledger entry in the dispatch.
 - Record the implementer's agent identity from the dispatch result —
@@ -297,7 +245,7 @@ Implementer subagents report one of four statuses. Handle each appropriately:
 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
-4. If the plan itself is wrong, rule on the correction, ledger it, and re-dispatch with the ruling carried in the dispatch
+4. If the plan itself is wrong, escalate to the human

 **Never** ignore an escalation or force the same model to retry without changes. If the implementer said it's stuck, something needs to change.

@@ -364,11 +312,10 @@ Before the loop starts, two routes leave it immediately:
  before merge. A roll-up nobody reads is a silent discard. Minor findings
  never enter the loop.
 - A finding labeled plan-mandated — or any finding that conflicts with
-  what the plan's text requires — is yours to rule on: weigh the finding
-  against the plan text, decide with the spec as the binding authority, and
-  ledger the ruling before you act on it. Do not dismiss the finding because
-  the plan mandates it, and do not dispatch a fix that contradicts the plan
-  without a recorded ruling.
+  what the plan's text requires — is the human's decision, like any plan
+  contradiction: present the finding and the plan text, ask which governs.
+  Do not dismiss the finding because the plan mandates it, and do not
+  dispatch a fix that contradicts the plan without asking.
 Everything else enters the loop. A fix round is one fix dispatch plus one
 scoped re-review. Five rounds maximum per task:

@@ -413,16 +360,15 @@ dispatching. Adjudicate each open finding yourself — you hold the plan and
 the cross-task context the reviewer lacks:

 - **The reviewer is wrong, or the point is contestable:** park it —
-  `Task <N>: parked — <finding> — Ruling: <why the code stands>`. The final
+  `Task <N>: parked — <finding> — ruling: <why the code stands>`. The final
  review sees both sides.
 - **Real, but nothing downstream builds on it:** park it the same way, with
  a ruling that says it's real and deferred.
 - **Real and load-bearing** — a later task builds on it, or it reveals a
-  plan defect: rule on the smallest change that unblocks the dependent work,
-  ledger it as `Task <N>: Ruling: <finding> — <what you decided and why>`,
-  and carry it into the next task's dispatch. Parking a structural failure
-  silently lets every dependent task build on it. Stop only when the defect
-  leaves every path forward a guess.
+  plan defect: STOP. Append `Task <N>: BLOCKED — <reason>` and report to
+  your human partner with the finding, the plan text it collides with, and
+  the fix history. Parking a structural failure lets every dependent task
+  build on it and hands the final review a problem it cannot fix either.

 Adjudicate only at the cap. Adjudicating earlier to end a loop is
 pre-judging with a different name. Every adjudication is a ledger entry —
@@ -463,22 +409,12 @@ Then run exactly one scoped re-review of the fix wave
 (`scripts/review-package PLAN_FILE FIX_BASE HEAD` over the fix range,
 [re-review-prompt.md](re-review-prompt.md)).
 Adjudicate any residual findings as in the task loop's breaker: park with
-rulings, or rule on the load-bearing ones and ledger what you decided. Only
-the four classes above stop you here. There is no second fix wave —
+rulings, or stop on load-bearing ones. There is no second fix wave —
 residual load-bearing findings surface to your human partner when
 finishing-a-development-branch presents the options.

 ## Finish

-Before you delete anything, collect every ledger line containing `Ruling:` —
-preflight rulings, parked findings, breaker adjudications, all of them — into
-your final message under "Rulings I made", in the order you made them, each
-with what it costs if wrong. The list is exhaustive: if the ledger holds a
-ruling, the list holds it. That list is the only place the decisions you
-took on your human partner's behalf reach them — they read it and rework
-whatever you got wrong. A ruling that dies with the workspace was a decision
-made in secret.
-
 When the final whole-branch review is clean and its fixes are merged,
 delete this plan's workspace (`rm -rf <workspace>`) — the git history is
 the record now. Sibling directories belong to other plans; leave them
@@ -498,7 +434,6 @@ Use superpowers:finishing-a-development-branch.
 | "The fix was small, skip the re-review" | Unreviewed fixes are how regressions land. Every round ends with a scoped re-review. |
 | "Reviews slow the loop down" | The loop without reviews is just unverified churn. Reviews are the loop's brakes and steering. |
 | "Ledger bookkeeping is overhead" | The ledger is what survives compaction. Controllers without one have re-dispatched entire completed task sequences. |
-| "The implementer spawned its own reviewer — free extra assurance" | It's a duplicate seat reviewing the same diff; the task review is the gate. A worker-spawned reviewer is a defect to flag, not rigor. |

 ## Example Workflow

--- a/skills/subagent-driven-development/implementer-prompt.md
+++ b/skills/subagent-driven-development/implementer-prompt.md
@@ -47,18 +47,6 @@ Subagent (general-purpose):
    While iterating, run the focused test for what you're changing; run the
    full suite once before committing, not after every edit.

-    ## You Do Not Dispatch Subagents
-
-    Do all of this task's work yourself. Never spawn a subagent to
-    implement part of the task, and above all never spawn a reviewer to
-    check your work. Self-review (below) means reading your own diff.
-    Review is the controller's job: after you report, it dispatches a
-    fresh reviewer against your diff. A reviewer you spawn duplicates
-    that review at full cost, and its approval counts for nothing in
-    the process. If you catch yourself thinking "an independent review
-    would strengthen my report" — that review is already scheduled.
-    Report instead.
-
    ## Code Organization

    You reason best about code you can hold in context at once, and your edits are more
--- a/skills/subagent-driven-development/re-review-prompt.md
+++ b/skills/subagent-driven-development/re-review-prompt.md
@@ -43,15 +43,6 @@ Subagent (general-purpose):
    Your review is read-only on this checkout. Do not mutate the working
    tree, the index, HEAD, or branch state in any way.

-    ## You Do Not Dispatch Subagents
-
-    Do all of this review yourself. Never spawn a subagent to review part
-    of the diff, and never spawn another reviewer for a second opinion.
-    This process already provides every review seat the work gets; a
-    reviewer you spawn duplicates one of them at full cost, and its
-    verdict counts for nothing. If the diff feels too large for one
-    pass, review it in passes yourself and say so in your report.
-
    ## Scope

    Your scope is the findings list and the fix diff. Verdict every finding.
--- a/skills/subagent-driven-development/task-reviewer-prompt.md
+++ b/skills/subagent-driven-development/task-reviewer-prompt.md
@@ -52,15 +52,6 @@ Subagent (general-purpose):
    Your review is read-only on this checkout. Do not mutate the working
    tree, the index, HEAD, or branch state in any way.

-    ## You Do Not Dispatch Subagents
-
-    Do all of this review yourself. Never spawn a subagent to review part
-    of the diff, and never spawn another reviewer for a second opinion.
-    This process already provides every review seat the work gets; a
-    reviewer you spawn duplicates one of them at full cost, and its
-    verdict counts for nothing. If the diff feels too large for one
-    pass, review it in passes yourself and say so in your report.
-
    ## Do Not Trust the Report

    Treat the implementer's report as unverified claims about the code. It
@@ -84,13 +75,6 @@ Subagent (general-purpose):
    Warnings or other noise in the implementer's reported test output are
    findings — test output should be pristine.

-    Evidence you cannot see is not evidence that doesn't exist. If the
-    report or its test evidence looks truncated, or you cannot locate the
-    results it claims, re-read the file at its stated path — and if it is
-    genuinely missing or garbled, report that as a gap for the controller.
-    Re-running the suite to regenerate what you failed to read is not
-    verification; illegibility of the evidence is not invalidation of it.
-
    ## Part 1: Spec Compliance

    Compare the diff against What Was Requested:
@@ -102,12 +86,6 @@ Subagent (general-purpose):
    - **Misunderstood:** right feature built the wrong way, wrong problem
      solved

-    If the brief lists several files each with its own change (a batched
-    dispatch), check the diff against that list file by file: every listed
-    file must have its corresponding hunk. A listed file the diff never
-    touches is a Missing finding, no matter how clean the rest of the
-    batch looks.
-
    If a requirement cannot be verified from this diff alone (it lives in
    unchanged code or spans tasks), report it as a ⚠️ item instead of
    broadening your search.
--- a/skills/using-superpowers/SKILL.md
+++ b/skills/using-superpowers/SKILL.md
@@ -56,7 +56,6 @@ If your harness appears here, read its reference file for special instructions:
 - Codex: `references/codex-tools.md`
 - Pi: `references/pi-tools.md`
 - Antigravity: `references/antigravity-tools.md`
- Hermes Agent: `references/hermes-tools.md`

 ## User Instructions

--- a/skills/using-superpowers/references/codex-tools.md
+++ b/skills/using-superpowers/references/codex-tools.md
@@ -7,76 +7,7 @@ Add to your Codex config (`~/.codex/config.toml`):
 multi_agent = true
 ```

-This enables the multi-agent tools that skills like
-`dispatching-parallel-agents` and `subagent-driven-development` use.
-Which tools you get depends on the multi-agent version your model
-preset selects (current presets run V2; older ones run V1). Trust your
-actual tool list over any table — including this one — when they
-disagree.
-
- **Spawning:** give children a clean context with
-  `spawn_agent {fork_turns: "none"}`; the default `"all"` copies your
-  entire transcript into the child. On Codex 0.145+, role files under
-  `~/.codex/agents/` attach to isolated forks via `agent_type`.
-  Full-history forks accept `model` and `reasoning_effort` overrides
-  (only `agent_type` is refused there) — isolated forks are the SDD
-  default for context hygiene, not because overrides require them.
- **Fix rounds:** resume the implementer with `followup_task` — it
-  delivers your message, triggers a turn, and transparently reloads a
-  child the harness evicted. Never dispatch a fresh implementer on the
-  theory that a spawned agent cannot be messaged again; on V2 it
-  always can.
- **Lifecycle:** V2 has no `close_agent`. Finished children are
-  evicted automatically when slots are needed; leaving them unclosed
-  costs nothing. Only V1 sessions have `close_agent` — there, close
-  reviewers when their review returns, and close each implementer
-  after its task's review passes.
- **Model names:** never copy a model name from a skill, table, or old
-  session into `spawn_agent` without checking it against your current
-  spawn allowlist — V2 accepts only V2-capable presets and hard-errors
-  on the rest.
-
-## Waiting on children
-
-`wait_agent` is an event subscription, not a poll: a long wait wakes
-the moment a child produces mailbox activity, with the same latency as
-a short one. Short-timeout polling buys nothing and costs a tool call —
-and a context rebill — per poll. In measured sessions, roughly
-two-thirds of all wait calls were short polls that timed out.
-
- While you still have local work, do not wait at all. A completed
-  child's final answer is pushed into your mailbox and arrives with
-  your next turn.
- When you are genuinely idle with children outstanding, wait in
-  bounded stretches: `wait_agent` with `timeout_ms` 300000-600000
-  (5-10 minutes). After each stretch — wake or timeout — post one
-  status line, run `list_agents`, and chase any child that finished
-  without reporting. Never stack polls shorter than five minutes; the
-  event subscription wakes a bounded stretch just as fast as a short
-  one.
- Completion mail cannot wake an idle controller (it is delivered
-  without triggering a turn); covering that idle window is
-  `wait_agent`'s only job. A stretch that times out with no activity
-  is your cue to reconcile, not to shorten the next stretch.
-
-## Model routing on spawns
-
-Every `spawn_agent` you issue — including when you are yourself a
-spawned child running a fan-out — sets `model` AND `reasoning_effort`
-explicitly, per the Model Selection rules of the skill you are
-executing. Setting `model` alone is a trap: the child's effort
-silently resets to that model's default, not to yours.
-
-Ask your human partner to add a machine-level backstop to
-`~/.codex/config.toml` so any spawn that slips through still routes to
-a deliberate tier instead of silently inheriting the session's most
-expensive model:
-
-```toml
-[agents]
-default_subagent_model = "<a mid-tier model from your spawn allowlist>"
-default_subagent_reasoning_effort = "medium"
-```
+This enables `spawn_agent`, `wait_agent`, and `close_agent` for skills like `dispatching-parallel-agents` and `subagent-driven-development`. When using subagent-driven-development, close reviewer subagents when their review returns. Keep each implementer subagent open until its task's review passes — the fix loop resumes the implementer — then close it. If your harness cannot send another message to a spawned agent, dispatch each fix round as a fresh implementer carrying the brief, the report file, and the findings.

 ## Environment Detection

--- a/skills/using-superpowers/references/hermes-tools.md
+++ b/skills/using-superpowers/references/hermes-tools.md
@@ -1,56 +0,0 @@
-# Hermes Agent Tool Mapping
-
-Skills speak in actions ("dispatch a subagent", "create a todo", "read a file"). On Hermes Agent these resolve to the tools below.
-
-## Tools
-
-| Action skills request | Hermes tool |
-|---|---|
-| Read a file | `read_file` |
-| Create a new file | `write_file` |
-| Edit a file (targeted patch) | `patch` |
-| Run a shell command | `terminal` |
-| Search file contents | `search_files` |
-| Find files by name | `terminal` with `find` |
-| Fetch a URL / read a webpage | `web_extract(urls=[...])` |
-| Search the web | `web_search(query=...)` |
-| Dispatch a subagent | `delegate_task(goal=..., context=..., toolsets=[...], role="leaf")` |
-| Task tracking | `todo` tool |
-| Invoke a skill | `skill_view("skill-name")` |
-
-## Instructions file
-
-When a skill mentions "your instructions file," on Hermes Agent this is **`AGENTS.md`** in the project directory, or **`SOUL.md`** globally at `~/.hermes/SOUL.md`.
-
-## Invoking a skill
-
-Hermes Agent has a `skills` toolset with `skill_view` and `skills_list` tools.
-To invoke a superpowers skill, use:
-
-```
-skill_view("brainstorming")
-skill_view("test-driven-development")
-```
-
-If `skill_view` cannot find a superpowers skill (it may not appear in the catalog
-until the plugin fully registers it), fall back to reading the SKILL.md directly:
-
-```
-read_file(path="~/.hermes/plugins/superpowers/skills/<skill-name>/SKILL.md")
-```
-
-This fallback is the same mechanism used by other harnesses without native skill loading.
-
-## Subagent dispatch
-
-Use `delegate_task` to spawn isolated subagents for parallel or sequential workstreams:
-
-```
-delegate_task(goal="...", context="...", toolsets=[...], role="leaf")
-```
-
-If `delegate_task` is unavailable, do the work inline rather than inventing tool calls.
-
-## Task tracking
-
-Use the `todo` tool for task tracking within a session. For multi-agent task boards, use `hermes kanban` CLI if available. Treat older `TodoWrite` references as the task-tracking action.
--- a/skills/writing-plans/SKILL.md
+++ b/skills/writing-plans/SKILL.md
@@ -66,9 +66,6 @@ independently testable deliverable.

 **Tech Stack:** [Key technologies/libraries]

-**Spec:** [path to the spec/design doc this plan implements — the plan
-argues from the spec, so the spec travels with it; executors read both]
-
 ## Global Constraints

 [The spec's project-wide requirements — version floors, dependency limits,
--- a/skills/writing-skills/render-graphs.js
+++ b/skills/writing-skills/render-graphs.js
@@ -13,9 +13,9 @@
 * Requires: graphviz (dot) installed on system
 */

-import * as fs from 'fs';
-import * as path from 'path';
-import { execFileSync } from 'child_process';
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');

 function extractDotBlocks(markdown) {
  const blocks = [];
@@ -69,7 +69,7 @@ ${bodies.join('\n\n')}

 function renderToSvg(dotContent) {
  try {
-    return execFileSync('dot', ['-Tsvg'], {
+    return execSync('dot -Tsvg', {
      input: dotContent,
      encoding: 'utf-8',
      maxBuffer: 10 * 1024 * 1024
@@ -107,10 +107,9 @@ function main() {
    process.exit(1);
  }

-  // Check if dot is available. Run the binary directly rather than probing
-  // with `which`, which is not a command on Windows.
+  // Check if dot is available
  try {
-    execFileSync('dot', ['-V'], { stdio: 'ignore' });
+    execSync('which dot', { encoding: 'utf-8' });
  } catch {
    console.error('Error: graphviz (dot) not found. Install with:');
    console.error('  brew install graphviz    # macOS');
--- a/tests/devin/test-devin-plugin.sh
+++ b/tests/devin/test-devin-plugin.sh
@@ -1,63 +0,0 @@
-#!/usr/bin/env bash
-# Validate the Devin CLI integration. `devin plugins install obra/superpowers`
-# reads `.devin-plugin/plugin.json` and auto-discovers the co-located `skills/`
-# directory; Devin CLI surfaces every installed skill's name + description in
-# the system prompt at session start and invokes them via its native `skill`
-# tool, and its system prompt already documents its own tools (subagent
-# profiles, todo tracking, question prompts), so there is no hook, injector,
-# or tool-mapping scaffold to test. What IS Devin-specific is the manifest.
-#
-# Mirrors tests/kimi/test-plugin-manifest.sh. CI-safe: does not require
-# `devin` installed.
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-
-MANIFEST="$REPO_ROOT/.devin-plugin/plugin.json"
-
-fail() { echo "FAIL: $*" >&2; exit 1; }
-
-echo "test-devin-plugin: checking Devin CLI manifest"
-
-# --- Manifest is valid and matches the repo version -------------------------
-[ -f "$MANIFEST" ] || fail "manifest missing at $MANIFEST"
-
-python3 - "$MANIFEST" <<'PY'
-import json
-import sys
-from pathlib import Path
-
-manifest_path = Path(sys.argv[1])
-manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-repo_root = manifest_path.parents[1]
-
-if manifest.get("name") != "superpowers":
-    raise AssertionError(f"plugin name: expected 'superpowers', got {manifest.get('name')!r}")
-
-package = json.loads((repo_root / "package.json").read_text(encoding="utf-8"))
-if manifest.get("version") != package.get("version"):
-    raise AssertionError(
-        f"manifest version {manifest.get('version')!r} != package.json version {package.get('version')!r}"
-    )
-
-# Devin CLI plugins carry skills only (auto-discovered from ./skills/); the
-# manifest supports metadata + dependency lists, nothing executable.
-unsupported = ["skills", "hooks", "commands", "sessionStart", "contextFileName", "inject"]
-present = sorted(field for field in unsupported if field in manifest)
-if present:
-    raise AssertionError("unsupported Devin manifest fields present: " + ", ".join(present))
-
-version_config = json.loads((repo_root / ".version-bump.json").read_text(encoding="utf-8"))
-entries = version_config.get("files")
-if not isinstance(entries, list) or not any(
-    entry.get("path") == ".devin-plugin/plugin.json" and entry.get("field") == "version"
-    for entry in entries
-    if isinstance(entry, dict)
-):
-    raise AssertionError(".version-bump.json must update .devin-plugin/plugin.json version")
-
-print("Devin plugin manifest looks good")
-PY
-
-echo "PASS: Devin CLI plugin valid (manifest)"
--- a/tests/hermes/init.py
+++ b/tests/hermes/init.py
--- a/tests/hermes/conftest.py
+++ b/tests/hermes/conftest.py
@@ -1,30 +0,0 @@
-from pathlib import Path
-
-import pytest
-from unittest.mock import MagicMock
-
-
-@pytest.fixture
-def mock_ctx():
-    ctx = MagicMock()
-    ctx._hooks = {}
-    ctx._skills = {}
-
-    def register_hook(event, fn):
-        ctx._hooks[event] = fn
-
-    def register_skill(name, path):
-        # Mimic hermes' real register_skill, which calls path.exists() and
-        # therefore breaks on a str (the bug that silently disabled the whole
-        # plugin, found 2026-07-23). Keeping that fidelity here means a
-        # regression to str paths fails these tests instead of failing
-        # silently inside hermes.
-        if not isinstance(path, Path):
-            raise AttributeError(
-                f"register_skill requires a pathlib.Path, got {type(path).__name__}"
-            )
-        ctx._skills[name] = path
-
-    ctx.register_hook.side_effect = register_hook
-    ctx.register_skill.side_effect = register_skill
-    return ctx
--- a/tests/hermes/test_bootstrap.py
+++ b/tests/hermes/test_bootstrap.py
@@ -1,98 +0,0 @@
-import importlib
-import os
-import sys
-
-import pytest
-
-sys.path.insert(0, os.path.abspath(
-    os.path.join(os.path.dirname(__file__), "../../.hermes-plugin")
-))
-
-BOOTSTRAP_MARKER = "superpowers:using-superpowers bootstrap for hermes"
-
-# Hermes spills injected context over 10,000 chars to a file, which breaks
-# inline injection semantics. The bootstrap must stay under it with margin.
-HERMES_CONTEXT_SPILL_LIMIT = 10_000
-
-
-def _load():
-    if "__init__" in sys.modules:
-        del sys.modules["__init__"]
-    return importlib.import_module("__init__")
-
-
-def _bootstrap():
-    m = _load()
-    return m._build_bootstrap(m._skills_dir())
-
-
-class TestStripFrontmatter:
-    def test_strips_yaml_block(self):
-        m = _load()
-        content = "---\nname: foo\ndescription: bar\n---\n# Body\nContent here"
-        assert m._strip_frontmatter(content) == "# Body\nContent here"
-
-    def test_no_frontmatter_returns_trimmed_content(self):
-        m = _load()
-        content = "# No frontmatter\nJust content"
-        assert m._strip_frontmatter(content) == "# No frontmatter\nJust content"
-
-    def test_strips_surrounding_whitespace_from_body(self):
-        m = _load()
-        content = "---\nname: foo\n---\n\n\n# Body\n\n"
-        assert m._strip_frontmatter(content) == "# Body"
-
-
-class TestSkillsDirResolution:
-    def test_repo_layout_resolves(self):
-        # The repo checkout IS the git-clone layout: .hermes-plugin/ and
-        # skills/ are siblings, so resolution must succeed from here.
-        m = _load()
-        skills = m._skills_dir()
-        assert os.path.isfile(
-            os.path.join(skills, "using-superpowers", "SKILL.md")
-        )
-
-
-class TestBootstrapContent:
-    def test_marker_and_wrapper(self):
-        content = _bootstrap()
-        assert BOOTSTRAP_MARKER in content
-        assert content.startswith("<EXTREMELY_IMPORTANT>")
-        assert content.rstrip().endswith("</EXTREMELY_IMPORTANT>")
-
-    def test_contains_using_superpowers_body(self):
-        content = _bootstrap()
-        # A distinctive line from the skill body proves the real SKILL.md was
-        # embedded, not a stub.
-        assert "You have superpowers" in content
-        assert "## The Rule" in content
-
-    def test_frontmatter_stripped(self):
-        content = _bootstrap()
-        assert "---\nname:" not in content
-
-    def test_tool_mapping_sourced_from_reference_file(self):
-        m = _load()
-        content = _bootstrap()
-        ref = os.path.join(
-            m._skills_dir(), "using-superpowers", "references", "hermes-tools.md"
-        )
-        with open(ref, encoding="utf-8") as f:
-            ref_text = f.read().strip()
-        # The mapping is included verbatim from the reference file — the
-        # single source, not a drift-prone inline copy.
-        assert ref_text in content
-        assert "read_file" in content
-
-    def test_skill_view_guidance_present(self):
-        content = _bootstrap()
-        assert 'skill_view("superpowers:brainstorming")' in content
-
-    def test_under_hermes_context_spill_limit(self):
-        content = _bootstrap()
-        assert len(content) < HERMES_CONTEXT_SPILL_LIMIT, (
-            f"bootstrap is {len(content)} chars; hermes spills injected "
-            f"context over {HERMES_CONTEXT_SPILL_LIMIT} to a file, which "
-            "breaks inline injection"
-        )
--- a/tests/hermes/test_plugin.py
+++ b/tests/hermes/test_plugin.py
@@ -1,142 +0,0 @@
-import importlib
-import importlib.util
-import os
-import shutil
-import sys
-from pathlib import Path
-
-import pytest
-
-# Point at the plugin directory
-_PLUGIN_DIR = os.path.abspath(
-    os.path.join(os.path.dirname(__file__), "../../.hermes-plugin")
-)
-sys.path.insert(0, _PLUGIN_DIR)
-
-BOOTSTRAP_MARKER = "superpowers:using-superpowers bootstrap for hermes"
-
-
-def _load_plugin():
-    """Re-import plugin module fresh."""
-    if "__init__" in sys.modules:
-        del sys.modules["__init__"]
-    return importlib.import_module("__init__")
-
-
-def _fire_pre_llm(ctx, **kwargs):
-    hook = ctx._hooks["pre_llm_call"]
-    defaults = {
-        "session_id": "s1",
-        "user_message": "hi",
-        "conversation_history": [],
-        "is_first_turn": False,
-        "model": "test-model",
-        "platform": "cli",
-    }
-    defaults.update(kwargs)
-    return hook(**defaults)
-
-
-class TestPluginRegistration:
-    def test_register_attaches_only_pre_llm_call_hook(self, mock_ctx):
-        plugin = _load_plugin()
-        plugin.register(mock_ctx)
-        assert list(mock_ctx._hooks.keys()) == ["pre_llm_call"]
-
-    def test_register_registers_every_stock_skill_as_path(self, mock_ctx):
-        plugin = _load_plugin()
-        plugin.register(mock_ctx)
-        # The conftest mock raises on non-Path (mirroring hermes' real
-        # register_skill), so reaching these asserts proves every
-        # registration passed a pathlib.Path.
-        assert "using-superpowers" in mock_ctx._skills
-        assert "brainstorming" in mock_ctx._skills
-        for name, path in mock_ctx._skills.items():
-            assert isinstance(path, Path)
-            assert path.name == "SKILL.md"
-            assert path.parent.name == name
-            assert path.is_file()
-
-    def test_registered_skills_match_skill_directories(self, mock_ctx):
-        plugin = _load_plugin()
-        plugin.register(mock_ctx)
-        skills_root = plugin._skills_dir()
-        expected = {
-            entry
-            for entry in os.listdir(skills_root)
-            if os.path.isfile(os.path.join(skills_root, entry, "SKILL.md"))
-        }
-        assert set(mock_ctx._skills.keys()) == expected
-
-
-class TestBootstrapInjection:
-    def test_first_turn_returns_bootstrap_context(self, mock_ctx):
-        plugin = _load_plugin()
-        plugin.register(mock_ctx)
-        result = _fire_pre_llm(mock_ctx, is_first_turn=True)
-        assert isinstance(result, dict)
-        content = result["context"]
-        assert BOOTSTRAP_MARKER in content
-        assert content.startswith("<EXTREMELY_IMPORTANT>")
-        assert content.rstrip().endswith("</EXTREMELY_IMPORTANT>")
-
-    def test_later_turns_return_none(self, mock_ctx):
-        plugin = _load_plugin()
-        plugin.register(mock_ctx)
-        assert _fire_pre_llm(mock_ctx, is_first_turn=False) is None
-        assert _fire_pre_llm(mock_ctx, is_first_turn=None) is None
-
-    def test_hook_tolerates_future_kwargs(self, mock_ctx):
-        plugin = _load_plugin()
-        plugin.register(mock_ctx)
-        result = _fire_pre_llm(
-            mock_ctx, is_first_turn=True, telemetry_schema_version=3
-        )
-        assert BOOTSTRAP_MARKER in result["context"]
-
-
-class TestLayoutResolution:
-    def _stage(self, tmp_path, layout):
-        """Copy the plugin module + a minimal skills tree in the given layout."""
-        src_skills = Path(_PLUGIN_DIR).parent / "skills"
-        if layout == "clone":
-            plugdir = tmp_path / "superpowers" / ".hermes-plugin"
-        else:  # flat: module at the plugin dir root, skills nested inside it
-            plugdir = tmp_path / "superpowers"
-        skills = tmp_path / "superpowers" / "skills"
-        plugdir.mkdir(parents=True, exist_ok=True)
-        shutil.copy(Path(_PLUGIN_DIR) / "__init__.py", plugdir / "__init__.py")
-        for skill in ("using-superpowers", "brainstorming"):
-            shutil.copytree(src_skills / skill, skills / skill)
-        return plugdir
-
-    def _load_from(self, plugdir):
-        spec = importlib.util.spec_from_file_location(
-            f"hermes_plugin_test_{plugdir.parent.name}_{plugdir.name}",
-            plugdir / "__init__.py",
-        )
-        mod = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(mod)
-        return mod
-
-    def test_clone_layout_resolves_sibling_skills(self, tmp_path, mock_ctx):
-        # git-clone install: .hermes-plugin/ and skills/ are siblings.
-        plugdir = self._stage(tmp_path, "clone")
-        mod = self._load_from(plugdir)
-        mod.register(mock_ctx)
-        assert "using-superpowers" in mock_ctx._skills
-
-    def test_flat_layout_resolves_nested_skills(self, tmp_path, mock_ctx):
-        # flattened install: module at the plugin dir root, skills/ inside it.
-        plugdir = self._stage(tmp_path, "flat")
-        mod = self._load_from(plugdir)
-        mod.register(mock_ctx)
-        assert "using-superpowers" in mock_ctx._skills
-
-    def test_missing_skills_raises_loudly(self, tmp_path, mock_ctx):
-        plugdir = tmp_path / "superpowers"
-        plugdir.mkdir(parents=True)
-        shutil.copy(Path(_PLUGIN_DIR) / "__init__.py", plugdir / "__init__.py")
-        mod = self._load_from(plugdir)
-        with pytest.raises(RuntimeError, match="cannot find the skills"):
-            mod.register(mock_ctx)
--- a/tests/version-bump/test-bump-version.sh
+++ b/tests/version-bump/test-bump-version.sh
@@ -1,76 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-SCRIPT_SOURCE="$REPO_ROOT/scripts/bump-version.sh"
-TEST_ROOT="$(mktemp -d)"
-
-cleanup() {
-  rm -rf "$TEST_ROOT"
-}
-trap cleanup EXIT
-
-fail() {
-  echo "FAIL: $*" >&2
-  exit 1
-}
-
-make_fixture() {
-  local repo="$1"
-  local yaml_body="$2"
-
-  mkdir -p "$repo/scripts" "$repo/.hermes-plugin"
-  cp "$SCRIPT_SOURCE" "$repo/scripts/bump-version.sh"
-  cat >"$repo/.version-bump.json" <<'JSON'
-{
-  "files": [
-    { "path": "package.json", "field": "version" },
-    { "path": ".hermes-plugin/plugin.yaml", "field": "version" }
-  ],
-  "audit": { "exclude": [] }
-}
-JSON
-  cat >"$repo/package.json" <<'JSON'
-{
-  "name": "fixture",
-  "version": "1.2.3"
-}
-JSON
-  printf '%s\n' "$yaml_body" >"$repo/.hermes-plugin/plugin.yaml"
-}
-
-happy_repo="$TEST_ROOT/happy"
-make_fixture "$happy_repo" $'name: superpowers\nversion: 1.2.3'
-
-/bin/bash "$happy_repo/scripts/bump-version.sh" --check >"$TEST_ROOT/check.out"
-/bin/bash "$happy_repo/scripts/bump-version.sh" --audit >"$TEST_ROOT/audit.out"
-/bin/bash "$happy_repo/scripts/bump-version.sh" 2.3.4 >"$TEST_ROOT/bump.out"
-
-[[ "$(jq -r '.version' "$happy_repo/package.json")" == "2.3.4" ]] \
-  || fail "JSON manifest was not bumped"
-[[ "$(yq -r '.version' "$happy_repo/.hermes-plugin/plugin.yaml")" == "2.3.4" ]] \
-  || fail "YAML manifest was not bumped"
-
-jq -e '
-  any(.files[];
-    .path == ".hermes-plugin/plugin.yaml" and .field == "version")
-' "$REPO_ROOT/.version-bump.json" >/dev/null \
-  || fail "Hermes manifest is not registered"
-
-invalid_repo="$TEST_ROOT/invalid"
-make_fixture "$invalid_repo" $'name: superpowers\nversion: 123'
-cp "$invalid_repo/package.json" "$TEST_ROOT/package.before"
-cp "$invalid_repo/.hermes-plugin/plugin.yaml" "$TEST_ROOT/plugin.before"
-
-if /bin/bash "$invalid_repo/scripts/bump-version.sh" 2.3.4 \
-  >"$TEST_ROOT/invalid.out" 2>&1; then
-  fail "bump accepted a non-string YAML version"
-fi
-
-cmp -s "$TEST_ROOT/package.before" "$invalid_repo/package.json" \
-  || fail "JSON manifest changed before YAML validation failed"
-cmp -s "$TEST_ROOT/plugin.before" "$invalid_repo/.hermes-plugin/plugin.yaml" \
-  || fail "invalid YAML manifest changed"
-
-echo "Version-bump tests passed"
--- a/tests/writing-skills/test-render-graphs.sh
+++ b/tests/writing-skills/test-render-graphs.sh
@@ -1,113 +0,0 @@
-#!/usr/bin/env bash
-set -u
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-SCRIPT_UNDER_TEST="$REPO_ROOT/skills/writing-skills/render-graphs.js"
-NODE_BIN="$(command -v node)"
-
-PASSES=0
-FAILURES=0
-TEST_ROOT="$(mktemp -d)"
-
-cleanup() {
-  rm -rf "$TEST_ROOT"
-}
-trap cleanup EXIT
-
-pass() {
-  echo "  [PASS] $1"
-  PASSES=$((PASSES + 1))
-}
-
-fail() {
-  echo "  [FAIL] $1"
-  FAILURES=$((FAILURES + 1))
-}
-
-assert_contains() {
-  local haystack="$1"
-  local needle="$2"
-  local description="$3"
-
-  if printf '%s' "$haystack" | grep -Fq -- "$needle"; then
-    pass "$description"
-  else
-    fail "$description"
-    echo "    expected to find: $needle"
-  fi
-}
-
-assert_not_contains() {
-  local haystack="$1"
-  local needle="$2"
-  local description="$3"
-
-  if printf '%s' "$haystack" | grep -Fq -- "$needle"; then
-    fail "$description"
-    echo "    did not expect to find: $needle"
-  else
-    pass "$description"
-  fi
-}
-
-fixture="$TEST_ROOT/fixture-skill"
-mkdir -p "$fixture" "$TEST_ROOT/empty-path"
-cat >"$fixture/SKILL.md" <<'EOF'
---
-name: fixture-skill
---
-
-# Fixture Skill
-
-```dot
-digraph fixture_graph {
-  start -> end;
-}
-```
-EOF
-
-echo "Writing-skills render-graphs tests"
-
-missing_dot_output="$(PATH="$TEST_ROOT/empty-path" "$NODE_BIN" "$SCRIPT_UNDER_TEST" "$fixture" 2>&1)"
-missing_dot_status=$?
-
-if [[ "$missing_dot_status" -ne 0 ]]; then
-  pass "missing Graphviz exits non-zero"
-else
-  fail "missing Graphviz exits non-zero"
-fi
-assert_contains "$missing_dot_output" "Error: graphviz (dot) not found." "missing Graphviz reports install guidance"
-assert_not_contains "$missing_dot_output" "ReferenceError: require is not defined" "script runs as an ES module"
-
-render_output="$("$NODE_BIN" "$SCRIPT_UNDER_TEST" "$fixture" 2>&1)"
-render_status=$?
-
-if [[ "$render_status" -eq 0 ]]; then
-  pass "fixture diagram renders"
-else
-  fail "fixture diagram renders"
-  printf '%s\n' "$render_output"
-fi
-
-assert_contains "$render_output" "Found 1 diagram(s)" "reports discovered diagram"
-assert_contains "$render_output" "Rendered: fixture_graph.svg" "reports rendered SVG"
-
-if [[ -f "$fixture/diagrams/fixture_graph.svg" ]]; then
-  pass "writes SVG output"
-else
-  fail "writes SVG output"
-fi
-
-if [[ -f "$fixture/diagrams/fixture_graph.svg" ]] && grep -Fq "<svg" "$fixture/diagrams/fixture_graph.svg"; then
-  pass "SVG output has SVG markup"
-else
-  fail "SVG output has SVG markup"
-fi
-
-echo
-echo "Results: $PASSES passed, $FAILURES failed"
-
-if [[ "$FAILURES" -gt 0 ]]; then
-  exit 1
-fi