merge: v2.7.0 — Research-Grounded Brainstorm (Trigger 0 recon + batched elicitation; 6 Codex rounds, 10 findings)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: copeus

.claude-plugin/marketplace.json

@@ -8,8 +8,8 @@
   "plugins": [
     {
       "name": "superpowers-v",
-      "description": "Compound V for Superpowers: triple parallel pre-flight (code archaeology + domain-expert + Context7 library validator), disjoint partitioning, manifest-driven multi-backend dispatch (Claude + Codex + Antigravity + Cursor), git-diff scope enforcement, crash-resumable runs, adaptive tier-based routing, epic mode, V-memory local-first semantic+lexical recall over docs/superpowers (opt-in pure-python embeddings + a deterministic recall→action bridge), and batched parallel dispatch (Opus default, narrow Sonnet exception)",
-      "version": "2.6.4",
+      "description": "Compound V for Superpowers: triple parallel pre-flight (code archaeology + domain-expert + Context7 library validator), disjoint partitioning, manifest-driven multi-backend dispatch (Claude + Codex + Antigravity + Cursor), git-diff scope enforcement, crash-resumable runs, adaptive tier-based routing, epic mode, research-grounded brainstorming (gated pre-brainstorm recon + batched elicitation), V-memory local-first semantic+lexical recall over docs/superpowers (opt-in pure-python embeddings + a deterministic recall→action bridge), and batched parallel dispatch (Opus default, narrow Sonnet exception)",
+      "version": "2.7.0",
       "source": "./",
       "author": {
         "name": "Oleg",

.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "superpowers-v",
-  "description": "Compound V for Superpowers: triple parallel pre-flight (code archaeology + domain-expert advisor + library/doc validator via Context7), disjoint file partitioning, manifest-driven multi-backend dispatch (Claude + headless Codex + Antigravity + Cursor workers), git-diff scope enforcement, crash-resumable runs, adaptive tier-based routing, epic mode for multi-feature builds, V-memory local-first semantic+lexical recall over docs/superpowers (opt-in pure-python embeddings + a deterministic recall\u2192action bridge), and batched parallel dispatch (Opus default, Sonnet for narrow junior-task carve-out), plus /v:onboard — a project-onboarding command that builds a citation-verified knowledge base + AGENTS.md/CLAUDE.md bridge behind a human gate. Auto-intercepts brainstorming \u2192 writing-plans \u2192 execution transitions.",
-  "version": "2.6.4",
+  "description": "Compound V for Superpowers: triple parallel pre-flight (code archaeology + domain-expert advisor + library/doc validator via Context7), disjoint file partitioning, manifest-driven multi-backend dispatch (Claude + headless Codex + Antigravity + Cursor workers), git-diff scope enforcement, crash-resumable runs, adaptive tier-based routing, epic mode for multi-feature builds, V-memory local-first semantic+lexical recall over docs/superpowers (opt-in pure-python embeddings + a deterministic recall\u2192action bridge), and batched parallel dispatch (Opus default, Sonnet for narrow junior-task carve-out), plus /v:onboard — a project-onboarding command that builds a citation-verified knowledge base + AGENTS.md/CLAUDE.md bridge behind a human gate. Auto-intercepts four transitions: pre-brainstorm recon \u2192 brainstorming \u2192 writing-plans \u2192 execution.",
+  "version": "2.7.0",
   "author": {
     "name": "Oleg",
     "email": "copeus@gmail.com"

.github/workflows/validate.yml

@@ -51,6 +51,35 @@ jobs:
           fi
           echo "✅ versions in lockstep: $pv"
 
+      - name: Verify CHANGELOG top version matches plugin.json (lockstep guard)
+        run: |
+          PLUGIN_VERSION=$(jq -r .version .claude-plugin/plugin.json)
+          # First release heading OUTSIDE fenced code blocks; [Unreleased] (non-numeric) is skipped.
+          # Fences per CommonMark: ``` or ~~~ (≤3 leading spaces); closer = same char, run ≥ opener's.
+          CHANGELOG_VERSION=$(awk '
+            NR==1 { sub(/^\xef\xbb\xbf/, "") }
+            /^ {0,3}(```|~~~)/ {
+              match($0, /(`+|~+)/); c = substr($0, RSTART, 1); len = RLENGTH
+              rest = substr($0, RSTART + RLENGTH)
+              if (!fence) {
+                # a backtick opener whose info string contains a backtick is NOT a fence (CommonMark)
+                if (!(c == "`" && rest ~ /`/)) { fence = 1; fc = c; flen = len }
+              } else if (c == fc && len >= flen && rest ~ /^[ \t]*$/) { fence = 0 }
+              next
+            }
+            !fence && /^ {0,3}##[ \t]+\[[0-9]+\.[0-9]+\.[0-9]+\]/ {
+              match($0, /\[[0-9]+\.[0-9]+\.[0-9]+\]/); print substr($0, RSTART+1, RLENGTH-2); exit
+            }
+          ' CHANGELOG.md)
+          if [ -z "$CHANGELOG_VERSION" ]; then
+            echo "::error::No release heading '## [x.y.z]' found in CHANGELOG.md (outside code fences)."
+            exit 1
+          fi
+          if [ "$PLUGIN_VERSION" != "$CHANGELOG_VERSION" ]; then
+            echo "::error::CHANGELOG top entry ($CHANGELOG_VERSION) != plugin.json version ($PLUGIN_VERSION). Bump plugin.json, marketplace.json AND the CHANGELOG heading together."
+            exit 1
+          fi
+
       - name: Verify agent files have required frontmatter
         run: |
           set -e

.gitignore

@@ -20,3 +20,5 @@ docs/superpowers/_runs/
 # over-broad ignore here would blind enforcement. Un-ignore explicitly to be safe.
 !docs/superpowers/execution/
 !docs/superpowers/memory/
+# Trigger 0 recon docs — defense-in-depth; must stay visible to the scope gate.
+!docs/superpowers/recon/

AGENTS.md

@@ -4,8 +4,9 @@ This file documents how the plugin's content *would* be consumed by tools that r
 
 ## What this plugin does
 
-Compound V is a **sidekick to Superpowers**. It intercepts the three Superpowers phase transitions (brainstorming → writing-plans → execution) and adds:
+Compound V is a **sidekick to Superpowers**. It intercepts the four Superpowers phase transitions (pre-brainstorm recon → brainstorming → writing-plans → execution) and adds:
 
+0. **Gated pre-brainstorm recon (Trigger 0)** 🧪 description-driven, **zero hook backstop** (it fires before any file exists, so no hook can reinforce it — weaker than the other three interception points): before a brainstorm begins on an unfamiliar topic, a gated, bounded research pass (bundled `deep-research` if present, ≤6 parallel WebSearch otherwise, skip-with-notice if neither) writes an anti-anchoring recon doc to `docs/superpowers/recon/` that the brainstorm — and later pre-flights 1B/1C — read first. Gate order: plumbing-skip → V-memory KB hit → `brainstorm.deep_research` config (`ask` default / `auto` / `off` hard kill-switch). Recon is evidence, never a routing input. Also 🧪 description-driven: **batched elicitation** — ≥3 *independent* clarifying questions may batch into one Visual Companion form screen (dependent chains stay sequential; when unsure → sequential); see `skills/compound-v/brainstorm-elicitation.md`.
 1. **Three parallel pre-flights** after brainstorming:
    - Code archaeology (existing-code reality)
    - Domain-expert advisor with three-layer audience search (product/regulatory reality)

CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to **superpowers-v (Compound V)** are documented here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project uses semantic versioning.
 
+## [2.7.0] — 2026-07-10
+
+### Added
+- **Trigger 0 — pre-brainstorm recon** (`skills/compound-v/phase-0-recon.md`): when a brainstorm is about to begin on an unfamiliar topic, a gated, bounded research pass (bundled `deep-research` if present, ≤6 parallel WebSearch otherwise, skip-with-notice if neither) writes an anti-anchoring recon doc to `docs/superpowers/recon/` that the brainstorm — and later pre-flights 1B/1C — read first. Gate order: plumbing-skip → V-memory KB hit → `brainstorm.deep_research` config (`ask` default / `auto` / `off` hard kill-switch). Recon is evidence, never a routing input. Description-driven with zero hook backstop — weaker than Triggers 1–3, documented as such.
+- **Batched elicitation** (`skills/compound-v/brainstorm-elicitation.md`): ≥3 *independent* questions (≤5 groups/screen, never a grid) may batch into ONE Visual Companion form screen — reusing upstream's companion server as-is, only if the user already accepted it this session. Independence is judged on answer interaction; when unsure → sequential. Deliberately overrides upstream's "text questions → terminal" rule for this narrow case, and says so.
+- **`/v:init`**: `brainstorm.deep_research` + `brainstorm.batch_elicitation` policy keys (committed config) and a `deep_research` presence probe (machine-local capabilities cache, advisory only — fire-time listing check is the contract).
+- **CI guard:** CHANGELOG top version must equal `plugin.json` version — closes the bug class where v2.6.4 shipped with both manifests still at 2.6.3 (the bump was written but never committed, and manifest-vs-manifest lockstep can't see it).
+
+### Fixed
+- Pre-flight phase docs 1B/1C now read `docs/superpowers/recon/` before opening new searches (deepen, don't repeat).
+- `skills/compound-v/skill-escalation.md` reconciled with Trigger 0's earlier deep-research use (previously claimed deep-research fires only past 1B/1C).
+
+### Cross-model review (Codex gpt-5.6-sol, 6 rounds, 10 accepted findings)
+- `/v:init` stated `ask`/`auto` unconditionally — now explicitly gate 3 of 3 (plumbing-skip and KB-hit gates named, authority linked).
+- **Epic mode silently bypassed Trigger 0** — per-feature brainstorms now run the recon gate sequence up front; later features converge via the KB-hit gate by design; the autonomous loop is described as the post-spec execution tail.
+- Stale three-phase enumerations (SKILL.md quick-reference heading, plugin/marketplace descriptions) updated to the four-transition reality.
+- The CHANGELOG guard was hardened round-by-round to CommonMark-correct fence handling: opener char+length tracked, closer requires same char + run ≥ opener + only trailing whitespace, a backtick opener with a backtick in its info string is not a fence, headings indented ≤3 spaces are matched with indent-independent version extraction. A 15-fixture adversarial suite was exercised locally; unbalanced fences still fail conservatively (loud, never a false pass).
+
 ## [2.6.4] — 2026-07-10
 
 ### Fixed — Compound V's own audit trail could be silently deleted, and `/v:status` could mislead

README.md

@@ -30,6 +30,8 @@ The fastest way to *get* what this plugin does. Three gamified episodes — **De
 
 - **V-memory** — project memory that builds up as you work: decisions made, bugs fixed, things that failed. It surfaces the relevant bits when you plan or review.
 
+- **Research-grounded brainstorming** 🧪 — before a brainstorm on an unfamiliar topic, a gated, bounded recon pass (off by one config key) writes an evidence doc the brainstorm reads first. And when the brainstorm has 3+ *independent* clarifying questions, it can batch them into one Visual Companion form instead of asking one at a time (dependent questions stay sequential). Both are description-driven guidance, not hook-enforced.
+
 ---
 
 ## Install
@@ -63,7 +65,7 @@ _(Optional)_ Context7 MCP makes the library-docs check sharper: `/plugin install
 
 It detects which model CLIs you have, picks a routing setup, and saves the config.
 
-**2. Then just work.** Describe the feature or start brainstorming as usual — Compound V takes over planning and execution by itself. **There is no command to "launch" the orchestration; it's automatic.**
+**2. Then just work.** Describe the feature or start brainstorming as usual — Compound V takes over planning and execution by itself. On unfamiliar topics it first *offers* a quick pre-brainstorm research pass (gated, bounded, off by one config key) and saves the findings as a recon doc in `docs/superpowers/recon/` for the brainstorm — and the later pre-flights — to read. **There is no command to "launch" the orchestration; it's automatic.**
 
 That's it.
 

commands/v-epic.md

@@ -1,5 +1,5 @@
 ---
-description: Drive an EPIC — chain several features into one autonomous, resumable, dependency-ordered build on a single branch. Each feature runs through the FULL v1.0 pipeline (spec → 3 pre-flights → writing-plans + partition → manifest → dispatch → 3-pass review) in topological order, accumulating onto the current branch. Resume-aware via epic-state.json; ends with a cross-feature integration review and finishing-a-development-branch.
+description: Drive an EPIC — chain several features into one autonomous, resumable, dependency-ordered build on a single branch. Each feature runs through the FULL v1.0 pipeline (recon-gated spec → 3 pre-flights → writing-plans + partition → manifest → dispatch → 3-pass review) in topological order, accumulating onto the current branch. Resume-aware via epic-state.json; ends with a cross-feature integration review and finishing-a-development-branch.
 ---
 
 You are running **`/v:epic`** — the **epic driver** of Compound V. A v1.0 run executes ONE plan (one feature). An **epic** chains several: an ordered set of features, each run through the full v1.0 pipeline, in dependency order, accumulating onto **one branch**. "Build a whole app." It is the same discipline one level up — resumable, topological, no daemon.
@@ -12,7 +12,7 @@ The epic model, run-dir layout, the final integration review, and the honesty bo
 
 1. **Resolve the epic spec.** From `{{args}}`: if it is a path to an epic brief, read it; if it is a described feature set, work from the description. If `{{args}}` is empty, ask the user for the epic brief (or list existing epics under `docs/superpowers/execution/epics/` to resume one). Pick an `<epic-id>` (convention: `YYYY-MM-DD-<slug>`) and an epic **title**, and capture the epic's **acceptance criteria** (used by the final integration review). Agree an **autonomy budget** with the user — `MAX_FEATURES` per `/v:epic` invocation. Seed the default from `.claude/compound-v.json` `epic.max_features` if set (written by [`/v:init`](v-init.md) Step 3c), else **1**: build one feature, then checkpoint; raise it only when the user wants more autonomy per run. An epic is *N full v1.0 runs*, so this is the **human checkpoint cadence** — a *driver policy*, not a script-enforced token meter: by default the loop builds one feature, reports `--stats`, and stops for you to review and re-run.
 
-2. **Decompose + spec every feature UP FRONT — the one interactive phase.** Decompose the product into independent-ish **features**, each a *vertical slice* (`auth`, `api`, `ui`), not a layer; capture cross-feature dependencies in `depends_on` (`api` depends_on `auth`). Then, for **each** feature, run `superpowers:brainstorming` to produce a real **per-feature spec file** (with feature-level Acceptance Criteria), saved to `docs/superpowers/execution/epics/<epic-id>/specs/<feature-id>.md`. This is the **only** human-interactive phase: every spec is written and approved *here*, before the autonomous loop — so the loop never pauses to brainstorm. That batching is what makes the epic genuinely **autonomous** *and* keeps a **real spec per feature** (the central tension, resolved). Write `features.json` = a JSON array of `{id, title, depends_on, spec_path}`, each `spec_path` pointing at its spec file.
+2. **Decompose + spec every feature UP FRONT — the one interactive phase.** Decompose the product into independent-ish **features**, each a *vertical slice* (`auth`, `api`, `ui`), not a layer; capture cross-feature dependencies in `depends_on` (`api` depends_on `auth`). Then, for **each** feature, run `superpowers:brainstorming` to produce a real **per-feature spec file** (with feature-level Acceptance Criteria), saved to `docs/superpowers/execution/epics/<epic-id>/specs/<feature-id>.md`. **Trigger 0 applies to each of these brainstorms:** before each per-feature brainstorm, run the pre-brainstorm recon gate sequence from [`phase-0-recon.md`](../skills/compound-v/phase-0-recon.md) (plumbing-skip → KB-hit → config); later features in the same epic increasingly skip via the KB-hit gate as earlier recon/audit docs accumulate — designed behavior, not a bypass. This is the **only** human-interactive phase: every spec is written and approved *here*, before the autonomous loop — so the loop never pauses to brainstorm. That batching is what makes the epic genuinely **autonomous** *and* keeps a **real spec per feature** (the central tension, resolved). Write `features.json` = a JSON array of `{id, title, depends_on, spec_path}`, each `spec_path` pointing at its spec file.
 
 3. **Review the decomposition, then init (specs enforced).**
    - **Gate the feature DAG before building** (one level up from partition-review): `python3 scripts/compound-v-epic-state.py --lint --features docs/superpowers/execution/epics/<epic-id>/features.json` flags structural smells (an **ISLAND** feature with no deps *and* no dependents = a likely missed dependency; an **over-coupled** feature depending on most others = a layer, not a slice) plus any hard validation error. Then **critique it yourself**: are these real vertical slices, are `depends_on` correct *and complete*? A missing edge means a feature builds before its prerequisite. Fix `features.json` until lint is clean and the split is sound — a weak decomposition is the #1 way an epic fails downstream.
@@ -35,7 +35,7 @@ The epic model, run-dir layout, the final integration review, and the honesty bo
      It prints `{"feature": <feature|null>, "reason": "runnable|epic complete|epic blocked: …|epic needs reconcile: …"}`. A feature is runnable when it is `pending` and **all** its `depends_on` are `done`, returned in topological order. The loop is **fail-fast**: any `failed` feature halts the whole epic (even independent pending features wait) until reconciled — `--next` will not route around a failure.
    - **If `feature` is non-null** (`reason == "runnable"`):
      1. **Choose the run-id, then mark it running WITH that run-id.** Pick the feature's run-id up front (convention `<epic-id>-<feature-id>`) — it names the v1.0 run dir — and record it **now**: `compound-v-epic-state.py --update --feature <id> --status running --run-id <run-id> --state <epic-state.json>`. Recording `run_id` at *running* time (not only on done/failed) is what makes a **mid-run crash recoverable** via `/v:resume <run-id>` (step 7); a `running` feature with a null `run_id` has nothing to resume.
-     2. **Run that ONE feature through the full v1.0 pipeline on the current branch** — exactly as a standalone feature, reusing everything:
+     2. **Run that ONE feature through the v1.0 pipeline's post-spec execution tail on the current branch** — exactly as a standalone feature, reusing everything (Trigger 0 recon and brainstorming already ran up front in step 2; the loop never repeats them):
         - **Read the feature's already-approved spec** (`spec_path` from step 2). The loop does **not** brainstorm — specs were batched + approved up front, so this stage is non-interactive.
         - The **three pre-flights** in parallel (1A archaeology ∥ 1B domain ∥ 1C library) per [`SKILL.md`](../skills/compound-v/SKILL.md). A 🔴 critical finding HALTs this feature.
         - `superpowers:writing-plans` + **Phase-2 Partition Map** ([`phase-2-disjoint-partitioning.md`](../skills/compound-v/phase-2-disjoint-partitioning.md)).