docs: describe the :; label-line wrapper mechanism (#571)

bash >= 5.1 writes heredocs into a pipe pre-fork; under macOS pipe
pressure the kernel hands out 512-byte pipes and the wrapper's 1.4KB
CMDBLOCK heredoc deadlocks every hook. Label lines parse nowhere:
cmd.exe skips them as labels, POSIX shells exec away before the batch
block. Also: silent fail-open when bash or the script name is missing,
and CDPATH-proof directory resolution.

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

.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)

.hermes-plugin/plugin.yaml

@@ -1,6 +0,0 @@
-name: superpowers
-version: 6.2.0
-description: Superpowers skills and workflow bootstrap for Hermes Agent
-author: obra
-provides_hooks:
-  - pre_llm_call

.version-bump.json

@@ -1,7 +1,6 @@
 {
   "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" },

README.md

@@ -30,7 +30,7 @@ Superpowers is a complete software development methodology for your coding agent
 
 ## 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), [Hermes Agent](#hermes-agent), [Kimi Code](#kimi-code), [OpenCode](#opencode), [Pi](#pi).
+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
 
@@ -218,18 +218,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.

docs/porting-to-a-new-harness.md

@@ -745,8 +745,10 @@ single file that's valid as both a Windows batch script and a Unix shell script.
 On Windows, `cmd.exe` runs the batch portion, which locates `bash` (Git for
 Windows, then `bash` on PATH) and runs the named hook script; if no bash is
 found it exits cleanly so the harness still works, just without injection. On
-Unix, the leading `:` makes the batch block a no-op and the shell runs the
-script directly.
+Unix, the shell executes the leading `:;` lines and `exec`s the hook script
+before reaching the batch block (cmd.exe skips those lines as labels).
+Heredocs are banned throughout hooks/ — see issue #571 and the fence test
+`tests/hooks/test-no-heredocs-in-hooks.sh`.
 
 Two rules this enforces, which you must respect:
 

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.

docs/superpowers/specs/2026-07-30-codex-efficiency-fixes-design.md

@@ -1,252 +0,0 @@
-# Codex Efficiency Fixes — Design
-
-Date: 2026-07-30
-Status: approved by Jesse (in-session)
-Branch: `codex-efficiency-fixes` off `dev`
-
-## Sources
-
-- Eval campaign closeout: `superpowers-autoresearch/reports/2026-07-codex-efficiency-campaign.md`
-  (treatment table §4; every treatment below has a scorer and a measured
-  `dev` baseline).
-- Codex source recon: `superpowers-autoresearch/docs/2026-07-29-codex-multiagent-v2-capabilities.md`
-  (file:line citations against the Codex CLI source; grounds T2, T3, T5).
-- Published experiment write-ups: `superpowers-evals/docs/experiments/`.
-- Drew's spinout stack (PRs #2036, #2035) is **evidence, not adopted text**:
-  Jesse wants to dig into those fixes in more detail before adopting any
-  of them; they inform the problem statements only.
-
-## Goal
-
-Ship the five evidence-strong treatments from the codex-efficiency eval
-campaign as superpowers skill/doc changes, each graded against its
-pre-registered criterion by the campaign's scorers before its PR is cut.
-Phase 2 (everything else in the closeout treatment table) follows, each
-item gated on new baseline work first.
-
-## Scope decisions (settled with Jesse)
-
-- **Phase 1 = the evidence-strong five** (T1–T5 below). Phase 2 items
-  each need a failing baseline before any fix ships (discrimination
-  rule: inconclusive-by-zero is a stop).
-- **One branch, PR per treatment.** Development and batteries happen on
-  `codex-efficiency-fixes`; when a treatment beats its criterion, it is
-  cut into its own PR against `dev` with its eval evidence. No merge
-  without Jesse's per-PR approval.
-- **T4 ships cross-harness with a global regression battery** (Claude
-  Code, Codex, Gemini), variant C shape: ceremony scales, approval never
-  does.
-
-## The five treatments
-
-### T1. SDD worker-review prohibition
-
-**Evidence:** 9/9 depth-2 spawns across 4 corpora were implementer-issued
-reviewers; all 9 were same-task duplicates of the review the controller
-dispatches anyway. The dispatch contract never says review is not the
-worker's job; "self-review" in the implementer prompt gets reified into a
-reviewer subagent on harnesses where children can spawn (Codex).
-
-**Changes:**
-- `skills/subagent-driven-development/implementer-prompt.md`: an explicit
-  "You do not dispatch subagents" clause — self-review means reading your
-  own diff; the controller owns all review dispatch; a reviewer you spawn
-  duplicates a review the process already provides.
-- `skills/subagent-driven-development/SKILL.md`: one dispatch-contract
-  line in the task loop, plus a Red Flags row: "An independent review
-  would strengthen my report" → review is the controller's next step;
-  your reviewer is a duplicate seat.
-- Harness-agnostic wording (no-op where children cannot spawn).
-
-**Graded by:** `score_e6.py` (depth-2 spawns by spawner role, duplicate
-review families); `score_e5.py` for the same-scope variant.
-**Baseline:** 9/9 worker-issued, 0 counter-examples.
-**Criterion:** 0 worker-issued depth-2 spawns AND review coverage
-preserved (every task still gets exactly one controller-dispatched task
-review).
-
-### T2. Event-driven waiting
-
-**Evidence:** 60–78% of `wait_agent` calls time out in every corpus
-(dev 67.1%, spinout 60.2%). Source recon: V2 waits are event
-subscriptions, not polls — one long wait has the same wake latency as a
-10s poll at ~1/90th the calls; a completed child's FINAL_ANSWER is pushed
-into the parent's mailbox and drained into the next model request with no
-wait at all.
-
-**Changes** (`skills/using-superpowers/references/codex-tools.md`):
-- Never short-timeout poll.
-- While local work remains, do not wait — child results arrive with your
-  next turn via the mailbox.
-- When genuinely idle, issue ONE `wait_agent` with a long `timeout_ms`
-  (900000+; harness max 3600000).
-- V2 caveat stated: completion mail carries `trigger_turn=false` and will
-  not wake an idle controller — that is the one job `wait_agent` has.
-
-**Graded by:** `score_e7.py` (timeout rate, inter-poll cadence,
-cache-rebill estimate — the rebill figure stays labeled as an estimate).
-**Baseline:** dev 67.1% timeout rate.
-**Criterion:** timeout rate < 25% with no loss of task completion.
-
-### T3. codex-tools.md corrections
-
-**Evidence:** five claims in the current guidance are contradicted by the
-Codex source (all file:line-cited in the capabilities doc):
-1. `close_agent` does not exist in multi-agent V2 (V1-only). V2 LRU-evicts
-   finished children automatically; not closing costs nothing;
-   `followup_task` transparently reloads an evicted child.
-2. Fix rounds can always resume the implementer via `followup_task` —
-   dev's "if your harness cannot send another message to a spawned agent,
-   dispatch each fix round as a fresh implementer" branch is dead on V2.
-3. Role files (`~/.codex/agents/**.toml`) DO attach to spawns via
-   `agent_type` on isolated forks (0.145+).
-4. Full-history forks accept `model`/`reasoning_effort` overrides; only
-   `agent_type` is refused. (Isolated forks remain the SDD guidance for
-   context-hygiene reasons, stated accurately.)
-5. Dispatch guidance must never name non-V2 model presets — the V2 spawn
-   allowlist is v2 presets only; others hard-error.
-
-**Changes:** rewrite the multi-agent paragraph of
-`skills/using-superpowers/references/codex-tools.md` to be
-version-honest (V1 vs V2 behavior labeled where they differ).
-
-**Graded by:** source citation (already verified); no scorer regressions
-on the shared battery. `score_e8.py` is retained as a V1/V2 schema
-detector, not a hygiene grader — no `close_agent` checklist ships.
-
-### T4. Brainstorming three-path router (variant C: approval always)
-
-**Evidence:** micro — the current HARD-GATE text pushes a bounded task to
-FULL ceremony 5/5, while Z-null (no guidance) and a three-path router
-both differentiate 5/5: the absolute wording suppresses discrimination
-the model draws natively. FULL battery — ceremony volume scales
-moderately (16.7 vs 24.0 tool calls, bounded vs arch), but the
-two-document ritual (spec file → plan file) ran unconditionally in every
-rep. The measured waste is the unconditional artifact ritual, not the
-approval gate.
-
-**Design (variant C):** three paths scale the ARTIFACT; every path keeps
-human approval before implementation:
-- **Spike** (feasibility question, explicitly throwaway): present the
-  question and the intended probe in 2–3 sentences, get a nod, go. No
-  docs. Findings return as a recommendation; anything built stays labeled
-  throwaway.
-- **Bounded** (well-scoped change to an existing, understood flow):
-  present a short design in chat, get approval, implement. No spec file,
-  no writing-plans invocation.
-- **Architectural** (restructures components, new subsystem, public
-  interface change): the full current flow — spec doc, review,
-  writing-plans.
-
-**Guards (all ship with the router):**
-- Classification is said out loud ("this looks bounded, so I'll present a
-  short design here rather than write a spec") so the human can override.
-- When in doubt between two paths, take the heavier one.
-- One-way ratchet: hidden complexity discovered mid-path upgrades the
-  path; never downgrade mid-task.
-- New Red Flags rows targeting classification-as-escape-hatch ("I'll call
-  it bounded to skip the doc").
-
-**Changes** (`skills/brainstorming/SKILL.md`): HARD-GATE keeps "no
-implementation before approval" and drops "regardless of perceived
-simplicity" as the ceremony driver; anti-pattern section reframed (the
-sin is skipping approval, not skipping documents); checklist steps 6–9
-become the architectural path; process-flow graph gains the router; Red
-Flags rows added. This is carefully-tuned content — the edit follows
-writing-skills methodology and ships only with the full eval evidence
-below.
-
-**Graded by (three layers):**
-1. **Micro** (`ceremony-path-micro.py`, adapted): variant C literal text,
-   plus adversarially ambiguous briefs the campaign never tested (a task
-   that pattern-matches bounded but hides a public interface change).
-   Criteria: spike/bounded/arch differentiate (≥4/5 per cell); ambiguous
-   briefs escalate to FULL (≥4/5); arch never downgrades (5/5).
-2. **Codex ceremony battery:** `cx-ceremony-{spike,bounded,arch}` on the
-   fix arm, 3 reps each, `score_e4.py` census. Criteria: bounded reps
-   show an approval turn but zero committed spec files and zero
-   writing-plans ritual; arch reps keep the full two-doc flow; spike reps
-   stay minimal.
-3. **Global regression battery:** the same three ceremony scenarios on
-   Claude Code and Gemini (rig work: those scenarios are currently
-   codex-gated), 3 reps each; plus the triggering acceptance check
-   ("Let's make a react todo list" auto-triggers brainstorming into the
-   full/architectural path) on all three harnesses.
-
-### T5. Explicit model on child-issued spawns
-
-**Evidence:** root spawns are 100% explicit-model at CLI 0.146 (dev
-14/14); the live gap is depth-2 — 2/2 child-issued spawns omitted
-`model`. Source recon: `model` without `reasoning_effort` resets effort
-to the MODEL's default, not the parent's.
-
-**Changes** (`skills/using-superpowers/references/codex-tools.md`):
-- Every spawn you issue — including as a child — sets `model` AND
-  `reasoning_effort`; the effort-reset trap is named.
-- Advise `[agents].default_subagent_model` and
-  `[agents].default_subagent_reasoning_effort` in `~/.codex/config.toml`
-  as the machine-level backstop for anything that slips through.
-
-**Graded by:** `score_e1.py` (per-spawn explicit-model rate, by depth) on
-the shared battery.
-**Baseline:** depth-2: 0/2 explicit.
-**Criterion:** every spawn at every depth carries explicit model +
-effort. Pre-registered caveat: if T1 eliminates depth-2 spawns entirely,
-T5 grades as root-spawn regression (hold 100%) plus doc correctness and
-is recorded inconclusive-by-zero at depth-2 — the config backstop is then
-the operative mechanism.
-
-## Grading plan
-
-- **Shared SDD battery** carries T1, T2, T5: `cx-sdd-small`, fix-branch
-  arm (`/tmp/sp-arm-fix`), 8 reps across both container lanes. Dev
-  baselines are already measured; no baseline re-runs.
-- **T4 batteries** as listed above (micro + codex ceremony + global
-  regression).
-- **Pre-registration:** every battery gets a hypothesis-log entry
-  (prediction, scorer, criterion) in
-  `superpowers-autoresearch/logs/2026-07-30-codex-efficiency-fixes.md`
-  BEFORE it runs. Standing rules carry over: append-only log, manual
-  inspection of scorer matches on fix-arm runs (non-circular
-  verification), no raw rollouts committed, correctness rides beside
-  cost in every verdict.
-- **Attribution:** orthogonal scorers on one combined branch; unexpected
-  regressions bisect by treatment commit.
-- **Budget:** shared battery ~$40, codex ceremony ~$40, global
-  regression ~$40–80, micros ~$5 → phase 1 ≈ $150–200 of the ~$850
-  remaining from the campaign's $1000.
-
-## Process
-
-- Work happens in the `codex-efficiency-fixes` worktree (branched off
-  `dev`); execution via subagent-driven-development from a written plan.
-- Skill-text changes follow writing-skills methodology.
-- Scenario/rig changes (un-gating ceremony scenarios for Claude
-  Code/Gemini, adversarial micro briefs) land in `superpowers-evals`
-  main, as authorized.
-- PR-per-treatment against `dev`, each with its eval evidence and the
-  standard identification block; merges only on Jesse's per-PR approval.
-
-## Phase 2 queue (baseline-first; not in this plan's tasks)
-
-Each item requires a failing baseline before any fix ships:
-1. **Dispatch routing / long-session drift** — needs a long-session
-   elicitation rig (fresh sessions don't reproduce the pathology at CLI
-   0.146). Drew's stack informs the treatment shape.
-2. **Verification leases / evidence receipts** — needs the
-   substring-aware duplicate counter added to `score_e3.py` first
-   (current baseline 1/23 exact-string pairs is too weak).
-3. **Remediation cap** — small-n baseline (2/3 reps) needs more reps.
-4. **Cross-task-race probe redesign** — `score_e5.py`'s probe is
-   inconclusive-by-zero by design tradeoff; needs a stronger probe.
-5. **E5 D4 shell-command parser** — fix-review-scope classifier cannot
-   parse compound commands; scorer work, not skill work.
-
-## Out of scope
-
-- Adopting Drew's spinout stack (#2036/#2035) or its text.
-- RoboRev, Codex token telemetry (separate codebases).
-- A `close_agent` hygiene checklist (V2 has no such tool — closed as
-  do-not-ship in the campaign).
-- Claude Code/Gemini-specific efficiency treatments beyond the T4
-  regression battery.

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.

docs/windows/polyglot-hooks.md

@@ -65,9 +65,9 @@ The path is quoted because `${CLAUDE_PLUGIN_ROOT}` may contain spaces.
 
 ## How `run-hook.cmd` Works at a High Level
 
-`run-hook.cmd` is a polyglot script: Windows treats the first block as batch
-commands, while Unix shells treat that block as a no-op heredoc and continue
-after it.
+`run-hook.cmd` is a polyglot script: its first lines start with `:;`, which
+cmd.exe skips as labels and Unix shells execute — the shell execs the hook
+before ever reaching the batch block that Windows runs.
 
 Do not copy an implementation from this document. Read `hooks/run-hook.cmd`
 directly when changing the dispatcher, and run `tests/hooks/test-session-start.sh`
@@ -89,10 +89,14 @@ afterward.
 
 ### How it works on Unix (bash/sh)
 
-1. `: << 'CMDBLOCK'` opens a heredoc on a no-op command.
-2. The entire CMD batch block is consumed by the heredoc and ignored.
-3. After `CMDBLOCK`, bash resolves the script directory and `exec`s the named
-   extensionless script directly.
+1. Each leading `:;` line is a no-op label to cmd.exe but real commands to a
+   POSIX shell.
+2. The shell checks bash exists (silent exit 0 if not), resolves the script
+   directory CDPATH-proof, and `exec`s the named extensionless script — it
+   never reads the batch block at all.
+3. Heredocs are banned in this file and all hooks/ executables (issue #571:
+   bash >= 5.1 pre-fork pipe writes deadlock on macOS under pipe pressure);
+   `tests/hooks/test-no-heredocs-in-hooks.sh` enforces the ban.
 
 ### Key design decisions
 

hooks/run-hook.cmd

@@ -1,8 +1,20 @@
-: << 'CMDBLOCK'
+:; command -v bash >/dev/null 2>&1 || exit 0
+:; [ $# -ge 1 ] || exit 0
+:; SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+:; SCRIPT_NAME="$1"; shift; exec bash "${SCRIPT_DIR}/${SCRIPT_NAME}" "$@"
 @echo off
 REM Cross-platform polyglot wrapper for hook scripts.
-REM On Windows: cmd.exe runs the batch portion, which finds and calls bash.
-REM On Unix: the shell interprets this as a script (: is a no-op in bash).
+REM On Unix: POSIX shells execute the ":;" lines above and exec away before
+REM reaching this batch block (":" is a no-op; cmd.exe treats lines starting
+REM with ":" as labels and skips them). If bash or the script name is
+REM missing, the wrapper exits 0 silently - hooks are optional context, never
+REM a session breaker.
+REM On Windows: cmd.exe runs this batch portion, which finds and calls bash.
+REM
+REM Heredocs are banned in this file and every hooks/ executable: bash 5.1+
+REM delivers them via a pre-fork pipe write that deadlocks on macOS under
+REM pipe pressure (issue #571). tests/hooks/test-no-heredocs-in-hooks.sh is
+REM the fence.
 REM
 REM Hook scripts use extensionless filenames (e.g. "session-start" not
 REM "session-start.sh") so Claude Code's Windows auto-detection -- which
@@ -35,12 +47,4 @@ if %ERRORLEVEL% equ 0 (
 )
 
 REM No bash found - exit silently rather than error
-REM (plugin still works, just without SessionStart context injection)
 exit /b 0
-CMDBLOCK
-
-# Unix: run the named script directly
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-SCRIPT_NAME="$1"
-shift
-exec bash "${SCRIPT_DIR}/${SCRIPT_NAME}" "$@"

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)
 

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:**
 

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

skills/subagent-driven-development/SKILL.md

@@ -154,10 +154,7 @@ 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:

skills/subagent-driven-development/task-reviewer-prompt.md

@@ -84,13 +84,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:

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
 

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.

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,

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');

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

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"
-        )

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)

tests/hooks/test-no-heredocs-in-hooks.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Heredocs are banned from the hook delivery chain: bash >= 5.1 delivers
+# them through a pre-fork pipe write that deadlocks on macOS under pipe
+# pressure (issue #571; the #571 class). This fence fails the moment one
+# returns. The operator is spelled out of a variable so this file does not
+# trip its own check.
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+
+OP='<''<'
+FAILURES=0
+for f in "$REPO_ROOT"/hooks/*; do
+    case "$f" in *.json) continue;; esac
+    [ -f "$f" ] || continue
+    if hits="$(grep -nE "$OP" "$f")"; then
+        echo "  [FAIL] heredoc operator in ${f#"$REPO_ROOT"/}:"
+        printf '%s\n' "$hits" | sed 's/^/    /'
+        FAILURES=$((FAILURES + 1))
+    else
+        echo "  [PASS] ${f#"$REPO_ROOT"/} is heredoc-free"
+    fi
+done
+
+if [ "$FAILURES" -gt 0 ]; then
+    echo "STATUS: FAILED ($FAILURES file(s))"
+    exit 1
+fi
+echo "STATUS: PASSED"

tests/hooks/test-session-start.sh

@@ -184,6 +184,15 @@ assert_command_output \
     CLAUDE_PLUGIN_ROOT="$REPO_ROOT" \
     bash "$WRAPPER_UNDER_TEST" session-start
 
+# With no bash available, the wrapper must fail open: silent, exit 0.
+if output="$(env -i PATH=/nonexistent /bin/sh "$WRAPPER_UNDER_TEST" session-start 2>&1)" \
+   && [ -z "$output" ]; then
+    pass "wrapper with no bash on PATH is silent and exits 0"
+else
+    fail "wrapper with no bash on PATH is silent and exits 0"
+    printf '%s\n' "$output" | head -3 | sed 's/^/    /'
+fi
+
 cursor_home="$(make_home cursor)"
 assert_command_output \
     "Cursor emits top-level additional_context only" \

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"

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