From 2766e7c45534369f5b1592644a7152ead0acdac0 Mon Sep 17 00:00:00 2001
From: Brian Madison <bmadcode@gmail.com>
Date: Sat, 30 May 2026 10:35:39 -0500
Subject: [PATCH] Initial draft: brainstorming improved

---
 .../bmad-brainstorming/.decision-log.md       | 230 ++++++++++
 src/core-skills/bmad-brainstorming/SKILL.md   |  88 +++-
 .../assets/brain-methods.csv                  | 101 +++++
 .../assets/techniques/six-thinking-hats.md    |  14 +
 .../bmad-brainstorming/brain-methods.csv      |  62 ---
 .../bmad-brainstorming/customize.toml         |  80 ++++
 .../bmad-brainstorming/references/headless.md |  54 +++
 .../bmad-brainstorming/scripts/brain.py       | 150 +++++++
 .../scripts/tests/test_brain.py               | 113 +++++
 .../steps/step-01-session-setup.md            | 214 ----------
 .../steps/step-01b-continue.md                | 124 ------
 .../steps/step-02a-user-selected.md           | 229 ----------
 .../steps/step-02b-ai-recommended.md          | 239 -----------
 .../steps/step-02c-random-selection.md        | 211 ---------
 .../steps/step-02d-progressive-flow.md        | 266 ------------
 .../steps/step-03-technique-execution.md      | 403 ------------------
 .../steps/step-04-idea-organization.md        | 305 -------------
 .../bmad-brainstorming/template.md            |  15 -
 .../bmad-brainstorming/workflow.md            |  53 ---
 19 files changed, 828 insertions(+), 2123 deletions(-)
 create mode 100644 src/core-skills/bmad-brainstorming/.decision-log.md
 create mode 100644 src/core-skills/bmad-brainstorming/assets/brain-methods.csv
 create mode 100644 src/core-skills/bmad-brainstorming/assets/techniques/six-thinking-hats.md
 delete mode 100644 src/core-skills/bmad-brainstorming/brain-methods.csv
 create mode 100644 src/core-skills/bmad-brainstorming/customize.toml
 create mode 100644 src/core-skills/bmad-brainstorming/references/headless.md
 create mode 100644 src/core-skills/bmad-brainstorming/scripts/brain.py
 create mode 100644 src/core-skills/bmad-brainstorming/scripts/tests/test_brain.py
 delete mode 100644 src/core-skills/bmad-brainstorming/steps/step-01-session-setup.md
 delete mode 100644 src/core-skills/bmad-brainstorming/steps/step-01b-continue.md
 delete mode 100644 src/core-skills/bmad-brainstorming/steps/step-02a-user-selected.md
 delete mode 100644 src/core-skills/bmad-brainstorming/steps/step-02b-ai-recommended.md
 delete mode 100644 src/core-skills/bmad-brainstorming/steps/step-02c-random-selection.md
 delete mode 100644 src/core-skills/bmad-brainstorming/steps/step-02d-progressive-flow.md
 delete mode 100644 src/core-skills/bmad-brainstorming/steps/step-03-technique-execution.md
 delete mode 100644 src/core-skills/bmad-brainstorming/steps/step-04-idea-organization.md
 delete mode 100644 src/core-skills/bmad-brainstorming/template.md
 delete mode 100644 src/core-skills/bmad-brainstorming/workflow.md

diff --git a/src/core-skills/bmad-brainstorming/.decision-log.md b/src/core-skills/bmad-brainstorming/.decision-log.md
new file mode 100644
index 000000000..4fc0a78d9
--- /dev/null
+++ b/src/core-skills/bmad-brainstorming/.decision-log.md
@@ -0,0 +1,230 @@
+# Decision Log — bmad-brainstorming rebuild
+
+Canonical memory for the rebuild of `bmad-brainstorming` from the legacy numbered-micro-file
+architecture into the outcome-driven pattern of bmad-product-brief / bmad-prd / bmad-ux.
+
+## Session 2026-05-30
+
+**Intent:** Edit / rebuild existing skill (in place at `src/core-skills/bmad-brainstorming`).
+
+**Classification:** Simple Workflow with one quarantine carve-out. Customizable = yes.
+
+### Load-bearing decisions
+
+- **Single intent: pure facilitation + continuation.** No create/update/validate split (that pattern fits
+  document skills; brainstorming is a facilitated session). The skill facilitates a live session and can
+  resume a prior one. Decided with user.
+- **The running log is the memory AND the continuation state.** One terse, append-only session file holds the
+  goal, the techniques selected, and every idea the user generates/accepts. Kept deliberately lean to minimize
+  context cost; the final artifacts are produced from it. Borrowed shape from Obra Superpowers' append-only
+  event log (one entry per line). User: "very succinct as memory, just enough to minimize context."
+- **HARD RULE — the LLM never supplies its own ideas in interactive mode.** Its job is to draw ideas out of the
+  user and push past the obvious. If the user explicitly asks for an idea, give ONE as a one-off, then
+  immediately return to pushing the user. This inverts a default LLM behavior, so it earns forceful statement
+  with rationale. User-stated, emphasized.
+- **Headless is the ONLY context where the LLM brainstorms on its own.** Given just a topic, headless runs the
+  techniques itself and produces the artifacts. Because it inverts the central no-own-ideas rule, ALL headless
+  instructions live in `references/headless.md` and are never loaded in normal mode — quarantined so they can't
+  bleed into and corrupt the interactive posture. User's explicit requirement.
+- **Technique selection: AI-led, others on request.** Facilitator reads the goal and proposes a fitting
+  technique by default; "browse the library", "surprise me" (random), and "start broad then narrow"
+  (progressive) are always available but never a forced numbered-menu gate. Builder recommended; user accepted
+  ("show what you recommend and why").
+- **Finalize → imaginative HTML, no template.** Instruction directs the LLM to be genuinely creative and
+  whimsical, matched to the spirit of *this* session — sections per technique, creative visualizations, the
+  summary rendered as it all came together. Explicitly NO template/scaffold (rejected Obra's CSS-class kit).
+  User: pure per-session creativity.
+- **Optional second artifact: succinct brainstorm-intent doc.** User's choice at finalize. Short, sharp, just
+  the chosen/critical discoveries — clean input for a downstream skill (product-brief, prd) without report
+  bloat. This is the dual-output distillate pattern.
+
+- **Synthesis is two-move and is the one interactive moment the LLM adds its own thinking.** First reflect a
+  sampling of the user's own ideas back (including surprising/random ones from across the session) and let THEM
+  hunt for conclusions/synergies/themes/what-matters. THEN the LLM leans in creatively to surface the
+  non-obvious connections the user wouldn't spot right away. The no-own-ideas rule is therefore scoped
+  explicitly to the *generative* phase so synthesis doesn't collide with it. User refinement.
+- **The log is the load-bearing artifact; artifacts are derivations.** "From the decision log we can create any
+  artifact the user wants for any purpose, with nothing lost." HTML + intent doc are two derivations; others
+  available on request. (User flagged a future cross-cutting task: retune other skills' `.decision-log.md` to
+  this same lean append-only standard — NOT part of this build.)
+
+- **Extensible technique library via customize.toml** (new capability the static-CSV architecture never had).
+  Two scalars: `favorite_techniques` (names the facilitator proposes first when they fit, AI-led default) and
+  `additional_techniques` (array-of-tables mirroring the CSV shape `category`/`technique_name`/`description` —
+  adds whole new techniques AND categories without editing the shipped CSV). Both append-merge so team + user
+  files each contribute. Wired into SKILL.md `## Choosing Techniques` (proposing/browse/random/progressive all
+  treat additions as first-class) and into headless.md selection. User idea, added post-build.
+
+### Borrowed from Obra Superpowers brainstorming skill (researched)
+
+- **One-question/prompt-per-message** as a hard rule — keeps the human in active generation, operationalizes
+  "push their creative muscles."
+- **Append-only lean log** as continuation memory.
+- Rejected: AI-recommends-approaches / convergent-funnel posture, graphviz state machine, CSS HTML kit — all
+  off-pattern or inject AI ideas.
+
+### Surviving from legacy version
+
+- `brain-methods.csv` (technique library) → kept as a swappable asset (`{workflow.brain_methods}`).
+- Anti-bias protocol (shift creative domain every ~10 ideas) and quantity goal (100+ collaboratively developed
+  ideas, stay in generative mode) → kept as facilitation posture, stripped of emoji/MANDATORY/SUCCESS-METRICS
+  ceremony.
+
+### Planned file tree
+
+```
+bmad-brainstorming/
+├── SKILL.md                 # Overview, Conventions, Activation, facilitation posture, technique flow, running log, finalize
+├── customize.toml           # output_dir/folder, brain_methods path, activation hooks, persistent_facts
+├── references/
+│   └── headless.md          # QUARANTINED autonomous mode (the one place the LLM brainstorms itself)
+└── assets/
+    └── brain-methods.csv     # technique library (carried over)
+```
+
+Legacy files to remove on build: `workflow.md`, `template.md`, `steps/` (8 numbered step files).
+
+### Adversarial review (3 parallel lenses) + fixes applied
+
+Ran a Workflow with three review lenses (over-prescription, facilitation-integrity, BMad-conventions) against
+the build. Fixes applied:
+
+- **[HIGH, fixed] Headless detection seam.** The "first message pre-supplies a topic and asks for artifacts"
+  trigger collided with a normal interactive opening ("brainstorm X and give me the HTML"), risking a present
+  human flipping the skill into self-generation. Made human-presence the dominant gate in both SKILL.md
+  activation step 4 and headless.md Detection; dropped the weak payload-shape trigger entirely.
+- **[HIGH, fixed] `external_handoffs` declared-but-unused.** Wired it (not deleted) into SKILL.md
+  `## Producing Artifacts` and headless.md step 5, matching product-brief/prd; headless JSON now populated from
+  results. Scalar cross-check now 1:1 (every declared scalar referenced, every reference declared).
+- **[MEDIUM, fixed] One-off idea exception loose/uncapped.** Tightened trigger to a *direct* ask (not "stuck"
+  / "what do you think") and capped recurrence (repeated reaching = pivot the technique).
+- **[MEDIUM, fixed] Overview forward-reference + Running Log triple-imperative padding.** Trimmed both; added
+  "never with your own examples" glue at the provocation point and the headless-boundary clause to the scope
+  statement; ran `on_complete` in headless too.
+- **Rejected (reviewers self-assessed as keepers):** ~10-idea rationale, self-contained-HTML constraint,
+  headless restatement (justified by reference-file self-containment under compaction), and the subjective
+  "spent / mined out" progression condition (a numeric gate would contradict "resist concluding").
+
+### Technique library: 61 → 100, made context-lean via a script (user-requested)
+
+- **Schema change.** CSV is now `category, technique_name, description, detail`. `description` rewritten to a
+  terse ≤140-char *gist* that doubles as the index entry AND is enough to run most techniques (the LLM
+  reconstructs specifics from name + gist — user's insight). `detail` is an optional path (relative to the CSV
+  dir) to a per-technique instruction file, for techniques complex enough to warrant one — loaded only on
+  `show`. This absorbs the best of the "sharded files" idea for exactly the cases that need it. No separate
+  tagline column needed.
+- **`scripts/brain.py`** (stdlib-only, PEP723, `uv run`, 15 passing tests in `scripts/tests/`): `categories` /
+  `list [--category]` / `show "<name>"` (inlines detail file iff present) / `random`. Single source of truth;
+  index derived; never loads the whole catalog into main context. Decided script over subagent because
+  selecting/filtering is pure plumbing (quality-bar: scripts do plumbing, prompts do judgment); a subagent
+  would add latency without saving meaningful context now that the gist index is cheap. Noted one future case a
+  subagent helps: deep full-description matching across the whole library.
+- **Context win:** whole-catalog load was ~4K tokens (61) and would have been ~6.5K at 100; now `categories`
+  ~0.1K, `list --category` ~0.3-0.6K, `show` ~0.07K each — flat as the library grows. The 100-technique CSV is
+  14.6KB, *smaller* than the original 61-technique 16KB because gists replaced the long descriptions.
+- **100 techniques, 13 categories** generated via a 13-agent parallel workflow (one flavored generator per
+  category: shorten existing + invent new), then curated by the parent to exactly 100 (dropped 7 cross-category
+  near-dups/one exact dup). New categories: `absurdist` (genuinely funny unstickers), `constraint`,
+  `speculative_future`. Spectrum spans silly→serious per user's "fun wild funny or super helpful."
+- **Live detail-file demo:** `Six Thinking Hats` → `assets/techniques/six-thinking-hats.md` (full multi-round
+  method), proving the lazy-load path end to end.
+- **"Invent a technique" option** added to `## Choosing Techniques` (pure prompt; logged as a technique; finalize
+  may offer to persist a keeper into `additional_techniques`). SKILL.md technique section + headless both rewired
+  to reach the library only through the script. Scalar consistency re-verified identical; scan-scripts passes.
+
+### Interactive tool techniques — a technique can BE a generated interactive HTML app (user breakthrough)
+
+The detail-file mechanism generalized into a new class: a technique whose "instructions" tell the LLM to
+generate a bespoke, self-contained **interactive HTML tool** (CDN libs like three.js/d3 allowed) the user
+manipulates directly, with results flowing back into the log.
+
+- **The copy-back bridge** (the load-bearing new mechanism, user-identified): the browser can't write to chat,
+  so every interactive tool carries a "Copy results for chat" button → `navigator.clipboard.writeText` of a
+  compact structured summary → user pastes it back → LLM captures it into `session.md` under that technique →
+  next technique. Stated ONCE in `references/interactive-tools.md` (shared build-and-bridge pattern), loaded only
+  when an interactive technique runs; each technique's detail file carries only its specifics. The Stance still
+  holds in chat — the tool externalizes the user's thinking, it does not start generating for them. Graceful
+  fallback to conversational facilitation if HTML can't run.
+- **No per-technique python scripts needed:** the tool's logic lives in the generated HTML's JS (combinatorics,
+  genetic crossover, force/3D layouts run in-browser). `brain.py` stays the only script. This is simpler AND more
+  impressive (the artifact is shareable, runs anywhere) than server-side compute.
+- **New `interactive` category (4 flagship tools)**, each with a detail spec in `assets/techniques/`:
+  Guided Mind Map (user's ask), Morphological Combinator (combinatorial-explosion + shuffle), Idea Genome
+  (genetic-algorithm breeding + lineage), Idea Constellation (force/3D star-map + gap-finding). Retired the
+  conversational Mind Mapping (structured) and Morphological Analysis (deep) — superseded by their interactive
+  versions; trimmed 2 weak ones (absurdist "Wizard Did It", wild "Villain's Master Plan") to hold exactly 100.
+- **Two detail tiers now demoed:** simple (Six Thinking Hats — markdown only) and deep (the 4 interactive tools —
+  markdown spec for a generated JS app + the copy-back bridge). SKILL.md `## Choosing Techniques` routes to
+  `references/interactive-tools.md` + `show` when an interactive technique runs. scan-scripts passes; SKILL.md 92
+  lines. Cruft (`.pytest_cache`, `__pycache__`) removed from the tree.
+
+### Open item for BMad (not a build defect)
+
+`.decision-log.md` trips the path-standards scanner (it flags any non-SKILL root `.md`). This is the builder's
+canonical build memory, mandated at skill root by build-process.md and read by resume detection — moving it to
+`references/` (the scanner's suggested fix) would be wrong. The reference skills (product-brief/prd) ship none,
+so it is build-time-only: gitignore or delete it before release rather than "fixing" the lint.
+
+### Interactive tools: bundled & tested, not generated per-run (user-directed pivot)
+
+User flagged the live-generation approach as needlessly risky (the constellation demo shipped two engine-layer
+typos that blanked the page) and conceptually wrong for one tool. Two decisions:
+
+- **Bundle the flagship interactive tools as tested HTML shells; inject data, never regenerate code.** The risk
+  lives entirely in the engine layer (WebGL/d3/event wiring/clipboard) which is identical every run; the
+  per-session value lives in the data + theming. So each tool now ships as a self-contained
+  `assets/techniques/<tool>.html` with a `<script type="application/json" id="session-state">` injection point —
+  the LLM writes only the JSON (`topic`/`goal`/`resume`), never engine code, making the demo's bug class
+  structurally impossible. Pure runtime generation is retained only for (a) the finalize keepsake HTML, where
+  per-session whimsy is the point and stakes are low, and (b) invented / user-added interactive techniques, which
+  can't be pre-bundled (the four shipped tools are their reference implementations).
+- **Interactive tools are generative ARENAS — brainstorming happens *inside* the surface.** User's load-bearing
+  correction. Every tool boots fully usable from empty `{}`; injected JSON only seeds/resumes. This retired
+  **Idea Constellation** outright: it only visualizes ideas that already exist (retrospective), so it is not a
+  surface you ideate in. Its star-map spirit moves to the finalize keepsake (already an example viz there,
+  runtime-generated). Replaced in the flagship four by **Crazy 8s Sprint** — a timed 8-cell quantity engine, the
+  purest generate-inside-the-surface tool.
+
+**Library bookkeeping (held at 100, 14 categories).** Removed `interactive,Idea Constellation`; added
+`interactive,Crazy 8s Sprint` (detail `crazy-8s-sprint.md`, tool `crazy-8s-sprint.html`). Retired the
+conversational `structured,Crazy 8s` (the interactive Sprint supersedes it, matching the Mind Mapping→Guided
+Mind Map / Morphological Analysis→Combinator precedent); restored the slot with `structured,Lotus Blossom`
+(recursive 3x3 expansion — a genuinely distinct generative method). Interactive category now = Guided Mind Map,
+Morphological Combinator, Idea Genome, Crazy 8s Sprint.
+
+**Build process.** A 4-agent parallel Workflow built the bundled tools (each self-checking `node --check`), then
+a per-tool adversarial verifier ran syntax + data-contract + the generative-surface test + a Stance check. All
+four returned `pass`: syntax-clean, data-injection tag + copy-back bridge present, boot-empty confirmed,
+generative-surface TRUE, no auto-writing of the user's ideas. `references/interactive-tools.md` reframed from
+"build the tool" to "open & seed the shipped tool"; the four detail `.md` files reframed to facilitation + JSON
+contract + copy-back shape; SKILL.md `## Choosing Techniques` updated (open/seed, not generate). The earlier
+`_bmad-output/brainstorming/idea-constellation.html` demo stays as keepsake inspiration, no longer a technique.
+
+### Interactive tools removed — back to a pure conversational facilitator (user-directed)
+
+User pulled all four interactive HTML tools and the `interactive` category for now. Rationale: the coaching/
+facilitation IS the soul of the skill, and a separate user-manipulated canvas risks silencing the facilitator
+during the most generative phase — the exact "blank canvas, fill in your ideas" failure the skill exists to beat.
+A long design discussion (tool-as-instrument, copy-back-as-heartbeat, seeded coach rail, cadence matched to each
+tool's built-in provocation) showed it is *solvable* but not yet worth the complexity. Decisions:
+
+- **Deleted** the 4 bundled tools + detail specs (`guided-mind-map`, `morphological-combinator`, `idea-genome`,
+  `crazy-8s-sprint` — both `.html` and `.md`) and `references/interactive-tools.md` (the open-and-bridge pattern
+  is no longer referenced).
+- **Reverted SKILL.md:** removed the interactive-tools paragraph from `## Choosing Techniques`; restored
+  `## Producing Artifacts` keepsake to self-contained / no-external-deps (dropped the mermaid.js / d3 / three.js
+  CDN allowance that existed only to serve the tools). The interactive-*mode* language (human-present vs headless)
+  in SKILL.md and all of `headless.md` is a different, correct concept and was left untouched.
+- **Held the library at 100** (now 13 categories, no `interactive`) by backfilling 4 conversational techniques:
+  restored `Mind Mapping` (structured), `Morphological Analysis` (deep), `Crazy 8s` (structured); added
+  `Laddering` (deep — climb 'and what would that give you?' to the real need). Kept `Lotus Blossom`.
+- **Kept the expanded-detail-file pattern:** `Six Thinking Hats` → `techniques/six-thinking-hats.md` is the one
+  technique with a richer instruction file, so the lazy-loaded `show`-pulls-detail path stays demonstrated and
+  ready for any future technique that needs more than a gist.
+
+**DEFERRED (build one, later):** a single technique that drives a *real-time visualization which updates live
+during fully-guided facilitative chat* — fundamentally different from the removed user-manipulated canvases. There
+the facilitator stays in the chat dialogue (Stance fully intact, one prompt per message) and a visual reflects the
+conversation as it unfolds, rather than the user going solo in a separate window. The removed bundled tool HTMLs
+and the headless-Chrome render-verification learnings (catch runtime bugs `node --check` misses: bad SRI hashes,
+TDZ ordering) are preserved in this log for when we build that one.
diff --git a/src/core-skills/bmad-brainstorming/SKILL.md b/src/core-skills/bmad-brainstorming/SKILL.md
index 865b476cc..b251e9b44 100644
--- a/src/core-skills/bmad-brainstorming/SKILL.md
+++ b/src/core-skills/bmad-brainstorming/SKILL.md
@@ -1,6 +1,90 @@
 ---
 name: bmad-brainstorming
-description: 'Facilitate interactive brainstorming sessions using diverse creative techniques and ideation methods. Use when the user says help me brainstorm or help me ideate.'
+description: Facilitate a brainstorming session using diverse creative techniques. Use when the user says 'help me brainstorm' or 'help me ideate'.
 ---
 
-Follow the instructions in ./workflow.md.
+# BMad Brainstorming
+
+You are a brainstorming facilitator. The user has a topic and a mind full of ideas they have not pulled out yet — your job is to pull them out, push them past the obvious — with sharper questions and harder constraints, never with your own examples — and keep them generating far longer than feels comfortable. The best sessions end with the user surprised by what *they* came up with.
+
+You do not brainstorm *for* them — in interactive mode you are a forcing function for their creativity, not a source of ideas. Everything you capture lands in one running log that is the session's memory, its resume point, and the single source from which every final artifact is built.
+
+## Conventions
+
+- Bare paths (e.g. `references/headless.md`) resolve from the skill root.
+- `{skill-root}` resolves to this skill's installed directory (where `customize.toml` lives).
+- `{project-root}`-prefixed paths resolve from the project working directory.
+- `{workflow.<name>}` resolves to fields in the merged `customize.toml` `[workflow]` table.
+
+## On Activation
+
+1. Resolve customization: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults.
+2. Execute each entry in `{workflow.activation_steps_prepend}` in order. Treat every entry in `{workflow.persistent_facts}` as foundational context for the run (entries prefixed `file:` are paths/globs under `{project-root}` — load their contents as facts; all others are facts verbatim).
+3. Load `{project-root}/_bmad/core/config.yaml` (and `config.user.yaml` if present). Resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{output_folder}`, `{project_name}`, `{date}`. Missing keys → neutral defaults; never block.
+4. **If there is no interactive user** — a machine or automation context with no human sending messages (`references/headless.md` lists the exact signals) — load `references/headless.md` and follow it for the entire run; it is the *only* context in which you generate ideas yourself, so do not load it when a human is present. A present human asking you to "brainstorm X and give me the HTML" is a normal interactive opening, not a headless trigger. **Otherwise (a human is here), interactive:** greet `{user_name}` in `{communication_language}` — and stay in `{communication_language}` every turn for the whole session. Let them know they can invoke `bmad-party-mode` for multi-agent perspectives or `bmad-advanced-elicitation` for a deeper pass on any thread at any time. Then check `{workflow.output_dir}` for an in-progress session (a `session.md` whose frontmatter `status` is not `complete`); if one exists, offer to resume it (`## Resuming a Session`) before starting fresh.
+
+Execute each entry in `{workflow.activation_steps_append}` in order. If `activation_steps_prepend` or `activation_steps_append` were non-empty, confirm every entry ran before continuing.
+
+## The Facilitator's Stance
+
+These fight your defaults, so hold them deliberately:
+
+- **You do not supply ideas during generative exploration.** Your moves are questions, provocations, constraints, and reflections that make *the user* generate. When the well looks dry, do not fill it — change the technique, shift the angle, or push harder on a thread. Supply an idea only when the user *directly asks you to* — not when they go quiet, say they are stuck, or ask what you think; those are cues to pivot the technique or push harder, never to ideate. Even then, give exactly one as a spark and hand the pen back ("...does that knock anything loose for you?"); if you find yourself reaching for this exception repeatedly, that is the signal to change technique, not to keep feeding ideas. This constraint holds for the entire generative session; it relaxes only at `## Synthesis`, where surfacing connections is the point — and never elsewhere in interactive mode (the headless inversion in `references/headless.md` replaces this flow entirely rather than relaxing it).
+- **One prompt per message.** Never stack questions into a wall the user reads instead of answers. One provocation, wait, build on what comes back.
+- **Shift the creative domain every ~10 ideas.** LLMs and people both drift into semantic clustering — ideas start rhyming with the last one. Force an orthogonal pivot: if you have been mining the technical angle, jump to user experience, then business model, then failure modes, then a wildcard. Divergence is a discipline, not a mood.
+- **Aim past 100 ideas; resist concluding.** Quantity is the session goal — ideas count only when they emerge through the dialogue or the user develops and keeps them. The urge to organize, summarize, or wrap is the enemy of divergence. When in doubt, ask one more question. Move to `## Synthesis` only when the user signals they are spent or the topic is genuinely mined out.
+
+## Session Setup
+
+Open the floor: what are we brainstorming, and what would a great outcome look like for them? Take the dump, reflect back the topic and goal so it is shared, and ask up front for anything they want you to read (a brief, a problem statement, prior notes) — read what exists rather than re-asking.
+
+Once the topic is set, bind `{doc_workspace} = {workflow.output_dir}/{workflow.output_folder_name}/` and create `session.md` there (`## The Running Log`). Tell the user the path — state lives on disk from this moment, so the session survives interruption.
+
+## Choosing Techniques
+
+The library is large, so never read `{workflow.brain_methods}` whole — reach it through the helper script, which serves only what you ask for (if Python is unavailable, fall back to reading the CSV directly via subagent that returns just what is needed, but prefer the script):
+
+- `python3 {skill-root}/scripts/brain.py categories` — category names + counts; the cheap entry point.
+- `python3 {skill-root}/scripts/brain.py list [--category X]` — the index (name + one-line gist), optionally filtered.
+- `python3 {skill-root}/scripts/brain.py show "<name>"` — the full method for one technique, pulling its detail file only if it has one. Call this only when a technique is about to run.
+
+(Pass `--file {workflow.brain_methods}` only if that path has been customized away from the shipped default.) The `list` gist is usually enough to both propose and run a technique; reach for `show` only when you need deeper mechanics. Treat `{workflow.additional_techniques}` as first-class entries of the same catalog (including any new categories they introduce), and prefer `{workflow.favorite_techniques}` where they fit.
+
+Offer these ways in, but keep them levers the user pulls, never a gate they pass:
+
+- **AI-led (default)** — read the goal, propose a fitting technique (favorites first), start facilitating.
+- **Browse** — show `categories`, then the gists in the ones they pick.
+- **Random** — `scripts/brain.py random [--category X]` for a surprise.
+- **Progressive** — sequence techniques broad-divergence first, then systematically narrowing.
+- **Invent one** — make up a technique tailored to their exact topic on the spot, name it, and run it like any other. Log invented techniques as techniques; at finalize you may offer to save a keeper into their `additional_techniques`.
+
+Run a technique until it stops producing, then transition — announce the new lens so the shift is shared, and let the change of technique do the domain-shifting work from the Stance.
+
+## The Running Log
+
+`session.md` is the memory, the resume point, and the source every final artifact derives from — so it must be lean enough to stay cheap across a long session yet complete enough to lose nothing that mattered. Frontmatter carries the recoverable state: `topic`, `goal`, `techniques` (appended as used), `status` (`in-progress` → `complete`). The body is an append-only running record — one terse line per idea the user generates or accepts, grouped under the technique that produced it, plus a marked line for any genuine insight or connection the user lands on. Capture each accepted idea as it lands. Write the user's idea, not a polished rewrite — keep your prose out of the body; it is their record.
+
+## Resuming a Session
+
+Read the existing `session.md` — frontmatter recovers the topic, goal, and techniques already run; the body recovers every idea so far. Reflect back where things stand, then either continue generating (re-enter `## Choosing Techniques`) or move to `## Synthesis` if they are ready to land it. A resumed session appends to the same log.
+
+## Synthesis
+
+This is the turn that earns its name, and the one place your own creative contribution is welcome — run it in two moves, in order:
+
+1. **Hand them the mirror first.** Reflect a vivid sampling of *their* ideas back — deliberately include the odd, random, or buried ones from earlier in the session, not just the recent obvious ones. Ask what they see now: conclusions, synergies, themes, the few that actually matter. Let them connect first; their own pattern-recognition is the point.
+2. **Then add the connections they would miss.** Now lean in creatively — not new raw ideas, but the non-obvious links: this idea from technique one quietly solves that tension from technique four; these three are one idea wearing three hats; this wildcard is the actual breakthrough. Surface the synergies and patterns they did not see right away, and let them react.
+
+Record the insights and chosen directions that come out of both moves into the log (`status: complete` when done). The log now holds everything; the artifacts are derivations of it.
+
+## Producing Artifacts
+
+From the completed log, produce the outputs the user wants — the log is the canonical source, so any artifact is fair game and nothing is lost in the deriving.
+
+**The imaginative HTML (default).** Generate a single self-contained HTML file — `brainstorm.html` in `{doc_workspace}` — that is a genuine creative artifact, not a report poured into a template. There is no template on purpose. Let *this* session's subject, energy, and whimsy drive the visual language; a session about a children's game and a session about supply-chain logistics should not look alike. Give each technique its own treatment, invent visualizations that fit the ideas (timelines, constellations, mind-maps, alien autopsies, whatever the techniques used and content wants), and render the synthesis as the climax — the moment it all came together. Inline all CSS (and any JS); no external dependencies. Be genuinely creative here — this is the keepsake of their session - open once complete.
+
+**The intent doc (offer, do not assume).** Offer a succinct `brainstorm-intent.md` — the chosen and critical discoveries only, structured to drop straight into a downstream skill (`bmad-product-brief`, `bmad-prd`) as clean input, with none of the report's bloat. Build it only if they want it.
+
+**Anything else they ask for.** The log can feed a pitch, a one-pager, a task list — produce what they name from the same source.
+
+Execute each entry in `{workflow.external_handoffs}` to route artifacts beyond local files — invoke the named MCP tool, capture any returned URLs/IDs, surface them to the user; skip and flag any unavailable tool, since the local files always exist. Then close by sharing the artifact paths (and any handoff destinations), and invoke `bmad-help` to suggest where this leads next in the BMad ecosystem. Run `{workflow.on_complete}` if non-empty.
diff --git a/src/core-skills/bmad-brainstorming/assets/brain-methods.csv b/src/core-skills/bmad-brainstorming/assets/brain-methods.csv
new file mode 100644
index 000000000..e4d3276f6
--- /dev/null
+++ b/src/core-skills/bmad-brainstorming/assets/brain-methods.csv
@@ -0,0 +1,101 @@
+category,technique_name,description,detail
+collaborative,Yes And Building,"Never negate; each person opens with ""Yes, and..."" and adds to the last idea, stacking a chain of accepted additions",
+collaborative,Brain Writing Round Robin,"Everyone writes ideas silently, then passes their sheet; you build on whatever lands in front of you, round after round",
+collaborative,Random Stimulation,"Pull a random word or image and force a link to the problem: ""how does THIS spark a solution?""",
+collaborative,Role Playing,"Each person speaks as a different stakeholder, voicing what that role wants, fears, and would demand of the idea",
+collaborative,Ideation Relay Race,"30-second turns, no pausing: add one idea, slap it to the next person, keep the baton moving before anyone overthinks",
+collaborative,Idea Hot Potato,"One idea gets tossed around the circle; each catcher must mutate it in 10 seconds before passing, no repeats allowed",
+collaborative,Steal And Upgrade,"Pick a neighbor's idea you envy, claim it out loud, then make it visibly better before handing it back improved",
+collaborative,Fold The Paper,"Each person adds one line to a hidden drawing or sentence, sees only the previous fragment, then unfold the surreal whole",
+creative,What If Scenarios,"Detonate one constraint at a time — unlimited budget, opposite is true, problem vanished — and chase what rushes in",
+creative,Analogical Thinking,Ask 'this is like what?' and steal the solution pattern from the domain that answers,
+creative,First Principles Thinking,"Strip every assumption to bedrock facts, then rebuild the solution from scratch on truth alone",
+creative,Forced Relationships,Grab two unrelated things at random and force a bridge between them until an idea falls out,
+creative,Time Shifting,"Solve the problem as a 1900s artisan, then a 2150 colonist — harvest the era-bound constraints and tricks",
+creative,Metaphor Mapping,"Declare the problem IS a chosen metaphor, extend the metaphor fully, map each part back to find insights",
+creative,Cross-Pollination,"Ask how a wildly different industry — casinos, ERs, beekeeping — would crack this, then adapt their move",
+creative,Concept Blending,"Fuse two concepts into one new hybrid category and name what the merger becomes, not just combines",
+creative,Reverse Brainstorming,Generate problems instead of solutions — 'how could we make this fail?' — then mine each for its inverse,
+creative,Sensory Exploration,"Interrogate the idea through each sense — its taste, smell, sound, texture — to surface non-analytical angles",
+deep,Five Whys,"Ask ""why?"" five times in a chain, each answer feeding the next, until you hit the root cause beneath the symptom",
+deep,Provocation Technique,"State something deliberately absurd, then mine it: ""how could this be useful?"" Extract the usable principle hiding inside",
+deep,Assumption Reversal,"List every assumption baked into the problem, flip each to its opposite, then rebuild a solution on the inverted foundation",
+deep,Question Storming,"Generate only questions about the problem, zero answers allowed, until the real problem worth solving comes into focus",
+deep,Constraint Mapping,"Map every constraint, sort real from imagined, then attack each: dissolve it, route around it, or turn it into an asset",
+deep,Failure Analysis,"Dissect a relevant failure: what broke, why it broke, what lesson it leaves, and how to apply that wisdom here",
+deep,Emergent Thinking,Stop forcing a solution; watch what patterns the system keeps producing and name what's trying to emerge on its own,
+deep,Causal Loop Mapping,"Diagram the feedback loops linking causes and effects, find the reinforcing and balancing cycles, and target the leverage point",
+deep,Morphological Analysis,"List the problem's independent parameters, generate options for each, then combine across them to surface untried configurations",
+deep,Laddering,"Ask 'and what would that give you?' up the chain until you reach the real underlying need, then ideate fresh at that level",
+introspective_delight,Inner Child Conference,"Answer as your 7-year-old self: ask naive 'why why why' questions, chase wonder, ban every boring adult thought",
+introspective_delight,Shadow Work Mining,"Name what you're avoiding, resisting, or scared of about this — then dig there for the buried insight",
+introspective_delight,Values Archaeology,Keep asking 'why do I care?' until you hit bedrock: the non-negotiable value secretly steering the choice,
+introspective_delight,Future Self Interview,Interview your wise 80-year-old self about this problem and write down the advice they give you,
+introspective_delight,Body Wisdom Dialogue,"Scan for the tension, flutter, or gut pull each option triggers; let the body's yes/no drive the ideas",
+introspective_delight,Permission Giving,"Write yourself an explicit permission slip to think the forbidden, impossible thought — then think it out loud",
+introspective_delight,Secret Wish Confession,"Whisper the embarrassing thing you secretly want here but won't admit, then build the idea honoring it",
+introspective_delight,Mood Weather Report,"Name the inner weather right now (fog, storm, sun) and let that exact emotional climate generate the ideas",
+structured,SCAMPER Method,"Run your idea through seven lenses: Substitute, Combine, Adapt, Modify, Put-to-other-use, Eliminate, Reverse",
+structured,Six Thinking Hats,"Examine the problem six ways one at a time: facts, feelings, benefits, risks, new ideas, process",techniques/six-thinking-hats.md
+structured,Decision Tree Mapping,"Chart every choice point and the paths it forks into, following each branch to its outcome and risk",
+structured,Solution Matrix,"Grid problem variables against solution approaches, score every cell, hunt the best pairings and empty gaps",
+structured,Trait Transfer,"Name what makes an unrelated success work, then graft those winning traits onto your own problem",
+structured,Lotus Blossom,"Put the theme at the center of a 3x3 grid, fill the 8 cells around it, then promote each of those to the center of its own new 3x3",
+structured,Worst Possible Idea,"Deliberately generate the most terrible solutions you can, then flip each into what it teaches you to do right",
+structured,Disney Method,"Cycle the idea through three rooms: Dreamer (anything goes), Realist (how we'd build it), Critic (what breaks)",
+structured,Starbursting,"Interrogate the idea with only questions — who, what, where, when, why, how — exhaust each before answering any",
+structured,Mind Mapping,"Branch the central topic outward, each node spawning children; follow tangents wherever they pull and let the web sprawl",
+structured,Crazy 8s,"Eight ideas in eight minutes, one per box, no editing — speed outruns your inner critic",
+theatrical,Time Travel Talk Show,"Host a talk show interviewing your past, present, and future selves to mine each era for advice on the problem",
+theatrical,Alien Anthropologist,"Become a baffled alien studying the problem and narrate aloud what seems strange, arbitrary, or insane about it",
+theatrical,Dream Fusion Laboratory,"Voice the impossible fantasy solution first, then reverse-engineer the bridging steps back to reality",
+theatrical,Emotion Orchestra,"Run a separate ideation round led by each emotion (rage, joy, fear, hope), then harmonize their conflicting ideas",
+theatrical,Parallel Universe Cafe,"Rewrite one fundamental rule of reality (physics, economics, social norms) and solve the problem under those laws",
+theatrical,Persona Journey,"Embody an archetype and solve the problem in-character, naming what that persona sees that you normally miss",
+theatrical,Devil's Advocate Courtroom,"Stage a trial: prosecute the idea, defend it, then deliver the jury verdict, each role argued fully in character",
+wild,Chaos Engineering,"Deliberately break your idea every way it could fail, then rebuild only the parts that survive the wreckage",
+wild,Guerrilla Gardening Ideas,Plant your solution in the least expected place and let it grow underground until it surprises everyone,
+wild,Pirate Code Brainstorm,"Steal the best bits from anywhere, remix without asking permission, grab what works and run",
+wild,Zombie Apocalypse Planning,"Society just collapsed — strip your idea to only what survives with no power, no rules, no backup",
+wild,Drunk History Retelling,"Explain it like you're three drinks in: no filter, no jargon, just the raw stupid-simple truth",
+wild,Anti-Solution,"Brainstorm how to make the problem spectacularly worse, then invert every sabotage into a fix",
+wild,Elemental Forces,"Let fire, water, earth, and air each sculpt your idea their own brutal way and see what survives",
+biomimetic,Nature's Solutions,"Name an organism that already solved your problem, then copy its mechanism into your design",
+biomimetic,Ecosystem Thinking,"Map your problem as an ecosystem: who eats whom, who partners, what decays, what fills the gaps",
+biomimetic,Evolutionary Pressure,"Spawn many ugly variants, apply a brutal selection rule, breed the survivors, repeat until it adapts",
+biomimetic,Predator & Prey,"Pick a threat to your idea, then design the defense, camouflage, or escape an animal would evolve against it",
+biomimetic,Metamorphosis Stages,"Force your idea through egg, larva, pupa, adult: a radically different form and purpose at each life stage",
+biomimetic,Swarm Logic,Forbid the master plan: solve it with dumb local rules each agent follows so order emerges from the bottom up,
+quantum,Observer Effect,"Ask how the act of watching, measuring, or shipping this idea changes the very thing you're trying to capture",
+quantum,Entanglement Thinking,Pair two distant parts of the problem and insist a change in one instantly flips the other — surface the hidden linkage,
+quantum,Superposition Collapse,"Hold all rival solutions alive at once, then name the one constraint that collapses them to a single winner",
+quantum,Relativity Frame Shift,"Re-run the idea from a wildly different observer's reference frame — the slow user, the rival, future-you — and see what warps",
+quantum,Field Lines,Treat the goal as a charge and map the invisible forces pulling every stakeholder toward or away from it,
+quantum,Quantum Tunneling,"Assume the idea can pass straight through the 'impossible' barrier instead of over it — what's on the other side, reached cheaply",
+cultural,Indigenous Wisdom,"Ask how an indigenous or traditional knowledge system would approach this — name the culture, channel its ancestral problem-solving",
+cultural,Fusion Cuisine,Pick two unrelated cultures and force-blend their approaches; harvest the hybrid that neither alone would invent,
+cultural,Ritual Innovation,"Redesign the idea as a ceremony — define the threshold, the gestures, the transformation participants undergo",
+cultural,Mythic Frameworks,"Map the problem onto a myth: name the archetypes, find the parallel tale, let its structure dictate the resolution",
+cultural,Proverb Mining,"Collect proverbs from many cultures on this theme, then build the solution from the one that clashes hardest with your assumptions",
+cultural,Ancestor Council,"Convene three ancestors or elders from different traditions, voice each one's verdict on your idea, reconcile their disagreement",
+cultural,Trickster's Gambit,"Channel the trickster figure — coyote, Anansi, Loki — and solve it by cheating, inverting, or breaking the sacred rule",
+absurdist,Villain's Monologue,Pitch your problem as an evil mastermind gloating about their scheme; the diabolical plan reveals the real solution,
+absurdist,Explain It to a Golden Retriever,"Re-pitch the idea to an excitable dog who only cares about treats, balls, and naps; keep only what survives",
+absurdist,Infomercial at 3AM,"Sell your half-baked idea as a desperate late-night infomercial: 'But wait, there's more!' until features fall out",
+absurdist,Drunk Uncle at Thanksgiving,"Have your loudest, least-filtered relative rant about the problem; mine the unhinged hot takes for buried truth",
+absurdist,Cursed Genie,"Make a wish, then let a malicious genie grant it in the most technically-correct disastrous way; patch each loophole",
+absurdist,Three Rounds of Stupid,"Round 1 absurd ideas, Round 2 make each MORE absurd, Round 3 find the smallest serious thing hiding in the silliest",
+constraint,Kill the Crown Jewel,"Delete the single best, most beloved feature — now redesign the whole thing to win without it",
+constraint,1000x Budget,"Pretend money, time, and people are infinite — design the absurd version, then mine it for ideas you can actually steal",
+constraint,Ship in 60 Minutes,"You launch in one hour with what's already on hand — name what you cut, fake, or borrow to make it real",
+constraint,The $0 Mandate,"Achieve the goal spending literally nothing — no tools, hires, or ads; only people, favors, and what you own",
+constraint,One Feature Only,"You may keep exactly ONE capability and nothing else — pick it, then make that single thing unbelievably good",
+constraint,Crank the Dial to 11,"Pick one dimension and exaggerate it to a ludicrous extreme — fastest, biggest, cheapest, weirdest — and see what breaks open",
+constraint,Constraint Roulette,"Each round draw a brutal random limit (no screens, half the team, one day) and re-solve under it; survivors become real ideas",
+speculative_future,Time Horizon Ladder,"Solve the idea for 1 year out, then 10, then 100 — note what survives, breaks, or becomes absurd at each rung",
+speculative_future,Post-Scarcity Test,"Assume the core constraint (money, energy, time, attention) is now infinite and free — what does the idea become",
+speculative_future,Utopia vs Dystopia Split-Screen,Write the same future twice: the brochure where it went perfectly and the headline where it went horribly,
+speculative_future,Sci-Fi Artifact From the Future,"Describe one physical object, ad, or news clip from the world where this idea already won — reverse-engineer it",
+speculative_future,Emerging Tech Collision,"Force-marry your idea to a frontier tech (AGI, fusion, neural implants, gene edit) and ask what new thing is born",
+speculative_future,What-If-The-World-Changed Card Flip,"Draw a wild world-shift (no privacy, half population, 200-yr lifespans) and redesign the idea to fit that world",
+speculative_future,Future Anthropologist Dig,"A scholar in 2200 unearths your idea as a relic — what do they conclude it reveals about us, and what replaced it",
diff --git a/src/core-skills/bmad-brainstorming/assets/techniques/six-thinking-hats.md b/src/core-skills/bmad-brainstorming/assets/techniques/six-thinking-hats.md
new file mode 100644
index 000000000..eaaae9681
--- /dev/null
+++ b/src/core-skills/bmad-brainstorming/assets/techniques/six-thinking-hats.md
@@ -0,0 +1,14 @@
+# Six Thinking Hats — full method
+
+Edward de Bono's method: the group wears one "hat" at a time, so everyone explores the *same* mode of thinking together instead of arguing across modes. The power is in the discipline of separation — no defending while in White, no inventing while in Black.
+
+Facilitate the hats in sequence, one at a time. Keep the user generating within each hat before switching; announce each switch so the shift in thinking is shared.
+
+- **White — facts.** Only what is known and what is missing. Data, figures, gaps. No opinions, no interpretation. "What do we actually know? What don't we?"
+- **Red — feelings.** Gut reactions, hunches, emotions — stated without justification. The one hat where "because I just feel it" is the whole point. "What's your gut say, no reasons needed?"
+- **Yellow — benefits.** Best case, value, why it could work. Optimism with reasons. "If this went right, what would we gain?"
+- **Black — risks.** Caution, flaws, what could fail. Critical judgment — but *only* under this hat, so it doesn't poison the rest. "Where does this break? What's the real danger?"
+- **Green — new ideas.** Creativity, alternatives, provocations, growth from what the other hats surfaced. "Given all that — what else? What's the wild alternative?"
+- **Blue — process.** Step back: summarize what came out, decide what matters, name the next move. Usually last; can also open the session to set the agenda. "What did we learn, and what do we do with it?"
+
+A common order is White → Red → Yellow → Black → Green → Blue, but adapt to the topic — lead with Red when feelings are running hot, or open with Blue to frame the session. Loop a hat if it is still producing. Capture each hat's output under its name in the running log.
diff --git a/src/core-skills/bmad-brainstorming/brain-methods.csv b/src/core-skills/bmad-brainstorming/brain-methods.csv
deleted file mode 100644
index 29c7787d5..000000000
--- a/src/core-skills/bmad-brainstorming/brain-methods.csv
+++ /dev/null
@@ -1,62 +0,0 @@
-category,technique_name,description
-collaborative,Yes And Building,"Build momentum through positive additions where each idea becomes a launching pad - use prompts like 'Yes and we could also...' or 'Building on that idea...' to create energetic collaborative flow that builds upon previous contributions"
-collaborative,Brain Writing Round Robin,"Silent idea generation followed by building on others' written concepts - gives quieter voices equal contribution while maintaining documentation through the sequence of writing silently, passing ideas, and building on received concepts"
-collaborative,Random Stimulation,"Use random words/images as creative catalysts to force unexpected connections - breaks through mental blocks with serendipitous inspiration by asking how random elements relate, what connections exist, and forcing relationships"
-collaborative,Role Playing,"Generate solutions from multiple stakeholder perspectives to build empathy while ensuring comprehensive consideration - embody different roles by asking what they want, how they'd approach problems, and what matters most to them"
-collaborative,Ideation Relay Race,"Rapid-fire idea building under time pressure creates urgency and breakthroughs - structure with 30-second additions, quick building on ideas, and fast passing to maintain creative momentum and prevent overthinking"
-creative,What If Scenarios,"Explore radical possibilities by questioning all constraints and assumptions - perfect for breaking through stuck thinking using prompts like 'What if we had unlimited resources?' 'What if the opposite were true?' or 'What if this problem didn't exist?'"
-creative,Analogical Thinking,"Find creative solutions by drawing parallels to other domains - transfer successful patterns by asking 'This is like what?' 'How is this similar to...' and 'What other examples come to mind?' to connect to existing solutions"
-creative,Reversal Inversion,"Deliberately flip problems upside down to reveal hidden assumptions and fresh angles - great when conventional approaches fail by asking 'What if we did the opposite?' 'How could we make this worse?' and 'What's the reverse approach?'"
-creative,First Principles Thinking,"Strip away assumptions to rebuild from fundamental truths - essential for breakthrough innovation by asking 'What do we know for certain?' 'What are the fundamental truths?' and 'If we started from scratch?'"
-creative,Forced Relationships,"Connect unrelated concepts to spark innovative bridges through creative collision - take two unrelated things, find connections between them, identify bridges, and explore how they could work together to generate unexpected solutions"
-creative,Time Shifting,"Explore solutions across different time periods to reveal constraints and opportunities by asking 'How would this work in the past?' 'What about 100 years from now?' 'Different era constraints?' and 'What time-based solutions apply?'"
-creative,Metaphor Mapping,"Use extended metaphors as thinking tools to explore problems from new angles - transforms abstract challenges into tangible narratives by asking 'This problem is like a metaphor,' extending the metaphor, and mapping elements to discover insights"
-creative,Cross-Pollination,"Transfer solutions from completely different industries or domains to spark breakthrough innovations by asking how industry X would solve this, what patterns work in field Y, and how to adapt solutions from domain Z"
-creative,Concept Blending,"Merge two or more existing concepts to create entirely new categories - goes beyond simple combination to genuine innovation by asking what emerges when concepts merge, what new category is created, and how the blend transcends original ideas"
-creative,Reverse Brainstorming,"Generate problems instead of solutions to identify hidden opportunities and unexpected pathways by asking 'What could go wrong?' 'How could we make this fail?' and 'What problems could we create?' to reveal solution insights"
-creative,Sensory Exploration,"Engage all five senses to discover multi-dimensional solution spaces beyond purely analytical thinking by asking what ideas feel, smell, taste, or sound like, and how different senses engage with the problem space"
-deep,Five Whys,"Drill down through layers of causation to uncover root causes - essential for solving problems at source rather than symptoms by asking 'Why did this happen?' repeatedly until reaching fundamental drivers and ultimate causes"
-deep,Morphological Analysis,"Systematically explore all possible parameter combinations for complex systems requiring comprehensive solution mapping - identify key parameters, list options for each, try different combinations, and identify emerging patterns"
-deep,Provocation Technique,"Use deliberately provocative statements to extract useful ideas from seemingly absurd starting points - catalyzes breakthrough thinking by asking 'What if provocative statement?' 'How could this be useful?' 'What idea triggers?' and 'Extract the principle'"
-deep,Assumption Reversal,"Challenge and flip core assumptions to rebuild from new foundations - essential for paradigm shifts by asking 'What assumptions are we making?' 'What if the opposite were true?' 'Challenge each assumption' and 'Rebuild from new assumptions'"
-deep,Question Storming,"Generate questions before seeking answers to properly define problem space - ensures solving the right problem by asking only questions, no answers yet, focusing on what we don't know, and identifying what we should be asking"
-deep,Constraint Mapping,"Identify and visualize all constraints to find promising pathways around or through limitations - ask what all constraints exist, which are real vs imagined, and how to work around or eliminate barriers to solution space"
-deep,Failure Analysis,"Study successful failures to extract valuable insights and avoid common pitfalls - learns from what didn't work by asking what went wrong, why it failed, what lessons emerged, and how to apply failure wisdom to current challenges"
-deep,Emergent Thinking,"Allow solutions to emerge organically without forcing linear progression - embraces complexity and natural development by asking what patterns emerge, what wants to happen naturally, and what's trying to emerge from the system"
-introspective_delight,Inner Child Conference,"Channel pure childhood curiosity and wonder to rekindle playful exploration - ask what 7-year-old you would ask, use 'why why why' questioning, make it fun again, and forbid boring thinking to access innocent questioning that cuts through adult complications"
-introspective_delight,Shadow Work Mining,"Explore what you're actively avoiding or resisting to uncover hidden insights - examine unconscious blocks and resistance patterns by asking what you're avoiding, where's resistance, what scares you, and mining the shadows for buried wisdom"
-introspective_delight,Values Archaeology,"Excavate deep personal values driving decisions to clarify authentic priorities - dig to bedrock motivations by asking what really matters, why you care, what's non-negotiable, and what core values guide your choices"
-introspective_delight,Future Self Interview,"Seek wisdom from wiser future self for long-term perspective - gain temporal self-mentoring by asking your 80-year-old self what they'd tell younger you, how future wisdom speaks, and what long-term perspective reveals"
-introspective_delight,Body Wisdom Dialogue,"Let physical sensations and gut feelings guide ideation - tap somatic intelligence often ignored by mental approaches by asking what your body says, where you feel it, trusting tension, and following physical cues for embodied wisdom"
-introspective_delight,Permission Giving,"Grant explicit permission to think impossible thoughts and break self-imposed creative barriers - give yourself permission to explore, try, experiment, and break free from limitations that constrain authentic creative expression"
-structured,SCAMPER Method,"Systematic creativity through seven lenses for methodical product improvement and innovation - Substitute (what could you substitute), Combine (what could you combine), Adapt (how could you adapt), Modify (what could you modify), Put to other uses, Eliminate, Reverse"
-structured,Six Thinking Hats,"Explore problems through six distinct perspectives without conflict - White Hat (facts), Red Hat (emotions), Yellow Hat (benefits), Black Hat (risks), Green Hat (creativity), Blue Hat (process) to ensure comprehensive analysis from all angles"
-structured,Mind Mapping,"Visually branch ideas from central concept to discover connections and expand thinking - perfect for organizing complex thoughts and seeing big picture by putting main idea in center, branching concepts, and identifying sub-branches"
-structured,Resource Constraints,"Generate innovative solutions by imposing extreme limitations - forces essential priorities and creative efficiency under pressure by asking what if you had only $1, no technology, one hour to solve, or minimal resources only"
-structured,Decision Tree Mapping,"Map out all possible decision paths and outcomes to reveal hidden opportunities and risks - visualizes complex choice architectures by identifying possible paths, decision points, and where different choices lead"
-structured,Solution Matrix,"Create systematic grid of problem variables and solution approaches to find optimal combinations and discover gaps - identify key variables, solution approaches, test combinations, and identify most effective pairings"
-structured,Trait Transfer,"Borrow attributes from successful solutions in unrelated domains to enhance approach - systematically adapts winning characteristics by asking what traits make success X work, how to transfer these traits, and what they'd look like here"
-theatrical,Time Travel Talk Show,"Interview past/present/future selves for temporal wisdom - playful method for gaining perspective across different life stages by interviewing past self, asking what future you'd say, and exploring different timeline perspectives"
-theatrical,Alien Anthropologist,"Examine familiar problems through completely foreign eyes - reveals hidden assumptions by adopting outsider's bewildered perspective by becoming alien observer, asking what seems strange, and getting outside perspective insights"
-theatrical,Dream Fusion Laboratory,"Start with impossible fantasy solutions then reverse-engineer practical steps - makes ambitious thinking actionable through backwards design by dreaming impossible solutions, working backwards to reality, and identifying bridging steps"
-theatrical,Emotion Orchestra,"Let different emotions lead separate brainstorming sessions then harmonize - uses emotional intelligence for comprehensive perspective by exploring angry perspectives, joyful approaches, fearful considerations, hopeful solutions, then harmonizing all voices"
-theatrical,Parallel Universe Cafe,"Explore solutions under alternative reality rules - breaks conventional thinking by changing fundamental assumptions about how things work by exploring different physics universes, alternative social norms, changed historical events, and reality rule variations"
-theatrical,Persona Journey,"Embody different archetypes or personas to access diverse wisdom through character exploration - become the archetype, ask how persona would solve this, and explore what character sees that normal thinking misses"
-wild,Chaos Engineering,"Deliberately break things to discover robust solutions - builds anti-fragility by stress-testing ideas against worst-case scenarios by asking what if everything went wrong, breaking on purpose, how it fails gracefully, and building from rubble"
-wild,Guerrilla Gardening Ideas,"Plant unexpected solutions in unlikely places - uses surprise and unconventional placement for stealth innovation by asking where's the least expected place, planting ideas secretly, growing solutions underground, and implementing with surprise"
-wild,Pirate Code Brainstorm,"Take what works from anywhere and remix without permission - encourages rule-bending rapid prototyping and maverick thinking by asking what pirates would steal, remixing without asking, taking best and running, and needing no permission"
-wild,Zombie Apocalypse Planning,"Design solutions for extreme survival scenarios - strips away all but essential functions to find core value by asking what happens when society collapses, what basics work, building from nothing, and thinking in survival mode"
-wild,Drunk History Retelling,"Explain complex ideas with uninhibited simplicity - removes overthinking barriers to find raw truth through simplified expression by explaining like you're tipsy, using no filter, sharing raw thoughts, and simplifying to absurdity"
-wild,Anti-Solution,"Generate ways to make the problem worse or more interesting - reveals hidden assumptions through destructive creativity by asking how to sabotage this, what would make it fail spectacularly, and how to create more problems to find solution insights"
-wild,Quantum Superposition,"Hold multiple contradictory solutions simultaneously until best emerges through observation and testing - explores how all solutions could be true simultaneously, how contradictions coexist, and what happens when outcomes are observed"
-wild,Elemental Forces,"Imagine solutions being sculpted by natural elements to tap into primal creative energies - explore how earth would sculpt this, what fire would forge, how water flows through this, and what air reveals to access elemental wisdom"
-biomimetic,Nature's Solutions,"Study how nature solves similar problems and adapt biological strategies to challenge - ask how nature would solve this, what ecosystems provide parallels, and what biological strategies apply to access 3.8 billion years of evolutionary wisdom"
-biomimetic,Ecosystem Thinking,"Analyze problem as ecosystem to identify symbiotic relationships, natural succession, and ecological principles - explore symbiotic relationships, natural succession application, and ecological principles for systems thinking"
-biomimetic,Evolutionary Pressure,"Apply evolutionary principles to gradually improve solutions through selective pressure and adaptation - ask how evolution would optimize this, what selective pressures apply, and how this adapts over time to harness natural selection wisdom"
-quantum,Observer Effect,"Recognize how observing and measuring solutions changes their behavior - uses quantum principles for innovation by asking how observing changes this, what measurement effects matter, and how to use observer effect advantageously"
-quantum,Entanglement Thinking,"Explore how different solution elements might be connected regardless of distance - reveals hidden relationships by asking what elements are entangled, how distant parts affect each other, and what hidden connections exist between solution components"
-quantum,Superposition Collapse,"Hold multiple potential solutions simultaneously until constraints force single optimal outcome - leverages quantum decision theory by asking what if all options were possible, what constraints force collapse, and which solution emerges when observed"
-cultural,Indigenous Wisdom,"Draw upon traditional knowledge systems and indigenous approaches overlooked by modern thinking - ask how specific cultures would approach this, what traditional knowledge applies, and what ancestral wisdom guides us to access overlooked problem-solving methods"
-cultural,Fusion Cuisine,"Mix cultural approaches and perspectives like fusion cuisine - creates innovation through cultural cross-pollination by asking what happens when mixing culture A with culture B, what cultural hybrids emerge, and what fusion creates"
-cultural,Ritual Innovation,"Apply ritual design principles to create transformative experiences and solutions - uses anthropological insights for human-centered design by asking what ritual would transform this, how to make it ceremonial, and what transformation this needs"
-cultural,Mythic Frameworks,"Use myths and archetypal stories as frameworks for understanding and solving problems - taps into collective unconscious by asking what myth parallels this, what archetypes are involved, and how mythic structure informs solution"
\ No newline at end of file
diff --git a/src/core-skills/bmad-brainstorming/customize.toml b/src/core-skills/bmad-brainstorming/customize.toml
new file mode 100644
index 000000000..5b1ee63fe
--- /dev/null
+++ b/src/core-skills/bmad-brainstorming/customize.toml
@@ -0,0 +1,80 @@
+# DO NOT EDIT -- overwritten on every update.
+#
+# Workflow customization surface for bmad-brainstorming.
+#
+# Override files (not edited here):
+#   {project-root}/_bmad/custom/bmad-brainstorming.toml         (team)
+#   {project-root}/_bmad/custom/bmad-brainstorming.user.toml    (personal)
+
+[workflow]
+
+# --- Configurable below. Overrides merge per BMad structural rules: ---
+#   scalars: override wins • arrays: append
+
+# Steps to run before the standard activation (config load, greet).
+# Use for pre-flight loads, compliance checks, etc.
+activation_steps_prepend = []
+
+# Steps to run after greet but before facilitation begins.
+# Use for context-heavy setup that should happen once the user has been acknowledged.
+activation_steps_append = []
+
+# Persistent facts the facilitator keeps in mind for the whole session
+# (domain constraints, house rules, stylistic guardrails). Each entry is a
+# literal sentence, a skill prefixed with `skill:`, or a `file:`-prefixed
+# path/glob whose contents are loaded as facts. Default loads project-context.md
+# if bmad-generate-project-context has produced one, giving the facilitator
+# persistent awareness of the project's domain without re-asking.
+persistent_facts = [
+  "file:{project-root}/**/project-context.md",
+]
+
+# The technique library loaded on demand during the session. Swap the path in
+# team/user TOML to ship a different or extended catalog of creative methods.
+brain_methods = "assets/brain-methods.csv"
+
+# Techniques the facilitator should reach for first. When proposing a method
+# (the AI-led default), it prefers these where they fit the goal before ranging
+# wider. Names should match an entry in the library or in additional_techniques.
+# Append-merges, so a team list and a personal list both contribute. Empty = no
+# preference; the facilitator chooses purely on fit.
+#
+# Example (set in team/user override TOML):
+#   favorite_techniques = ["SCAMPER", "Six Thinking Hats", "First Principles"]
+favorite_techniques = []
+
+# Extra techniques — and whole new categories — merged into the catalog the
+# facilitator chooses from, without editing the shipped CSV. Each entry mirrors
+# the library's shape (category, technique_name, description); a new category is
+# just a category value the CSV doesn't have. Entries append, so teams and users
+# can each grow the library. The facilitator treats these as first-class
+# alongside brain_methods for proposing, browsing, random, and progressive flows.
+#
+# Example (set in team/user override TOML):
+#   [[workflow.additional_techniques]]
+#   category = "domain-specific"
+#   technique_name = "Regulatory Inversion"
+#   description = "Start from the compliance constraint and brainstorm what becomes possible only because of it — turn the rule into a generative frame rather than a limit."
+additional_techniques = []
+
+# Session output location. The running log and any final artifacts land inside
+# `{output_dir}/{output_folder_name}/`. The resume check scans `{output_dir}`
+# for prior in-progress sessions.
+output_dir = "{output_folder}/brainstorming"
+output_folder_name = "brainstorm-{project_name}-{date}"
+
+# Executed when the session completes (after artifacts are produced and the user
+# has the paths). Accepts a string scalar (single instruction) or an array of
+# instructions executed in order. Empty for none.
+on_complete = ""
+
+# External-handoff routing. Natural-language directives applied after artifacts
+# are produced, to route them beyond local files (Confluence, Notion, Drive,
+# etc.). Each entry names the MCP tool, the destination, and the fields it needs.
+# URLs/IDs returned are surfaced to the user. If a named tool is unavailable at
+# runtime, the handoff is skipped and flagged; local files always exist. Empty
+# by default.
+#
+# Example (set in team/user override TOML):
+#   "After artifacts are produced, upload brainstorm.html to Confluence via corp:confluence_upload (space_key='IDEAS', parent_page='Brainstorms', author={user_name})."
+external_handoffs = []
diff --git a/src/core-skills/bmad-brainstorming/references/headless.md b/src/core-skills/bmad-brainstorming/references/headless.md
new file mode 100644
index 000000000..ce8e84780
--- /dev/null
+++ b/src/core-skills/bmad-brainstorming/references/headless.md
@@ -0,0 +1,54 @@
+# Headless Mode
+
+Load this file ONLY when bmad-brainstorming is invoked headless. It is quarantined here on purpose: headless is the single context in which you generate ideas yourself, which is the exact inverse of the interactive Stance. Loading it in a normal session would corrupt the facilitation. Follow it for the whole run.
+
+## Detection
+
+**If a human is sending messages in this session, you are interactive — no payload shape or phrasing overrides that.** Headless requires the *absence* of an interactive user. It is in effect only when one of these unambiguous machine signals holds:
+
+- the caller sets a `headless: true` flag (or the equivalent argument the harness exposes),
+- the invocation comes from another skill or a non-interactive runner (no TTY, no user message stream),
+- `{workflow.activation_steps_prepend}` includes an entry that explicitly declares headless.
+
+When in doubt, you are interactive — a present human asking you to "brainstorm X and give me the HTML" is a normal interactive opening, not a headless trigger. Facilitate them; do not brainstorm for them.
+
+## The inversion
+
+There is no user to draw ideas out of, so you become the brainstormer. Run a real divergent session against the supplied topic: discover techniques with `python3 {skill-root}/scripts/brain.py list` (and `show "<name>"` for a technique's full method on demand), plus any `{workflow.additional_techniques}`, preferring `{workflow.favorite_techniques}` where they fit; work them, and **shift the creative domain every ~10 ideas** exactly as the interactive Stance demands — technical, then experiential, then business, then failure modes, then wildcards. Push past the obvious; the same quantity ambition (aim past 100) and anti-clustering discipline apply. The only thing that changes is that the ideas are now yours to generate. This relaxation is scoped entirely to this file — it never applies to interactive sessions.
+
+## Inputs the caller is expected to provide
+
+Free-form structured payload in the first message; provide what applies:
+
+- `topic` — what to brainstorm. Required. If absent and uninferable, halt `blocked`.
+- `goal` — desired outcome / framing, if any.
+- `techniques` — specific methods to use; otherwise you choose fitting ones from the library.
+- `context` — file paths or text to ground the session (problem statement, prior notes, brief).
+- `doc_workspace` — a specific run folder; otherwise bind the default `{workflow.output_dir}/{workflow.output_folder_name}/`.
+- `artifacts` — which outputs to produce: `html`, `intent`, or both. Default: both.
+
+## Run
+
+1. Bind `{doc_workspace}` and write `session.md` with the same lean shape the interactive log uses (frontmatter `topic`/`goal`/`techniques`/`status`; append-only one-line-per-idea body grouped by technique). It remains the canonical source every artifact derives from.
+2. Run the divergent session per **The inversion**, capturing each idea to the log as it lands.
+3. Synthesize: surface the conclusions, connections, and the few directions that matter, and record them to the log. Set `status: complete`.
+4. Produce the requested artifacts from the log — `brainstorm.html` (the imaginative, self-contained, no-template report) and/or the succinct `brainstorm-intent.md` — exactly as the interactive `## Producing Artifacts` section specifies.
+5. Execute each entry in `{workflow.external_handoffs}` (capture returned URLs/IDs into the JSON `external_handoffs` array; skip and flag unavailable tools — local files always exist). Then run `{workflow.on_complete}` if non-empty.
+
+Do not ask questions; do not greet. Record any assumption you made (a topic you had to infer, a goal you invented to frame the session) in `assumptions[]`.
+
+## Return
+
+End with a JSON status block. Use `complete` when the artifacts stand on their own, `partial` when produced but key inputs were inferred (e.g. topic was thin), `blocked` when no artifact was produced (e.g. no topic). Omit keys for artifacts not produced.
+
+```json
+{
+  "status": "complete",
+  "intent": "brainstorm",
+  "session_log": "{doc_workspace}/session.md",
+  "html": "{doc_workspace}/brainstorm.html",
+  "intent_doc": "{doc_workspace}/brainstorm-intent.md",
+  "assumptions": [],
+  "external_handoffs": []
+}
+```
diff --git a/src/core-skills/bmad-brainstorming/scripts/brain.py b/src/core-skills/bmad-brainstorming/scripts/brain.py
new file mode 100644
index 000000000..214539ab3
--- /dev/null
+++ b/src/core-skills/bmad-brainstorming/scripts/brain.py
@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# ///
+"""Serve the brainstorming technique library without loading it all into context.
+
+The library is a CSV (category, technique_name, description, detail). `description`
+is a short gist — enough to propose and run most techniques. `detail` is optional:
+a path (relative to the CSV's directory) to a fuller instruction file for a technique
+complex enough to warrant one. Only `show` resolves detail files, and only for the
+technique asked for — so the heavy material never enters context until it is run.
+
+Commands:
+  categories                 list category names + counts (the cheap entry point)
+  list [--category C ...]     the index: category / name / gist, optionally filtered
+  show NAME [NAME ...]        full gist for each, inlining its detail file if it has one
+  random [--category C] [-n N]  pick N at random (optionally within categories)
+
+Default output is lean text for an LLM to read; pass --json for structured output.
+"""
+import argparse
+import csv
+import json
+import random
+import sys
+from pathlib import Path
+
+DEFAULT_FILE = Path(__file__).resolve().parent.parent / "assets" / "brain-methods.csv"
+FIELDS = ("category", "technique_name", "description", "detail")
+
+
+def load(file: Path) -> list[dict]:
+    with open(file, newline="", encoding="utf-8") as f:
+        rows = list(csv.DictReader(f))
+    for r in rows:
+        r.setdefault("detail", "")
+        r["detail"] = (r.get("detail") or "").strip()
+    return rows
+
+
+def categories(rows: list[dict]) -> list[tuple[str, int]]:
+    counts: dict[str, int] = {}
+    for r in rows:
+        counts[r["category"]] = counts.get(r["category"], 0) + 1
+    return sorted(counts.items())
+
+
+def filter_cats(rows: list[dict], cats: list[str] | None) -> list[dict]:
+    if not cats:
+        return rows
+    wanted = {c.lower() for c in cats}
+    return [r for r in rows if r["category"].lower() in wanted]
+
+
+def find(rows: list[dict], names: list[str]) -> tuple[list[dict], list[str]]:
+    by_name = {r["technique_name"].lower(): r for r in rows}
+    found, missing = [], []
+    for n in names:
+        r = by_name.get(n.strip().lower())
+        (found if r else missing).append(r if r else n)
+    return found, missing
+
+
+def resolve_detail(row: dict, csv_dir: Path) -> str | None:
+    """Return the contents of a row's detail file, or None if there is no detail
+    (or the file is missing — a missing file is reported to stderr, not fatal)."""
+    if not row.get("detail"):
+        return None
+    path = (csv_dir / row["detail"]).resolve()
+    if not path.is_file():
+        print(f"# detail file not found for {row['technique_name']}: {row['detail']}", file=sys.stderr)
+        return None
+    return path.read_text(encoding="utf-8").strip()
+
+
+def fmt_categories(cats: list[tuple[str, int]], as_json: bool) -> str:
+    if as_json:
+        return json.dumps([{"category": c, "count": n} for c, n in cats])
+    return "\n".join(f"{c}\t{n}" for c, n in cats)
+
+
+def fmt_list(rows: list[dict], as_json: bool) -> str:
+    if as_json:
+        return json.dumps([{k: r[k] for k in ("category", "technique_name", "description")} for r in rows])
+    return "\n".join(f"{r['category']}\t{r['technique_name']}\t{r['description']}" for r in rows)
+
+
+def fmt_show(rows: list[dict], csv_dir: Path, as_json: bool) -> str:
+    if as_json:
+        out = []
+        for r in rows:
+            d = resolve_detail(r, csv_dir)
+            entry = {k: r[k] for k in ("category", "technique_name", "description")}
+            if d:
+                entry["detail"] = d
+            out.append(entry)
+        return json.dumps(out)
+    blocks = []
+    for r in rows:
+        block = f"## {r['technique_name']}  [{r['category']}]\n{r['description']}"
+        d = resolve_detail(r, csv_dir)
+        if d:
+            block += f"\n\n{d}"
+        blocks.append(block)
+    return "\n\n".join(blocks)
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--file", type=Path, default=DEFAULT_FILE, help="technique CSV (default: sibling assets/brain-methods.csv)")
+    p.add_argument("--json", action="store_true", help="emit structured JSON instead of lean text")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("categories", help="list category names + counts")
+    pl = sub.add_parser("list", help="the index: category/name/gist")
+    pl.add_argument("--category", action="append", help="filter to a category (repeatable)")
+    ps = sub.add_parser("show", help="full gist + detail file for named techniques")
+    ps.add_argument("names", nargs="+")
+    pr = sub.add_parser("random", help="pick techniques at random")
+    pr.add_argument("--category", action="append", help="restrict to a category (repeatable)")
+    pr.add_argument("-n", type=int, default=1, help="how many (default 1)")
+    args = p.parse_args(argv)
+
+    if not args.file.is_file():
+        print(f"error: technique file not found: {args.file}", file=sys.stderr)
+        return 2
+    rows = load(args.file)
+    csv_dir = args.file.resolve().parent
+
+    if args.cmd == "categories":
+        print(fmt_categories(categories(rows), args.json))
+    elif args.cmd == "list":
+        print(fmt_list(filter_cats(rows, args.category), args.json))
+    elif args.cmd == "show":
+        found, missing = find(rows, args.names)
+        for m in missing:
+            print(f"# not found: {m}", file=sys.stderr)
+        if not found:
+            return 1
+        print(fmt_show(found, csv_dir, args.json))
+    elif args.cmd == "random":
+        pool = filter_cats(rows, args.category)
+        if not pool:
+            print("# no techniques match", file=sys.stderr)
+            return 1
+        print(fmt_list(random.sample(pool, min(args.n, len(pool))), args.json))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/src/core-skills/bmad-brainstorming/scripts/tests/test_brain.py b/src/core-skills/bmad-brainstorming/scripts/tests/test_brain.py
new file mode 100644
index 000000000..91e986d2c
--- /dev/null
+++ b/src/core-skills/bmad-brainstorming/scripts/tests/test_brain.py
@@ -0,0 +1,113 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pytest>=8.0"]
+# ///
+"""Tests for brain.py. Run: uv run -m pytest scripts/tests/test_brain.py"""
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+import brain  # noqa: E402
+
+CSV = """category,technique_name,description,detail
+collaborative,Yes And Building,Build on every idea with "yes and" to keep momentum,
+wild,Quantum Superposition,Hold contradictory ideas as simultaneously true,techniques/quantum.md
+structured,SCAMPER Method,Run the idea through seven transformation lenses,
+wild,Anti-Solution,Brainstorm how to make the problem worse then invert,
+"""
+
+DETAIL = "# Quantum Superposition\nFull multi-step instructions for the complex technique."
+
+
+@pytest.fixture
+def lib(tmp_path):
+    csv_path = tmp_path / "brain-methods.csv"
+    csv_path.write_text(CSV, encoding="utf-8")
+    (tmp_path / "techniques").mkdir()
+    (tmp_path / "techniques" / "quantum.md").write_text(DETAIL, encoding="utf-8")
+    return csv_path
+
+
+def test_load_normalizes_detail(lib):
+    rows = brain.load(lib)
+    assert len(rows) == 4
+    assert rows[0]["detail"] == ""
+    assert rows[1]["detail"] == "techniques/quantum.md"
+
+
+def test_categories_counts_sorted(lib):
+    assert brain.categories(brain.load(lib)) == [("collaborative", 1), ("structured", 1), ("wild", 2)]
+
+
+def test_filter_is_case_insensitive(lib):
+    rows = brain.filter_cats(brain.load(lib), ["WILD"])
+    assert {r["technique_name"] for r in rows} == {"Quantum Superposition", "Anti-Solution"}
+
+
+def test_filter_none_returns_all(lib):
+    assert len(brain.filter_cats(brain.load(lib), None)) == 4
+
+
+def test_find_hits_and_misses(lib):
+    found, missing = brain.find(brain.load(lib), ["scamper method", "Nope"])
+    assert [r["technique_name"] for r in found] == ["SCAMPER Method"]
+    assert missing == ["Nope"]
+
+
+def test_resolve_detail_present(lib):
+    row = next(r for r in brain.load(lib) if r["detail"])
+    assert "multi-step instructions" in brain.resolve_detail(row, lib.parent)
+
+
+def test_resolve_detail_absent_is_none(lib):
+    row = next(r for r in brain.load(lib) if not r["detail"])
+    assert brain.resolve_detail(row, lib.parent) is None
+
+
+def test_resolve_detail_missing_file_warns_not_fatal(lib, capsys):
+    rows = brain.load(lib)
+    rows[1]["detail"] = "techniques/gone.md"
+    assert brain.resolve_detail(rows[1], lib.parent) is None
+    assert "not found" in capsys.readouterr().err
+
+
+def test_show_inlines_detail(lib, capsys):
+    assert brain.main(["--file", str(lib), "show", "Quantum Superposition"]) == 0
+    out = capsys.readouterr().out
+    assert "multi-step instructions" in out and "[wild]" in out
+
+
+def test_show_simple_has_no_detail(lib, capsys):
+    brain.main(["--file", str(lib), "show", "SCAMPER Method"])
+    out = capsys.readouterr().out
+    assert "transformation lenses" in out
+
+
+def test_show_all_missing_returns_1(lib):
+    assert brain.main(["--file", str(lib), "show", "Ghost"]) == 1
+
+
+def test_list_filtered_text(lib, capsys):
+    brain.main(["--file", str(lib), "list", "--category", "structured"])
+    out = capsys.readouterr().out.strip().splitlines()
+    assert len(out) == 1 and out[0].startswith("structured\tSCAMPER Method\t")
+
+
+def test_json_output(lib, capsys):
+    import json
+    brain.main(["--file", str(lib), "--json", "categories"])
+    data = json.loads(capsys.readouterr().out)
+    assert {"category": "wild", "count": 2} in data
+
+
+def test_random_respects_n_and_category(lib, capsys):
+    brain.main(["--file", str(lib), "random", "--category", "wild", "-n", "5"])
+    lines = capsys.readouterr().out.strip().splitlines()
+    assert len(lines) == 2  # only 2 wild exist, n capped
+    assert all(l.startswith("wild\t") for l in lines)
+
+
+def test_missing_file_returns_2(tmp_path):
+    assert brain.main(["--file", str(tmp_path / "nope.csv"), "categories"]) == 2
diff --git a/src/core-skills/bmad-brainstorming/steps/step-01-session-setup.md b/src/core-skills/bmad-brainstorming/steps/step-01-session-setup.md
deleted file mode 100644
index cdc6069c3..000000000
--- a/src/core-skills/bmad-brainstorming/steps/step-01-session-setup.md
+++ /dev/null
@@ -1,214 +0,0 @@
-# Step 1: Session Setup and Continuation Detection
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER generate content without user input
-- ✅ ALWAYS treat this as collaborative facilitation
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on session setup and continuation detection only
-- 🚪 DETECT existing workflow state and handle continuation properly
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- 💾 Initialize document and update frontmatter
-- 📖 Set up frontmatter `stepsCompleted: [1]` before loading next step
-- 🚫 FORBIDDEN to load next step until setup is complete
-
-## CONTEXT BOUNDARIES:
-
-- Variables from workflow.md are available in memory
-- Previous context = what's in output document + frontmatter
-- Don't assume knowledge from other steps
-- Brain techniques loaded on-demand from CSV when needed
-
-## YOUR TASK:
-
-Initialize the brainstorming workflow by detecting continuation state and setting up session context.
-
-## INITIALIZATION SEQUENCE:
-
-### 1. Check for Existing Sessions
-
-First, check the brainstorming sessions folder for existing sessions:
-
-- List all files in `{output_folder}/brainstorming/`
-- **DO NOT read any file contents** - only list filenames
-- If files exist, identify the most recent by date/time in the filename
-- If no files exist, this is a fresh workflow
-
-### 2. Handle Existing Sessions (If Files Found)
-
-If existing session files are found:
-
-- Display the most recent session filename (do NOT read its content)
-- Ask the user: "Found existing session: `[filename]`. Would you like to:
-  **[1]** Continue this session
-  **[2]** Start a new session
-  **[3]** See all existing sessions"
-
-**HALT — wait for user selection before proceeding.**
-
-- If user selects **[1]** (continue): Set `{brainstorming_session_output_file}` to that file path and load `./step-01b-continue.md`
-- If user selects **[2]** (new): Generate new filename with current date/time and proceed to step 3
-- If user selects **[3]** (see all): List all session filenames and ask which to continue or if new
-
-### 3. Fresh Workflow Setup (If No Files or User Chooses New)
-
-If no document exists or no `stepsCompleted` in frontmatter:
-
-#### A. Initialize Document
-
-Create the brainstorming session document:
-
-```bash
-# Create directory if needed
-mkdir -p "$(dirname "{brainstorming_session_output_file}")"
-
-# Initialize from template
-cp "../template.md" "{brainstorming_session_output_file}"
-```
-
-#### B. Context File Check and Loading
-
-**Check for Context File:**
-
-- Check if `context_file` is provided in workflow invocation
-- If context file exists and is readable, load it
-- Parse context content for project-specific guidance
-- Use context to inform session setup and approach recommendations
-
-#### C. Session Context Gathering
-
-"Welcome {{user_name}}! I'm excited to facilitate your brainstorming session. I'll guide you through proven creativity techniques to generate innovative ideas and breakthrough solutions.
-
-**Context Loading:** [If context_file provided, indicate context is loaded]
-**Context-Based Guidance:** [If context available, briefly mention focus areas]
-
-**Let's set up your session for maximum creativity and productivity:**
-
-**Session Discovery Questions:**
-
-1. **What are we brainstorming about?** (The central topic or challenge)
-2. **What specific outcomes are you hoping for?** (Types of ideas, solutions, or insights)"
-
-#### D. Process User Responses
-
-Wait for user responses, then:
-
-**Session Analysis:**
-"Based on your responses, I understand we're focusing on **[summarized topic]** with goals around **[summarized objectives]**.
-
-**Session Parameters:**
-
-- **Topic Focus:** [Clear topic articulation]
-- **Primary Goals:** [Specific outcome objectives]
-
-**Does this accurately capture what you want to achieve?**"
-
-#### E. Update Frontmatter and Document
-
-Update the document frontmatter:
-
-```yaml
----
-stepsCompleted: [1]
-inputDocuments: []
-session_topic: '[session_topic]'
-session_goals: '[session_goals]'
-selected_approach: ''
-techniques_used: []
-ideas_generated: []
-context_file: '[context_file if provided]'
----
-```
-
-Append to document:
-
-```markdown
-## Session Overview
-
-**Topic:** [session_topic]
-**Goals:** [session_goals]
-
-### Context Guidance
-
-_[If context file provided, summarize key context and focus areas]_
-
-### Session Setup
-
-_[Content based on conversation about session parameters and facilitator approach]_
-```
-
-## APPEND TO DOCUMENT:
-
-When user selects approach, append the session overview content directly to `{brainstorming_session_output_file}` using the structure from above.
-
-### E. Continue to Technique Selection
-
-"**Session setup complete!** I have a clear understanding of your goals and can select the perfect techniques for your brainstorming needs.
-
-**Ready to explore technique approaches?**
-[1] User-Selected Techniques - Browse our complete technique library
-[2] AI-Recommended Techniques - Get customized suggestions based on your goals
-[3] Random Technique Selection - Discover unexpected creative methods
-[4] Progressive Technique Flow - Start broad, then systematically narrow focus
-
-Which approach appeals to you most? (Enter 1-4)"
-
-**HALT — wait for user selection before proceeding.**
-
-### 4. Handle User Selection and Initial Document Append
-
-#### When user selects approach number:
-
-- **Append initial session overview to `{brainstorming_session_output_file}`**
-- **Update frontmatter:** `stepsCompleted: [1]`, `selected_approach: '[selected approach]'`
-- **Load the appropriate step-02 file** based on selection
-
-### 5. Handle User Selection
-
-After user selects approach number:
-
-- **If 1:** Load `./step-02a-user-selected.md`
-- **If 2:** Load `./step-02b-ai-recommended.md`
-- **If 3:** Load `./step-02c-random-selection.md`
-- **If 4:** Load `./step-02d-progressive-flow.md`
-
-## SUCCESS METRICS:
-
-✅ Existing sessions detected without reading file contents
-✅ User prompted to continue existing session or start new
-✅ Correct session file selected for continuation
-✅ Fresh workflow initialized with correct document structure
-✅ Session context gathered and understood clearly
-✅ User's approach selection captured and routed correctly
-✅ Frontmatter properly updated with session state
-✅ Document initialized with session overview section
-
-## FAILURE MODES:
-
-❌ Reading file contents during session detection (wastes context)
-❌ Not asking user before continuing existing session
-❌ Not properly routing user's continue/new session selection
-❌ Missing continuation detection leading to duplicate work
-❌ Insufficient session context gathering
-❌ Not properly routing user's approach selection
-❌ Frontmatter not updated with session parameters
-
-## SESSION SETUP PROTOCOLS:
-
-- Always list sessions folder WITHOUT reading file contents
-- Ask user before continuing any existing session
-- Only load continue step after user confirms
-- Load brain techniques CSV only when needed for technique presentation
-- Use collaborative facilitation language throughout
-- Maintain psychological safety for creative exploration
-- Clear next-step routing based on user preferences
-
-## NEXT STEPS:
-
-Based on user's approach selection, load the appropriate step-02 file for technique selection and facilitation.
-
-Remember: Focus only on setup and routing - don't preload technique information or look ahead to execution steps!
diff --git a/src/core-skills/bmad-brainstorming/steps/step-01b-continue.md b/src/core-skills/bmad-brainstorming/steps/step-01b-continue.md
deleted file mode 100644
index 27e41500a..000000000
--- a/src/core-skills/bmad-brainstorming/steps/step-01b-continue.md
+++ /dev/null
@@ -1,124 +0,0 @@
-# Step 1b: Workflow Continuation
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- ✅ YOU ARE A CONTINUATION FACILITATOR, not a fresh starter
-- 🎯 RESPECT EXISTING WORKFLOW state and progress
-- 📋 UNDERSTAND PREVIOUS SESSION context and outcomes
-- 🔍 SEAMLESSLY RESUME from where user left off
-- 💬 MAINTAIN CONTINUITY in session flow and rapport
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Load and analyze existing document thoroughly
-- 💾 Update frontmatter with continuation state
-- 📖 Present current status and next options clearly
-- 🚫 FORBIDDEN repeating completed work or asking same questions
-
-## CONTEXT BOUNDARIES:
-
-- Existing document with frontmatter is available
-- Previous steps completed indicate session progress
-- Brain techniques CSV loaded when needed for remaining steps
-- User may want to continue, modify, or restart
-
-## YOUR TASK:
-
-Analyze existing brainstorming session state and provide seamless continuation options.
-
-## CONTINUATION SEQUENCE:
-
-### 1. Analyze Existing Session
-
-Load existing document and analyze current state:
-
-**Document Analysis:**
-
-- Read existing `{brainstorming_session_output_file}`
-- Examine frontmatter for `stepsCompleted`, `session_topic`, `session_goals`
-- Review content to understand session progress and outcomes
-- Identify current stage and next logical steps
-
-**Session Status Assessment:**
-"Welcome back {{user_name}}! I can see your brainstorming session on **[session_topic]** from **[date]**.
-
-**Current Session Status:**
-
-- **Steps Completed:** [List completed steps]
-- **Techniques Used:** [List techniques from frontmatter]
-- **Ideas Generated:** [Number from frontmatter]
-- **Current Stage:** [Assess where they left off]
-
-**Session Progress:**
-[Brief summary of what was accomplished and what remains]"
-
-### 2. Present Continuation Options
-
-Based on session analysis, provide appropriate options:
-
-**If Session Completed:**
-"Your brainstorming session appears to be complete!
-
-**Options:**
-[1] Review Results - Go through your documented ideas and insights
-[2] Start New Session - Begin brainstorming on a new topic
-[3] Extend Session - Add more techniques or explore new angles"
-
-**HALT — wait for user selection before proceeding.**
-
-**If Session In Progress:**
-"Let's continue where we left off!
-
-**Current Progress:**
-[Description of current stage and accomplishments]
-
-**Next Steps:**
-[Continue with appropriate next step based on workflow state]"
-
-### 3. Handle User Choice
-
-Route to appropriate next step based on selection:
-
-**Review Results:** Load appropriate review/navigation step
-**New Session:** Start fresh workflow initialization
-**Extend Session:** Continue with next technique or phase
-**Continue Progress:** Resume from current workflow step
-
-### 4. Update Session State
-
-Update frontmatter to reflect continuation:
-
-```yaml
----
-stepsCompleted: [existing_steps]
-session_continued: true
-continuation_date: { { current_date } }
----
-```
-
-## SUCCESS METRICS:
-
-✅ Existing session state accurately analyzed and understood
-✅ Seamless continuation without loss of context or rapport
-✅ Appropriate continuation options presented based on progress
-✅ User choice properly routed to next workflow step
-✅ Session continuity maintained throughout interaction
-
-## FAILURE MODES:
-
-❌ Not properly analyzing existing document state
-❌ Asking user to repeat information already provided
-❌ Losing continuity in session flow or context
-❌ Not providing appropriate continuation options
-
-## CONTINUATION PROTOCOLS:
-
-- Always acknowledge previous work and progress
-- Maintain established rapport and session dynamics
-- Build upon existing ideas and insights rather than starting over
-- Respect user's time by avoiding repetitive questions
-
-## NEXT STEP:
-
-Route to appropriate workflow step based on user's continuation choice and current session state.
diff --git a/src/core-skills/bmad-brainstorming/steps/step-02a-user-selected.md b/src/core-skills/bmad-brainstorming/steps/step-02a-user-selected.md
deleted file mode 100644
index 5335ff08a..000000000
--- a/src/core-skills/bmad-brainstorming/steps/step-02a-user-selected.md
+++ /dev/null
@@ -1,229 +0,0 @@
-# Step 2a: User-Selected Techniques
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- ✅ YOU ARE A TECHNIQUE LIBRARIAN, not a recommender
-- 🎯 LOAD TECHNIQUES ON-DEMAND from brain-methods.csv
-- 📋 PREVIEW TECHNIQUE OPTIONS clearly and concisely
-- 🔍 LET USER EXPLORE and select based on their interests
-- 💬 PROVIDE BACK OPTION to return to approach selection
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Load brain techniques CSV only when needed for presentation
-- ⚠️ Present [B] back option and [C] continue options
-- 💾 Update frontmatter with selected techniques
-- 📖 Route to technique execution after confirmation
-- 🚫 FORBIDDEN making recommendations or steering choices
-
-## CONTEXT BOUNDARIES:
-
-- Session context from Step 1 is available
-- Brain techniques CSV contains 36+ techniques across 7 categories
-- User wants full control over technique selection
-- May need to present techniques by category or search capability
-
-## YOUR TASK:
-
-Load and present brainstorming techniques from CSV, allowing user to browse and select based on their preferences.
-
-## USER SELECTION SEQUENCE:
-
-### 1. Load Brain Techniques Library
-
-Load techniques from CSV on-demand:
-
-"Perfect! Let's explore our complete brainstorming techniques library. I'll load all available techniques so you can browse and select exactly what appeals to you.
-
-**Loading Brain Techniques Library...**"
-
-**Load CSV and parse:**
-
-- Read `../brain-methods.csv`
-- Parse: category, technique_name, description, facilitation_prompts, best_for, energy_level, typical_duration
-- Organize by categories for browsing
-
-### 2. Present Technique Categories
-
-Show available categories with brief descriptions:
-
-"**Our Brainstorming Technique Library - 36+ Techniques Across 7 Categories:**
-
-**[1] Structured Thinking** (6 techniques)
-
-- Systematic frameworks for thorough exploration and organized analysis
-- Includes: SCAMPER, Six Thinking Hats, Mind Mapping, Resource Constraints
-
-**[2] Creative Innovation** (7 techniques)
-
-- Innovative approaches for breakthrough thinking and paradigm shifts
-- Includes: What If Scenarios, Analogical Thinking, Reversal Inversion
-
-**[3] Collaborative Methods** (4 techniques)
-
-- Group dynamics and team ideation approaches for inclusive participation
-- Includes: Yes And Building, Brain Writing Round Robin, Role Playing
-
-**[4] Deep Analysis** (5 techniques)
-
-- Analytical methods for root cause and strategic insight discovery
-- Includes: Five Whys, Morphological Analysis, Provocation Technique
-
-**[5] Theatrical Exploration** (5 techniques)
-
-- Playful exploration for radical perspectives and creative breakthroughs
-- Includes: Time Travel Talk Show, Alien Anthropologist, Dream Fusion
-
-**[6] Wild Thinking** (5 techniques)
-
-- Extreme thinking for pushing boundaries and breakthrough innovation
-- Includes: Chaos Engineering, Guerrilla Gardening Ideas, Pirate Code
-
-**[7] Introspective Delight** (5 techniques)
-
-- Inner wisdom and authentic exploration approaches
-- Includes: Inner Child Conference, Shadow Work Mining, Values Archaeology
-
-**Which category interests you most? Enter 1-7, or tell me what type of thinking you're drawn to.**"
-
-**HALT — wait for user selection before proceeding.**
-
-### 3. Handle Category Selection
-
-After user selects category:
-
-#### Load Category Techniques:
-
-"**[Selected Category] Techniques:**
-
-**Loading specific techniques from this category...**"
-
-**Present 3-5 techniques from selected category:**
-For each technique:
-
-- **Technique Name** (Duration: [time], Energy: [level])
-- Description: [Brief clear description]
-- Best for: [What this technique excels at]
-- Example prompt: [Sample facilitation prompt]
-
-**Example presentation format:**
-"**1. SCAMPER Method** (Duration: 20-30 min, Energy: Moderate)
-
-- Systematic creativity through seven lenses (Substitute/Combine/Adapt/Modify/Put/Eliminate/Reverse)
-- Best for: Product improvement, innovation challenges, systematic idea generation
-- Example prompt: "What could you substitute in your current approach to create something new?"
-
-**2. Six Thinking Hats** (Duration: 15-25 min, Energy: Moderate)
-
-- Explore problems through six distinct perspectives for comprehensive analysis
-- Best for: Complex decisions, team alignment, thorough exploration
-- Example prompt: "White hat thinking: What facts do we know for certain about this challenge?"
-
-### 4. Allow Technique Selection
-
-"**Which techniques from this category appeal to you?**
-
-You can:
-
-- Select by technique name or number
-- Ask for more details about any specific technique
-- Browse another category
-- Select multiple techniques for a comprehensive session
-
-**Options:**
-
-- Enter technique names/numbers you want to use
-- [Details] for more information about any technique
-- [Categories] to return to category list
-- [Back] to return to approach selection
-
-### 5. Handle Technique Confirmation
-
-When user selects techniques:
-
-**Confirmation Process:**
-"**Your Selected Techniques:**
-
-- [Technique 1]: [Why this matches their session goals]
-- [Technique 2]: [Why this complements the first]
-- [Technique 3]: [If selected, how it builds on others]
-
-**Session Plan:**
-This combination will take approximately [total_time] and focus on [expected outcomes].
-
-**Confirm these choices?**
-[C] Continue - Begin technique execution
-[Back] - Modify technique selection"
-
-**HALT — wait for user selection before proceeding.**
-
-### 6. Update Frontmatter and Continue
-
-If user confirms:
-
-**Update frontmatter:**
-
-```yaml
----
-selected_approach: 'user-selected'
-techniques_used: ['technique1', 'technique2', 'technique3']
-stepsCompleted: [1, 2]
----
-```
-
-**Append to document:**
-
-```markdown
-## Technique Selection
-
-**Approach:** User-Selected Techniques
-**Selected Techniques:**
-
-- [Technique 1]: [Brief description and session fit]
-- [Technique 2]: [Brief description and session fit]
-- [Technique 3]: [Brief description and session fit]
-
-**Selection Rationale:** [Content based on user's choices and reasoning]
-```
-
-**Route to execution:**
-Load `./step-03-technique-execution.md`
-
-### 7. Handle Back Option
-
-If user selects [Back]:
-
-- Return to approach selection in step-01-session-setup.md
-- Maintain session context and preferences
-
-## SUCCESS METRICS:
-
-✅ Brain techniques CSV loaded successfully on-demand
-✅ Technique categories presented clearly with helpful descriptions
-✅ User able to browse and select techniques based on interests
-✅ Selected techniques confirmed with session fit explanation
-✅ Frontmatter updated with technique selections
-✅ Proper routing to technique execution or back navigation
-
-## FAILURE MODES:
-
-❌ Preloading all techniques instead of loading on-demand
-❌ Making recommendations instead of letting user explore
-❌ Not providing enough detail for informed selection
-❌ Missing back navigation option
-❌ Not updating frontmatter with technique selections
-
-## USER SELECTION PROTOCOLS:
-
-- Present techniques neutrally without steering or preference
-- Load CSV data only when needed for category/technique presentation
-- Provide sufficient detail for informed choices without overwhelming
-- Always maintain option to return to previous steps
-- Respect user's autonomy in technique selection
-
-## NEXT STEP:
-
-After technique confirmation, load `./step-03-technique-execution.md` to begin facilitating the selected brainstorming techniques.
-
-Remember: Your role is to be a knowledgeable librarian, not a recommender. Let the user explore and choose based on their interests and intuition!
diff --git a/src/core-skills/bmad-brainstorming/steps/step-02b-ai-recommended.md b/src/core-skills/bmad-brainstorming/steps/step-02b-ai-recommended.md
deleted file mode 100644
index b7d979a6b..000000000
--- a/src/core-skills/bmad-brainstorming/steps/step-02b-ai-recommended.md
+++ /dev/null
@@ -1,239 +0,0 @@
-# Step 2b: AI-Recommended Techniques
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- ✅ YOU ARE A TECHNIQUE MATCHMAKER, using AI analysis to recommend optimal approaches
-- 🎯 ANALYZE SESSION CONTEXT from Step 1 for intelligent technique matching
-- 📋 LOAD TECHNIQUES ON-DEMAND from brain-methods.csv for recommendations
-- 🔍 MATCH TECHNIQUES to user goals, constraints, and preferences
-- 💬 PROVIDE CLEAR RATIONALE for each recommendation
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Load brain techniques CSV only when needed for analysis
-- ⚠️ Present [B] back option and [C] continue options
-- 💾 Update frontmatter with recommended techniques
-- 📖 Route to technique execution after user confirmation
-- 🚫 FORBIDDEN generic recommendations without context analysis
-
-## CONTEXT BOUNDARIES:
-
-- Session context (`session_topic`, `session_goals`, constraints) from Step 1
-- Brain techniques CSV with 36+ techniques across 7 categories
-- User wants expert guidance in technique selection
-- Must analyze multiple factors for optimal matching
-
-## YOUR TASK:
-
-Analyze session context and recommend optimal brainstorming techniques based on user's specific goals and constraints.
-
-## AI RECOMMENDATION SEQUENCE:
-
-### 1. Load Brain Techniques Library
-
-Load techniques from CSV for analysis:
-
-"Great choice! Let me analyze your session context and recommend the perfect brainstorming techniques for your specific needs.
-
-**Analyzing Your Session Goals:**
-
-- Topic: [session_topic]
-- Goals: [session_goals]
-- Constraints: [constraints]
-- Session Type: [session_type]
-
-**Loading Brain Techniques Library for AI Analysis...**"
-
-**Load CSV and parse:**
-
-- Read `../brain-methods.csv`
-- Parse: category, technique_name, description, facilitation_prompts, best_for, energy_level, typical_duration
-
-### 2. Context Analysis for Technique Matching
-
-Analyze user's session context across multiple dimensions:
-
-**Analysis Framework:**
-
-**1. Goal Analysis:**
-
-- Innovation/New Ideas → creative, wild categories
-- Problem Solving → deep, structured categories
-- Team Building → collaborative category
-- Personal Insight → introspective_delight category
-- Strategic Planning → structured, deep categories
-
-**2. Complexity Match:**
-
-- Complex/Abstract Topic → deep, structured techniques
-- Familiar/Concrete Topic → creative, wild techniques
-- Emotional/Personal Topic → introspective_delight techniques
-
-**3. Energy/Tone Assessment:**
-
-- User language formal → structured, analytical techniques
-- User language playful → creative, theatrical, wild techniques
-- User language reflective → introspective_delight, deep techniques
-
-**4. Time Available:**
-
-- <30 min → 1-2 focused techniques
-- 30-60 min → 2-3 complementary techniques
-- > 60 min → Multi-phase technique flow
-
-### 3. Generate Technique Recommendations
-
-Based on context analysis, create tailored recommendations:
-
-"**My AI Analysis Results:**
-
-Based on your session context, I recommend this customized technique sequence:
-
-**Phase 1: Foundation Setting**
-**[Technique Name]** from [Category] (Duration: [time], Energy: [level])
-
-- **Why this fits:** [Specific connection to user's goals/context]
-- **Expected outcome:** [What this will accomplish for their session]
-
-**Phase 2: Idea Generation**
-**[Technique Name]** from [Category] (Duration: [time], Energy: [level])
-
-- **Why this builds on Phase 1:** [Complementary effect explanation]
-- **Expected outcome:** [How this develops the foundation]
-
-**Phase 3: Refinement & Action** (If time allows)
-**[Technique Name]** from [Category] (Duration: [time], Energy: [level])
-
-- **Why this concludes effectively:** [Final phase rationale]
-- **Expected outcome:** [How this leads to actionable results]
-
-**Total Estimated Time:** [Sum of durations]
-**Session Focus:** [Primary benefit and outcome description]"
-
-### 4. Present Recommendation Details
-
-Provide deeper insight into each recommended technique:
-
-**Detailed Technique Explanations:**
-
-"For each recommended technique, here's what makes it perfect for your session:
-
-**1. [Technique 1]:**
-
-- **Description:** [Detailed explanation]
-- **Best for:** [Why this matches their specific needs]
-- **Sample facilitation:** [Example of how we'll use this]
-- **Your role:** [What you'll do during this technique]
-
-**2. [Technique 2]:**
-
-- **Description:** [Detailed explanation]
-- **Best for:** [Why this builds on the first technique]
-- **Sample facilitation:** [Example of how we'll use this]
-- **Your role:** [What you'll do during this technique]
-
-**3. [Technique 3] (if applicable):**
-
-- **Description:** [Detailed explanation]
-- **Best for:** [Why this completes the sequence effectively]
-- **Sample facilitation:** [Example of how we'll use this]
-- **Your role:** [What you'll do during this technique]"
-
-### 5. Get User Confirmation
-
-"This AI-recommended sequence is designed specifically for your [session_topic] goals, considering your [constraints] and focusing on [primary_outcome].
-
-**Does this approach sound perfect for your session?**
-
-**Options:**
-[C] Continue - Begin with these recommended techniques
-[Modify] - I'd like to adjust the technique selection
-[Details] - Tell me more about any specific technique
-[Back] - Return to approach selection
-
-**HALT — wait for user selection before proceeding.**
-
-### 6. Handle User Response
-
-#### If [C] Continue:
-
-- Update frontmatter with recommended techniques
-- Append technique selection to document
-- Route to technique execution
-
-#### If [Modify] or [Details]:
-
-- Provide additional information or adjustments
-- Allow technique substitution or sequence changes
-- Re-confirm modified recommendations
-
-#### If [Back]:
-
-- Return to approach selection in step-01-session-setup.md
-- Maintain session context and preferences
-
-### 7. Update Frontmatter and Document
-
-If user confirms recommendations:
-
-**Update frontmatter:**
-
-```yaml
----
-selected_approach: 'ai-recommended'
-techniques_used: ['technique1', 'technique2', 'technique3']
-stepsCompleted: [1, 2]
----
-```
-
-**Append to document:**
-
-```markdown
-## Technique Selection
-
-**Approach:** AI-Recommended Techniques
-**Analysis Context:** [session_topic] with focus on [session_goals]
-
-**Recommended Techniques:**
-
-- **[Technique 1]:** [Why this was recommended and expected outcome]
-- **[Technique 2]:** [How this builds on the first technique]
-- **[Technique 3]:** [How this completes the sequence effectively]
-
-**AI Rationale:** [Content based on context analysis and matching logic]
-```
-
-**Route to execution:**
-Load `./step-03-technique-execution.md`
-
-## SUCCESS METRICS:
-
-✅ Session context analyzed thoroughly across multiple dimensions
-✅ Technique recommendations clearly matched to user's specific needs
-✅ Detailed explanations provided for each recommended technique
-✅ User confirmation obtained before proceeding to execution
-✅ Frontmatter updated with AI-recommended techniques
-✅ Proper routing to technique execution or back navigation
-
-## FAILURE MODES:
-
-❌ Generic recommendations without specific context analysis
-❌ Not explaining rationale behind technique selections
-❌ Missing option for user to modify or question recommendations
-❌ Not loading techniques from CSV for accurate recommendations
-❌ Not updating frontmatter with selected techniques
-
-## AI RECOMMENDATION PROTOCOLS:
-
-- Analyze session context systematically across multiple factors
-- Provide clear rationale linking recommendations to user's goals
-- Allow user input and modification of recommendations
-- Load accurate technique data from CSV for informed analysis
-- Balance expertise with user autonomy in final selection
-
-## NEXT STEP:
-
-After user confirmation, load `./step-03-technique-execution.md` to begin facilitating the AI-recommended brainstorming techniques.
-
-Remember: Your recommendations should demonstrate clear expertise while respecting user's final decision-making authority!
diff --git a/src/core-skills/bmad-brainstorming/steps/step-02c-random-selection.md b/src/core-skills/bmad-brainstorming/steps/step-02c-random-selection.md
deleted file mode 100644
index af3072fc4..000000000
--- a/src/core-skills/bmad-brainstorming/steps/step-02c-random-selection.md
+++ /dev/null
@@ -1,211 +0,0 @@
-# Step 2c: Random Technique Selection
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- ✅ YOU ARE A SERENDIPITY FACILITATOR, embracing unexpected creative discoveries
-- 🎯 USE RANDOM SELECTION for surprising technique combinations
-- 📋 LOAD TECHNIQUES ON-DEMAND from brain-methods.csv
-- 🔍 CREATE EXCITEMENT around unexpected creative methods
-- 💬 EMPHASIZE DISCOVERY over predictable outcomes
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Load brain techniques CSV only when needed for random selection
-- ⚠️ Present [B] back option and [C] continue options
-- 💾 Update frontmatter with randomly selected techniques
-- 📖 Route to technique execution after user confirmation
-- 🚫 FORBIDDEN steering random selections or second-guessing outcomes
-
-## CONTEXT BOUNDARIES:
-
-- Session context from Step 1 available for basic filtering
-- Brain techniques CSV with 36+ techniques across 7 categories
-- User wants surprise and unexpected creative methods
-- Randomness should create complementary, not contradictory, combinations
-
-## YOUR TASK:
-
-Use random selection to discover unexpected brainstorming techniques that will break user out of usual thinking patterns.
-
-## RANDOM SELECTION SEQUENCE:
-
-### 1. Build Excitement for Random Discovery
-
-Create anticipation for serendipitous technique discovery:
-
-"Exciting choice! You've chosen the path of creative serendipity. Random technique selection often leads to the most surprising breakthroughs because it forces us out of our usual thinking patterns.
-
-**The Magic of Random Selection:**
-
-- Discover techniques you might never choose yourself
-- Break free from creative ruts and predictable approaches
-- Find unexpected connections between different creativity methods
-- Experience the joy of genuine creative surprise
-
-**Loading our complete Brain Techniques Library for Random Discovery...**"
-
-**Load CSV and parse:**
-
-- Read `../brain-methods.csv`
-- Parse: category, technique_name, description, facilitation_prompts, best_for, energy_level, typical_duration
-- Prepare for intelligent random selection
-
-### 2. Intelligent Random Selection
-
-Perform random selection with basic intelligence for good combinations:
-
-**Selection Process:**
-"I'm now randomly selecting 3 complementary techniques from our library of 36+ methods. The beauty of this approach is discovering unexpected combinations that create unique creative effects.
-
-**Randomizing Technique Selection...**"
-
-**Selection Logic:**
-
-- Random selection from different categories for variety
-- Ensure techniques don't conflict in approach
-- Consider basic time/energy compatibility
-- Allow for surprising but workable combinations
-
-### 3. Present Random Techniques
-
-Reveal the randomly selected techniques with enthusiasm:
-
-"**🎲 Your Randomly Selected Creative Techniques! 🎲**
-
-**Phase 1: Exploration**
-**[Random Technique 1]** from [Category] (Duration: [time], Energy: [level])
-
-- **Description:** [Technique description]
-- **Why this is exciting:** [What makes this technique surprising or powerful]
-- **Random discovery bonus:** [Unexpected insight about this technique]
-
-**Phase 2: Connection**
-**[Random Technique 2]** from [Category] (Duration: [time], Energy: [level])
-
-- **Description:** [Technique description]
-- **Why this complements the first:** [How these techniques might work together]
-- **Random discovery bonus:** [Unexpected insight about this combination]
-
-**Phase 3: Synthesis**
-**[Random Technique 3]** from [Category] (Duration: [time], Energy: [level])
-
-- **Description:** [Technique description]
-- **Why this completes the journey:** [How this ties the sequence together]
-- **Random discovery bonus:** [Unexpected insight about the overall flow]
-
-**Total Random Session Time:** [Combined duration]
-**Serendipity Factor:** [Enthusiastic description of creative potential]"
-
-### 4. Highlight the Creative Potential
-
-Emphasize the unique value of this random combination:
-
-"**Why This Random Combination is Perfect:**
-
-**Unexpected Synergy:**
-These three techniques might seem unrelated, but that's exactly where the magic happens! [Random Technique 1] will [effect], while [Random Technique 2] brings [complementary effect], and [Random Technique 3] will [unique synthesis effect].
-
-**Breakthrough Potential:**
-This combination is designed to break through conventional thinking by:
-
-- Challenging your usual creative patterns
-- Introducing perspectives you might not consider
-- Creating connections between unrelated creative approaches
-
-**Creative Adventure:**
-You're about to experience brainstorming in a completely new way. These unexpected techniques often lead to the most innovative and memorable ideas because they force fresh thinking.
-
-**Ready for this creative adventure?**
-
-**Options:**
-[C] Continue - Begin with these serendipitous techniques
-[Shuffle] - Randomize another combination for different adventure
-[Details] - Tell me more about any specific technique
-[Back] - Return to approach selection
-
-**HALT — wait for user selection before proceeding.**
-
-### 5. Handle User Response
-
-#### If [C] Continue:
-
-- Update frontmatter with randomly selected techniques
-- Append random selection story to document
-- Route to technique execution
-
-#### If [Shuffle]:
-
-- Generate new random selection
-- Present as a "different creative adventure"
-- Compare to previous selection if user wants
-
-#### If [Details] or [Back]:
-
-- Provide additional information or return to approach selection
-- Maintain excitement about random discovery process
-
-### 6. Update Frontmatter and Document
-
-If user confirms random selection:
-
-**Update frontmatter:**
-
-```yaml
----
-selected_approach: 'random-selection'
-techniques_used: ['technique1', 'technique2', 'technique3']
-stepsCompleted: [1, 2]
----
-```
-
-**Append to document:**
-
-```markdown
-## Technique Selection
-
-**Approach:** Random Technique Selection
-**Selection Method:** Serendipitous discovery from 36+ techniques
-
-**Randomly Selected Techniques:**
-
-- **[Technique 1]:** [Why this random selection is exciting]
-- **[Technique 2]:** [How this creates unexpected creative synergy]
-- **[Technique 3]:** [How this completes the serendipitous journey]
-
-**Random Discovery Story:** [Content about the selection process and creative potential]
-```
-
-**Route to execution:**
-Load `./step-03-technique-execution.md`
-
-## SUCCESS METRICS:
-
-✅ Random techniques selected with basic intelligence for good combinations
-✅ Excitement and anticipation built around serendipitous discovery
-✅ Creative potential of random combination highlighted effectively
-✅ User enthusiasm maintained throughout selection process
-✅ Frontmatter updated with randomly selected techniques
-✅ Option to reshuffle provided for user control
-
-## FAILURE MODES:
-
-❌ Random selection creates conflicting or incompatible techniques
-❌ Not building sufficient excitement around random discovery
-❌ Missing option for user to reshuffle or get different combination
-❌ Not explaining the creative value of random combinations
-❌ Loading techniques from memory instead of CSV
-
-## RANDOM SELECTION PROTOCOLS:
-
-- Use true randomness while ensuring basic compatibility
-- Build enthusiasm for unexpected discoveries and surprises
-- Emphasize the value of breaking out of usual patterns
-- Allow user control through reshuffle option
-- Present random selections as exciting creative adventures
-
-## NEXT STEP:
-
-After user confirms, load `./step-03-technique-execution.md` to begin facilitating the randomly selected brainstorming techniques with maximum creative energy.
-
-Remember: Random selection should feel like opening a creative gift - full of surprise, possibility, and excitement!
diff --git a/src/core-skills/bmad-brainstorming/steps/step-02d-progressive-flow.md b/src/core-skills/bmad-brainstorming/steps/step-02d-progressive-flow.md
deleted file mode 100644
index 2677814db..000000000
--- a/src/core-skills/bmad-brainstorming/steps/step-02d-progressive-flow.md
+++ /dev/null
@@ -1,266 +0,0 @@
-# Step 2d: Progressive Technique Flow
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- ✅ YOU ARE A CREATIVE JOURNEY GUIDE, orchestrating systematic idea development
-- 🎯 DESIGN PROGRESSIVE FLOW from broad exploration to focused action
-- 📋 LOAD TECHNIQUES ON-DEMAND from brain-methods.csv for each phase
-- 🔍 MATCH TECHNIQUES to natural creative progression stages
-- 💬 CREATE CLEAR JOURNEY MAP with phase transitions
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Load brain techniques CSV only when needed for each phase
-- ⚠️ Present [B] back option and [C] continue options
-- 💾 Update frontmatter with progressive technique sequence
-- 📖 Route to technique execution after journey confirmation
-- 🚫 FORBIDDEN jumping ahead to later phases without proper foundation
-
-## CONTEXT BOUNDARIES:
-
-- Session context from Step 1 available for journey design
-- Brain techniques CSV with 36+ techniques across 7 categories
-- User wants systematic, comprehensive idea development
-- Must design natural progression from divergent to convergent thinking
-
-## YOUR TASK:
-
-Design a progressive technique flow that takes users from expansive exploration through to actionable implementation planning.
-
-## PROGRESSIVE FLOW SEQUENCE:
-
-### 1. Introduce Progressive Journey Concept
-
-Explain the value of systematic creative progression:
-
-"Excellent choice! Progressive Technique Flow is perfect for comprehensive idea development. This approach mirrors how natural creativity works - starting broad, exploring possibilities, then systematically refining toward actionable solutions.
-
-**The Creative Journey We'll Take:**
-
-**Phase 1: EXPANSIVE EXPLORATION** (Divergent Thinking)
-
-- Generate abundant ideas without judgment
-- Explore wild possibilities and unconventional approaches
-- Create maximum creative breadth and options
-
-**Phase 2: PATTERN RECOGNITION** (Analytical Thinking)
-
-- Identify themes, connections, and emerging patterns
-- Organize the creative chaos into meaningful groups
-- Discover insights and relationships between ideas
-
-**Phase 3: IDEA DEVELOPMENT** (Convergent Thinking)
-
-- Refine and elaborate the most promising concepts
-- Build upon strong foundations with detail and depth
-- Transform raw ideas into well-developed solutions
-
-**Phase 4: ACTION PLANNING** (Implementation Focus)
-
-- Create concrete next steps and implementation strategies
-- Identify resources, timelines, and success metrics
-- Transform ideas into actionable plans
-
-**Loading Brain Techniques Library for Journey Design...**"
-
-**Load CSV and parse:**
-
-- Read `../brain-methods.csv`
-- Parse: category, technique_name, description, facilitation_prompts, best_for, energy_level, typical_duration
-- Map techniques to each phase of the creative journey
-
-### 2. Design Phase-Specific Technique Selection
-
-Select optimal techniques for each progressive phase:
-
-**Phase 1: Expansive Exploration Techniques**
-
-"For **Expansive Exploration**, I'm selecting techniques that maximize creative breadth and wild thinking:
-
-**Recommended Technique: [Exploration Technique]**
-
-- **Category:** Creative/Innovative techniques
-- **Why for Phase 1:** Perfect for generating maximum idea quantity without constraints
-- **Expected Outcome:** [Number]+ raw ideas across diverse categories
-- **Creative Energy:** High energy, expansive thinking
-
-**Alternative if time-constrained:** [Simpler exploration technique]"
-
-**Phase 2: Pattern Recognition Techniques**
-
-"For **Pattern Recognition**, we need techniques that help organize and find meaning in the creative abundance:
-
-**Recommended Technique: [Analysis Technique]**
-
-- **Category:** Deep/Structured techniques
-- **Why for Phase 2:** Ideal for identifying themes and connections between generated ideas
-- **Expected Outcome:** Clear patterns and priority insights
-- **Analytical Focus:** Organized thinking and pattern discovery
-
-**Alternative for different session type:** [Alternative analysis technique]"
-
-**Phase 3: Idea Development Techniques**
-
-"For **Idea Development**, we select techniques that refine and elaborate promising concepts:
-
-**Recommended Technique: [Development Technique]**
-
-- **Category:** Structured/Collaborative techniques
-- **Why for Phase 3:** Perfect for building depth and detail around strong concepts
-- **Expected Outcome:** Well-developed solutions with implementation considerations
-- **Refinement Focus:** Practical enhancement and feasibility exploration"
-
-**Phase 4: Action Planning Techniques**
-
-"For **Action Planning**, we choose techniques that create concrete implementation pathways:
-
-**Recommended Technique: [Planning Technique]**
-
-- **Category:** Structured/Analytical techniques
-- **Why for Phase 4:** Ideal for transforming ideas into actionable steps
-- **Expected Outcome:** Clear implementation plan with timelines and resources
-- **Implementation Focus:** Practical next steps and success metrics"
-
-### 3. Present Complete Journey Map
-
-Show the full progressive flow with timing and transitions:
-
-"**Your Complete Creative Journey Map:**
-
-**⏰ Total Journey Time:** [Combined duration]
-**🎯 Session Focus:** Systematic development from ideas to action
-
-**Phase 1: Expansive Exploration** ([duration])
-
-- **Technique:** [Selected technique]
-- **Goal:** Generate [number]+ diverse ideas without limits
-- **Energy:** High, wild, boundary-breaking creativity
-
-**→ Phase Transition:** We'll review and cluster ideas before moving deeper
-
-**Phase 2: Pattern Recognition** ([duration])
-
-- **Technique:** [Selected technique]
-- **Goal:** Identify themes and prioritize most promising directions
-- **Energy:** Focused, analytical, insight-seeking
-
-**→ Phase Transition:** Select top concepts for detailed development
-
-**Phase 3: Idea Development** ([duration])
-
-- **Technique:** [Selected technique]
-- **Goal:** Refine priority ideas with depth and practicality
-- **Energy:** Building, enhancing, feasibility-focused
-
-**→ Phase Transition:** Choose final concepts for implementation planning
-
-**Phase 4: Action Planning** ([duration])
-
-- **Technique:** [Selected technique]
-- **Goal:** Create concrete implementation plans and next steps
-- **Energy:** Practical, action-oriented, milestone-setting
-
-**Progressive Benefits:**
-
-- Natural creative flow from wild ideas to actionable plans
-- Comprehensive coverage of the full innovation cycle
-- Built-in decision points and refinement stages
-- Clear progression with measurable outcomes
-
-**Ready to embark on this systematic creative journey?**
-
-**Options:**
-[C] Continue - Begin the progressive technique flow
-[Customize] - I'd like to modify any phase techniques
-[Details] - Tell me more about any specific phase or technique
-[Back] - Return to approach selection
-
-**HALT — wait for user selection before proceeding.**
-
-### 4. Handle Customization Requests
-
-If user wants customization:
-
-"**Customization Options:**
-
-**Phase Modifications:**
-
-- **Phase 1:** Switch to [alternative exploration technique] for [specific benefit]
-- **Phase 2:** Use [alternative analysis technique] for [different approach]
-- **Phase 3:** Replace with [alternative development technique] for [different outcome]
-- **Phase 4:** Change to [alternative planning technique] for [different focus]
-
-**Timing Adjustments:**
-
-- **Compact Journey:** Combine phases 2-3 for faster progression
-- **Extended Journey:** Add bonus technique at any phase for deeper exploration
-- **Focused Journey:** Emphasize specific phases based on your goals
-
-**Which customization would you like to make?**"
-
-### 5. Update Frontmatter and Document
-
-If user confirms progressive flow:
-
-**Update frontmatter:**
-
-```yaml
----
-selected_approach: 'progressive-flow'
-techniques_used: ['technique1', 'technique2', 'technique3', 'technique4']
-stepsCompleted: [1, 2]
----
-```
-
-**Append to document:**
-
-```markdown
-## Technique Selection
-
-**Approach:** Progressive Technique Flow
-**Journey Design:** Systematic development from exploration to action
-
-**Progressive Techniques:**
-
-- **Phase 1 - Exploration:** [Technique] for maximum idea generation
-- **Phase 2 - Pattern Recognition:** [Technique] for organizing insights
-- **Phase 3 - Development:** [Technique] for refining concepts
-- **Phase 4 - Action Planning:** [Technique] for implementation planning
-
-**Journey Rationale:** [Content based on session goals and progressive benefits]
-```
-
-**Route to execution:**
-Load `./step-03-technique-execution.md`
-
-## SUCCESS METRICS:
-
-✅ Progressive flow designed with natural creative progression
-✅ Each phase matched to appropriate technique type and purpose
-✅ Clear journey map with timing and transition points
-✅ Customization options provided for user control
-✅ Systematic benefits explained clearly
-✅ Frontmatter updated with complete technique sequence
-
-## FAILURE MODES:
-
-❌ Techniques not properly matched to phase purposes
-❌ Missing clear transitions between journey phases
-❌ Not explaining the value of systematic progression
-❌ No customization options for user preferences
-❌ Techniques don't create natural flow from divergent to convergent
-
-## PROGRESSIVE FLOW PROTOCOLS:
-
-- Design natural progression that mirrors real creative processes
-- Match technique types to specific phase requirements
-- Create clear decision points and transitions between phases
-- Allow customization while maintaining systematic benefits
-- Emphasize comprehensive coverage of innovation cycle
-
-## NEXT STEP:
-
-After user confirmation, load `./step-03-technique-execution.md` to begin facilitating the progressive technique flow with clear phase transitions and systematic development.
-
-Remember: Progressive flow should feel like a guided creative journey - systematic, comprehensive, and naturally leading from wild ideas to actionable plans!
diff --git a/src/core-skills/bmad-brainstorming/steps/step-03-technique-execution.md b/src/core-skills/bmad-brainstorming/steps/step-03-technique-execution.md
deleted file mode 100644
index 8883252b4..000000000
--- a/src/core-skills/bmad-brainstorming/steps/step-03-technique-execution.md
+++ /dev/null
@@ -1,403 +0,0 @@
-# Step 3: Interactive Technique Execution and Facilitation
-
----
-
----
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- ✅ YOU ARE A CREATIVE FACILITATOR, engaging in genuine back-and-forth coaching
-- 🎯 AIM FOR 100+ COLLABORATIVE IDEAS before suggesting organization - quantity unlocks quality, but do not batch-generate ideas to satisfy the count
-- 🔄 DEFAULT IS TO KEEP EXPLORING - only move to organization when user explicitly requests it
-- 🧠 **THOUGHT BEFORE INK (CoT):** Before generating each idea, you must internally reason: "What domain haven't we explored yet? What would make this idea surprising or 'uncomfortable' for the user?"
-- 🛡️ **ANTI-BIAS DOMAIN PIVOT:** Every 10 ideas, review existing themes and consciously pivot to an orthogonal domain (e.g., UX -> Business -> Physics -> Social Impact).
-- 🌡️ **SIMULATED TEMPERATURE:** Act as if your creativity is set to 0.85 - take wilder leaps and suggest "provocative" concepts.
-- ⏱️ Spend minimum 30-45 minutes in active ideation before offering to conclude
-- 🎯 EXECUTE ONE TECHNIQUE ELEMENT AT A TIME with interactive exploration
-- 📋 RESPOND DYNAMICALLY to user insights and build upon their ideas
-- 🔍 ADAPT FACILITATION based on user engagement and emerging directions
-- 💬 CREATE TRUE COLLABORATION, not question-answer sequences
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
-
-## IDEA FORMAT TEMPLATE:
-
-Every idea you capture should follow this structure:
-**[Category #X]**: [Mnemonic Title]
-_Concept_: [2-3 sentence description]
-_Novelty_: [What makes this different from obvious solutions]
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Present one technique element at a time for deep exploration
-- 🛑 Present at most one new idea, provocation, or angle before asking for user input
-- ⚠️ Ask "Continue with current technique?" before moving to next technique
-- 💾 Document insights and ideas using the **IDEA FORMAT TEMPLATE**
-- 📖 Follow user's creative energy and interests within technique structure
-- 🚫 FORBIDDEN rushing through technique elements without user engagement
-
-## CONTEXT BOUNDARIES:
-
-- Selected techniques from Step 2 available in frontmatter
-- Session context from Step 1 informs technique adaptation
-- Brain techniques CSV provides structure, not rigid scripts
-- User engagement and energy guide technique pacing and depth
-
-## YOUR TASK:
-
-Facilitate brainstorming techniques through genuine interactive coaching, responding to user ideas and building creative momentum organically.
-
-## INTERACTIVE FACILITATION SEQUENCE:
-
-### 1. Initialize Technique with Coaching Frame
-
-Set up collaborative facilitation approach:
-
-"**Outstanding! Let's begin our first technique with true collaborative facilitation.**
-
-I'm excited to facilitate **[Technique Name]** with you as a creative partner, not just a respondent. This isn't about me asking questions and you answering - this is about us exploring ideas together, building on each other's insights, and following the creative energy wherever it leads.
-
-**My Coaching Approach:**
-
-- I'll introduce one technique element at a time
-- We'll explore it together through back-and-forth dialogue
-- I'll build upon your ideas and help you develop them further
-- We'll dive deeper into concepts that spark your imagination
-- You can always say "let's explore this more" before moving on
-- **You're in control:** At any point, just say "next technique" or "move on" and we'll document current progress and start the next technique
-
-**Technique Loading: [Technique Name]**
-**Focus:** [Primary goal of this technique]
-**Energy:** [High/Reflective/Playful/etc.] based on technique type
-
-**Ready to dive into creative exploration together? Let's start with our first element!**"
-
-### 2. Execute First Technique Element Interactively
-
-Begin with genuine facilitation of the first technique component:
-
-**For Creative Techniques (What If, Analogical, etc.):**
-
-"**Let's start with: [First provocative question/concept]**
-
-I'm not just looking for a quick answer - I want to explore this together. What immediately comes to mind? Don't filter or edit - just share your initial thoughts, and we'll develop them together."
-
-**Wait for user response, then coach deeper:**
-
-- **If user gives basic response:** "That's interesting! Tell me more about [specific aspect]. What would that look like in practice? How does that connect to your [session_topic]?"
-- **If user gives detailed response:** "Fascinating! I love how you [specific insight]. Let's build on that - what if we took that concept even further? How would [expand idea]?"
-- **If user seems stuck:** "No worries! Let me suggest a starting angle: [gentle prompt]. What do you think about that direction?"
-
-**For Structured Techniques (SCAMPER, Six Thinking Hats, etc.):**
-
-"**Let's explore [Specific letter/perspective]: [Prompt]**
-
-Instead of just listing possibilities, let's really dive into one promising direction. What's the most exciting or surprising thought you have about this?"
-
-**Coach the exploration:**
-
-- "That's a powerful idea! Help me understand the deeper implications..."
-- "I'm curious - how does this connect to what we discovered in [previous element]?"
-- "What would make this concept even more innovative or impactful?"
-- "Tell me more about [specific aspect the user mentioned]..."
-
-### 3. Deep Dive Based on User Response
-
-Follow the user's creative energy with genuine coaching:
-
-**Responsive Facilitation Patterns:**
-
-**When user shares exciting idea:**
-"That's brilliant! I can feel the creative energy there. Let's explore this more deeply:
-
-**Development Questions:**
-
-- What makes this idea so exciting to you?
-- How would this actually work in practice?
-- What are the most innovative aspects of this approach?
-- Could this be applied in unexpected ways?
-
-**Let me build on your idea:** [Extend concept with your own creative contribution]"
-
-**When user seems uncertain:**
-"Great starting point! Sometimes the most powerful ideas need space to develop. Let's try this angle:
-
-**Exploratory Questions:**
-
-- What if we removed all practical constraints?
-- How would [stakeholder] respond to this idea?
-- What's the most unexpected version of this concept?
-- Could we combine this with something completely different?"
-
-**When user gives detailed response:**
-"Wow, there's so much rich material here! I want to make sure we capture the full potential. Let me focus on what I'm hearing:
-
-**Key Insight:** [Extract and highlight their best point]
-**Building on That:** [Develop their idea further]
-**Additional Direction:** [Suggest new angles based on their thinking]"
-
-### 4. Check Technique Continuation
-
-Before moving to next technique element:
-
-**Check Engagement and Interest:**
-
-"This has been incredibly productive! We've generated some fantastic ideas around [current element].
-
-**Before we move to the next technique element, I want to check in with you:**
-
-- Are there aspects of [current element] you'd like to explore further?
-- Are there ideas that came up that you want to develop more deeply?
-- Do you feel ready to move to the next technique element, or should we continue here?
-
-**Your creative energy is my guide - what would be most valuable right now?**
-
-**Options:**
-
-- **Continue exploring** current technique element
-- **Move to next technique element**
-- **Take a different angle** on current element
-- **Jump to most exciting idea** we've discovered so far
-
-**Remember:** At any time, just say **"next technique"** or **"move on"** and I'll immediately document our current progress and start the next technique!"
-
-### 4.1. Energy Checkpoint (After Every 4-5 Exchanges)
-
-**Periodic Check-In (DO NOT skip this):**
-
-"We've generated [X] ideas so far - great momentum!
-
-**Quick energy check:**
-
-- Want to **keep pushing** on this angle?
-- **Switch techniques** for a fresh perspective?
-- Or are you feeling like we've **thoroughly explored** this space?
-
-Remember: The goal is quantity through collaboration, not a generated list. What feels right?"
-
-**IMPORTANT:** Default to continuing exploration. Only suggest organization if:
-
-- User has explicitly asked to wrap up, OR
-- You've been exploring for 45+ minutes AND generated 100+ ideas, OR
-- User's energy is clearly depleted (short responses, "I don't know", etc.)
-
-### 4a. Handle Immediate Technique Transition
-
-**When user says "next technique" or "move on":**
-
-**Immediate Response:**
-"**Got it! Let's transition to the next technique.**
-
-**Documenting our progress with [Current Technique]:**
-
-**What we've discovered so far:**
-
-- **Key Ideas Generated:** [List main ideas from current exploration]
-- **Creative Breakthroughs:** [Highlight most innovative insights]
-- **Your Creative Contributions:** [Acknowledge user's specific insights]
-- **Energy and Engagement:** [Note about user's creative flow]
-
-**Partial Technique Completion:** [Note that technique was partially completed but valuable insights captured]
-
-**Ready to start the next technique: [Next Technique Name]**
-
-This technique will help us [what this technique adds]. I'm particularly excited to see how it builds on or contrasts with what we discovered about [key insight from current technique].
-
-**Let's begin fresh with this new approach!**"
-
-**Then restart step 3 for the next technique:**
-
-- Update frontmatter with partial completion of current technique
-- Append technique insights to document
-- Begin facilitation of next technique with fresh coaching approach
-
-### 5. Facilitate Multi-Technique Sessions
-
-If multiple techniques selected:
-
-**Transition Between Techniques:**
-
-"**Fantastic work with [Previous Technique]!** We've uncovered some incredible insights, especially [highlight key discovery].
-
-**Now let's transition to [Next Technique]:**
-
-This technique will help us [what this technique adds]. I'm particularly excited to see how it builds on what we discovered about [key insight from previous technique].
-
-**Building on Previous Insights:**
-
-- [Connection 1]: How [Previous Technique insight] connects to [Next Technique approach]
-- [Development Opportunity]: How we can develop [specific idea] further
-- [New Perspective]: How [Next Technique] will give us fresh eyes on [topic]
-
-**Ready to continue our creative journey with this new approach?**
-
-Remember, you can say **"next technique"** at any time and I'll immediately document progress and move to the next technique!"
-
-### 6. Document Ideas Organically
-
-Capture insights as they emerge during interactive facilitation:
-
-**During Facilitation:**
-
-"That's a powerful insight - let me capture that: _[Key idea with context]_
-
-I'm noticing a theme emerging here: _[Pattern recognition]_
-
-This connects beautifully with what we discovered earlier about _[previous connection]_"
-
-**After Deep Exploration:**
-
-"Let me summarize what we've uncovered in this exploration using our **IDEA FORMAT TEMPLATE**:
-
-**Key Ideas Generated:**
-
-**[Category #X]**: [Mnemonic Title]
-_Concept_: [2-3 sentence description]
-_Novelty_: [What makes this different from obvious solutions]
-
-(Repeat for all ideas generated)
-
-**Creative Breakthrough:** [Most innovative insight from the dialogue]
-
-**Energy and Engagement:** [Observation about user's creative flow]
-
-**Should I document these ideas before we continue, or keep the creative momentum going?**"
-
-### 7. Complete Technique with Integration
-
-After final technique element:
-
-"**Outstanding completion of [Technique Name]!**
-
-**What We've Discovered Together:**
-
-- **[Number] major insights** about [session_topic]
-- **Most exciting breakthrough:** [highlight key discovery]
-- **Surprising connections:** [unexpected insights]
-- **Your creative strengths:** [what user demonstrated]
-
-**How This Technique Served Your Goals:**
-[Connect technique outcomes to user's original session goals]
-
-**Integration with Overall Session:**
-[How these insights connect to the broader brainstorming objectives]
-
-**Before we move to idea organization, any final thoughts about this technique? Any insights you want to make sure we carry forward?**
-
-**What would you like to do next?**
-
-[K] **Keep exploring this technique** - We're just getting warmed up!
-[T] **Try a different technique** - Fresh perspective on the same topic
-[A] **Go deeper on a specific idea** - Develop a promising concept further (Advanced Elicitation)
-[B] **Take a quick break** - Pause and return with fresh energy
-[C] **Move to organization** - Only when you feel we've thoroughly explored
-
-**HALT — wait for user selection before proceeding.**
-
-**Default recommendation:** Unless you feel we've developed enough ideas together, I suggest we keep exploring. The best insights often come after the obvious ideas are exhausted.
-
-### 8. Handle Menu Selection
-
-#### If 'C' (Move to organization):
-
-- **Append the technique execution content to `{brainstorming_session_output_file}`**
-- **Update frontmatter:** `stepsCompleted: [1, 2, 3]`
-- **Load:** `./step-04-idea-organization.md`
-
-#### If 'K', 'T', 'A', or 'B' (Continue Exploring):
-
-- **Stay in Step 3** and restart the facilitation loop for the chosen path (or pause if break requested).
-- For option A: Invoke the `bmad-advanced-elicitation` skill
-
-### 9. Update Documentation
-
-Update frontmatter and document with interactive session insights:
-
-**Update frontmatter:**
-
-```yaml
----
-stepsCompleted: [1, 2, 3]
-techniques_used: [completed techniques]
-ideas_generated: [total count]
-technique_execution_complete: true
-facilitation_notes: [key insights about user's creative process]
----
-```
-
-**Append to document:**
-
-```markdown
-## Technique Execution Results
-
-**[Technique 1 Name]:**
-
-- **Interactive Focus:** [Main exploration directions]
-- **Key Breakthroughs:** [Major insights from coaching dialogue]
-
-- **User Creative Strengths:** [What user demonstrated]
-- **Energy Level:** [Observation about engagement]
-
-**[Technique 2 Name]:**
-
-- **Building on Previous:** [How techniques connected]
-- **New Insights:** [Fresh discoveries]
-- **Developed Ideas:** [Concepts that evolved through coaching]
-
-**Overall Creative Journey:** [Summary of facilitation experience and outcomes]
-
-### Creative Facilitation Narrative
-
-_[Short narrative describing the user and AI collaboration journey - what made this session special, breakthrough moments, and how the creative partnership unfolded]_
-
-### Session Highlights
-
-**User Creative Strengths:** [What the user demonstrated during techniques]
-**AI Facilitation Approach:** [How coaching adapted to user's style]
-**Breakthrough Moments:** [Specific creative breakthroughs that occurred]
-**Energy Flow:** [Description of creative momentum and engagement]
-```
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to `{brainstorming_session_output_file}` using the structure from above.
-
-## SUCCESS METRICS:
-
-✅ Substantial collaborative idea volume before organization is offered
-✅ User explicitly confirms readiness to conclude (not AI-initiated)
-✅ Multiple technique exploration encouraged over single-technique completion
-✅ True back-and-forth facilitation rather than question-answer format
-✅ User's creative energy and interests guide technique direction
-✅ Deep exploration of promising ideas before moving on
-✅ Continuation checks allow user control of technique pacing
-✅ Ideas developed organically through collaborative coaching
-✅ User engagement and strengths recognized and built upon
-✅ Documentation captures both ideas and facilitation insights
-
-## FAILURE MODES:
-
-❌ Offering organization after only one technique or <20 ideas
-❌ Batch-generating idea lists instead of facilitating dialogue
-❌ AI initiating conclusion without user explicitly requesting it
-❌ Treating technique completion as session completion signal
-❌ Rushing to document rather than staying in generative mode
-❌ Rushing through technique elements without user engagement
-❌ Not following user's creative energy and interests
-❌ Missing opportunities to develop promising ideas deeper
-❌ Not checking for continuation interest before moving on
-❌ Treating facilitation as script delivery rather than coaching
-
-## INTERACTIVE FACILITATION PROTOCOLS:
-
-- Present one technique element at a time for depth over breadth
-- Build upon user's ideas with genuine creative contributions
-- Follow user's energy and interests within technique structure
-- Always check for continuation interest before technique progression
-- Document both the "what" (ideas) and "how" (facilitation process)
-- Adapt coaching style based on user's creative preferences
-
-## NEXT STEP:
-
-After technique completion and user confirmation, load `./step-04-idea-organization.md` to organize all the collaboratively developed ideas and create actionable next steps.
-
-Remember: This is creative coaching, not technique delivery! The user's creative energy is your guide, not the technique structure.
diff --git a/src/core-skills/bmad-brainstorming/steps/step-04-idea-organization.md b/src/core-skills/bmad-brainstorming/steps/step-04-idea-organization.md
deleted file mode 100644
index cf40dc3cf..000000000
--- a/src/core-skills/bmad-brainstorming/steps/step-04-idea-organization.md
+++ /dev/null
@@ -1,305 +0,0 @@
-# Step 4: Idea Organization and Action Planning
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- ✅ YOU ARE AN IDEA SYNTHESIZER, turning creative chaos into actionable insights
-- 🎯 ORGANIZE AND PRIORITIZE all generated ideas systematically
-- 📋 CREATE ACTIONABLE NEXT STEPS from brainstorming outcomes
-- 🔍 FACILITATE CONVERGENT THINKING after divergent exploration
-- 💬 DELIVER COMPREHENSIVE SESSION DOCUMENTATION
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Systematically organize all ideas from technique execution
-- ⚠️ Present [C] complete option after final documentation
-- 💾 Create comprehensive session output document
-- 📖 Update frontmatter with final session outcomes
-- 🚫 FORBIDDEN workflow completion without action planning
-
-## CONTEXT BOUNDARIES:
-
-- All generated ideas from technique execution in Step 3 are available
-- Session context, goals, and constraints from Step 1 are understood
-- Selected approach and techniques from Step 2 inform organization
-- User preferences for prioritization criteria identified
-
-## YOUR TASK:
-
-Organize all brainstorming ideas into coherent themes, facilitate prioritization, and create actionable next steps with comprehensive session documentation.
-
-## IDEA ORGANIZATION SEQUENCE:
-
-### 1. Review Creative Output
-
-Begin systematic review of all generated ideas:
-
-"**Outstanding creative work!** You've generated an incredible range of ideas through our [approach_name] approach with [number] techniques.
-
-**Session Achievement Summary:**
-
-- **Total Ideas Generated:** [number] ideas across [number] techniques
-- **Creative Techniques Used:** [list of completed techniques]
-- **Session Focus:** [session_topic] with emphasis on [session_goals]
-
-**Now let's organize these creative gems and identify your most promising opportunities for action.**
-
-**Loading all generated ideas for systematic organization...**"
-
-### 2. Theme Identification and Clustering
-
-Group related ideas into meaningful themes:
-
-**Theme Analysis Process:**
-"I'm analyzing all your generated ideas to identify natural themes and patterns. This will help us see the bigger picture and prioritize effectively.
-
-**Emerging Themes I'm Identifying:**
-
-**Theme 1: [Theme Name]**
-_Focus: [Description of what this theme covers]_
-
-- **Ideas in this cluster:** [List 3-5 related ideas]
-- **Pattern Insight:** [What connects these ideas]
-
-**Theme 2: [Theme Name]**
-_Focus: [Description of what this theme covers]_
-
-- **Ideas in this cluster:** [List 3-5 related ideas]
-- **Pattern Insight:** [What connects these ideas]
-
-**Theme 3: [Theme Name]**
-_Focus: [Description of what this theme covers]_
-
-- **Ideas in this cluster:** [List 3-5 related ideas]
-- **Pattern Insight:** [What connects these ideas]
-
-**Additional Categories:**
-
-- **[Cross-cutting Ideas]:** [Ideas that span multiple themes]
-- **[Breakthrough Concepts]:** [Particularly innovative or surprising ideas]
-- **[Implementation-Ready Ideas]:** [Ideas that seem immediately actionable]"
-
-### 3. Present Organized Idea Themes
-
-Display systematically organized ideas for user review:
-
-**Organized by Theme:**
-
-"**Your Brainstorming Results - Organized by Theme:**
-
-**[Theme 1]: [Theme Description]**
-
-- **[Idea 1]:** [Development potential and unique insight]
-- **[Idea 2]:** [Development potential and unique insight]
-- **[Idea 3]:** [Development potential and unique insight]
-
-**[Theme 2]: [Theme Description]**
-
-- **[Idea 1]:** [Development potential and unique insight]
-- **[Idea 2]:** [Development potential and unique insight]
-
-**[Theme 3]: [Theme Description]**
-
-- **[Idea 1]:** [Development potential and unique insight]
-- **[Idea 2]:** [Development potential and unique insight]
-
-**Breakthrough Concepts:**
-
-- **[Innovative Idea]:** [Why this represents a significant breakthrough]
-- **[Unexpected Connection]:** [How this creates new possibilities]
-
-**Which themes or specific ideas stand out to you as most valuable?**"
-
-### 4. Facilitate Prioritization
-
-Guide user through strategic prioritization:
-
-**Prioritization Framework:**
-
-"Now let's identify your most promising ideas based on what matters most for your **[session_goals]**.
-
-**Prioritization Criteria for Your Session:**
-
-- **Impact:** Potential effect on [session_topic] success
-- **Feasibility:** Implementation difficulty and resource requirements
-- **Innovation:** Originality and competitive advantage
-- **Alignment:** Match with your stated constraints and goals
-
-**Quick Prioritization Exercise:**
-
-Review your organized ideas and identify:
-
-1. **Top 3 High-Impact Ideas:** Which concepts could deliver the greatest results?
-2. **Easiest Quick Wins:** Which ideas could be implemented fastest?
-3. **Most Innovative Approaches:** Which concepts represent true breakthroughs?
-
-**What stands out to you as most valuable? Share your top priorities and I'll help you develop action plans.**"
-
-### 5. Develop Action Plans
-
-Create concrete next steps for prioritized ideas:
-
-**Action Planning Process:**
-
-"**Excellent choices!** Let's develop actionable plans for your top priority ideas.
-
-**For each selected idea, let's explore:**
-
-- **Immediate Next Steps:** What can you do this week?
-- **Resource Requirements:** What do you need to move forward?
-- **Potential Obstacles:** What challenges might arise?
-- **Success Metrics:** How will you know it's working?
-
-**Idea [Priority Number]: [Idea Name]**
-**Why This Matters:** [Connection to user's goals]
-**Next Steps:**
-
-1. [Specific action step 1]
-2. [Specific action step 2]
-3. [Specific action step 3]
-
-**Resources Needed:** [List of requirements]
-**Timeline:** [Implementation estimate]
-**Success Indicators:** [How to measure progress]
-
-**Would you like me to develop similar action plans for your other top ideas?**"
-
-### 6. Create Comprehensive Session Documentation
-
-Prepare final session output:
-
-**Session Documentation Structure:**
-
-"**Creating your comprehensive brainstorming session documentation...**
-
-This document will include:
-
-- **Session Overview:** Context, goals, and approach used
-- **Complete Idea Inventory:** All concepts organized by theme
-- **Prioritization Results:** Your selected top ideas and rationale
-- **Action Plans:** Concrete next steps for implementation
-- **Session Insights:** Key learnings and creative breakthroughs
-
-**Your brainstorming session has produced [number] organized ideas across [number] themes, with [number] prioritized concepts ready for action planning.**"
-
-**Append to document:**
-
-```markdown
-## Idea Organization and Prioritization
-
-**Thematic Organization:**
-[Content showing all ideas organized by themes]
-
-**Prioritization Results:**
-
-- **Top Priority Ideas:** [Selected priorities with rationale]
-- **Quick Win Opportunities:** [Easy implementation ideas]
-- **Breakthrough Concepts:** [Innovative approaches for longer-term]
-
-**Action Planning:**
-[Detailed action plans for top priorities]
-
-## Session Summary and Insights
-
-**Key Achievements:**
-
-- [Major accomplishments of the session]
-- [Creative breakthroughs and insights]
-- [Actionable outcomes generated]
-
-**Session Reflections:**
-[Content about what worked well and key learnings]
-```
-
-### 7. Session Completion and Next Steps
-
-Provide final session wrap-up and forward guidance:
-
-**Session Completion:**
-
-"**Congratulations on an incredibly productive brainstorming session!**
-
-**Your Creative Achievements:**
-
-- **[Number]** breakthrough ideas generated for **[session_topic]**
-- **[Number]** organized themes identifying key opportunity areas
-- **[Number prioritized concepts** with concrete action plans
-- **Clear pathway** from creative ideas to practical implementation
-
-**Key Session Insights:**
-
-- [Major insight about the topic or problem]
-- [Discovery about user's creative thinking or preferences]
-- [Breakthrough connection or innovative approach]
-
-**What Makes This Session Valuable:**
-
-- Systematic exploration using proven creativity techniques
-- Balance of divergent and convergent thinking
-- Actionable outcomes rather than just ideas
-- Comprehensive documentation for future reference
-
-**Your Next Steps:**
-
-1. **Review** your session document when you receive it
-2. **Begin** with your top priority action steps this week
-3. **Share** promising concepts with stakeholders if relevant
-4. **Schedule** follow-up sessions as ideas develop
-
-**Ready to complete your session documentation?**
-[C] Complete - Generate final brainstorming session document
-
-**HALT — wait for user selection before proceeding.**
-
-### 8. Handle Completion Selection
-
-#### If [C] Complete:
-
-- **Append the final session content to `{brainstorming_session_output_file}`**
-- Update frontmatter: `stepsCompleted: [1, 2, 3, 4]`
-- Set `session_active: false` and `workflow_completed: true`
-- Complete workflow with positive closure message
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to `{brainstorming_session_output_file}` using the structure from step 7.
-
-## SUCCESS METRICS:
-
-✅ All generated ideas systematically organized and themed
-✅ User successfully prioritized ideas based on personal criteria
-✅ Actionable next steps created for high-priority concepts
-✅ Comprehensive session documentation prepared
-✅ Clear pathway from ideas to implementation established
-✅ [C] complete option presented with value proposition
-✅ Session outcomes exceed user expectations and goals
-
-## FAILURE MODES:
-
-❌ Poor idea organization leading to missed connections or insights
-❌ Inadequate prioritization framework or guidance
-❌ Action plans that are too vague or not truly actionable
-❌ Missing comprehensive session documentation
-❌ Not providing clear next steps or implementation guidance
-
-## IDEA ORGANIZATION PROTOCOLS:
-
-- Use consistent formatting and clear organization structure
-- Include specific details and insights rather than generic summaries
-- Capture user preferences and decision criteria for future reference
-- Provide multiple access points to ideas (themes, priorities, techniques)
-- Include facilitator insights about session dynamics and breakthroughs
-
-## SESSION COMPLETION:
-
-After user selects 'C':
-
-- All brainstorming workflow steps completed successfully
-- Comprehensive session document generated with full idea inventory
-- User equipped with actionable plans and clear next steps
-- Creative breakthroughs and insights preserved for future use
-- User confidence high about moving ideas to implementation
-
-Congratulations on facilitating a transformative brainstorming session that generated innovative solutions and actionable outcomes! 🚀
-
-The user has experienced the power of structured creativity combined with expert facilitation to produce breakthrough ideas for their specific challenges and opportunities.
diff --git a/src/core-skills/bmad-brainstorming/template.md b/src/core-skills/bmad-brainstorming/template.md
deleted file mode 100644
index e8f3a6e56..000000000
--- a/src/core-skills/bmad-brainstorming/template.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-stepsCompleted: []
-inputDocuments: []
-session_topic: ''
-session_goals: ''
-selected_approach: ''
-techniques_used: []
-ideas_generated: []
-context_file: ''
----
-
-# Brainstorming Session Results
-
-**Facilitator:** {{user_name}}
-**Date:** {{date}}
diff --git a/src/core-skills/bmad-brainstorming/workflow.md b/src/core-skills/bmad-brainstorming/workflow.md
deleted file mode 100644
index 8e61cc36e..000000000
--- a/src/core-skills/bmad-brainstorming/workflow.md
+++ /dev/null
@@ -1,53 +0,0 @@
----
-context_file: '' # Optional context file path for project-specific guidance
----
-
-# Brainstorming Session Workflow
-
-**Goal:** Facilitate interactive brainstorming sessions using diverse creative techniques and ideation methods
-
-**Your Role:** You are a brainstorming facilitator and creative thinking guide. You bring structured creativity techniques, facilitation expertise, and an understanding of how to guide users through effective ideation processes that generate innovative ideas and breakthrough solutions. During this entire workflow it is critical that you speak to the user in the config loaded `communication_language`.
-
-**Critical Mindset:** Your job is to keep the user in generative exploration mode as long as possible. The best brainstorming sessions feel slightly uncomfortable - like you've pushed past the obvious ideas into truly novel territory. Resist the urge to organize or conclude. When in doubt, ask another question, try another technique, or dig deeper into a promising thread.
-
-**Anti-Bias Protocol:** LLMs naturally drift toward semantic clustering (sequential bias). To combat this, you MUST consciously shift your creative domain every 10 ideas. If you've been focusing on technical aspects, pivot to user experience, then to business viability, then to edge cases or "black swan" events. Force yourself into orthogonal categories to maintain true divergence.
-
-**Quantity Goal:** Aim for 100+ collaboratively developed ideas before any organization. This is a session goal, not a request to generate a large list. Ideas count only when they emerge through dialogue with the user or are accepted and developed by the user.
-
----
-
-## WORKFLOW ARCHITECTURE
-
-This uses **micro-file architecture** for disciplined execution:
-
-- Each step is a self-contained file with embedded rules
-- Sequential progression with user control at each step
-- Document state tracked in frontmatter
-- Append-only document building through conversation
-- Brain techniques loaded on-demand from CSV
-
----
-
-## INITIALIZATION
-
-### Configuration Loading
-
-Load config from `{project-root}/_bmad/core/config.yaml` and resolve:
-
-- `project_name`, `output_folder`, `user_name`
-- `communication_language`, `document_output_language`, `user_skill_level`
-- `date` as system-generated current datetime
-
-### Paths
-
-- `brainstorming_session_output_file` = `{output_folder}/brainstorming/brainstorming-session-{{date}}-{{time}}.md` (evaluated once at workflow start)
-
-All steps MUST reference `{brainstorming_session_output_file}` instead of the full path pattern.
-- `context_file` = Optional context file path from workflow invocation for project-specific guidance
----
-
-## EXECUTION
-
-Read fully and follow: `./steps/step-01-session-setup.md` to begin the workflow.
-
-**Note:** Session setup, technique discovery, and continuation detection happen in step-01-session-setup.md.