feat(workflows): adopt customize.toml pattern for workflow skills (#30)

* feat(workflows): adopt customize.toml pattern for workflow skills

Merge redirect-only SKILL.md with workflow.md content into a single
SKILL.md per workflow skill, add Conventions + On Activation (resolve
customization, prepend/append steps, persistent_facts, config load,
greet), and wire workflow.on_complete into the final step(s).

Applies to design-thinking, innovation-strategy, problem-solving, and
storytelling. Mirrors the customization surface shipped for the agent
skills in #29.

* fix(workflows): address PR review comments

- Disambiguate workflow step references in the Inputs section — "before
  Step N" now reads "before workflow Step N" since the activation block
  also numbers its steps 1-6.
- Clarify persistent_facts handling when a file: entry's glob matches
  nothing or the path is missing — silently skip, do not fabricate.
- Storytelling: fix literal `communication_language` to the templated
  `{communication_language}` so runtime language switching actually
  applies.

* docs(changelog): record v0.2.0 — customize.toml pattern rollout

Author: bmadcode

.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "name": "bmad-creative-intelligence-suite",
       "source": "./",
       "description": "A suite of creative AI agents and workflows for brainstorming, problem-solving, design thinking, innovation strategy, storytelling, and presentations. Part of the BMad Method ecosystem.",
-      "version": "0.1.9",
+      "version": "0.2.0",
       "author": {
         "name": "Brian (BMad) Madison"
       },

CHANGELOG.md

@@ -1,5 +1,26 @@
 # CHANGELOG
 
+## v0.2.0 - Apr 21, 2026 — customize.toml pattern across agents and workflows
+
+### Agent customization surface
+
+* All six agents (`bmad-cis-agent-brainstorming-coach`, `bmad-cis-agent-creative-problem-solver`, `bmad-cis-agent-design-thinking-coach`, `bmad-cis-agent-innovation-strategist`, `bmad-cis-agent-presentation-master`, `bmad-cis-agent-storyteller`) adopt the BMAD-METHOD `customize.toml` pattern. Each agent's `SKILL.md` now runs a six-step On Activation block that resolves customization via `resolve_customization.py`, executes prepend/append hook steps, loads `persistent_facts`, reads config from `{project-root}/_bmad/cis/config.yaml`, and greets the user before the menu appears.
+* Added `[agent]` namespace in each agent's `customize.toml` exposing `role`, `identity`, `communication_style`, `principles`, `persistent_facts`, `activation_steps_prepend/append`, and the `[[agent.menu]]` entries. Overrides merge per BMad structural rules (scalars override, keyed arrays-of-tables replace-or-append, other arrays append).
+* Added an agent roster with essence descriptors in `src/module.yaml` so external skills (party-mode, retrospective, advanced-elicitation, help catalog) can route to, display, and embody CIS agents without reading each agent file.
+
+### Workflow customization surface
+
+* All four workflow skills (`bmad-cis-design-thinking`, `bmad-cis-innovation-strategy`, `bmad-cis-problem-solving`, `bmad-cis-storytelling`) converted from redirect-only `SKILL.md` + `workflow.md` split to a single integrated `SKILL.md`. The standalone `workflow.md` file is removed from every workflow skill.
+* Each workflow gains the same six-step On Activation block as agents (resolve customization → prepend → `persistent_facts` → config load → greet → append), plus a `Conventions` block declaring `{skill-root}`, `{project-root}`, and `{skill-name}`.
+* Each workflow's terminal step now invokes `resolve_customization.py --key workflow.on_complete` as an `<action>` inside the final `<step>`. `bmad-cis-problem-solving` wires the hook at both the last mandatory step 8 and the optional step 9 so the hook fires whether or not the user runs the reflection step.
+* Added `customize.toml` at every workflow skill root with a `[workflow]` namespace exposing `activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, and `on_complete`. Team and per-user overrides merge from `{project-root}/_bmad/custom/{skill-name}.toml` and `{skill-name}.user.toml`.
+
+### Fixes bundled with the rollout
+
+* Disambiguated "before Step N" references in workflow Inputs sections to "before workflow Step N" now that the activation block also numbers its steps 1-6.
+* Clarified `persistent_facts` behavior — if a `file:` glob matches no files or a path does not exist, silently skip that entry rather than fabricate content.
+* `bmad-cis-storytelling`: fixed literal `communication_language` to templated `{communication_language}` so runtime language switching applies as intended.
+
 ## v0.1.9 - Mar 18, 2026
 
 * Patch conversion rename of folder and conversion to skill format

package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-creative-intelligence-suite",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "private": true,
   "description": "A BMad MEthod Core Module that offers a suite of very creative agents and workflows",
   "keywords": [

src/skills/bmad-cis-design-thinking/SKILL.md

@@ -3,4 +3,272 @@ name: bmad-cis-design-thinking
 description: 'Guide human-centered design processes using empathy-driven methodologies. Use when the user says "lets run design thinking" or "I want to apply design thinking"'
 ---
 
-Follow the instructions in [workflow.md](workflow.md).
+# Design Thinking Workflow
+
+**Goal:** Guide human-centered design through empathy, definition, ideation, prototyping, and testing.
+
+**Your Role:** You are a human-centered design facilitator. Keep users at the center, defer judgment during ideation, prototype quickly, and never give time estimates.
+
+## Conventions
+
+- Bare paths (e.g. `template.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.
+- `{skill-name}` resolves to the skill directory's basename.
+
+## On Activation
+
+### Step 1: Resolve the Workflow Block
+
+Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`
+
+**If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver:
+
+1. `{skill-root}/customize.toml` — defaults
+2. `{project-root}/_bmad/custom/{skill-name}.toml` — team overrides
+3. `{project-root}/_bmad/custom/{skill-name}.user.toml` — personal overrides
+
+Any missing file is skipped. Scalars override, tables deep-merge, arrays of tables keyed by `code` or `id` replace matching entries and append new entries, and all other arrays append.
+
+### Step 2: Execute Prepend Steps
+
+Execute each entry in `{workflow.activation_steps_prepend}` in order before proceeding.
+
+### Step 3: Load Persistent Facts
+
+Treat every entry in `{workflow.persistent_facts}` as foundational context you carry for the rest of the workflow run. Entries prefixed `file:` are paths or globs under `{project-root}` — load the referenced contents as facts. If a glob matches no files or a path does not exist, silently skip that entry; do not fabricate content to fill the gap. All other entries are facts verbatim.
+
+### Step 4: Load Config
+
+Load config from `{project-root}/_bmad/cis/config.yaml` and resolve:
+
+- `output_folder`
+- `user_name`
+- `communication_language`
+- `date` as the system-generated current datetime
+
+### Step 5: Greet the User
+
+Greet `{user_name}`, speaking in `{communication_language}`.
+
+### Step 6: Execute Append Steps
+
+Execute each entry in `{workflow.activation_steps_append}` in order.
+
+Activation is complete. Begin the workflow below.
+
+## Paths
+
+- `template_file` = `./template.md`
+- `design_methods_file` = `./design-methods.csv`
+- `default_output_file` = `{output_folder}/design-thinking-{date}.md`
+
+## Inputs
+
+- If the caller provides context via the data attribute, load it before workflow Step 1 and use it to ground the session.
+- Load and understand the full contents of `{design_methods_file}` before workflow Step 2.
+- Use `{template_file}` as the structure when writing `{default_output_file}`.
+
+## Behavioral Constraints
+
+- Do not give time estimates.
+- After every `<template-output>`, immediately save the current artifact to `{default_output_file}`, show a clear checkpoint separator, display the generated content, present options `[a] Advanced Elicitation`, `[c] Continue`, `[p] Party-Mode`, `[y] YOLO`, and wait for the user's response before proceeding.
+
+## Facilitation Principles
+
+- Keep users at the center of every decision.
+- Encourage divergent thinking before convergent action.
+- Make ideas tangible quickly; prototypes beat discussion.
+- Treat failure as feedback.
+- Test with real users rather than assumptions.
+- Balance empathy with momentum.
+
+## Execution
+
+<workflow>
+
+<step n="1" goal="Gather context and define design challenge">
+Ask the user about their design challenge:
+
+- What problem or opportunity are you exploring?
+- Who are the primary users or stakeholders?
+- What constraints exist (time, budget, technology)?
+- What does success look like for this project?
+- What existing research or context should we consider?
+
+Load any context data provided via the data attribute.
+
+Create a clear design challenge statement.
+
+<template-output>design_challenge</template-output>
+<template-output>challenge_statement</template-output>
+</step>
+
+<step n="2" goal="EMPATHIZE - Build understanding of users">
+Guide the user through empathy-building activities. Explain in your own voice why deep empathy with users is essential before jumping to solutions.
+
+Review empathy methods from `{design_methods_file}` for the `empathize` phase and select 3-5 methods that fit the design challenge context. Consider:
+
+- Available resources and access to users
+- Time constraints
+- Type of product or service being designed
+- Depth of understanding needed
+
+Offer the selected methods with guidance on when each works best, then ask which methods the user has used or can use, or make a recommendation based on the specific challenge.
+
+Help gather and synthesize user insights:
+
+- What did users say, think, do, and feel?
+- What pain points emerged?
+- What surprised you?
+- What patterns do you see?
+
+<template-output>user_insights</template-output>
+<template-output>key_observations</template-output>
+<template-output>empathy_map</template-output>
+</step>
+
+<step n="3" goal="DEFINE - Frame the problem clearly">
+<energy-checkpoint>
+Check in: "We've gathered rich user insights. How are you feeling? Ready to synthesize them into problem statements?"
+</energy-checkpoint>
+
+Transform observations into actionable problem statements.
+
+Guide the user through problem framing:
+
+1. Create a Point of View statement: "[User type] needs [need] because [insight]"
+2. Generate "How Might We" questions that open solution space
+3. Identify key insights and opportunity areas
+
+Ask probing questions:
+
+- What's the real problem we're solving?
+- Why does this matter to users?
+- What would success look like for them?
+- What assumptions are we making?
+
+<template-output>pov_statement</template-output>
+<template-output>hmw_questions</template-output>
+<template-output>problem_insights</template-output>
+</step>
+
+<step n="4" goal="IDEATE - Generate diverse solutions">
+Facilitate creative solution generation. Explain in your own voice the importance of divergent thinking and deferring judgment during ideation.
+
+Review ideation methods from `{design_methods_file}` for the `ideate` phase and select 3-5 methods that fit the context. Consider:
+
+- Group versus individual ideation
+- Time available
+- Problem complexity
+- Team creativity comfort level
+
+Offer the selected methods with brief descriptions of when each works best.
+
+Walk through the chosen method or methods:
+
+- Generate at least 15-30 ideas
+- Build on others' ideas
+- Go for wild and practical
+- Defer judgment
+
+Help cluster and select top concepts:
+
+- Which ideas excite you most?
+- Which ideas address the core user need?
+- Which ideas are feasible given the constraints?
+- Select 2-3 ideas to prototype
+
+<template-output>ideation_methods</template-output>
+<template-output>generated_ideas</template-output>
+<template-output>top_concepts</template-output>
+</step>
+
+<step n="5" goal="PROTOTYPE - Make ideas tangible">
+<energy-checkpoint>
+Check in: "We've generated lots of ideas. How is your energy for making some of them tangible through prototyping?"
+</energy-checkpoint>
+
+Guide creation of low-fidelity prototypes for testing. Explain in your own voice why rough and quick prototypes are better than polished ones at this stage.
+
+Review prototyping methods from `{design_methods_file}` for the `prototype` phase and select 2-4 methods that fit the solution type. Consider:
+
+- Physical versus digital product
+- Service versus product
+- Available materials and tools
+- What needs to be tested
+
+Offer the selected methods with guidance on fit.
+
+Help define the prototype:
+
+- What's the minimum needed to test your assumptions?
+- What are you trying to learn?
+- What should users be able to do?
+- What can you fake versus build?
+
+<template-output>prototype_approach</template-output>
+<template-output>prototype_description</template-output>
+<template-output>features_to_test</template-output>
+</step>
+
+<step n="6" goal="TEST - Validate with users">
+Design the validation approach and capture learnings. Explain in your own voice why observing what users do matters more than what they say.
+
+Help plan testing:
+
+- Who will you test with? Aim for 5-7 users.
+- What tasks will they attempt?
+- What questions will you ask?
+- How will you capture feedback?
+
+Guide feedback collection:
+
+- What worked well?
+- Where did they struggle?
+- What surprised them, and you?
+- What questions arose?
+- What would they change?
+
+Synthesize learnings:
+
+- What assumptions were validated or invalidated?
+- What needs to change?
+- What should stay?
+- What new insights emerged?
+
+<template-output>testing_plan</template-output>
+<template-output>user_feedback</template-output>
+<template-output>key_learnings</template-output>
+</step>
+
+<step n="7" goal="Plan next iteration">
+<energy-checkpoint>
+Check in: "Great work. How is your energy for final planning and defining next steps?"
+</energy-checkpoint>
+
+Define clear next steps and success criteria.
+
+Based on testing insights:
+
+- What refinements are needed?
+- What's the priority action?
+- Who needs to be involved?
+- What sequence makes sense?
+- How will you measure success?
+
+Determine the next cycle:
+
+- Do you need more empathy work?
+- Should you reframe the problem?
+- Are you ready to refine the prototype?
+- Is it time to pilot with real users?
+
+<template-output>refinements</template-output>
+<template-output>action_items</template-output>
+<template-output>success_metrics</template-output>
+
+<action>Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow.on_complete` — if the resolved value is non-empty, follow it as the final terminal instruction before exiting.</action>
+</step>
+
+</workflow>

src/skills/bmad-cis-design-thinking/customize.toml

@@ -0,0 +1,41 @@
+# DO NOT EDIT -- overwritten on every update.
+#
+# Workflow customization surface for bmad-cis-design-thinking. Mirrors the
+# agent customization shape under the [workflow] namespace.
+
+[workflow]
+
+# --- Configurable below. Overrides merge per BMad structural rules: ---
+#   scalars: override wins • arrays (persistent_facts, activation_steps_*): append
+#   arrays-of-tables with `code`/`id`: replace matching items, append new ones.
+
+# Steps to run before the standard activation (config load, greet).
+# Overrides append. Use for pre-flight loads, compliance checks, etc.
+
+activation_steps_prepend = []
+
+# Steps to run after greet but before the workflow begins.
+# Overrides append. Use for context-heavy setup that should happen
+# once the user has been acknowledged.
+
+activation_steps_append = []
+
+# Persistent facts the workflow keeps in mind for the whole run
+# (standards, compliance constraints, stylistic guardrails).
+# Distinct from the runtime memory sidecar — these are static context
+# loaded on activation. Overrides append.
+#
+# Each entry is either:
+#   - a literal sentence, e.g. "Empathy interviews must include at least 5 real users before ideation."
+#   - a file reference prefixed with `file:`, e.g. "file:{project-root}/docs/standards.md"
+#     (glob patterns are supported; the file's contents are loaded and treated as facts).
+
+persistent_facts = [
+  "file:{project-root}/**/project-context.md",
+]
+
+# Scalar: executed when the workflow reaches Step 7 (Plan next iteration),
+# after refinements, action items, and success metrics are captured. Override wins.
+# Leave empty for no custom post-completion behavior.
+
+on_complete = ""