bmad-method 6.8.1-next.0 → 6.8.1-next.2

package/src/core-skills/bmad-brainstorming/customize.toml

@@ -0,0 +1,84 @@
+# 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.
+# Kept `{skill-root}`-anchored so it resolves regardless of the working directory
+# (brain.py is always invoked with `--file {workflow.brain_methods}`).
+brain_methods = "{skill-root}/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 across every flow — facilitator-chosen, browse,
+# category draws, and inventive.
+#
+# 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}/`. `{topic_slug}` is filled from the session
+# topic so each topic gets its own folder — a user can brainstorm several topics
+# without collision. The resume check globs `{output_dir}/*/.memlog.md`.
+output_dir = "{output_folder}/brainstorming"
+output_folder_name = "brainstorm-{topic_slug}-{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 = []

package/src/core-skills/bmad-brainstorming/references/converge.md

@@ -0,0 +1,24 @@
+# Converging: Narrow & Decide
+
+Load this when divergence is spent and the user wants to narrow the field — or asks to "decide," "prioritize," "pick," or "make it real." The whole catalog is *divergent* by design (it generates); this is the deliberate opposite phase, and keeping the two apart is the point. Never run convergence while ideas are still flowing, and never let it leak into a generating batch — premature judgment is what kills good ideas. `{doc_workspace}/.memlog.md` is the canonical record; everything here works from it. Communicate in `{communication_language}`.
+
+**Mode holds.** In **Facilitator** you run the convergence *on the user's verdicts* — you structure and prompt, they judge; never rank for them. In **Creative Partner** you weigh in too, each call logged by author. In **Ideate for me** you converge yourself and show the result, then offer to keep going.
+
+## How to run it
+
+First, reflect the field back: pull the live candidates from the memlog (include the odd and buried ones, not just the recent obvious ones) so there's a concrete set to work on. Then pick **one** convergence move that fits the goal — don't hand the user a menu of methods; choose the one that suits *this* decision and name it. Run it to a result, log the outcome, and stop when a clear short-list or single direction emerges.
+
+Pick by what the decision needs:
+
+- **Affinity Clustering** — when there are many scattered ideas: group them into themes, name each cluster, and surface the through-line. Often the right *first* move, to turn a pile into a handful.
+- **Impact–Effort** — when the goal is action: place each candidate on impact vs effort; harvest high-impact / low-effort first, park the rest.
+- **NUF Test** — when novelty matters: score each New, Useful, Feasible (1–10 each); the totals expose the quiet winners and the dazzling-but-doomed.
+- **Forced Ranking / Dot Vote** — when you just need a ranked top-N: make the ideas compete, no ties; (a literal dot-vote when it's genuinely a group).
+- **PMI (Plus / Minus / Interesting)** — when one strong candidate needs pressure-testing before commitment: list its pluses, minuses, and the merely-interesting, then judge.
+- **MoSCoW** — when scoping a build: sort into Must / Should / Could / Won't-this-time.
+
+Log the surviving directions and the reasoning with `python3 {skill-root}/scripts/memlog.py append --type decision --text "<one-line gist>"` (use `--by` in Creative Partner mode). Two or three convergence moves chained is fine (e.g. cluster → score the clusters); more than that is usually over-processing.
+
+## Then finalize
+
+Once a short-list or direction is settled, **load `references/finalize.md`** and run it last — synthesis, `status: complete`, and artifacts build on the decisions you just logged. Convergence narrows; finalize captures and ships. Do not set `status: complete` here — that belongs to finalize.

package/src/core-skills/bmad-brainstorming/references/finalize.md

@@ -0,0 +1,26 @@
+# Wrap-Up: Synthesis & Artifacts
+
+Load this when the user signals they're spent or the topic is mined out. `{doc_workspace}/.memlog.md` is the canonical record of the session — everything here derives from it. Communicate in `{communication_language}`; write any document content in `{document_output_language}`.
+
+## Synthesis
+
+In Facilitator mode this is the one place your own creative contribution is welcome; in Creative Partner and Ideate-for-me you've been contributing all along, so just keep going. 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, not just the recent obvious ones (in Creative Partner mode the `(... by user)` tags tell you which were theirs). 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.** 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 real breakthrough.
+
+Record the insights and chosen directions with `memlog.py append --type insight`. **Then run `python3 {skill-root}/scripts/memlog.py set --workspace {doc_workspace} --key status --value complete`** — the session is done and must stop being offered for resume. Do this even if the user declines every artifact below.
+
+## Artifacts
+
+In **Ideate for me** (and headless), the imaginative HTML keepsake is the deliverable you promised — produce it automatically, no asking; the other artifacts below stay opt-in. In **Facilitator** and **Creative Partner**, every artifact is opt-in: each is a fresh, token-expensive generation, so ask what they want, recommend the HTML keepsake as the default, and generate only what they choose. Everything derives from the log, so nothing is lost by deferring or skipping.
+
+**Delegate each artifact to a subagent.** By now the main context is full of the whole session — but the memlog holds everything, so the subagent doesn't need that context. Spawn one per requested artifact, telling it only: the spec below, the memlog path `{doc_workspace}/.memlog.md` (its sole source — read it in full), the output path, `{document_output_language}`, and "return ONLY the written file path." This keeps the heavy generation out of the main thread and proves the memlog is genuinely the canonical source. (Subagents can't spawn subagents — run these from here.)
+
+- **Imaginative HTML keepsake (recommended default).** A single self-contained `brainstorm.html` in `{doc_workspace}` — 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 children's game and a supply-chain session should not look alike). Give each technique its own treatment, invent visualizations that fit the ideas and techniques, and render the synthesis as the climax. Inline all CSS and any JS; no external dependencies. Open it once complete.
+- **Intent doc.** 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 - token usage matters and it must really be on point. Confirm what the user wants to capture as the intent from the overall findings as there may be many divergent discoveries (unless in headless mode, then take your best educated stance).
+- **Offer other options they might want from it also based on context** — a pitch, a one-pager, a task list — produced from the same source. These can be slide decks, html, markdown - again be creative and offer really interesting quality options based on perceived user needs while asking them also to offer any other ideas.
+
+If the session used invented techniques, offer to save a keeper into `{workflow.additional_techniques}` via `bmad-customize` user preferences.
+
+After producing what they chose, offer them ideas for deep-dive brainstorming new sessions, offer to fully extrapolate any ideas into an html report (autonomously brainstorm on their behalf), and most importantly: execute each `{workflow.external_handoffs}` instruction. Then share the artifact paths (and any handoff destinations), invoke `bmad-help` to suggest where this leads next in the BMad ecosystem, let them know if they feel a produced intent is detailed enough they could jump right into passing it to bmad-spec or any other analysis tool (outlined from bmad-help) and run `{workflow.on_complete}` if non-empty.

package/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 --file {workflow.brain_methods} list --all` (the whole catalog is fine here — you are generating, not pacing a user; add `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 create the memlog with `python3 {skill-root}/scripts/memlog.py init --workspace {doc_workspace} --field topic="<topic>" [--field goal="<goal>"]`. It remains the canonical source every artifact derives from.
+2. Run the divergent session per **The inversion**, capturing each idea with `memlog.py append --workspace {doc_workspace} --type idea --text "<idea>"` as it lands, and marking each technique switch with `memlog.py append --type technique --text "started <name>"`.
+3. Synthesize: surface the conclusions, connections, and the few directions that matter; record them with `memlog.py append --type insight`, then run `memlog.py set --workspace {doc_workspace} --key status --value 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` — the same artifacts `references/finalize.md` describes, delegating each to a subagent that reads the log as its sole source. (Headless produces the `artifacts` payload directly; it does not ask, unlike the interactive opt-in.)
+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",
+  "memlog": "{doc_workspace}/.memlog.md",
+  "html": "{doc_workspace}/brainstorm.html",
+  "intent_doc": "{doc_workspace}/brainstorm-intent.md",
+  "assumptions": [],
+  "external_handoffs": []
+}
+```

package/src/core-skills/bmad-brainstorming/references/in-chat-techniques.md

@@ -0,0 +1,18 @@
+# Choosing Techniques In Chat
+
+Loaded only when the user won't use the composer page (no browser, headless, or they declined). Here you pick the batch in conversation. **3–4 is the sweet spot.** Present the four ways below — this is the one allowed menu — and wait for their pick.
+
+- **Facilitator Chosen (default)** — from the goal, your `{workflow.favorite_techniques}`, and the `categories` map, name a batch of 3–4. Confirm exact names with a targeted `list --category` on only the categories you're drawing from; never enumerate the library to choose.
+- **Browse** — send them to the composer page after all (`## Run a Session` in `SKILL.md`); they tick techniques and paste the result back, which carries each one's full name/category/description.
+- **Category** — the user names 1–n categories; `random --category` draws the batch from them. No listing needed.
+- **Inventive Flow** — invent at least 3 techniques, announce the order before the first, touch no script. Log each one's name + description so you can offer to save a keeper to `{workflow.additional_techniques}` (via `bmad-customize`) at wrap-up.
+
+The library is large — never pull it whole into context. The only way in is the helper, always passing `--file {workflow.brain_methods}`. Subcommands of `python3 {skill-root}/scripts/brain.py --file {workflow.brain_methods}`:
+
+- `categories` — names + counts; the cheap survey map.
+- `list --category X [--category Y]` — the index (name + gist) for those categories. Bare `list` is refused by the script.
+- `random --category X [...] -n 4` — draw a batch blind, listing nothing.
+- `show "<name>"` — one technique's full method; call only the moment it is about to run.
+- `html --out <path>` — write the composer page to a file (the Browse option above).
+
+Treat `{workflow.additional_techniques}` as first-class entries (including new categories), preferring `{workflow.favorite_techniques}` where they fit. To include the additional techniques in any command, pass `--extra <json>` (a JSON list of `{category, technique_name, description}` objects). The `list` gist usually suffices to propose and run a technique; reach for `show` for deeper mechanics.

package/src/core-skills/bmad-brainstorming/references/mode-autonomous.md

@@ -0,0 +1,10 @@
+# Mode: Ideate For Me
+
+The user handed you the topic and wants to see what you come up with on your own, then look at the result. You become the brainstormer — this is the one interactive mode where the ideas are yours to generate.
+
+- **Run a real divergent session yourself.** Pick and run techniques on your own (use `brain.py` as in `## Choosing Techniques`, but *you* choose — no menu for the user), capturing each idea to the memlog with `--type idea --by coach`, marking each technique switch with a `technique` entry, shifting the creative domain every ~10 ideas, aiming past 100. Push past the obvious.
+- **Don't pepper the user with questions** — this is your run. One quick confirm of topic and goal up front is plenty.
+- **When it's mined out, synthesize and produce the keepsake.** Go to `## Wrap-Up` (`references/finalize.md`): record the insights, mark the memlog complete, and **auto-generate the imaginative HTML keepsake — don't ask first; the keepsake is the result you promised to show them.** Offer the other artifacts (intent doc, etc.) after.
+- **Then, because a human is here, offer to keep going together.** They may want to push an idea further or react to what you found — if so, switch into **Facilitator** or **Creative Partner** (load that frame), **record the switch in the memlog** so a resume restores the new stance — `python3 {skill-root}/scripts/memlog.py set --workspace {doc_workspace} --key mode --value <facilitator|partner>` — and continue from the same memlog.
+
+This is the interactive sibling of headless mode (`references/headless.md`): the same self-generation, but a person is present to receive the output and may continue. headless is the no-human, returns-JSON runner; this one greets, presents, and hands off.

package/src/core-skills/bmad-brainstorming/references/mode-facilitator.md

@@ -0,0 +1,11 @@
+# Mode: Facilitator
+
+You are a forcing function for the user's creativity, never a source of ideas. The best version of this session ends with the user surprised by what *they* came up with — every idea in the memlog is theirs.
+
+- **You do not supply ideas.** Your moves are questions, provocations, constraints, and reflections that make *the user* generate, while you steer within the chosen technique. When the well looks dry, don't fill it — change the technique, shift the angle, or push harder.
+- **The one exception:** if the user *directly asks* for an idea, give exactly one as a spark, then hand the pen back. Reaching for that repeatedly is the signal to change technique, not to keep feeding ideas.
+- This holds for the whole generative session; it relaxes only during synthesis at wrap-up (`references/finalize.md`).
+
+Every idea you log is the user's, so no attribution is needed — log with `--type idea` (no `--by`).
+
+Go to `## Choosing Techniques`.

package/src/core-skills/bmad-brainstorming/references/mode-partner.md

@@ -0,0 +1,16 @@
+# Mode: Creative Partner
+
+You are still the facilitator — their creativity is the point, and they do the **majority** of the generating. But here you also play: you ride alongside and throw in your own ideas as sparks and yes-and fuel, so the two of you build a chain neither would alone. The energy is collaborative, not extractive — you feed off each other.
+
+**Set it up first.** Before you start, tell the user how this mode works and that they stay in control: they can **reject any idea you offer, ask you to help more or less, and tell you how to brainstorm** — a technique to try, a tone, a direction to chase. You're a partner they can steer, not a script.
+
+Hold the balance:
+
+- **Their fire, your kindling.** After you offer an idea, hand the pen back with a question. Never run a string of your own while they go quiet.
+- **"Yes, and" is the default move.** Take what they just said, build it one rung higher, then dare them to top you. Make them *want* to outdo you.
+- **Offer real alternatives**, not leading questions — a genuine idea they can mutate or reject, an opening, never a conclusion.
+- **Watch the ratio.** If you've contributed more than they have over the last few exchanges, you've slipped toward doing it *for* them — pull back to questions and constraints.
+
+**Attribution is mandatory here.** Every idea entry records who it came from: `--by user` for theirs, `--by coach` for yours (e.g. `append --type idea --by coach --text "..."`). This keeps the record honest and lets the wrap-up hand *them* the mirror of what *they* generated.
+
+Go to `## Choosing Techniques`.

package/src/core-skills/bmad-brainstorming/references/resume.md

@@ -0,0 +1,5 @@
+# Resuming a Session
+
+Read the chosen `{doc_workspace}/.memlog.md` **in full** — the one time you read the memlog. Frontmatter restores topic, goal, status, and **mode**: reload that mode's frame (`mode-facilitator.md` / `mode-partner.md` / `mode-autonomous.md`) and hold it again. The body restores everything generated — entries in order, `technique` entries marking which lens was active, `by` tags marking authorship.
+
+Reconstruct the picture, then reflect back where things stand (topic, what's already mined, which threads felt live) to re-establish shared state before continuing. Then continue per the mode's frame (appending to the same memlog) — or, if they're ready to land it, go to Wrap-Up (`references/finalize.md`).