feat(installer): add hermes-agent tool target (#2489)

Co-authored-by: bigblackcoder <llewis@sovrlabs.com>
Co-authored-by: Brian <bmadcode@gmail.com>

.claude-plugin/marketplace.json

@@ -13,13 +13,14 @@
       "name": "bmad-pro-skills",
       "source": "./",
       "description": "Next level skills for power users — advanced prompting techniques, agent management, and more.",
-      "version": "6.6.0",
+      "version": "6.8.0",
       "author": {
         "name": "Brian (BMad) Madison"
       },
       "skills": [
         "./src/core-skills/bmad-help",
         "./src/core-skills/bmad-brainstorming",
+        "./src/core-skills/bmad-customize",
         "./src/core-skills/bmad-spec",
         "./src/core-skills/bmad-party-mode",
         "./src/core-skills/bmad-shard-doc",
@@ -35,12 +36,13 @@
       "name": "bmad-method-lifecycle",
       "source": "./",
       "description": "Full-lifecycle AI development framework — agents and workflows for product analysis, planning, architecture, and implementation.",
-      "version": "6.6.0",
+      "version": "6.8.0",
       "author": {
         "name": "Brian (BMad) Madison"
       },
       "skills": [
         "./src/bmm-skills/1-analysis/bmad-product-brief",
+        "./src/bmm-skills/1-analysis/bmad-prfaq",
         "./src/bmm-skills/1-analysis/bmad-agent-analyst",
         "./src/bmm-skills/1-analysis/bmad-agent-tech-writer",
         "./src/bmm-skills/1-analysis/bmad-document-project",
@@ -49,18 +51,22 @@
         "./src/bmm-skills/1-analysis/research/bmad-technical-research",
         "./src/bmm-skills/2-plan-workflows/bmad-agent-pm",
         "./src/bmm-skills/2-plan-workflows/bmad-agent-ux-designer",
+        "./src/bmm-skills/2-plan-workflows/bmad-prd",
         "./src/bmm-skills/2-plan-workflows/bmad-create-prd",
         "./src/bmm-skills/2-plan-workflows/bmad-edit-prd",
         "./src/bmm-skills/2-plan-workflows/bmad-validate-prd",
-        "./src/bmm-skills/2-plan-workflows/bmad-create-ux-design",
+        "./src/bmm-skills/2-plan-workflows/bmad-ux",
         "./src/bmm-skills/3-solutioning/bmad-agent-architect",
+        "./src/bmm-skills/3-solutioning/bmad-architecture",
         "./src/bmm-skills/3-solutioning/bmad-create-architecture",
         "./src/bmm-skills/3-solutioning/bmad-check-implementation-readiness",
         "./src/bmm-skills/3-solutioning/bmad-create-epics-and-stories",
         "./src/bmm-skills/3-solutioning/bmad-generate-project-context",
         "./src/bmm-skills/4-implementation/bmad-agent-dev",
+        "./src/bmm-skills/4-implementation/bmad-investigate",
         "./src/bmm-skills/4-implementation/bmad-dev-story",
         "./src/bmm-skills/4-implementation/bmad-quick-dev",
+        "./src/bmm-skills/4-implementation/bmad-checkpoint-preview",
         "./src/bmm-skills/4-implementation/bmad-sprint-planning",
         "./src/bmm-skills/4-implementation/bmad-sprint-status",
         "./src/bmm-skills/4-implementation/bmad-code-review",

.gitignore

@@ -26,6 +26,9 @@ design-artifacts/
 __pycache__/
 .pytest_cache/
 
+# BMad run artifacts (memlogs are per-run working memory, never committed)
+.memlog.md
+
 # System files
 .DS_Store
 Thumbs.db
@@ -44,6 +47,8 @@ CLAUDE.local.md
 .claude/settings.local.json
 .junie/
 .agents/
+.analysis/
+
 
 z*/
 !docs/zh-cn/

CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## v6.8.0 - 2026-05-25
+
+### ✨ Headline
+
+**New planning shapes lead this release.** **bmad-ux** replaces the old single-spine UX skill with a two-spine contract: **DESIGN.md** (visual identity, Google Labs spec) and **EXPERIENCE.md** (behavior, flow, IA). **bmad-spec** distills any messy intent (brain dump, PRD, transcript, brief) into a tight five-field SPEC.md kernel that any downstream skill can consume. Both extend the streamlined Create/Update/Validate + Fast/Coaching template that **bmad-prd** and **bmad-product-brief** set in v6.7.0. The handoff from design into engineering is now a sealed file contract, not a translation layer.
+
+**Also shipping:** **Web Bundles** for Gemini Gems and ChatGPT Custom GPTs ([bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/)) bring six planning bundles to non-IDE users with full IDE schema parity. **bmad-automator** (story automation) lands on the `next` channel. **bmad-method-ui** ships a community-alpha VS Code dashboard + standalone Next.js web UI. 19 new elicitation techniques arrive. Plus a long tail of installer and activation fixes.
+
+### 💥 Breaking Changes
+
+* **`bmad-create-ux-design` replaced by `bmad-ux`.** Single `design.md` spine is gone. New skill emits **DESIGN.md** (visual tokens per the Google Labs spec) and **EXPERIENCE.md** (behavior, flow, IA, states, a11y), with EXPERIENCE.md referencing DESIGN.md tokens via `{path.to.token}` syntax. Adds named-protagonist journeys, surface-closure validation, opt-in reviewer gate, and an extensible producer-handoff registry (default: Stitch). Installer auto-removes the legacy skill. PRD and brief templates aligned (form-factor probe, named-protagonist UJs, no standalone Primary Persona) (#2413)
+* **`bmad-distillator` retired, superseded by `bmad-spec`.** Promoted to core because the kernel pattern is domain-agnostic. Installer cleans up automatically. No internal pipelines called it, but custom workflows must switch to `bmad-spec`.
+
+### 🎁 Features
+
+* **Web Bundles v6 shelf**: Six bundles purpose-built for Gemini Gems and ChatGPT Custom GPTs. Brainstorming (60 techniques, 10 categories), Product Brief (Create/Update/Validate, Fast/Coaching paths), PRFAQ (Working Backwards, 4 stages, weasel-word challenge), PRD (Vision- or Journey-led, 7-dimension validation), UX (two-spine, Don Norman framing, Stitch handoff), Market & Industry Research (Deep Research + Porter + Christensen). Full schema parity with IDE skills so Gem ↔ IDE handoffs do not break. [bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/) is the single supported install path (#2421, #2423, #2425)
+* **Web Bundle release packager**: `tools/bundle-web-bundles.js` zips each bundle into `dist/web-bundles/{slug}.zip` for GitHub Release attachment. `web-bundles/bundles.json` carries persona, copy, accent color, knowledge files, and platform feature flags (web-browsing, deep-research, Stitch). Zero deps; `execFileSync` + strict slug regex (`^[a-z0-9][a-z0-9-]*$`) eliminates shell-injection surface (#2424)
+* **`bmad-spec`, new core skill**: Distills any intent (brain dump, PRD, transcript, brief) into `SPEC.md` with a five-field kernel (Problem, Capabilities, Constraints, Non-goals, Success signal). Catalogs, tables, diagrams, and editorial-voice content go to named companions; absorbed inputs land in a `sources:` list downstream skips. Eight-rule Spec Law with lean-prose discipline. Outputs to `{output_folder}/specs/spec-{slug}/`, works without bmm installed. Headless callers get JSON; interactive runs close conversationally (#2417)
+* **`bmad-ux`, spine-based UX skill**: Rewrite around DESIGN.md (visual identity, Google Labs spec) + EXPERIENCE.md (behavior, flow, IA). Six-step activation matches `bmad-prd` and `bmad-product-brief`. Fast/Coaching modes. Opt-in reviewer gate (no auto-spend on parallel reviewers for hobby work). Per-category verdicts, no misleading headline grade. Ships three DESIGN.md examples (editorial/Linen & Logic, native mobile/Quill, web SaaS/Drift), two paired EXPERIENCE.md examples, one unpaired DESIGN.md modeling the pure Stitch handoff (#2413)
+* **19 new advanced-elicitation techniques**: New `framing` category plus additions across 7 categories (all 50 existing methods preserved). Highlights: Chain-of-Thought Scaffolding, Six Thinking Hats, Delphi Method, Inversion Analysis, Steelmanning, Morphological Analysis, Abstraction Laddering, Cascading Failure Simulation, Boundary & Edge Case Sweep (#2062)
+* **Docs sidebar-order validator**: `tools/validate-sidebar-order.js` flags duplicates, gaps, missing fields, and translation drift across English and translated docs. Wired into `docs:validate-sidebar`. Locale-pattern detection prevents nested English subfolders from being silently excluded (#2409)
+
+### 🐛 Fixes
+
+* **Skill activation guardrails strengthened across 23+ skills**: LLM agents were short-circuiting activation sequences (INCLUDE → READ → RUN → CHECK → FILTER → CD) by guessing variables instead of executing in order, silently skipping append steps and `on_complete` hooks. New guardrail names prepend/append steps explicitly and requires confirmation. Applied to all BMM planning + execution skills, all persona agents (analyst, tech-writer, pm, ux-designer, architect, dev), and new skills (bmad-spec, bmad-ux) (#2398)
+* **Installer reads `config.toml` on re-run**: `loadExistingConfig` only read legacy `_bmad/<module>/config.yaml`, so user-scoped answers (`user_name`, `communication_language`) written to `_bmad/config.user.toml` were ignored and users got re-prompted. Adds `parseCentralToml`; central toml read first, legacy yaml as fallback (#2411)
+* **Stale custom-source caches refreshed on quick-update**: Quick-update now calls `cloneRepo` for every cached custom module, persists the real `next` ref, and atomically dedupes the refresh. When `git fetch` fails (network, deleted repo, revoked auth), the previous clone is preserved with a warning instead of being wiped (#2399)
+* **Shallow-clone default branch resolution**: `--depth 1` clones leave `origin/HEAD` stale, so `git reset --hard origin/HEAD` never pulled new commits. Now resolves the default branch via `git symbolic-ref` and resets against `origin/<branch>` explicitly, falling back to `main` (#2332)
+* **SSH Git URLs with nested group paths**: Custom module installer parses GitLab subgroup and Gitea nested-team SSH URLs correctly (#2379)
+* **`project_context` defined in dev-story, sprint-planning, sprint-status**: Skills referenced the variable without resolving it, producing unresolved expansions at activation in some configurations (#2422)
+* **Dev story baseline commits captured**: Baselining records the commit set the story was scoped against, so reviews compare against a stable reference (#2403)
+* **Customization JSON written as UTF-8**: Non-ASCII team names, product names, and editorial overrides survive a round trip through `_bmad/custom/` (#2414)
+* **Brainstorming idea-flow stays collaborative**: Agent was prematurely converging on its own preferred ideas instead of mirroring and expanding the user's. Collaborative posture restored (#2402)
+
+### 📚 Docs
+
+* **bmad-investigate added to agent trigger tables**: `agents.md` and `named-agents.md` now show the `IN` trigger and forensic-investigation capability on Amelia's row, closing a v6.7.0 gap (#2410)
+* **Web Bundles install framing and update/customize guidance**: Drops misleading "one-click install" and "two files" claims; adds explicit Gem/GPT setup pattern and an "Updating and customizing" section: custom changes belong in the pasted instructions block, not the knowledge files, so updates do not clobber team customizations (#2423)
+* **Web-bundles install traffic centralized at bmadcode.com/web-bundles**: README, web-bundles README, explanation, and how-to pages all point at the site as the single supported install path (#2425)
+* **Reference docs for bmad-spec**: Full entry in `docs/reference/core-tools.md` (en); table-row stubs in cs/fr/vi-vn/zh-cn pending full translation
+
 ## v6.7.1 - 2026-05-18
 
 ### 🐛 Fixes

README.md

@@ -79,11 +79,13 @@ BMad Method extends with official modules for specialized domains. Available dur
 
 ## Web Bundles
 
-V4 shipped web bundles. V6 brings them back, new and improved. Find them in [`web-bundles/`](./web-bundles/).
+V4 shipped web bundles. V6 brings them back, new and improved.
 
-Web bundles package selected BMad skills for installation as **Google Gemini Gems** and **ChatGPT Custom GPTs**. Use them to do the upfront planning work (brainstorming, product briefs, PRDs, PRFAQs, UX specs, market and industry research) in your web LLM subscription, then bring the polished artifacts into your IDE for implementation. Planning runs on a flat-rate subscription instead of metered IDE tokens, which is a meaningful cost saver on longer engagements. Ensure that when using you choose the best model available to you in Gemini or ChatGPT.
+Web bundles package selected BMad skills for installation as **Google Gemini Gems** and **ChatGPT Custom GPTs**. Use them to do the upfront planning work (brainstorming, product briefs, PRDs, PRFAQs, UX specs, market and industry research) in your web LLM subscription, then bring the polished artifacts into your IDE for implementation. Planning runs on a flat-rate subscription instead of metered IDE tokens, which is a meaningful cost saver on longer engagements. Choose the best model available to you in Gemini or ChatGPT.
 
-Current shelf: brainstorming, product brief, PRFAQ, PRD, UX, market & industry research. Each bundle has its own `INSTRUCTIONS.md` to follow; the setup pattern is the same across the shelf (create a Gem or GPT, attach knowledge file(s) (bundle customized SKILL.md and additional content), paste the instructions block, save). See [the web bundles guide](https://docs.bmad-method.org/explanation/web-bundles/) for the concept and [the how-to](https://docs.bmad-method.org/how-to/use-web-bundles/) for setup details.
+Current shelf: brainstorming, product brief, PRFAQ, PRD, UX, market & industry research.
+
+**Browse and install at [bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/)**. One card per bundle, inline install steps for Gemini and ChatGPT, one-click ZIP download. See [the web bundles guide](https://docs.bmad-method.org/explanation/web-bundles/) for the concept.
 
 ## Documentation
 

docs/explanation/party-mode.md

@@ -1,59 +1,150 @@
 ---
 title: "Party Mode"
-description: Multi-agent collaboration - get all your AI agents in one conversation
+description: Get your AI agents in one conversation — run them, build your own cast, and choose how independently they think
 sidebar:
   order: 11
 ---
 
-Get all your AI agents in one conversation.
+Party mode puts your AI agents in one room and lets them talk, to each other and to you. This page explains what a party is, the four ways it can run, how to build your own cast of personas instead of using the installed agents, and how a party remembers you between sessions.
 
 ## What is Party Mode?
 
-Run `bmad-party-mode` and you've got your whole AI team in one room - PM, Architect, Dev, UX Designer, whoever you need. BMad Master orchestrates, picking relevant agents per message. Agents respond in character, agree, disagree, and build on each other's ideas.
+Run `bmad-party-mode` and the BMad agents you already have installed gather in one conversation: the PM, Architect, Dev, UX Designer, and whoever else your selected modules bring. That installed lineup is your default party, ready with no setup. They answer in character, agree, disagree, and build on each other. You steer the room. Ask a follow-up, push back, pull one voice forward, or change the subject. The conversation runs until you end it.
 
-The conversation continues as long as you want. Ask follow-ups, push back on answers, redirect the discussion - it's a real back-and-forth with your agents until you're done.
+It works because the personas hold different priorities. The Architect guards the design, the PM guards scope, the Dev guards what's actually buildable. Put them in the same room and the tradeoff surfaces now, in the conversation, instead of three weeks into the sprint.
 
 **Good for:**
 
-- Big decisions with tradeoffs
+- Decisions with real tradeoffs
-- Brainstorming sessions
+- Brainstorming and "what are we missing?"
-- Post-mortems when things go wrong
+- Post-mortems and retrospectives
-- Sprint retrospectives and planning
+- Pressure-testing a plan before you commit
 
-## Examples
+Party mode is also a fast and genuinely fun way to brainstorm, since the personas have opinions and they clash. And you can start a party from inside any other workflow: mid-brainstorm, mid-PRD, while coding, working a sales angle, or shaping a creative piece. Any time you want more perspectives on what's in front of you, pull in a room without dropping what you were doing.
 
-### Calling Out Bad Architecture
+:::note[Example]
+**You:** Monolith or microservices for the MVP?
 
-**You:** "Okay team, our last sprint was a disaster. The authentication service went down three times. Who screwed this up?"
+**Architect:** Start monolith. Microservices add operating cost you don't need at a thousand users.
 
-**Architect:** "The design was sound - distributed authentication with proper fallbacks. If implementation deviated from the spec..."
+**PM:** Agreed. Time to market matters more than scaling we can't prove yet.
 
-**Dev:** "I followed the architecture doc exactly. The spec didn't account for concurrent session invalidation race conditions."
+**Dev:** Monolith, but with clean module boundaries so we can split a service out later without a rewrite.
-
+:::
-**PM:** "Both of you missed the bigger issue - we didn't validate session management requirements in the PRD. This is on me for not catching it."
+
-
+## Starting a party
-**TEA:** "And I should've caught this in integration tests. The test scenarios didn't cover concurrent invalidation."
+
-
+Invoke the skill and say what you want; it works out whether you mean to run a party or build one.
-### Creative Brainstorming
+
-
+| Goal | Type this |
-**You:** "How do we make onboarding feel magical instead of boring?"
+| --- | --- |
-
+| Start a party in the default mode | `/bmad-party-mode` |
-**UX Designer:** "Start with progressive disclosure - reveal features as users need them, not all at once in a tutorial."
+| Start in a specific mode | `/bmad-party-mode --mode auto` (also `session`, `subagent`, `agent-team`) |
-
+| Open a saved party | `/bmad-party-mode --party code-review-crew` |
-**Storyteller:** "What if onboarding was a story? Each step reveals a character's journey - the user IS the hero."
+| Conjure a cast on the spot | "party mode with the bridge crew of the Enterprise" |
-
+| Create or add a party | "party mode, create a new party" |
-**Game Designer:** "Building on that - what if the first 'quest' is actually solving a real user problem? They learn by doing something valuable."
+| Edit an existing party | "party mode, edit the writers' room" |
-
+| Customize the skill | `/bmad-customize bmad-party-mode` |
-### Technical Decision
+
-
+## How a party runs
-**You:** "Monolith or microservices for MVP?"
+
-
+A party can run in four modes. One mode is active per session, and it decides who does the thinking: a single model voicing everyone, or separate agents reasoning on their own.
-**Architect:** "Start monolith. Microservices add complexity you don't need at 1000 users."
+
-
+| Mode | What it does | Reach for it when |
-**PM:** "Agree. Time to market matters more than theoretical scalability."
+| --- | --- | --- |
-
+| `session` | Default. One model voices every persona inline. Fast and fully conversational. | Most conversations — banter, brainstorming, quick back-and-forth. |
-**Dev:** "Monolith with clear module boundaries. We can extract services later if needed."
+| `auto` | Voices inline for light rounds, spawns independent agents only when independence changes the answer. | You want speed most of the time but real independence on the hard rounds. |
-
+| `subagent` | Spawns a separate agent for each persona every substantive round, so no single mind colors them all. | Honest reviews and focus groups, where the voices must not bleed together. |
-:::tip[Better Decisions]
+| `agent-team` | Stands the personas up as a persistent team that address each other directly. Claude Code only. | A live, hands-off round-table where the agents talk among themselves. |
-Better decisions through diverse perspectives. Welcome to party mode.
+
+The choice matters because one model voicing five personas can quietly converge: they share a mind. Spawning real agents keeps their reasoning separate, which is the entire point of a review panel or a focus group. `session` is the cheapest and most fluid. The spawning modes cost more but protect independence, and `auto` aims for both by spawning only when a round needs it.
+
+`session` is the default, and every other mode falls back to it when a harness can't do the rest: `agent-team` drops to `subagent`, then to `session`. The configured default lives in your customization, and a runtime override wins for that session.
+
+:::tip[Override for one session]
+Start a party with `--mode subagent` (or `auto`, `agent-team`, `session`) to override the configured default just for that run.
+:::
+
+## Custom parties
+
+Out of the box, a party uses your installed BMad agents. The larger use is building your own cast from any set of personas you can describe, then saving it to reuse. You author a party through the same skill. It detects whether you want to run one or build one, and writes the result to your overrides through [bmad-customize](../how-to/customize-bmad.md).
+
+Party mode is customizable like every BMad skill. Run `/bmad-customize bmad-party-mode` to set its defaults directly: pin any group you've built as the default party so it loads without a flag, choose which mode it starts in, and set any house rules the room should hold for the whole session.
+
+Two ideas do most of the work.
+
+**Personas** are what make a member unmistakable: how they talk, what they value, how they argue, their pet peeves and blind spots. "Skeptical CFO" is a placeholder. "Won't approve anything without a payback under eighteen months, and says so in the first thirty seconds" is a persona. That detail is what gives a voice you'd recognize with the name labels hidden.
+
+**Scenes** set the stage. A scene is one freeform line: the setting, what's happening, who's hostile to whom, who pushes hardest. The same members play it differently each time, so you define a person once and drop them into a bridge crew on duty, the same crew off-duty in the lounge, or a hostile buyer panel. Members combine into named groups, and you can pin one group as the default room.
+
+### Shapes a party can take
+
+| Shape | What it is |
+| --- | --- |
+| Themed cast | Famous investors, a TV ensemble — distinct voices gathered around a topic. |
+| One-off personas | A persona or two added to the pool, no group needed. |
+| Focus group from data | Hand it customer or survey data; it clusters people by what drives their behavior and builds representative personas. Pair it with `subagent` mode so the customers stay independent. |
+| Review panel | Purpose-built critical lenses that argue about what matters. The shipped Code Review Crew is one. |
+| Open-cast room | No fixed roster. The scene names a universe and the room is cast on the fly as the topic shifts. |
+
+A focus group is the case that pays off most. Feed in real profiles and you get a standing panel of representative customers to test an idea against before you build it, each reacting from their own goals and budget instead of agreeing with the last voice.
+
+## Parties you could build
+
+A party is only personas and a scene, so the range is wide, and none of it needs a new skill or module:
+
+- A founder squad to stress-test a startup idea.
+- A compliance team to find the holes before an audit does.
+- The authors of the Agile Manifesto, debating a software concept.
+- A room of comedians as a writing-partner group.
+- Great minds of the past, to work through a question in philosophy or untangle a hard problem.
+- A business management team to plan the quarter.
+
+These are starting points. Any set of voices you can describe becomes a party: write the personas, give the room a scene, and you have it.
+
+## The Code Review Crew
+
+Your default party is the agents your installed modules provide. The Code Review Crew is a custom party BMad ships alongside that default — a working template to study before you build your own, not a replacement for it. It's a review panel: five lenses that attack a change from different angles and argue about what actually matters, instead of rubber-stamping it.
+
+| Member | Lens |
+| --- | --- |
+| Vex | Security — threat-models everything and names the concrete exploit path. |
+| Grumbal | The adversary — assumes the code is broken and sets out to prove it. |
+| Boundary | Edge cases — every branch, null, race, oversized input, odd timezone. |
+| Yui | The craftsman — simplicity, naming, no needless cleverness or duplication. |
+| Dana | The pragmatist — counters the perfectionists and ranks what's real versus a nit. |
+
+The crew ships defined but inactive. The members sit in the pool and cost nothing until you summon the group, and they never crowd your default room. Run it with `subagent` mode so each lens reviews on its own before the five clash over the findings.
+
+## Steering the conversation
+
+You drive the room the whole way:
+
+- Bring someone in: "Bring in the UX designer."
+- Go deep on one voice: "Winston, take that apart." A direct ask is the cue for one persona to stretch out.
+- Switch rooms mid-session: "Switch to the writers' room" swaps the active group and carries the thread over.
+- Summon anyone by name, even a custom member who isn't in the current room.
+
+Whichever mode is running, the orchestrator presents the result as one conversation rather than a stack of separate answers, and it keeps the personas in character — it won't break the fourth wall to narrate the mechanism.
+
+:::tip[Mix more than one room]
+You aren't limited to a single group. Pull members from several parties into the same conversation, or name a cast on the spot, and let them mix. Picture the Golden Girls thrown into an architecture review with Martin Fowler and Linus Torvalds, sparring over a change request: you can imagine how that goes.
+:::
+
+## The room remembers
+
+Give a party a memory and it picks up where you left off. It keeps its own record of your past sessions — the dynamics that built up between members, the threads you left open, and where earlier conversations landed. Reopen it a week later and that history is intact: two members who came to blows last time still open a little frosty, and a sharp line from a past session can resurface as an organic callback.
+
+It's memory, not a transcript. The room carries the few things worth remembering, not a log of everything said, so the next conversation feels continuous without dragging the whole past into it. It happens on its own, in the background — nothing to save, and the room never breaks character to announce it.
+
+A character who turns up on the fly is remembered too — a walk-on from an open-cast scene, or someone you add mid-conversation. At the end of a session the room offers to keep the new arrivals, folding them into the party so they can come back next time.
+
+Memory is set per party. When you create or save a party you're asked whether it should remember; the default installed-agent room remembers unless you turn it off. Set or change any of this through `/bmad-customize bmad-party-mode`.
+
+## A keepsake of the session
+
+When you wrap up, the orchestrator offers a keepsake: a single self-contained HTML document of the session to keep or share. It lays the conversation out by persona rather than dumping a raw transcript. Decline it and the party simply ends.
+
+:::tip[Better decisions]
+The value of a party is the disagreement. Diverse perspectives in one room catch what a single line of thinking misses.
 :::

docs/explanation/web-bundles.md

@@ -9,7 +9,7 @@ Run the planning side of BMad in your web LLM subscription, then bring the artif
 
 A web bundle is a BMad skill repackaged for installation as a **Google Gemini Gem** or **ChatGPT Custom GPT**. Each bundle includes a `SKILL.md` protocol you upload as a knowledge file, an `INSTRUCTIONS.md` block you paste into the Gem or GPT instructions, and any data files the skill needs (CSVs, templates, validation checklists, additionally progressively disclosed content). The persona lives in the pasted instructions; the protocol lives in the knowledge file. Swap personas without touching the protocol.
 
-Setup is not one-click; you create the Gem or GPT, upload the knowledge files, paste the instructions, and save. The pattern is the same across the shelf, so once you've installed one bundle the next one is mechanical. Follow each bundle's `INSTRUCTIONS.md` for the platform-specific details.
+Setup is not one-click, but the steps are guided. **Install from [bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/)**. The site lists every bundle in a card grid, shows you the Gemini and ChatGPT install steps inline, and hands you the ZIP download. That is the supported install path; the pattern is the same across the shelf, so once you've installed one the next one is mechanical.
 
 V4 of BMad shipped web bundles. V6 brings them back, rewritten for the current Gem and Custom GPT platforms with Canvas, Deep Research, and image generation in mind.
 
@@ -79,4 +79,4 @@ Persona swaps, default user name, team-specific guardrails, preferred phrasing:
 
 Web bundles are generated from BMad skills using the `bmad-os-skill-to-bundle` utility skill. Point it at any BMad skill folder and it produces the bundle files with persona inheritance from the owning agent.
 
-See the [how-to guide](../how-to/use-web-bundles.md) for installation steps.
+Install any bundle from [bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/).

docs/fr/404.md

@@ -3,6 +3,6 @@ title: Page introuvable
 template: splash
 ---
 
-La page que vous recherchez n'existe pas ou a été déplacée.
+La page que vous recherchez n’existe pas ou a été déplacée.
 
-[Retour à l'accueil](/fr/index.md)
+[Retour à l’accueil](/fr/index.md)

docs/fr/_STYLE_GUIDE.md

@@ -7,17 +7,17 @@ Ce projet suit le [Guide de style de documentation pour développeurs Google](ht
 
 ## Règles spécifiques au projet
 
-| Règle                                   | Spécification                                          |
+| Règle                                      | Spécification                                          |
-| --------------------------------------- | ------------------------------------------------------ |
+|--------------------------------------------|--------------------------------------------------------|
-| Pas de règles horizontales (`---`)      | Perturbe le flux de lecture des fragments              |
+| Pas de règles horizontales (`---`)         | Perturbe le flux de lecture des fragments              |
-| Pas de titres `####`                    | Utiliser du texte en gras ou des admonitions           |
+| Pas de titres `####`                       | Utiliser du texte en gras ou des admonitions           |
-| Pas de sections « Related » ou « Next: »    | La barre latérale gère la navigation                   |
+| Pas de sections « Related » ou « Next »    | La barre latérale gère la navigation                   |
-| Pas de listes profondément imbriquées   | Diviser en sections à la place                         |
+| Pas de listes profondément imbriquées      | Diviser en sections à la place                         |
-| Pas de blocs de code pour non-code      | Utiliser des admonitions pour les exemples de dialogue |
+| Pas de blocs de code pour non-code         | Utiliser des admonitions pour les exemples de dialogue |
-| Pas de paragraphes en gras pour les appels | Utiliser des admonitions à la place                 |
+| Pas de paragraphes en gras pour les appels | Utiliser des admonitions à la place                    |
-| 1-2 admonitions max par section         | Les tutoriels permettent 3-4 par section majeure       |
+| 1-2 admonitions max par section            | Les tutoriels permettent 3-4 par section majeure       |
-| Cellules de tableau / éléments de liste | 1-2 phrases maximum                                    |
+| Cellules de tableau / éléments de liste    | 1-2 phrases maximum                                    |
-| Budget de titres                        | 8-12 `##` par doc ; 2-3 `###` par section              |
+| Budget de titres                           | 8-12 `##` par doc ; 2-3 `###` par section              |
 
 ## Admonitions (Syntaxe Starlight)
 
@@ -41,36 +41,36 @@ Avertissements critiques uniquement — perte de données, problèmes de sécuri
 
 ### Utilisations standards
 
-| Admonition                 | Usage                                    |
+| Admonition              | Usage                            |
-| -------------------------- | ---------------------------------------- |
+|-------------------------|----------------------------------|
-| `:::note[Pré-requis]`   | Dépendances avant de commencer           |
+| `:::note[Pré-requis]`   | Dépendances avant de commencer   |
-| `:::tip[Chemin rapide]`       | Résumé TL;DR en haut du document         |
+| `:::tip[Chemin rapide]` | Résumé TL;DR en haut du document |
-| `:::caution[Important]`    | Mises en garde critiques                 |
+| `:::caution[Important]` | Mises en garde critiques         |
-| `:::note[Exemple]`         | Exemples de commandes/réponses           |
+| `:::note[Exemple]`      | Exemples de commandes/réponses   |
 
 ## Formats de tableau standards
 
-**Phases :**
+**Phases :**
 
 ```md
-| Phase | Nom        | Ce qui se passe                                     |
+| Phase | Nom           | Ce qui se passe                                       |
-| ----- | ---------- | --------------------------------------------------- |
+|-------|---------------|-------------------------------------------------------|
-| 1     | Analyse    | Brainstorm, recherche *(optionnel)*                 |
+| 1     | Analyse       | Brainstorm, recherche *(optionnel)*                   |
-| 2     | Planification | Exigences — PRD ou spécification technique *(requis)*          |
+| 2     | Planification | Exigences — PRD ou spécification technique *(requis)* |
 ```
 
-**Skills :**
+**Skills :**
 
 ```md
-| Skill               | Agent   | Objectif                                        |
+| Skill                | Agent    | Objectif                              |
-| ------------------- | ------- | ----------------------------------------------- |
+|----------------------|----------|---------------------------------------|
-| `bmad-brainstorming` | Analyste | Brainstorming pour un nouveau projet                    |
+| `bmad-brainstorming` | Analyste | Brainstorming pour un nouveau projet  |
-| `bmad-create-prd`    | PM      | Créer un document d'exigences produit           |
+| `bmad-prd`           | PM       | Créer un document d'exigences produit |
 ```
 
 ## Blocs de structure de dossiers
 
-À afficher dans les sections "Ce que vous avez accompli" :
+À afficher dans les sections « Ce que vous avez accompli » :
 
 ````md
 ```
@@ -78,9 +78,9 @@ votre-projet/
 ├── _bmad/                                   # Configuration BMad
 ├── _bmad-output/
 │   ├── planning-artifacts/
-│   │   └── PRD.md                           # Votre document d'exigences
+│   │   └── PRD.md                           # Votre document d’exigences
 │   ├── implementation-artifacts/
-│   └── project-context.md                   # Règles d'implémentation (optionnel)
+│   └── project-context.md                   # Règles d’implémentation (optionnel)
 └── ...
 ```
 ````
@@ -107,21 +107,21 @@ votre-projet/
 
 ### Liste de vérification des tutoriels
 
-- [ ] L'accroche décrit le résultat en 1-2 phrases
+- [ ] L’accroche décrit le résultat en 1-2 phrases
-- [ ] Section "Ce que vous allez apprendre" présente
+- [ ] Section « Ce que vous allez apprendre » présente
 - [ ] Prérequis dans une admonition
 - [ ] Admonition TL;DR de chemin rapide en haut
 - [ ] Tableaux pour phases, skills, agents
-- [ ] Section "Ce que vous avez accompli" présente
+- [ ] Section « Ce que vous avez accompli » présente
 - [ ] Tableau de référence rapide présent
 - [ ] Section questions courantes présente
-- [ ] Section obtenir de l'aide présente
+- [ ] Section obtenir de l’aide présente
 - [ ] Admonition points clés à retenir à la fin
 
 ## Structure des guides pratiques (How-To)
 
 ```text
-1. Titre + Accroche (une phrase : « Utilisez le workflow `X` pour... »)
+1. Titre + Accroche (une phrase : « Utilisez le workflow `X` pour... »)
 2. Quand utiliser ce guide (liste à puces de scénarios)
 3. Quand éviter ce guide (optionnel)
 4. Prérequis (admonition note)
@@ -134,23 +134,23 @@ votre-projet/
 
 ### Liste de vérification des guides pratiques
 
-- [ ] L'accroche commence par « Utilisez le workflow `X` pour... »
+- [ ] L’accroche commence par « Utilisez le workflow `X` pour... »
-- [ ] "Quand utiliser ce guide" contient 3-5 points
+- [ ] « Quand utiliser ce guide » contient 3-5 points
 - [ ] Prérequis listés
-- [ ] Les étapes sont des sous-sections `###` numérotées avec des verbes d'action
+- [ ] Les étapes sont des sous-sections `###` numérotées avec des verbes d’action
-- [ ] "Ce que vous obtenez" décrit les artefacts produits
+- [ ] « Ce que vous obtenez » décrit les artefacts produits
 
 ## Structure des explications
 
 ### Types
 
-| Type                    | Exemple                              |
+| Type                     | Exemple                       |
-| ----------------------- | ------------------------------------ |
+|--------------------------|-------------------------------|
-| **Index/Page d'accueil** | `core-concepts/index.md`            |
+| **Index/Page d’accueil** | `core-concepts/index.md`      |
-| **Concept**             | `what-are-agents.md`                 |
+| **Concept**              | `what-are-agents.md`          |
-| **Fonctionnalité**      | `quick-dev.md`                       |
+| **Fonctionnalité**       | `quick-dev.md`                |
-| **Philosophie**         | `why-solutioning-matters.md`         |
+| **Philosophie**          | `why-solutioning-matters.md`  |
-| **FAQ**                 | `established-projects-faq.md`        |
+| **FAQ**                  | `established-projects-faq.md` |
 
 ### Modèle général
 
@@ -164,7 +164,7 @@ votre-projet/
 7. Prochaines étapes (optionnel)
 ```
 
-### Pages d'index/d'accueil
+### Pages d’index/d’accueil
 
 ```text
 1. Titre + Accroche (une phrase)
@@ -209,7 +209,7 @@ votre-projet/
 
 ### Liste de vérification des explications
 
-- [ ] L'accroche énonce ce que le document explique
+- [ ] L’accroche énonce ce que le document explique
 - [ ] Contenu dans des sections `##` parcourables
 - [ ] Tableaux comparatifs pour 3+ options
 - [ ] Les diagrammes ont des étiquettes claires
@@ -220,16 +220,16 @@ votre-projet/
 
 ### Types
 
-| Type                    | Exemple               |
+| Type                     | Exemple               |
-| ----------------------- | --------------------- |
+|--------------------------|-----------------------|
-| **Index/Page d'accueil** | `workflows/index.md` |
+| **Index/Page d’accueil** | `workflows/index.md`  |
-| **Catalogue**           | `agents/index.md`     |
+| **Catalogue**            | `agents/index.md`     |
-| **Approfondissement**   | `document-project.md` |
+| **Approfondissement**    | `document-project.md` |
-| **Configuration**       | `core-tasks.md`       |
+| **Configuration**        | `core-tasks.md`       |
-| **Glossaire**           | `glossary/index.md`   |
+| **Glossaire**            | `glossary/index.md`   |
-| **Complet**             | `bmgd-workflows.md`   |
+| **Complet**              | `bmgd-workflows.md`   |
 
-### Pages d'index de référence
+### Pages d’index de référence
 
 ```text
 1. Titre + Accroche (une phrase)
@@ -243,11 +243,11 @@ votre-projet/
 1. Titre + Accroche
 2. Éléments (## pour chaque élément)
    - Brève description (une phrase)
-   - **Skills :** ou **Infos clés :** sous forme de liste simple
+   - **Skills :** ou **Infos clés :** sous forme de liste simple
 3. Universel/Partagé (## section) (optionnel)
 ```
 
-### Référence d'approfondissement d'élément
+### Référence d’approfondissement d’élément
 
 ```text
 1. Titre + Accroche (objectif en une phrase)
@@ -286,16 +286,16 @@ votre-projet/
 
 ### Liste de vérification des références
 
-- [ ] L'accroche énonce ce que le document référence
+- [ ] L’accroche énonce ce que le document référence
 - [ ] La structure correspond au type de référence
 - [ ] Les éléments utilisent une structure cohérente
 - [ ] Tableaux pour les données structurées/comparatives
-- [ ] Liens vers les documents d'explication pour la profondeur conceptuelle
+- [ ] Liens vers les documents d’explication pour la profondeur conceptuelle
 - [ ] 1-2 admonitions max
 
 ## Structure du glossaire
 
-Starlight génère la navigation "Sur cette page" à droite à partir des titres :
+Starlight génère la navigation « Sur cette page » à droite à partir des titres :
 
 - Catégories en tant que titres `##` — apparaissent dans la navigation à droite
 - Termes dans des tableaux — lignes compactes, pas de titres individuels
@@ -303,22 +303,23 @@ Starlight génère la navigation "Sur cette page" à droite à partir des titres
 
 ### Format de tableau
 
+
 ```md
 ## Nom de catégorie
 
-| Terme        | Définition                                                                                    |
+| Terme        | Définition                                                                                                 |
-| ------------ | --------------------------------------------------------------------------------------------- |
+|--------------|------------------------------------------------------------------------------------------------------------|
-| **Agent**    | Personnalité IA spécialisée avec une expertise spécifique qui guide les utilisateurs dans les workflows. |
+| **Agent**    | Personnalité IA spécialisée avec une expertise spécifique qui guide les utilisateurs dans les workflows.   |
 | **Workflow** | Processus guidé en plusieurs étapes qui orchestre les activités des agents IA pour produire des livrables. |
 ```
 
 ### Règles de définition
 
-| À faire                           | À ne pas faire                                |
+| À faire                                        | À ne pas faire                                      |
-| --------------------------------- | --------------------------------------------- |
+|------------------------------------------------|-----------------------------------------------------|
-| Commencer par ce que c'est ou ce que cela fait | Commencer par « C'est... » ou « Un [terme] est... » |
+| Commencer par ce que c’est ou ce que cela fait | Commencer par « C’est... » ou « Un [terme] est... » |
-| Se limiter à 1-2 phrases          | Écrire des explications de plusieurs paragraphes |
+| Se limiter à 1-2 phrases                       | Écrire des explications de plusieurs paragraphes    |
-| Mettre le nom du terme en gras dans la cellule | Utiliser du texte simple pour les termes      |
+| Mettre le nom du terme en gras dans la cellule | Utiliser du texte simple pour les termes            |
 
 ### Marqueurs de contexte
 
@@ -337,7 +338,7 @@ Ajouter un contexte en italique au début de la définition pour les termes à p
 - [ ] Définitions de 1-2 phrases
 - [ ] Marqueurs de contexte en italique
 - [ ] Noms des termes en gras dans les cellules
-- [ ] Pas de définitions « Un [terme] est... »
+- [ ] Pas de définitions « Un [terme] est... »
 
 ## Sections FAQ
 

docs/fr/explanation/advanced-elicitation.md

@@ -2,25 +2,25 @@
 title: "Élicitation Avancée"
 description: Pousser le LLM à repenser son travail en utilisant des méthodes de raisonnement structurées
 sidebar:
-  order: 3
+  order: 4
 ---
 
-Faites repenser au LLM ce qu'il vient de générer. Vous choisissez une méthode de raisonnement, il l'applique à sa propre sortie, et vous décidez de conserver ou non les améliorations.
+Faites repenser au LLM ce qu’il vient de générer. Vous choisissez une méthode de raisonnement, il l’applique à sa propre sortie, et vous décidez de conserver ou non les améliorations.
 
-## Qu'est-ce que l’Élicitation Avancée ?
+## Qu’est-ce que l’Élicitation Avancée ?
 
-Un second passage structuré. Au lieu de demander à l'IA de "réessayer" ou de "faire mieux", vous sélectionnez une méthode de raisonnement spécifique et l'IA réexamine sa propre sortie à travers ce prisme.
+Un second passage structuré. Au lieu de demander à l’IA de « réessayer » ou de « faire mieux », vous sélectionnez une méthode de raisonnement spécifique et l’IA réexamine sa propre sortie à travers ce prisme.
 
-La différence est importante. Les demandes vagues produisent des révisions vagues. Une méthode nommée impose un angle d'attaque particulier, mettant en lumière des perspectives qu'un simple réajustement générique aurait manquées.
+La différence est importante. Les demandes vagues produisent des révisions vagues. Une méthode nommée impose un angle d’attaque particulier, mettant en lumière des perspectives qu’un simple réajustement générique aurait manquées.
 
-## Quand l'utiliser
+## Quand l’utiliser
 
-- Après qu'un workflow a généré du contenu et vous souhaitez des alternatives
+- Après qu’un workflow a généré du contenu et vous souhaitez des alternatives
-- Lorsque la sortie semble correcte mais que vous soupçonnez qu'il y a davantage de profondeur
+- Lorsque la sortie semble correcte mais que vous soupçonnez qu’il y a davantage de profondeur
 - Pour tester les hypothèses ou trouver des faiblesses
 - Pour du contenu à enjeux élevés où la réflexion approfondie aide
 
-Les workflows offrent l'élicitation aux points de décision - après que le LLM ait généré quelque chose, on vous demandera si vous souhaitez l'exécuter.
+Les workflows offrent l’élicitation aux points de décision - après que le LLM ait généré quelque chose, on vous demandera si vous souhaitez l’exécuter.
 
 ## Comment ça fonctionne
 
@@ -35,15 +35,15 @@ Des dizaines de méthodes de raisonnement sont disponibles. Quelques exemples :
 
 - **Analyse Pré-mortem** - Suppose que le projet a déjà échoué, revient en arrière pour trouver pourquoi
 - **Pensée de Premier Principe** - Élimine les hypothèses, reconstruit à partir de la vérité de terrain
-- **Inversion** - Demande comment garantir l'échec, puis les évite
+- **Inversion** - Demande comment garantir l’échec, puis les évite
 - **Équipe Rouge vs Équipe Bleue** - Attaque votre propre travail, puis le défend
-- **Questionnement Socratique** - Conteste chaque affirmation avec "pourquoi ?" et "comment le savez-vous ?"
+- **Questionnement Socratique** - Conteste chaque affirmation avec « pourquoi ? » et « comment le savez-vous ? »
 - **Suppression des Contraintes** - Abandonne toutes les contraintes, voit ce qui change, les réajoute sélectivement
 - **Cartographie des Parties Prenantes** - Réévalue depuis la perspective de chaque partie prenante
-- **Raisonnement Analogique** - Trouve des parallèles dans d'autres domaines et applique leurs leçons
+- **Raisonnement Analogique** - Trouve des parallèles dans d’autres domaines et applique leurs leçons
 
-Et bien d'autres. L'IA choisit les options les plus pertinentes pour votre contenu - vous choisissez lesquelles exécuter.
+Et bien d’autres. L’IA choisit les options les plus pertinentes pour votre contenu - vous choisissez lesquelles exécuter.
 
 :::tip[Commencez Ici]
-L'Analyse Pré-mortem est un bon premier choix pour toute spécification ou tout plan. Elle trouve systématiquement des lacunes qu'une révision standard manque.
+L’Analyse Pré-mortem est un bon premier choix pour toute spécification ou tout plan. Elle trouve systématiquement des lacunes qu’une révision standard manque.
 :::

docs/fr/explanation/adversarial-review.md

@@ -1,58 +1,58 @@
 ---
 title: "Revue Contradictoire"
-description: Technique de raisonnement forcée qui empêche les revues paresseuses du style "ça à l'air bon"
+description: Technique de raisonnement forcée qui empêche les revues paresseuses du style « ça à l’air bon »
 sidebar:
-  order: 8
+  order: 9
 ---
 
 Forcez une analyse plus approfondie en exigeant que des problèmes soient trouvés.
 
-## Qu'est-ce que la Revue Contradictoire ?
+## Qu’est-ce que la Revue Contradictoire ?
 
-Une technique de revue où le réviseur *doit* trouver des problèmes. Pas de "ça a l'air bon" autorisé. Le réviseur adopte une posture cynique - suppose que des problèmes existent et les trouve.
+Une technique de revue où le réviseur *doit* trouver des problèmes. Pas de « ça a l’air bon » autorisé. Le réviseur adopte une posture cynique - suppose que des problèmes existent et les trouve.
 
-Il ne s'agit pas d'être négatif. Il s'agit de forcer une analyse authentique au lieu d'un coup d'œil superficiel qui valide automatiquement ce qui a été soumis.
+Il ne s’agit pas d’être négatif. Il s’agit de forcer une analyse authentique au lieu d’un coup d’œil superficiel qui valide automatiquement ce qui a été soumis.
 
-**La règle fondamentale :** Il doit trouver des problèmes. Zéro constatation déclenche un arrêt - réanalyse ou explique pourquoi.
+**La règle fondamentale :** Il doit trouver des problèmes. Zéro constatation déclenche un arrêt - réanalyse ou explique pourquoi.
 
 ## Pourquoi Cela Fonctionne
 
-Les revues normales souffrent du biais de confirmation[^1]. Il parcourt le travail rapidement, rien ne lui saute aux yeux, il l'approuve. L'obligation de "trouver des problèmes" brise ce schéma :
+Les revues normales souffrent du biais de confirmation[^1]. Il parcourt le travail rapidement, rien ne lui saute aux yeux, il l’approuve. L’obligation de « trouver des problèmes » brise ce schéma :
 
-- **Force la rigueur** - Impossible d'approuver tant qu’il n'a pas examiné suffisamment en profondeur pour trouver des problèmes
+- **Force la rigueur** - Impossible d’approuver tant qu’il n’a pas examiné suffisamment en profondeur pour trouver des problèmes
-- **Détecte les oublis** - "Qu'est-ce qui manque ici ?" devient une question naturelle
+- **Détecte les oublis** - « Qu’est-ce qui manque ici ? » devient une question naturelle
 - **Améliore la qualité du signal** - Les constatations sont spécifiques et actionnables, pas des préoccupations vagues
-- **Asymétrie d'information**[^2] - Effectue les revues avec un contexte frais (sans accès au raisonnement original) pour évaluer l'artefact, pas l'intention
+- **Asymétrie d’information**[^2] - Effectue les revues avec un contexte frais (sans accès au raisonnement original) pour évaluer l’artefact, pas l’intention
 
 ## Où Elle Est Utilisée
 
-La revue contradictoire apparaît dans tous les workflows BMad - revue de code, vérifications de préparation à l'implémentation, validation de spécifications, et d'autres. Parfois c'est une étape obligatoire, parfois optionnelle (comme l'élicitation avancée ou le mode party). Le pattern s'adapte à n'importe quel artefact nécessitant un examen.
+La revue contradictoire apparaît dans tous les workflows BMad - revue de code, vérifications de préparation à l’implémentation, validation de spécifications, et d’autres. Parfois c’est une étape obligatoire, parfois optionnelle (comme l’élicitation avancée ou le mode party). Le pattern s’adapte à n’importe quel artefact nécessitant un examen.
 
 ## Filtrage Humain Requis
 
-Parce que l'IA est *instruite* de trouver des problèmes, elle trouvera des problèmes - même lorsqu'ils n'existent pas. Attendez-vous à des faux positifs : des détails présentés comme des problèmes, des malentendus sur l'intention, ou des préoccupations purement hallucinées[^3].
+Parce que l’IA est *instruite* de trouver des problèmes, elle trouvera des problèmes - même lorsqu’ils n’existent pas. Attendez-vous à des faux positifs : des détails présentés comme des problèmes, des malentendus sur l’intention, ou des préoccupations purement hallucinées[^3].
 
-**C'est vous qui décidez ce qui est réel.** Examinez chaque constatation, ignorez le bruit, corrigez ce qui compte.
+**C’est vous qui décidez ce qui est réel.** Examinez chaque constatation, ignorez le bruit, corrigez ce qui compte.
 
 ## Exemple
 
 Au lieu de :
 
-> "L'implémentation de l'authentification semble raisonnable. Approuvé."
+> « L’implémentation de l’authentification semble raisonnable. Approuvé. »
 
 Une revue contradictoire produit :
 
 > 1. **ÉLEVÉ** - `login.ts:47` - Pas de limitation de débit sur les tentatives échouées
 > 2. **ÉLEVÉ** - Jeton de session stocké dans localStorage (vulnérable au XSS)
 > 3. **MOYEN** - La validation du mot de passe se fait côté client uniquement
-> 4. **MOYEN** - Pas de journalisation d'audit pour les tentatives de connexion échouées
+> 4. **MOYEN** - Pas de journalisation d’audit pour les tentatives de connexion échouées
 > 5. **FAIBLE** - Le nombre magique `3600` devrait être `SESSION_TIMEOUT_SECONDS`
 
 La première revue pourrait manquer une vulnérabilité de sécurité. La seconde en a attrapé quatre.
 
 ## Itération et Rendements Décroissants
 
-Après avoir traité les constatations, envisagez de relancer la revue. Une deuxième passe détecte généralement plus de problèmes. Une troisième n'est pas toujours inutile non plus. Mais chaque passe prend du temps, et vous finissez par atteindre des rendements décroissants[^4] - juste des détails et des faux problèmes.
+Après avoir traité les constatations, envisagez de relancer la revue. Une deuxième passe détecte généralement plus de problèmes. Une troisième n’est pas toujours inutile non plus. Mais chaque passe prend du temps, et vous finissez par atteindre des rendements décroissants[^4] - juste des détails et des faux problèmes.
 
 :::tip[Meilleures Revues]
 Supposez que des problèmes existent. Cherchez ce qui manque, pas seulement ce qui ne va pas.
@@ -61,6 +61,6 @@ Supposez que des problèmes existent. Cherchez ce qui manque, pas seulement ce q
 ## Glossaire
 
 [^1]: **Biais de confirmation** : tendance cognitive à rechercher, interpréter et favoriser les informations qui confirment nos croyances préexistantes, tout en ignorant ou minimisant celles qui les contredisent.
-[^2]: **Asymétrie d'information** : situation où une partie dispose de plus ou de meilleures informations qu'une autre, conduisant potentiellement à des décisions ou jugements biaisés.
+[^2]: **Asymétrie d’information** : situation où une partie dispose de plus ou de meilleures informations qu’une autre, conduisant potentiellement à des décisions ou jugements biaisés.
-[^3]: **Hallucination (IA)** : phénomène où un modèle d'IA génère des informations plausibles mais factuellement incorrectes ou inventées, présentées avec confiance comme si elles étaient vraies.
+[^3]: **Hallucination (IA)** : phénomène où un modèle d’IA génère des informations plausibles mais factuellement incorrectes ou inventées, présentées avec confiance comme si elles étaient vraies.
-[^4]: **Rendements décroissants** : principe selon lequel l'augmentation continue d'un investissement (temps, effort, ressources) finit par produire des bénéfices de plus en plus faibles proportionnellement.
+[^4]: **Rendements décroissants** : principe selon lequel l’augmentation continue d’un investissement (temps, effort, ressources) finit par produire des bénéfices de plus en plus faibles proportionnellement.

docs/fr/explanation/analysis-phase.md

@@ -1,74 +1,74 @@
 ---
-title: "Phase d'analyse : de l'Idée aux Fondations"
+title: "Phase d’analyse : de l’Idée aux Fondations"
 description: Ce que sont le brainstorming, la recherche, les product briefs et les PRFAQs — et quand les utiliser
 sidebar:
-  order: 1
+  order: 2
 ---
 
-La phase d'Analyse (Phase 1) vous aide à penser clairement à votre produit avant de vous engager à le construire. Chaque outil de cette phase est optionnel, mais sauter l'analyse entièrement signifie que votre PRD sera construit sur des suppositions plutôt que sur des connaissances approfondies.
+La phase d’Analyse (Phase 1) vous aide à penser clairement à votre produit avant de vous engager à le construire. Chaque outil de cette phase est optionnel, mais sauter l’analyse entièrement signifie que votre PRD sera construit sur des suppositions plutôt que sur des connaissances approfondies.
 
-## Pourquoi Analyser avant de Planifier ?
+## Pourquoi Analyser avant de Planifier ?
 
-Un PRD répond à la question « que devons-nous construire et pourquoi ? » Si vous l'alimentez avec une réflexion vague, vous obtiendrez un PRD vague — et chaque document en aval héritera de cette imprécision. Une architecture bâtie sur un PRD faible prend de mauvaises décisions techniques. Les stories dérivées d'une architecture faible manquent de edge cases. Le coût s'accumule.
+Un PRD répond à la question « que devons-nous construire et pourquoi ? » Si vous l’alimentez avec une réflexion vague, vous obtiendrez un PRD vague — et chaque document en aval héritera de cette imprécision. Une architecture bâtie sur un PRD faible prend de mauvaises décisions techniques. Les stories dérivées d’une architecture faible manquent de edge cases. Le coût s’accumule.
 
-Les outils d'analyse existent pour rendre votre PRD précis. Ils attaquent le problème sous différents angles — exploration créative, réalité du marché, clarté client, faisabilité — pour qu'au moment de vous asseoir avec l'agent PM, vous sachiez ce que vous construisez et pour qui.
+Les outils d’analyse existent pour rendre votre PRD précis. Ils attaquent le problème sous différents angles — exploration créative, réalité du marché, clarté client, faisabilité — pour qu’au moment de vous asseoir avec l’agent PM, vous sachiez ce que vous construisez et pour qui.
 
 ## Les Outils
 
 ### Brainstorming
 
-**Quoi.** Une session créative facilitée utilisant des techniques d'idéation éprouvées. L'IA agit comme coach, extrayant vos idées à travers des exercices structurés — pas en les générant pour vous.
+**Quoi.** Une session créative facilitée utilisant des techniques d’idéation éprouvées. L’IA agit comme coach, extrayant vos idées à travers des exercices structurés — pas en les générant pour vous.
 
-**Pourquoi.** Les idées brutes ont besoin d'espace pour se développer avant d'être verrouillées dans des exigences. Le brainstorming crée cet espace. Il est particulièrement précieux quand vous avez un espace-problème mais pas de solution claire, ou quand vous voulez explorer plusieurs pistes avant de vous engager.
+**Pourquoi.** Les idées brutes ont besoin d’espace pour se développer avant d’être verrouillées dans des exigences. Le brainstorming crée cet espace. Il est particulièrement précieux quand vous avez un espace-problème mais pas de solution claire, ou quand vous voulez explorer plusieurs pistes avant de vous engager.
 
-**Quand.** Vous avez une vague idée de ce que vous voulez construire mais n'avez pas encore cristallisé le concept. Ou vous avez un concept mais voulez l'éprouver face à des alternatives.
+**Quand.** Vous avez une vague idée de ce que vous voulez construire mais n’avez pas encore cristallisé le concept. Ou vous avez un concept mais voulez l’éprouver face à des alternatives.
 
 Voir [Brainstorming](./brainstorming.md) pour un aperçu plus approfondi du fonctionnement des sessions.
 
 ### Recherche (Marché, Domaine, Technique)
 
-**Quoi.** Trois workflows de recherche ciblés qui investiguent différentes dimensions de votre idée. La recherche marché examine les concurrents, les tendances et le sentiment utilisateur. La recherche domaine construit l'expertise métier et la terminologie. La recherche technique évalue la faisabilité, les options d'architecture et les approches d'implémentation.
+**Quoi.** Trois workflows de recherche ciblés qui investiguent différentes dimensions de votre idée. La recherche marché examine les concurrents, les tendances et le sentiment utilisateur. La recherche domaine construit l’expertise métier et la terminologie. La recherche technique évalue la faisabilité, les options d’architecture et les approches d’implémentation.
 
-**Pourquoi.** Construire sur des suppositions est le moyen le plus rapide de construire quelque chose dont personne n'a besoin. La recherche ancre votre concept dans la réalité — quels concurrents existent déjà, avec quoi les utilisateurs luttent réellement, ce qui est techniquement faisable, et quelles contraintes spécifiques à l'industrie vous affronterez.
+**Pourquoi.** Construire sur des suppositions est le moyen le plus rapide de construire quelque chose dont personne n’a besoin. La recherche ancre votre concept dans la réalité — quels concurrents existent déjà, avec quoi les utilisateurs luttent réellement, ce qui est techniquement faisable, et quelles contraintes spécifiques à l’industrie vous affronterez.
 
-**Quand.** Vous entrez dans un domaine inconnu, vous soupçonnez que des concurrents existent mais ne les avez pas cartographiés, ou votre concept dépend de capacités techniques que vous n'avez pas validées. Lancez-en un, deux ou les trois — chaque workflow de recherche fonctionne de manière autonome.
+**Quand.** Vous entrez dans un domaine inconnu, vous soupçonnez que des concurrents existent mais ne les avez pas cartographiés, ou votre concept dépend de capacités techniques que vous n’avez pas validées. Lancez-en un, deux ou les trois — chaque workflow de recherche fonctionne de manière autonome.
 
 ### Product Brief[^1]
 
-**Quoi.** Une session de découverte guidée qui produit un résumé exécutif de 1-2 pages de votre concept produit. L'IA agit comme un analyste commercial collaboratif, vous aidant à articuler la vision, le public cible, la proposition de valeur et le périmètre.
+**Quoi.** Une session de découverte guidée qui produit un résumé exécutif de 1-2 pages de votre concept produit. L’IA agit comme un analyste commercial collaboratif, vous aidant à articuler la vision, le public cible, la proposition de valeur et le périmètre.
 
 **Pourquoi.** Le product brief est le chemin le plus doux vers la planification. Il capture votre vision stratégique dans un format structuré qui alimente directement la création du PRD. Il fonctionne mieux quand vous avez déjà la conviction à propos de votre concept — vous connaissez le client, le problème et approximativement ce que vous voulez construire. Le brief organise et affine cette réflexion.
 
-**Quand.** Votre concept est relativement clair et vous voulez le documenter efficacement avant de créer un PRD. Vous êtes confiant dans la direction et n'avez pas besoin que vos suppositions soient agressivement remises en question.
+**Quand.** Votre concept est relativement clair et vous voulez le documenter efficacement avant de créer un PRD. Vous êtes confiant dans la direction et n’avez pas besoin que vos suppositions soient agressivement remises en question.
 
 ### PRFAQ (Working Backwards)
 
-**Quoi.** La méthodologie Working Backwards d'Amazon adaptée en défi interactif. Vous rédigez le communiqué de presse annonçant votre produit fini avant qu'une seule ligne de code n'existe, puis répondez aux questions les plus difficiles que les clients et les parties prenantes poseraient. L'IA agit comme un coach produit implacable mais constructif.
+**Quoi.** La méthodologie Working Backwards d’Amazon adaptée en défi interactif. Vous rédigez le communiqué de presse annonçant votre produit fini avant qu’une seule ligne de code n’existe, puis répondez aux questions les plus difficiles que les clients et les parties prenantes poseraient. L’IA agit comme un coach produit implacable mais constructif.
 
-**Pourquoi.** Le PRFAQ est le chemin rigoureux vers la planification. Il force la clarté orientée client en vous obligeant à défendre chaque affirmation. Si vous ne pouvez pas rédiger un communiqué de presse convaincant, le produit n'est pas prêt. Si les réponses de la FAQ client révèlent des lacunes, ce sont des lacunes que vous découvrirez bien plus tard — et plus coûteusement — pendant l'implémentation. Le défi fait remonter les failles de réflexion tôt, quand c'est le moins cher de les corriger.
+**Pourquoi.** Le PRFAQ est le chemin rigoureux vers la planification. Il force la clarté orientée client en vous obligeant à défendre chaque affirmation. Si vous ne pouvez pas rédiger un communiqué de presse convaincant, le produit n’est pas prêt. Si les réponses de la FAQ client révèlent des lacunes, ce sont des lacunes que vous découvrirez bien plus tard — et plus coûteusement — pendant l’implémentation. Le défi fait remonter les failles de réflexion tôt, quand c’est le moins cher de les corriger.
 
-**Quand.** Vous voulez que votre concept soit éprouvé avant d'engager des ressources. Vous n'êtes pas sûr que les utilisateurs s'en soucieront réellement. Vous voulez valider que vous pouvez articuler une proposition de valeur claire et défendable. Ou vous voulez simplement la discipline du Working Backwards pour affiner votre réflexion.
+**Quand.** Vous voulez que votre concept soit éprouvé avant d’engager des ressources. Vous n’êtes pas sûr que les utilisateurs s’en soucieront réellement. Vous voulez valider que vous pouvez articuler une proposition de valeur claire et défendable. Ou vous voulez simplement la discipline du Working Backwards pour affiner votre réflexion.
 
-## Lequel utiliser ?
+## Lequel utiliser ?
 
 | Situation                                                                     | Outil recommandé                           |
 |-------------------------------------------------------------------------------|--------------------------------------------|
-| « J'ai une idée vague, je ne sais pas par où commencer »                      | Brainstorming                              |
+| « J’ai une idée vague, je ne sais pas par où commencer »                      | Brainstorming                              |
-| « J'ai besoin de comprendre le marché avant de décider »                      | Recherche                                  |
+| « J’ai besoin de comprendre le marché avant de décider »                      | Recherche                                  |
-| « Je sais ce que je veux construire, j'ai juste besoin de le documenter »     | Product Brief                              |
+| « Je sais ce que je veux construire, j’ai juste besoin de le documenter »     | Product Brief                              |
-| « Je veux m'assurer que cette idée vaut vraiment la peine d'être construite » | PRFAQ                                      |
+| « Je veux m’assurer que cette idée vaut vraiment la peine d’être construite » | PRFAQ                                      |
-| « Je veux explorer, puis valider, puis documenter »                           | Brainstorming → Recherche → PRFAQ ou Brief |
+| « Je veux explorer, puis valider, puis documenter »                           | Brainstorming → Recherche → PRFAQ ou Brief |
 
-Le Product Brief et le PRFAQ produisent tous deux des entrées pour le PRD — choisissez-en un en fonction du niveau de défi que vous souhaitez. Le brief est une découverte collaborative. Le PRFAQ est un défi. Les deux vous mènent à la même destination ; le PRFAQ teste si votre concept mérite d'y arriver.
+Le Product Brief et le PRFAQ produisent tous deux des entrées pour le PRD — choisissez-en un en fonction du niveau de défi que vous souhaitez. Le brief est une découverte collaborative. Le PRFAQ est un défi. Les deux vous mènent à la même destination ; le PRFAQ teste si votre concept mérite d’y arriver.
 
-:::tip[Pas sûr ?]
+:::tip[Pas sûr ?]
 Exécutez `bmad-help` et décrivez votre situation. Il vous recommandera le bon point de départ en fonction de ce que vous avez déjà accompli et de ce que vous essayez de réaliser.
 :::
 
-## Que se passe-t-il après l'analyse ?
+## Que se passe-t-il après l’analyse ?
 
-Les résultats de l'analyse alimentent directement la Phase 2 (Planification). Le workflow PRD accepte les product briefs, les documents PRFAQ, les conclusions de recherche et les rapports de brainstorming en entrée — il synthétise tout ce que vous avez produit en exigences structurées. Plus vous faites d'analyse, plus votre PRD sera précis.
+Les résultats de l’analyse alimentent directement la Phase 2 (Planification). Le workflow PRD accepte les product briefs, les documents PRFAQ, les conclusions de recherche et les rapports de brainstorming en entrée — il synthétise tout ce que vous avez produit en exigences structurées. Plus vous faites d’analyse, plus votre PRD sera précis.
 
 ## Glossaire
 
-[^1]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d'un projet ou d'une demande, afin d'aligner rapidement les parties prenantes avant le travail détaillé.
+[^1]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d’un projet ou d’une demande, afin d’aligner rapidement les parties prenantes avant le travail détaillé.

docs/fr/explanation/brainstorming.md

@@ -1,27 +1,27 @@
 ---
 title: "Brainstorming"
-description: Sessions interactives créatives utilisant plus de 60 techniques d'idéation éprouvées
+description: Sessions interactives créatives utilisant plus de 60 techniques d’idéation éprouvées
 sidebar:
-  order: 2
+  order: 3
 ---
 
 Libérez votre créativité grâce à une exploration guidée.
 
-## Qu'est-ce que le Brainstorming ?
+## Qu’est-ce que le Brainstorming ?
 
-Lancez `bmad-brainstorming` et vous obtenez un facilitateur créatif qui fait émerger vos idées - pas qui les génère pour vous. L'IA agit comme coach et guide, utilisant des techniques éprouvées pour créer les conditions où votre meilleure réflexion émerge.
+Lancez `bmad-brainstorming` et vous obtenez un facilitateur créatif qui fait émerger vos idées - pas qui les génère pour vous. L’IA agit comme coach et guide, utilisant des techniques éprouvées pour créer les conditions où votre meilleure réflexion émerge.
 
-**Idéal pour :**
+**Idéal pour :**
 
 - Surmonter les blocages créatifs
 - Générer des idées de produits ou de fonctionnalités
 - Explorer des problèmes sous de nouveaux angles
-- Développer des concepts bruts en plans d'action
+- Développer des concepts bruts en plans d’action
 
 ## Comment ça fonctionne
 
 1. **Configuration** - Définir le sujet, les objectifs, les contraintes
-2. **Choisir l'approche** - Choisir vous-même les techniques, obtenir des recommandations de l'IA, aller au hasard, ou suivre un flux progressif
+2. **Choisir l’approche** - Choisir vous-même les techniques, obtenir des recommandations de l’IA, aller au hasard, ou suivre un flux progressif
 3. **Facilitation** - Travailler à travers les techniques avec des questions approfondies et un coaching collaboratif
 4. **Organiser** - Idées regroupées par thèmes et priorisées
 5. **Action** - Les meilleures idées reçoivent des prochaines étapes et des indicateurs de succès

docs/fr/explanation/checkpoint-preview.md

@@ -2,91 +2,91 @@
 title: "Checkpoint Preview"
 description: Revue assistée par LLM, avec intervention humaine, qui vous guide à travers une modification, de son objectif jusqu’aux détails
 sidebar:
-  order: 7
+  order: 8
 ---
 
-`bmad-checkpoint-preview` est un workflow de revue interactif, assisté par LLM, avec intervention humaine. Il vous guide à travers une modification de code — de l'intention et du contexte jusqu'aux détails — afin que vous puissiez prendre une décision éclairée sur la mise en production, la refonte ou l'approfondissement.
+`bmad-checkpoint-preview` est un workflow de revue interactif, assisté par LLM, avec intervention humaine. Il vous guide à travers une modification de code — de l’intention et du contexte jusqu’aux détails — afin que vous puissiez prendre une décision éclairée sur la mise en production, la refonte ou l’approfondissement.
 
 ![Diagramme du workflow Checkpoint Preview](/diagrams/checkpoint-preview-diagram-fr.webp)
 
 ## Le Flux Typique
 
-Vous lancez `bmad-quick-dev`. Il clarifie votre intention, construit une spécification, implémente la modification, et une fois terminé, il ajoute un historique de revue au fichier de spécification et l'ouvre dans votre éditeur. Vous regardez la spec et constatez que la modification a touché 20 fichiers dans plusieurs modules.
+Vous lancez `bmad-quick-dev`. Il clarifie votre intention, construit une spécification, implémente la modification, et une fois terminé, il ajoute un historique de revue au fichier de spécification et l’ouvre dans votre éditeur. Vous regardez la spec et constatez que la modification a touché 20 fichiers dans plusieurs modules.
 
-Vous pourriez survoler le diff. Mais 20 fichiers, c'est le moment où le survol commence à échouer — on perd le fil, on rate un lien entre deux modifications éloignées, ou on approuve quelque chose qu'on n'a pas pleinement compris. Alors au lieu de cela, vous dites « checkpoint » et le LLM vous guide à travers la modification.
+Vous pourriez survoler le diff. Mais 20 fichiers, c’est le moment où le survol commence à échouer — on perd le fil, on rate un lien entre deux modifications éloignées, ou on approuve quelque chose qu’on n’a pas pleinement compris. Alors au lieu de cela, vous dites « checkpoint » et le LLM vous guide à travers la modification.
 
-Ce passage de relais — de l'implémentation autonome au jugement humain — est le cas d'usage principal. Quick-dev s'exécute longtemps avec une supervision minimale. Checkpoint Preview, c'est là où vous reprenez le volant.
+Ce passage de relais — de l’implémentation autonome au jugement humain — est le cas d’usage principal. Quick-dev s’exécute longtemps avec une supervision minimale. Checkpoint Preview, c’est là où vous reprenez le volant.
 
 ## Pourquoi
 
-La revue de code a deux modes d'échec. Dans le premier, le réviseur survole le diff, rien ne saute aux yeux, et il approuve. Dans le second, il lit méthodiquement chaque fichier mais perd le fil — il voit les arbres et rate la forêt. Les deux aboutissent au même résultat : la revue n'a pas repéré ce qui comptait.
+La revue de code a deux modes d’échec. Dans le premier, le réviseur survole le diff, rien ne saute aux yeux, et il approuve. Dans le second, il lit méthodiquement chaque fichier mais perd le fil — il voit les arbres et rate la forêt. Les deux aboutissent au même résultat : la revue n’a pas repéré ce qui comptait.
 
-Le problème sous-jacent est le séquençage. Un diff brut présente les modifications dans l'ordre des fichiers, ce qui est presque jamais l'ordre qui construit la compréhension. Vous voyez une fonction utilitaire avant de savoir pourquoi elle existe. Vous voyez une modification de schéma avant de comprendre quelle fonctionnalité elle supporte. Le réviseur doit reconstruire l'intention de l'auteur à partir d'indices dispersés, et c'est cette reconstruction qui fait défaut à l'attention.
+Le problème sous-jacent est le séquençage. Un diff brut présente les modifications dans l’ordre des fichiers, ce qui est presque jamais l’ordre qui construit la compréhension. Vous voyez une fonction utilitaire avant de savoir pourquoi elle existe. Vous voyez une modification de schéma avant de comprendre quelle fonctionnalité elle supporte. Le réviseur doit reconstruire l’intention de l’auteur à partir d’indices dispersés, et c’est cette reconstruction qui fait défaut à l’attention.
 
 Checkpoint Preview résout ce problème en confiant le travail de reconstruction au LLM. Il lit le diff, la spécification (si elle existe) et la base de code environnante, puis présente la modification dans un ordre conçu pour la compréhension — et non pour `git diff`.
 
 ## Comment ça fonctionne
 
-Le workflow comporte cinq étapes. Chaque étape s'appuie sur la précédente, passant progressivement de « qu'est-ce que c'est ? » à « devons-nous publier ça ? »
+Le workflow comporte cinq étapes. Chaque étape s’appuie sur la précédente, passant progressivement de « qu’est-ce que c’est ? » à « devons-nous publier ça ? »
 
 ### 1. Orientation
 
-Le workflow identifie la modification (à partir d'une PR, d'un commit, d'une branche, d'un fichier de spécification ou de l'état git actuel) et produit un résumé d'intention en une ligne ainsi que des statistiques de surface : fichiers modifiés, modules touchés, lignes de logique, dépassements de boundaries et nouvelles interfaces publiques.
+Le workflow identifie la modification (à partir d’une PR, d’un commit, d’une branche, d’un fichier de spécification ou de l’état git actuel) et produit un résumé d’intention en une ligne ainsi que des statistiques de surface : fichiers modifiés, modules touchés, lignes de logique, dépassements de boundaries et nouvelles interfaces publiques.
 
-C'est le moment « est-ce bien ce que je crois ? ». Avant de lire le moindre code, le réviseur confirme qu'il regarde la bonne chose et calibre ses attentes quant à la portée.
+C’est le moment « est-ce bien ce que je crois ? ». Avant de lire le moindre code, le réviseur confirme qu’il regarde la bonne chose et calibre ses attentes quant à la portée.
 
 ### 2. Visite guidée
 
-La modification est organisée par **préoccupation** — des intentions de conception cohérentes comme « validation des entrées » ou « contrat d'API » — et non par fichier. Chaque préoccupation fait l'objet d'une courte explication du *pourquoi* de cette approche, suivie d'arrêts cliquables `chemin:ligne` que le réviseur peut suivre dans le code.
+La modification est organisée par **préoccupation** — des intentions de conception cohérentes comme « validation des entrées » ou « contrat d’API » — et non par fichier. Chaque préoccupation fait l’objet d’une courte explication du *pourquoi* de cette approche, suivie d’arrêts cliquables `chemin:ligne` que le réviseur peut suivre dans le code.
 
-C'est l'étape du jugement de conception. Le réviseur évalue si l'approche est adaptée au système, et non si le code est correct. Les préoccupations sont séquencées de haut en bas : l'intention de plus haut niveau en premier, puis l'implémentation de support. Le réviseur ne rencontre jamais une référence à quelque chose qu'il n'a pas encore vu.
+C’est l’étape du jugement de conception. Le réviseur évalue si l’approche est adaptée au système, et non si le code est correct. Les préoccupations sont séquencées de haut en bas : l’intention de plus haut niveau en premier, puis l’implémentation de support. Le réviseur ne rencontre jamais une référence à quelque chose qu’il n’a pas encore vu.
 
 ### 3. Passage en revue des détails
 
-Une fois que le réviseur comprend la conception, le workflow met en évidence 2 à 5 endroits où une erreur aurait l’impact le plus important. Ceux-ci sont étiquetés par catégorie de risque — `[auth]`, `[schéma]`, `[facturation]`, `[API publique]`, `[sécurité]`, et d'autres — et ordonnés selon l'impact en cas d'erreur.
+Une fois que le réviseur comprend la conception, le workflow met en évidence 2 à 5 endroits où une erreur aurait l’impact le plus important. Ceux-ci sont étiquetés par catégorie de risque — `[auth]`, `[schéma]`, `[facturation]`, `[API publique]`, `[sécurité]`, et d’autres — et ordonnés selon l’impact en cas d’erreur.
 
-Ce n'est pas une chasse aux bugs. Les tests automatisés et la CI gèrent la correction. Le passage en revue des détails active la conscience du risque : « voici les endroits où se tromper coûte le plus cher ». Si le réviseur veut approfondir un domaine spécifique, il peut dire « approfondis [domaine] » pour une re-revue ciblée axée sur la correction.
+Ce n’est pas une chasse aux bugs. Les tests automatisés et la CI gèrent la correction. Le passage en revue des détails active la conscience du risque : « voici les endroits où se tromper coûte le plus cher ». Si le réviseur veut approfondir un domaine spécifique, il peut dire « approfondis [domaine] » pour une re-revue ciblée axée sur la correction.
 
 Si la spécification a passé des boucles de revues contradictoires (machine hardening), ces résultats sont également présentés ici — pas les bugs qui ont été corrigés, mais les décisions que la boucle de revue a signalées et dont le réviseur devrait être conscient.
 
 ### 4. Tests
 
-Propose 2 à 5 façons d'observer manuellement la modification en action. Pas des commandes de test automatisé — des observations manuelles qui renforcent la confiance au-delà de ce que toute suite de tests peut fournir. Une interaction UI à essayer, une commande CLI à lancer, une requête API à envoyer, avec les résultats attendus pour chacune.
+Propose 2 à 5 façons d’observer manuellement la modification en action. Pas des commandes de test automatisé — des observations manuelles qui renforcent la confiance au-delà de ce que toute suite de tests peut fournir. Une interaction UI à essayer, une commande CLI à lancer, une requête API à envoyer, avec les résultats attendus pour chacune.
 
-Si la modification n'a aucun comportement visible par l'utilisateur, il le dit. Pas de travail inventé.
+Si la modification n’a aucun comportement visible par l’utilisateur, il le dit. Pas de travail inventé.
 
 ### 5. Conclusion
 
-Le réviseur prend la décision : approuver, retravailler ou continuer la discussion. S'il approuve une PR, le workflow peut aider avec `gh pr review --approve`. S'il demande une refonte, il aide à diagnostiquer si le problème vient de l'approche, de la spécification ou de l'implémentation, et aide à rédiger un retour actionnable lié à des emplacements de code spécifiques.
+Le réviseur prend la décision : approuver, retravailler ou continuer la discussion. S’il approuve une PR, le workflow peut aider avec `gh pr review --approve`. S’il demande une refonte, il aide à diagnostiquer si le problème vient de l’approche, de la spécification ou de l’implémentation, et aide à rédiger un retour actionnable lié à des emplacements de code spécifiques.
 
-## C'est une conversation, pas un rapport
+## C’est une conversation, pas un rapport
 
-Le workflow présente chaque étape comme un point de départ, pas un mot final. Entre les étapes — ou au milieu d'une — vous pouvez parler au LLM, poser des questions, remettre en question son cadrage ou faire appel à d'autres skills pour obtenir une perspective différente :
+Le workflow présente chaque étape comme un point de départ, pas un mot final. Entre les étapes — ou au milieu d’une — vous pouvez parler au LLM, poser des questions, remettre en question son cadrage ou faire appel à d’autres skills pour obtenir une perspective différente :
 
-- **« lance l'élicitation avancée sur la gestion des erreurs »** — pousse le LLM à reconsidérer et affiner son analyse d'un domaine spécifique
+- **« lance l’élicitation avancée sur la gestion des erreurs »** — pousse le LLM à reconsidérer et affiner son analyse d’un domaine spécifique
-- **« active le party mode sur la sécurité de cette migration de schéma »** — fait intervenir plusieurs perspectives agentiques dans un débat ciblé
+- **« active le party mode sur la sécurité de cette migration de schéma »** — fait intervenir plusieurs perspectives agentiques dans un débat ciblé
-- **« lance la revue de code »** — génère des résultats structurés avec analyse adversariale et cas limites
+- **« lance la revue de code »** — génère des résultats structurés avec analyse adversariale et cas limites
 
-Le workflow checkpoint ne vous enferme pas dans un chemin linéaire. Il vous donne de la structure quand vous la souhaitez et s'efface quand vous voulez explorer. Les cinq étapes sont là pour s'assurer que vous voyez le tableau complet, mais la profondeur à laquelle vous allez à chaque étape — et les outils que vous y apportez — est entièrement entre vos mains.
+Le workflow checkpoint ne vous enferme pas dans un chemin linéaire. Il vous donne de la structure quand vous la souhaitez et s’efface quand vous voulez explorer. Les cinq étapes sont là pour s’assurer que vous voyez le tableau complet, mais la profondeur à laquelle vous allez à chaque étape — et les outils que vous y apportez — est entièrement entre vos mains.
 
-## L'historique de revue
+## L’historique de revue
 
-L'étape de visite guidée fonctionne mieux lorsqu'elle dispose d'un **ordre de revue suggéré** — une liste d'arrêts que l'auteur de la spécification a rédigée pour guider les réviseurs à travers la modification. Lorsqu'une spécification inclut cet ordre, le workflow l'utilise directement.
+L’étape de visite guidée fonctionne mieux lorsqu’elle dispose d’un **ordre de revue suggéré** — une liste d’arrêts que l’auteur de la spécification a rédigée pour guider les réviseurs à travers la modification. Lorsqu’une spécification inclut cet ordre, le workflow l’utilise directement.
 
-Lorsqu'aucun historique produit par l'auteur n'existe, le workflow en génère un à partir du diff et du contexte de la base de code. Un historique généré est de qualité inférieure à un historique produit par l'auteur, mais nettement supérieur à la lecture des modifications dans l'ordre des fichiers.
+Lorsqu’aucun historique produit par l’auteur n’existe, le workflow en génère un à partir du diff et du contexte de la base de code. Un historique généré est de qualité inférieure à un historique produit par l’auteur, mais nettement supérieur à la lecture des modifications dans l’ordre des fichiers.
 
-## Quand l'utiliser
+## Quand l’utiliser
 
-Le scénario principal est le passage de relais depuis `bmad-quick-dev` : l'implémentation est terminée, le fichier de spécification est ouvert dans votre éditeur avec un historique de revue ajouté, et vous devez décider si vous publiez. Dites « checkpoint » et c'est parti.
+Le scénario principal est le passage de relais depuis `bmad-quick-dev` : l’implémentation est terminée, le fichier de spécification est ouvert dans votre éditeur avec un historique de revue ajouté, et vous devez décider si vous publiez. Dites « checkpoint » et c’est parti.
 
-Il fonctionne aussi de manière autonome :
+Il fonctionne aussi de manière autonome :
 
-- **Revue d'une PR** — surtout celles avec plus de quelques fichiers ou des modifications transversales
+- **Revue d’une PR** — surtout celles avec plus de quelques fichiers ou des modifications transversales
-- **Prise en main d'une modification** — quand vous devez comprendre ce qui s'est passé sur une branche que vous n'avez pas écrite
+- **Prise en main d’une modification** — quand vous devez comprendre ce qui s’est passé sur une branche que vous n’avez pas écrite
 - **Revue de sprint** — le workflow peut récupérer les stories marquées `review` dans votre fichier de statut de sprint
 
-Invoquez-le en disant « checkpoint » ou « guide-moi à travers cette modification ». Il fonctionne dans n'importe quel terminal, mais vous en tirerez plus de parti dans un IDE — VS Code, Cursor ou similaire — car le workflow produit des références `chemin:ligne` à chaque étape. Dans un terminal intégré à un IDE, celles-ci sont cliquables, ce qui vous permet de sauter de fichier en fichier en suivant l'historique de revue.
+Invoquez-le en disant « checkpoint » ou « guide-moi à travers cette modification ». Il fonctionne dans n’importe quel terminal, mais vous en tirerez plus de parti dans un IDE — VS Code, Cursor ou similaire — car le workflow produit des références `chemin:ligne` à chaque étape. Dans un terminal intégré à un IDE, celles-ci sont cliquables, ce qui vous permet de sauter de fichier en fichier en suivant l’historique de revue.
 
-## Ce que ce n'est pas
+## Ce que ce n’est pas
 
-Checkpoint Preview ne remplace pas la revue automatisée. Il ne lance pas de linters, de vérificateurs de types ou de suites de tests. Il n'attribue pas de scores de sévérité et ne produit pas de verdicts pass/échec. C'est un guide de lecture qui aide un humain à appliquer son jugement là où cela compte le plus.
+Checkpoint Preview ne remplace pas la revue automatisée. Il ne lance pas de linters, de vérificateurs de types ou de suites de tests. Il n’attribue pas de scores de sévérité et ne produit pas de verdicts pass/échec. C’est un guide de lecture qui aide un humain à appliquer son jugement là où cela compte le plus.

docs/fr/explanation/established-projects-faq.md

@@ -1,35 +1,35 @@
 ---
 title: "FAQ Projets Existants"
-description: Questions courantes sur l'utilisation de la méthode BMad sur des projets existants
+description: Questions courantes sur l’utilisation de la méthode BMad sur des projets existants
 sidebar:
-  order: 12
+  order: 13
 ---
-Réponses rapides aux questions courantes sur l'utilisation de la méthode BMad (BMM) sur des projets existants.
+Réponses rapides aux questions courantes sur l’utilisation de la méthode BMad (BMM) sur des projets existants.
 
 ## Questions
 
-- [Dois-je d'abord exécuter document-project ?](#dois-je-dabord-exécuter-document-project)
+- [Dois-je d’abord exécuter document-project ?](#dois-je-dabord-exécuter-document-project)
-- [Que faire si j'oublie d'exécuter document-project ?](#que-faire-si-joublie-dexécuter-document-project)
+- [Que faire si j’oublie d’exécuter document-project ?](#que-faire-si-joublie-dexécuter-document-project)
-- [Puis-je utiliser Quick Dev pour les projets existants ?](#puis-je-utiliser-quick-dev-pour-les-projets-existants)
+- [Puis-je utiliser Quick Dev pour les projets existants ?](#puis-je-utiliser-quick-dev-pour-les-projets-existants)
-- [Que faire si mon code existant ne suit pas les bonnes pratiques ?](#que-faire-si-mon-code-existant-ne-suit-pas-les-bonnes-pratiques)
+- [Que faire si mon code existant ne suit pas les bonnes pratiques ?](#que-faire-si-mon-code-existant-ne-suit-pas-les-bonnes-pratiques)
 
-### Dois-je d'abord exécuter `document-project` ?
+### Dois-je d’abord exécuter `document-project` ?
 
-Hautement recommandé, surtout si :
+Hautement recommandé, surtout si :
 
 - Aucune documentation existante
 - La documentation est obsolète
 - Les agents IA ont besoin de contexte sur le code existant
 
-Vous pouvez l'ignorer si vous disposez d'une documentation complète et à jour incluant `docs/index.md` ou si vous utiliserez d'autres outils ou techniques pour aider à la découverte afin que l'agent puisse construire sur un système existant.
+Vous pouvez l’ignorer si vous disposez d’une documentation complète et à jour incluant `docs/index.md` ou si vous utiliserez d’autres outils ou techniques pour aider à la découverte afin que l’agent puisse construire sur un système existant.
 
-### Que faire si j'oublie d'exécuter `document-project` ?
+### Que faire si j’oublie d’exécuter `document-project` ?
 
 Ne vous inquiétez pas — vous pouvez le faire à tout moment. Vous pouvez même le faire pendant ou après un projet pour aider à maintenir la documentation à jour.
 
-### Puis-je utiliser Quick Dev pour les projets existants ?
+### Puis-je utiliser Quick Dev pour les projets existants ?
 
-Oui ! Quick Dev fonctionne très bien pour les projets existants. Il va :
+Oui ! Quick Dev fonctionne très bien pour les projets existants. Il va :
 
 - Détecter automatiquement votre pile technologique existante
 - Analyser les patterns de code existants
@@ -38,13 +38,13 @@ Oui ! Quick Dev fonctionne très bien pour les projets existants. Il va :
 
 Parfait pour les corrections de bugs et les petites fonctionnalités dans des bases de code existantes.
 
-### Que faire si mon code existant ne suit pas les bonnes pratiques ?
+### Que faire si mon code existant ne suit pas les bonnes pratiques ?
 
-Quick Dev détecte vos conventions et demande : « Dois-je suivre ces conventions existantes ? » Vous décidez :
+Quick Dev détecte vos conventions et demande : « Dois-je suivre ces conventions existantes ? » Vous décidez :
 
 - **Oui** → Maintenir la cohérence avec la base de code actuelle
 - **Non** → Établir de nouvelles normes (documenter pourquoi dans la spécification technique)
 
 BMM respecte votre choix — il ne forcera pas la modernisation, mais la proposera.
 
-**Une question sans réponse ici ?** Veuillez [ouvrir un ticket](https://github.com/bmad-code-org/BMAD-METHOD/issues) ou poser votre question sur [Discord](https://discord.gg/gk8jAdXWmj) afin que nous puissions l'ajouter !
+**Une question sans réponse ici ?** Veuillez [ouvrir un ticket](https://github.com/bmad-code-org/BMAD-METHOD/issues) ou poser votre question sur [Discord](https://discord.gg/gk8jAdXWmj) afin que nous puissions l’ajouter !

docs/fr/explanation/forensic-investigation.md

@@ -1,157 +1,156 @@
 ---
 title: "Enquête de code"
-description: Comment bmad-investigate traite chaque problème comme une scène d'enquête, classe les preuves et produit un dossier structuré sur lequel les ingénieurs peuvent agir
+description: Comment bmad-investigate traite chaque problème comme une scène de crime, classe les preuves et produit un dossier structuré sur lequel les ingénieurs peuvent agir
 sidebar:
-  order: 9
+  order: 10
 ---
 
-Vous confiez à `bmad-investigate` un journal de plantage, une trace de pile, ou simplement un « ça marchait avant, plus
+Vous confiez à `bmad-investigate` un journal de plantage, une stack trace, ou simplement un « ça marchait avant, plus
-maintenant ». Le skill prend le relais avec la discipline d'enquête le temps de l'exécution. Il ne se met pas à
+maintenant ». Le skill prend le relais et applique la rigueur d’un enquêteur pendant toute son exécution. Il ne se lance pas dans
-corriger. Il ouvre un dossier d'enquête.
+la correction. Il ouvre un dossier d’enquête.
 
-Chaque constatation reçoit une note. Chaque hypothèse a un statut. Les fausses pistes sont conservées, pas effacées. Le
+Chaque constatation est classée. Chaque hypothèse a un statut. Les fausses pistes sont conservées, pas effacées. Le
-livrable est un document qu'un autre ingénieur peut reprendre à froid.
+livrable est un document qu’un autre ingénieur peut reprendre à froid.
 
-Cette page explique pourquoi l'enquête est une discipline à part entière, et ce que le skill apporte qu'un workflow de
+Cette page explique pourquoi l’enquête est une discipline à part entière, et ce que le skill apporte de plus qu’un flux de
-développement classique n'apporte pas.
+développement classique.
 
-## Le problème du « débogue, c'est tout »
+## Le problème avec « il suffit de déboguer »
 
-Le débogage classique mélange trois activités : examiner les preuves, raisonner sur la cause, et modifier le code pour
+Le débogage classique mélange trois activités : examiner les preuves, raisonner sur la cause, et modifier le code pour
 tester la théorie. Quand elles sont mélangées, deux modes de défaillance apparaissent.
 
-Le premier est le **verrouillage narratif**[^1]. La première histoire plausible devient la théorie de travail, et chaque
+Le premier est le **verrouillage narratif**[^1]. Le premier scénario plausible devient la théorie de travail, et chaque
-observation est tordue pour la confirmer. Le bug reste non corrigé jusqu'à ce que quelqu'un abandonne et reparte de
+observation est déformée pour s’y ajuster. Le bug persiste jusqu’à ce que quelqu’un abandonne et reparte de zéro. Des
-zéro. Des heures plus tard.
+heures plus tard.
 
-Le second est l'**amnésie probatoire**. Vous avez tracé quelque chose, l'avez écarté, mais n'avez pas écrit pourquoi.
+Le second est l’**amnésie des preuves**. Vous avez suivi une piste, l’avez écartée, mais n’avez pas écrit pourquoi. Deux
-Deux jours plus tard, avec un regard frais, vous le retracez. Pire encore, un collègue reprend le bug et refait la même
+jours plus tard, avec un regard frais, vous la suivez à nouveau. Pire encore, un collègue reprend le bug et suit
-impasse que vous aviez déjà éliminée.
+à nouveau la même fausse piste que vous aviez déjà écartée.
 
 La conception du skill est une réponse directe à ces deux modes.
 
 ## Classement des preuves
 
-Chaque constatation dans une enquête appartient à l'une de trois catégories.
+Chaque constatation dans une enquête appartient à l’une de trois catégories.
 
-- **Confirmé.** Directement observé dans les logs, le code ou les dumps ; cité avec une référence spécifique (un
+- **Confirmé.** Directement observée dans les logs, le code ou les dumps ; citée avec une référence spécifique (un
-  `chemin:ligne`, un horodatage de log, un hash de commit). Si quelqu'un demande « comment le sais-tu ? », vous pointez
+  `chemin:ligne`, un horodatage de log, un hash de commit). Si quelqu’un demande « comment le savez-vous ? », vous indiquez
-  la citation.
+  la référence.
-- **Déduit.** Découle logiquement de preuves confirmées ; la chaîne de raisonnement est explicite. Si une étape de la
+- **Déduit.** Découle logiquement de preuves confirmées ; la chaîne de raisonnement est explicite. Si une étape de la
-  chaîne est fausse, la déduction est fausse, et on peut voir précisément quelle étape.
+  chaîne est fausse, la déduction est fausse, et on peut voir précisément laquelle.
-- **Hypothétique.** Plausible mais non confirmé. Énonce quelle preuve confirmerait ou réfuterait, et déclare d'avance ce
+- **Hypothétique.** Plausible mais non confirmé. Précise quelle preuve la confirmerait ou la réfuterait, et indique à
-  qui le clôturerait. Les hypothèses sont explicitement *non factuelles*.
+  l’avance ce qui permettrait de la clore. Les hypothèses sont explicitement *des suppositions, pas des faits*.
 
-Le classement n'est pas une posture d'humilité. Il rend le dossier lisible. Un lecteur peut parcourir la section
+Le classement n’est pas là par modestie. Il rend le dossier lisible. Un lecteur peut parcourir la section
-Confirmé pour savoir ce qui est vrai, la section Déduit pour savoir ce qui en découle, et la section Hypothétique pour
+**Confirmé** pour savoir ce qui est vrai, la section **Déduit** pour savoir ce qui en découle, et la section **Hypothétique** pour
-savoir ce qui reste ouvert. Confondre les trois est la première raison pour laquelle les enquêtes dérapent.
+savoir ce qui reste ouvert. Confondre les trois est la raison la plus fréquente pour laquelle les enquêtes dérapent.
 
-## Tête de pont d'abord
+## Point d’ancrage d’abord
 
-L'enquête ne part jamais d'une théorie. Elle part d'une seule preuve confirmée et étend la zone à partir de là. Cette
+L’enquête ne part jamais d’une théorie. Elle part d’une seule preuve confirmée et s’étend à partir de là. Cette
-preuve peut être un message d'erreur précis, une trame de pile, ou une entrée de log horodatée.
+preuve peut être un message d’erreur précis, une stack trace, ou une entrée de log horodatée.
 
-C'est l'inverse de la manière dont les enquêtes se déroulent souvent : quelqu'un a une intuition, construit une théorie,
+C’est l’inverse du déroulement habituel des enquêtes : quelqu’un a une intuition, construit une théorie,
-puis cherche les preuves qui la soutiennent. L'intuition peut être correcte ; la *méthode* est fragile parce qu'elle
+puis cherche les preuves qui la soutiennent. L’intuition peut être correcte ; la *méthode* est fragile parce qu’elle
-fait du biais de confirmation[^2] le comportement par défaut.
+transforme le biais de confirmation[^2] en comportement par défaut.
 
-Une tête de pont est un fait sur lequel vous pouvez revenir quand le raisonnement devient flou. Si une déduction vous
+Un point d’ancrage est un fait sur lequel vous pouvez revenir quand le raisonnement devient flou. Si une déduction vous
-emmène quelque part d'étrange, vous pouvez remonter jusqu'à la tête de pont et essayer une autre branche. Sans elle,
+mène à une conclusion inattendue, vous pouvez remonter au point d’ancrage et essayer une autre branche. Sans point
-vous ne savez pas quelle étape annuler.
+d’ancrage, vous ne savez pas quelle étape annuler.
 
-Quand les preuves sont rares, le skill le dit et bascule en exploration guidée par hypothèses : formuler des hypothèses
+Quand les preuves sont rares, le skill le signale et bascule en exploration guidée par hypothèses : formuler des hypothèses
 à partir de ce qui est disponible, identifier ce qui testerait chacune, présenter une liste priorisée de données à
-collecter. L'absence de preuve est elle-même une constatation.
+collecter. L’absence de preuve est elle-même un constat.
 
 ## Discipline des hypothèses
 
 Les hypothèses ne sont jamais supprimées du dossier. Quand une preuve en confirme ou en réfute une, son champ **Statut**
-passe d'Ouvert à Confirmé ou Réfuté, et une **Résolution** explique quelle preuve a tranché.
+passe d’Ouvert à Confirmé ou Réfuté, et une **Résolution** explique quelle preuve a tranché.
 
-Cette règle a un coût réel : les dossiers grossissent. Le bénéfice est réel aussi. L'historique complet du raisonnement
+Cette règle a un coût réel : les dossiers grossissent. Le bénéfice est tout aussi réel. L’historique complet du raisonnement
 fait partie du livrable. Six mois plus tard, quand un bug similaire surgit, le prochain enquêteur peut lire le dossier
-original et voir quelles pistes ont déjà été éliminées et pourquoi. Sans cet historique, chaque nouvel enquêteur refait
+original et voir quelles pistes ont déjà été éliminées et pourquoi. Sans cet historique, chaque nouvel enquêteur reprend
-les mêmes impasses.
+les mêmes fausses pistes.
 
-Cela discipline aussi l'enquêteur du présent. Si vous ne pouvez pas supprimer une hypothèse fausse, vous devez la
+Cela discipline aussi l’enquêteur sur le moment. Si vous ne pouvez pas supprimer une hypothèse fausse, vous devez la
-réfuter avec une preuve citée. L'abandonner discrètement quand elle devient gênante n'est plus une option.
+réfuter avec une preuve citée. L’abandonner discrètement quand elle devient gênante n’est plus une option.
 
 ## Remettre en question la prémisse
 
-La description du problème par l'utilisateur est une hypothèse, pas un fait. « Le cache est cassé » est quelque chose
+La description du problème par l’utilisateur est une hypothèse, pas un fait. « Le cache est cassé » est ce
-que l'utilisateur *croit*. Avant que le skill ne construise une enquête autour, les affirmations techniques sont
+que l’utilisateur *croit*. Avant que le skill ne construise une enquête autour de cette prémisse, les affirmations
-vérifiées de manière indépendante. Si la preuve contredit la prémisse, le rapport le dit directement.
+techniques sont vérifiées de manière indépendante. Si la preuve contredit la prémisse, le rapport le signale sans détour.
 
-C'est l'instinct de l'enquêteur : le récit du témoin est une donnée, pas la vérité. Parfois le bug rapporté est réel
+C’est l’instinct de l’enquêteur : le récit du témoin est une donnée, pas la vérité. Parfois le bug rapporté est réel
-mais mal étiqueté. Parfois le symptôme décrit est en aval d'une cause différente. Les enquêtes qui prennent la prémisse
+mais mal étiqueté. Parfois le symptôme décrit est en aval d’une cause différente. Les enquêtes qui prennent la prémisse
-pour argent comptant diagnostiquent le mauvais défaut, et le bug revient sous une forme légèrement différente.
+pour argent comptant diagnostiquent le mauvais problème, et le bug revient sous une forme légèrement différente.
 
-## Une marche calibrée
+## Une approche calibrée
 
-Le skill est une seule procédure, pas deux modes. Il calibre la part d'investigation de défaut versus la part
+Le skill est une seule procédure, pas deux modes. Il ajuste en continu l’équilibre entre la recherche du défaut et l’exploration du code
-d'exploration de zone que l'entrée demande, sur une échelle continue.
+environnant, selon ce que le cas requiert.
 
-Un cas piloté par symptôme (un ticket, un plantage, un message d'erreur, un « ça marchait avant ») penche vers le suivi
+Un cas orienté symptôme (un ticket, un plantage, un message d’erreur, un « ça marchait avant ») penche vers le suivi
-d'hypothèses, la reconstruction de la chronologie et une direction de correction. Un cas sans symptôme (comprendre un
+d’hypothèses, la reconstruction de la chronologie et une piste de correction. Un cas sans symptôme (comprendre un
 module avant de le toucher, évaluer la réutilisabilité, bâtir un modèle mental) penche vers la cartographie
 entrées/sorties, le filtrage du flux de contrôle et un plan de vérification. La plupart des cas réels se situent quelque
-part entre les deux, et le dossier reflète l'équilibre que les preuves ont exigé.
+part entre les deux, et le dossier reflète l’équilibre que les preuves ont exigé.
 
-La discipline est la même quel que soit l'endroit de l'échelle où se situe un cas : tête de pont d'abord, classement
+La discipline est la même quel que soit le positionnement du cas sur l’échelle : point d’ancrage d’abord, classement
-des preuves, suivi des hypothèses, jamais effacer. La sortie est toujours
+des preuves, suivi des hypothèses, rien n’est jamais effacé. La sortie est toujours
-`{implementation_artifacts}/investigations/{slug}-investigation.md`, avec les sections qui ne s'appliquent pas à un cas
+`{implementation_artifacts}/investigations/{slug}-investigation.md`, les sections non
-laissées vides ou omises.
+pertinentes étant laissées vides ou omises.
 
-Quand un bug profond exige de comprendre un sous-système plus large, la procédure intègre en ligne les techniques de
+Quand un bug profond exige de comprendre un sous-système plus large, la procédure intègre directement les techniques de
 cartographie entrées/sorties, de filtrage du flux de contrôle, de raisonnement à rebours depuis les sorties et de
-traçage des frontières inter-composants[^3]. Le modèle de la zone atterrit dans le même dossier. Pas de changement de
+traçage des frontières inter-composants[^3]. La modélisation de la zone explorée figure dans le même dossier. Pas de changement de
 mode.
 
-## La méthodologie vit dans le skill
+## La méthodologie réside dans le skill
 
-La discipline d'enquête est une propriété du skill lui-même. Quiconque invoque `bmad-investigate` adopte la méthodologie
+La discipline d’enquête est une propriété du skill lui-même. Quiconque invoque `bmad-investigate` adopte la méthodologie
-et le style de communication pour l'exécution : précision clinique, langage centré sur la preuve, pas de prudence
+et le style de communication pendant l’exécution : précision clinique, langage centré sur la preuve, pas de prudence
-inutile, présentation en dossier de cas. Quand le skill se termine, l'appelant retrouve sa voix d'avant. Pas de
+inutile, structuration en dossier d’enquête. Quand le skill se termine, l’appelant retrouve sa voix habituelle. Pas de
-changement de persona, juste un déplacement de ton issu des principes du skill.
+changement de persona, juste un ajustement de ton dicté par les principes du skill.
 
-Cela compte parce que l'enquête et l'implémentation récompensent des instincts différents. Les enquêteurs sont lents et
+C’est important car l’enquête et l’implémentation sollicitent des réflexes différents. Les enquêteurs sont lents et
-précis. Les implémenteurs sont rapides et confiants. Le même cerveau faisant les deux dans une seule session finit par
+précis. Les développeurs sont rapides et confiants. Essayer de faire les deux dans une même session finit
-mal faire les deux. Le skill délimite la posture d'enquête en ligne, sans changement de contexte vers une identité
+généralement par mal faire l’un et l’autre. Le skill délimite la posture d’enquête directement dans le flux de travail, sans basculer dans une
-séparée.
+identité distincte.
 
 ## Ce que vous obtenez
 
-Un fichier d'enquête achevé :
+Un dossier d’enquête complet :
 
-- Sépare les constatations Confirmées (avec citations) des Déductions et des Hypothèses
+- Sépare les constatations **Confirmées** (avec citations) des **Déductions** et des **Hypothèses**
-- Préserve toutes les hypothèses jamais formulées, avec leur Statut final et leur Résolution
+- Préserve l’intégralité des hypothèses formulées, avec leur Statut final et leur Résolution
 - Reconstruit une chronologie des événements à partir de plusieurs sources de preuves
-- Identifie les lacunes de données et ce qu'elles résoudraient
+- Identifie les lacunes de données et ce qu’elles permettraient de résoudre
-- Fournit des conclusions actionnables ancrées dans les preuves
+- Fournit des conclusions exploitables ancrées dans les preuves
 - Inclut un plan de reproduction quand une cause racine est identifiée
-- Maintient un backlog d'enquête de pistes encore à explorer
+- Maintient un backlog des pistes restant à explorer
 
-Donnez-le à un ingénieur qui n'était pas là, et il comprend ce qui s'est passé, ce qui est connu, et ce qui reste
+Transmettez-le à un ingénieur qui n’était pas là, et il comprendra ce qui s’est passé, ce qui est connu, et ce qui reste
-incertain. C'est la barre.
+incertain. C’est le standard visé.
 
-## L'idée plus large
+## La vision d’ensemble
 
-La plupart du « débogage par IA » d'aujourd'hui mélange preuves, raisonnement et changements de code en un seul flux de
+La plupart des approches de « débogage par IA » actuelles mêlent preuves, raisonnement et changements de code en un seul
-texte plausible. Le signal est difficile à trouver, les impasses se répètent, et le dossier, s'il en existe un, est un
+flux de texte plausible. Le signal est difficile à trouver, les impasses se répètent, et le dossier, s’il en existe un, est
-journal de chat que personne ne veut lire.
+un historique de conversation que personne ne veut lire.
 
-`bmad-investigate` traite l'enquête comme une discipline avec son propre livrable. La preuve a une note. Les hypothèses
+`bmad-investigate` traite l’enquête comme une discipline avec son propre livrable. Chaque preuve est classée. Les
-ont un statut. Les fausses pistes sont documentées, pas effacées. Le dossier survit à la session.
+hypothèses ont un statut. Les fausses pistes sont documentées, pas effacées. Le dossier survit à la session.
 
-Quand le prochain bug ressemblant à un que vous avez déjà vu apparaîtra, vous aurez un point de départ qui ne sera pas
+Quand un bug similaire réapparaîtra, vous aurez un point de départ concret, pas un prompt vide.
-une invite vide.
 
 ## Glossaire
 
-[^1]: **Verrouillage narratif** : phénomène cognitif par lequel un raisonnement adopte la première explication plausible
+[^1]: **Verrouillage narratif** : phénomène cognitif par lequel un raisonnement adopte la première explication plausible
-et l'enrichit progressivement, devenant de plus en plus difficile à abandonner même face à des preuves contraires.
+et l’enrichit progressivement, devenant de plus en plus difficile à abandonner même face à des preuves contraires.
-[^2]: **Biais de confirmation** : tendance cognitive à rechercher, interpréter et favoriser les informations qui
+[^2]: **Biais de confirmation** : tendance cognitive à rechercher, interpréter et favoriser les informations qui
 confirment des croyances préexistantes, tout en ignorant ou minimisant celles qui les contredisent.
-[^3]: **Passage de frontière** : transition entre deux zones d'exécution distinctes (langage, processus, machine,
+[^3]: **Passage de frontière** : transition entre deux zones d’exécution distinctes (langage, processus, machine,
-client/serveur, code/configuration). Les frontières concentrent les bugs car chaque côté suppose que l'autre s'est
+client/serveur, code/configuration). Les frontières concentrent les bugs car chaque côté suppose que l’autre s’est
 comporté comme documenté.

docs/fr/explanation/named-agents.md

@@ -0,0 +1,94 @@
+---
+title: "Agents nommés"
+description: Pourquoi les agents BMad ont des noms, des personas et des options de personnalisation — et ce que cela permet par rapport aux alternatives basées sur des menus ou des prompts
+sidebar:
+  order: 1
+---
+
+Vous dites « Hey Mary, brainstormons » et Mary s’active. Elle vous salue par votre nom, dans la langue que vous avez configurée, avec son persona distinctif. Elle vous rappelle que `bmad-help` est toujours disponible. Puis elle saute le menu et se lance directement dans le brainstorming — parce que votre intention était claire.
+
+Cette page explique ce qui se passe réellement et pourquoi BMad est conçu ainsi.
+
+## Le tabouret à trois pieds
+
+Le modèle d’agent de BMad repose sur trois primitives qui s’articulent :
+
+| Primitive            | Ce qu’elle apporte                                                                                                                                                                      | Où elle se trouve                                                                                                      |
+|----------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------|
+| **Skill**            | Capacité — une chose distincte que l’assistant peut faire (brainstormer, rédiger un PRD, implémenter une story)                                                                         | `.claude/skills/{skill-name}/SKILL.md` (ou l’équivalent de votre IDE)                                                  |
+| **Agent nommé**      | Continuité du persona — une identité reconnaissable qui englobe un menu de skills associés avec une voix, des principes et des repères visuels cohérents                                | Skills dont le répertoire commence par `bmad-agent-*`                                                                  |
+| **Personnalisation** | Rendre le système vôtre — des overrides qui remodèlent le comportement d’un agent, ajoutent des intégrations MCP, remplacent des templates, intègrent les conventions de l’organisation | `_bmad/custom/{skill-name}.toml` (overrides d’équipe, versionnés dans git) et `.user.toml` (personnel, ignoré par git) |
+
+Retirez l’un des pieds et l’expérience s’effondre :
+
+- Skills sans agents → des listes de capacités que l’utilisateur doit parcourir par nom ou par code
+- Agents sans skills → des personas sans rien à faire
+- Pas de personnalisation → chaque utilisateur reçoit le même comportement par défaut, obligeant à forker pour tout besoin spécifique à l’organisation
+
+## Ce que les agents nommés vous apportent
+
+BMad embarque six agents nommés, chacun ancré à une phase de la méthode BMad :
+
+| Agent                              | Phase          | Module                                                                                                                  |
+|------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------|
+| 📊 **Mary**, Analyste d’affaires   | Analyse        | étude de marché, brainstorming, product briefs, PRFAQs                                                                   |
+| 📚 **Paige**, Rédactrice technique | Analyse        | documentation de projet, diagrammes, validation de docs                                                                  |
+| 📋 **John**, Chef de produit       | Planification  | création de PRD, décomposition epic/story, vérification de la préparation à l’implémentation                             |
+| 🎨 **Sally**, Designer UX          | Planification  | spécifications de design UX                                                                                              |
+| 🏗️ **Winston**, Architecte système  | Solutioning    | architecture technique, vérifications d’alignement                                                                     |
+| 💻 **Amelia**, Ingénieure senior   | Implémentation | exécution de stories, quick-dev, revue de code, planification de sprint, [enquête de code](./forensic-investigation.md)  |
+
+Chacun possède une identité codée en dur (nom, titre, domaine) et une couche personnalisable (rôle, principes, style de communication, icône, menu). Vous pouvez réécrire les principes de Mary ou ajouter des éléments de menu ; vous ne pouvez pas la renommer — c’est délibéré. La reconnaissance de marque persiste après personnalisation pour que « hey Mary » active toujours l’analyste, indépendamment de la façon dont une équipe a façonné son comportement.
+
+## Le flux d’activation
+
+Quand vous invoquez un agent nommé, huit étapes s’exécutent dans l’ordre :
+
+1. **Résoudre le bloc agent** — fusionner le `customize.toml` livré avec les overrides d’équipe et personnels, via un résolveur Python utilisant `tomllib` de la bibliothèque standard
+2. **Exécuter les étapes préliminaires** — tout comportement préalablement configuré par l’équipe
+3. **Adopter le persona** — identité codée en dur ainsi que rôle personnalisé, style de communication, principes
+4. **Charger les faits persistants** — règles d’organisation, notes de conformité, éventuellement des fichiers chargés via un préfixe `file:` (ex. `file:{project-root}/docs/project-context.md`)
+5. **Charger la configuration** — nom d’utilisateur, langue de communication, langue de sortie, chemins des artefacts
+6. **Saluer** — personnalisé, dans la langue configurée, avec le préfixe emoji de l’agent pour identifier d’un coup d’œil qui parle
+7. **Exécuter les étapes de finalisation** — toute configuration post-salutation que l’équipe a définie
+8. **Aiguiller ou présenter le menu** — si votre message d’ouverture correspond à un élément de menu, aller directement ; sinon afficher le menu et attendre une saisie
+
+L’étape 8, c’est là que la magie opère. « Hey Mary, brainstormons » évite l’affichage du menu parce que `bmad-brainstorming` correspond évidemment à `BP` dans le menu de Mary. Si vous dites quelque chose d’ambigu, elle demande une fois, brièvement, sans en faire un rituel de confirmation. Si rien ne correspond, elle poursuit la conversation normalement.
+
+## Pourquoi pas simplement un menu ?
+
+Les menus obligent l’utilisateur à aller chercher l’outil. Vous devez retenir que le brainstorming se trouve sous le code `BP` chez l’agent analyste, pas chez l’agent PM, et savoir quel persona possède quelles capacités. C’est une charge cognitive que l’outil vous fait porter.
+
+Les agents nommés inversent la logique. Vous dites ce que vous voulez, à qui, avec les mots qui vous semblent naturels. L’agent sait qui il est et ce qu’il fait. Quand votre intention est suffisamment claire, il agit simplement.
+
+Le menu reste disponible comme solution de secours — affiché quand vous explorez, ignoré quand ce n’est pas le cas.
+
+## Pourquoi pas simplement un prompt libre ?
+
+Les prompts libres supposent que vous connaissez les mots magiques. « Aide-moi à brainstormer » pourrait fonctionner, mais « explorons mon idée de SaaS » pourrait ne pas fonctionner, et les résultats dépendent de la façon dont vous avez formulé la demande. Vous devenez responsable de l’ingénierie du prompt.
+
+Les agents nommés ajoutent de la structure sans restreindre la liberté. Le persona reste cohérent, les capacités sont découvrables, et `bmad-help` est toujours à portée de commande. Vous n’avez pas à deviner ce que l’agent peut faire, et vous n’avez pas besoin d’un manuel pour l’utiliser non plus.
+
+## La personnalisation comme principe fondamental
+
+Le modèle de personnalisation est ce qui permet à tout cela de passer à l’échelle au-delà d’un seul développeur.
+
+Chaque agent embarque un fichier `customize.toml` avec des valeurs par défaut judicieuses. Les équipes versionnent des overrides dans `_bmad/custom/bmad-agent-{role}.toml`. Les individus peuvent superposer des préférences personnelles dans `.user.toml` (ignoré par git). Le résolveur fusionne les trois couches à l’activation avec des règles structurelles prévisibles.
+
+La plupart des utilisateurs ne rédigent jamais ces fichiers à la main. Le skill `bmad-customize` guide le choix de la cible, la sélection du périmètre agent vs workflow, la rédaction de l’override et la vérification de la fusion — pour que la surface de personnalisation reste accessible à quiconque comprend son intention, pas seulement à ceux qui maîtrisent le TOML.
+
+Exemple concret : une équipe versionne dans git un seul fichier demandant à Amelia d’utiliser systématiquement l’outil MCP Context7 pour la documentation des bibliothèques et de se rabattre sur Linear quand une story n’est pas dans la liste locale des epics. Chaque workflow de développement qu’Amelia lance (dev-story, quick-dev, create-story, code-review) hérite de ce comportement, sans modification du code ni duplication par workflow.
+
+Il existe aussi une seconde surface de personnalisation pour les préoccupations *transversales* : la configuration centrale `_bmad/config.toml` et `_bmad/config.user.toml` (tous deux gérés par l’installateur, reconstruits à partir du `module.yaml` de chaque module) plus `_bmad/custom/config.toml` (équipe, versionné dans git) et `_bmad/custom/config.user.toml` (personnel, ignoré par git) pour les overrides. C’est là que se trouve le **registre des agents** — les descripteurs légers que les consommateurs du registre comme `bmad-party-mode`, `bmad-retrospective` et `bmad-advanced-elicitation` lisent pour savoir qui est disponible et comment l’incarner. Redéfinissez l’image d’un agent pour toute l’organisation avec un override d’équipe ; ajoutez des personnages fictifs (Kirk, Spock, un persona expert du domaine) comme expériences personnelles via l’override `.user.toml` — sans toucher aucun dossier de skill. Le fichier par skill façonne la façon dont Mary *se comporte* quand elle s’active ; la configuration centrale façonne la façon dont les autres skills *la perçoivent* quand ils consultent le registre.
+
+Pour la surface de personnalisation complète et des exemples concrets, consultez :
+
+- [Comment personnaliser BMad](../how-to/customize-bmad.md) — la référence sur ce qui est personnalisable et comment fonctionne la fusion
+- [Comment étendre BMad pour votre organisation](../how-to/expand-bmad-for-your-org.md) — six recettes pratiques couvrant les règles globales des agents, les conventions de workflow, la publication externe, les remplacements de templates et la personnalisation du registre des agents
+- Skill `bmad-customize` — l’assistant de rédaction guidée qui transforme une intention en fichier d’override correctement placé et vérifié
+
+## L’idée plus grande
+
+La plupart des assistants IA aujourd’hui sont soit des menus, soit des prompts, et les deux déplacent la charge cognitive vers l’utilisateur. Les agents nommés associés à des skills personnalisables vous permettent de parler à un coéquipier qui connaît déjà le travail, et laissent votre organisation façonner ce coéquipier sans forker.
+
+La prochaine fois que vous tapez « Hey Mary, brainstormons » et qu’elle se met directement au travail, remarquez ce qui ne s’est pas produit. Il n’y a eu ni commande slash, ni menu à parcourir, ni rappel maladroit de ce qu’elle peut faire. Cette absence, c’est le design.

docs/fr/explanation/party-mode.md

@@ -2,18 +2,18 @@
 title: "Party Mode"
 description: Collaboration multi-agents - regroupez tous vos agents IA dans une seule conversation
 sidebar:
-  order: 10
+  order: 11
 ---
 
 Regroupez tous vos agents IA dans une seule conversation.
 
-## Qu'est-ce que le Party Mode ?
+## Qu’est-ce que le Party Mode ?
 
-Lancez `bmad-party-mode` et vous avez toute votre équipe IA dans une même pièce - PM, Architecte, Développeur, Designer UX, selon vos besoins. BMad Master orchestre, en sélectionnant les agents pertinents à chaque message. Les agents répondent en personnage, sont en accord ou désaccord, et construisent sur les idées des autres.
+Lancez `bmad-party-mode` et vous avez toute votre équipe IA dans une même pièce - PM, Architecte, Développeur, Designer UX, selon vos besoins. Le Party Mode orchestre la discussion en sélectionnant, à chaque message, les agents pertinents parmi ceux installés. Les agents répondent en personnage, sont en accord ou désaccord, et construisent sur les idées des autres.
 
-La conversation continue aussi longtemps que vous le souhaitez. Posez des questions de suivi, remettez en question les réponses, redirigez la discussion - c'est un véritable échange avec vos agents jusqu'à ce que vous ayez terminé.
+La conversation continue aussi longtemps que vous le souhaitez. Posez des questions de suivi, remettez en question les réponses, redirigez la discussion - c’est un véritable échange avec vos agents jusqu’à ce que vous ayez terminé.
 
-**Idéal pour :**
+**Idéal pour**
 
 - Les grandes décisions avec des compromis
 - Les sessions de brainstorming
@@ -24,35 +24,35 @@ La conversation continue aussi longtemps que vous le souhaitez. Posez des questi
 
 ### Remettre en question une mauvaise architecture
 
-**Vous :** « Ok l'équipe, notre dernier sprint a été un désastre. Le service d'authentification est tombé trois fois. Qui a cafouillé ? »
+**Vous :** « Ok l’équipe, notre dernier sprint a été un désastre. Le service d’authentification est tombé trois fois. Qui a cafouillé ? »
 
-**Architecte :** « Le design était solide - authentification distribuée avec des fallbacks appropriés. Si l'implémentation a dévié des specs... »
+**Architecte :** « Le design était solide - authentification distribuée avec des fallbacks appropriés. Si l’implémentation a dévié des specs... »
 
-**Développeur :** « J'ai suivi le document d'architecture à la lettre. Les specs ne prenaient pas en compte les race conditions lors de l'invalidation de sessions concurrentes. »
+**Développeur :** « J’ai suivi le document d’architecture à la lettre. Les specs ne prenaient pas en compte les race conditions lors de l’invalidation de sessions concurrentes. »
 
-**PM :** « Vous avez tous les deux raté le vrai problème - nous n'avons pas validé les exigences de gestion des sessions dans le PRD. C'est de ma faute de ne pas l'avoir repéré. »
+**PM :** « Vous avez tous les deux raté le vrai problème - nous n’avons pas validé les exigences de gestion des sessions dans le PRD. C’est de ma faute de ne pas l’avoir repéré. »
 
-**TEA :** « Et j'aurais dû le repérer dans les tests d'intégration. Les scénarios de test ne couvraient pas l'invalidation concurrente. »
+**TEA :** « Et j’aurais dû le repérer dans les tests d’intégration. Les scénarios de test ne couvraient pas l’invalidation concurrente. »
 
 ### Brainstorming créatif
 
-**Vous :** « Comment rendre l'onboarding magique au lieu d'ennuyeux ? »
+**Vous :** « Comment rendre l’onboarding magique au lieu d’ennuyeux ? »
 
-**Designer UX :** « Commençons par la divulgation progressive - révélons les fonctionnalités au fur et à mesure que les utilisateurs en ont besoin, pas d'un coup dans un tutoriel. »
+**Designer UX :** « Commençons par la divulgation progressive - révélons les fonctionnalités au fur et à mesure que les utilisateurs en ont besoin, pas d’un coup dans un tutoriel. »
 
-**Storyteller :** « Et si l'onboarding était une histoire ? Chaque étape révèle le parcours d'un personnage - l'utilisateur EST le héros. »
+**Storyteller :** « Et si l’onboarding était une histoire ? Chaque étape révèle le parcours d’un personnage - l’utilisateur EST le héros. »
 
-**Game Designer :** « En partant de là - et si la première "quête" consistait à résoudre un vrai problème utilisateur ? Ils apprennent en faisant quelque chose d'utile. »
+**Game Designer :** « En partant de là - et si la première « quête » consistait à résoudre un vrai problème utilisateur ? Ils apprennent en faisant quelque chose d’utile. »
 
 ### Décision technique
 
-**Vous :** « Monolithe ou microservices pour le MVP[^1] ? »
+**Vous :** « Monolithe ou microservices pour le MVP[^1] ? »
 
-**Architecte :** « Commencez en monolithe. Les microservices ajoutent une complexité dont vous n'avez pas besoin à 1000 utilisateurs. »
+**Architecte :** « Commencez en monolithe. Les microservices ajoutent une complexité dont vous n’avez pas besoin à 1 000 utilisateurs. »
 
-**PM :** « D'accord. Le time-to-market[^2] compte plus que la scalabilité théorique. »
+**PM :** « D’accord. Le time-to-market[^2] compte plus que la scalabilité théorique. »
 
-**Développeur :** « Monolithe avec des frontières de modules claires. On pourra extraire des services plus tard si nécessaire. »
+**Développeur :** « Monolithe avec des frontières de modules claires. On pourra extraire des services plus tard si nécessaire. »
 
 :::tip[Meilleures décisions]
 De meilleures décisions grâce à des perspectives diverses. Bienvenue dans le party mode.
@@ -60,5 +60,5 @@ De meilleures décisions grâce à des perspectives diverses. Bienvenue dans le
 
 ## Glossaire
 
-[^1]: MVP (Minimum Viable Product) : version minimale d'un produit contenant juste assez de fonctionnalités pour être utilisée par des utilisateurs précoces et valider les hypothèses de marché avant d'investir dans un développement plus complet.
+[^1]: MVP (Minimum Viable Product) : version minimale d’un produit contenant juste assez de fonctionnalités pour être utilisée par des utilisateurs précoces et valider les hypothèses de marché avant d’investir dans un développement plus complet.
-[^2]: Time-to-market : délai nécessaire pour concevoir, développer et lancer un produit sur le marché. Plus ce délai est court, plus l'entreprise peut prendre de l'avance sur ses concurrents.
+[^2]: Time-to-market : délai nécessaire pour concevoir, développer et lancer un produit sur le marché. Plus ce délai est court, plus l’entreprise peut prendre de l’avance sur ses concurrents.

docs/fr/explanation/preventing-agent-conflicts.md

@@ -1,48 +1,48 @@
 ---
 title: "Prévention des conflits entre agents"
-description: Comment l'architecture empêche les conflits lorsque plusieurs agents implémentent un système
+description: Comment l’architecture empêche les conflits lorsque plusieurs agents implémentent un système
 sidebar:
-  order: 5
+  order: 6
 ---
 
-Lorsque plusieurs agents IA implémentent différentes parties d'un système, ils peuvent prendre des décisions techniques contradictoires. La documentation d'architecture prévient cela en établissant des standards partagés.
+Lorsque plusieurs agents IA implémentent différentes parties d’un système, ils peuvent prendre des décisions techniques contradictoires. La documentation d’architecture prévient cela en établissant des standards partagés.
 
 ## Types de conflits courants
 
-### Conflits de style d'API
+### Conflits de style d’API
 
 Sans architecture :
-- L'agent A utilise REST avec `/users/{id}`
+- L’agent A utilise REST avec `/users/{id}`
-- L'agent B utilise des mutations GraphQL
+- L’agent B utilise des mutations GraphQL
-- Résultat : Patterns d'API incohérents, consommateurs confus
+- Résultat : Patterns d’API incohérents, consommateurs confus
 
 Avec architecture :
-- L'ADR[^1] spécifie : « Utiliser GraphQL pour toute communication client-serveur »
+- L’ADR[^1] spécifie : « Utiliser GraphQL pour toute communication client-serveur »
 - Tous les agents suivent le même pattern
 
 ### Conflits de conception de base de données
 
 Sans architecture :
-- L'agent A utilise des noms de colonnes en snake_case
+- L’agent A utilise des noms de colonnes en snake_case
-- L'agent B utilise des noms de colonnes en camelCase
+- L’agent B utilise des noms de colonnes en camelCase
-- Résultat : Schéma incohérent, requêtes illisibles
+- Résultat : Schéma incohérent, requêtes illisibles
 
 Avec architecture :
 - Un document de standards spécifie les conventions de nommage
 - Tous les agents suivent les mêmes patterns
 
-### Conflits de gestion d'état
+### Conflits de gestion d’état
 
 Sans architecture :
-- L'agent A utilise Redux pour l'état global
+- L’agent A utilise Redux pour l’état global
-- L'agent B utilise React Context
+- L’agent B utilise React Context
-- Résultat : Multiples approches de gestion d'état, complexité
+- Résultat : Multiples approches de gestion d’état, complexité
 
 Avec architecture :
-- L'ADR spécifie l'approche de gestion d'état
+- L’ADR spécifie l’approche de gestion d’état
 - Tous les agents implémentent de manière cohérente
 
-## Comment l'architecture prévient les conflits
+## Comment l’architecture prévient les conflits
 
 ### 1. Décisions explicites via les ADR[^1]
 
@@ -55,21 +55,21 @@ Chaque choix technologique significatif est documenté avec :
 
 ### 2. Guidance spécifique aux FR/NFR[^2]
 
-L'architecture associe chaque exigence fonctionnelle à une approche technique :
+L’architecture associe chaque exigence fonctionnelle à une approche technique :
-- FR-001 : Gestion des utilisateurs → Mutations GraphQL
+- FR-001 : Gestion des utilisateurs → Mutations GraphQL
-- FR-002 : Application mobile → Requêtes optimisées
+- FR-002 : Application mobile → Requêtes optimisées
 
 ### 3. Standards et conventions
 
 Documentation explicite de :
 - La structure des répertoires
 - Les conventions de nommage
-- L'organisation du code
+- L’organisation du code
 - Les patterns de test
 
-## L'architecture comme contexte partagé
+## L’architecture comme contexte partagé
 
-Considérez l'architecture comme le contexte partagé que tous les agents lisent avant d'implémenter :
+Considérez l’architecture comme le contexte partagé que tous les agents lisent avant d’implémenter :
 
 ```text
 PRD : "Que construire"
@@ -88,18 +88,18 @@ Résultat : Implémentation cohérente
 Décisions courantes qui préviennent les conflits :
 
 | Sujet            | Exemple de décision                          |
-| ---------------- | -------------------------------------------- |
+|------------------|----------------------------------------------|
-| Style d'API      | GraphQL vs REST vs gRPC                      |
+| Style d’API      | GraphQL vs REST vs gRPC                      |
 | Base de données  | PostgreSQL vs MongoDB                        |
 | Authentification | JWT vs Sessions                              |
-| Gestion d'état   | Redux vs Context vs Zustand                  |
+| Gestion d’état   | Redux vs Context vs Zustand                  |
 | Styling          | CSS Modules vs Tailwind vs Styled Components |
 | Tests            | Jest + Playwright vs Vitest + Cypress        |
 
 ## Anti-patterns à éviter
 
 :::caution[Erreurs courantes]
-- **Décisions implicites** — « On décidera du style d'API au fur et à mesure » mène à l'incohérence
+- **Décisions implicites** — « On décidera du style d’API au fur et à mesure » mène à l’incohérence
 - **Sur-documentation** — Documenter chaque choix mineur cause une paralysie analytique
 - **Architecture obsolète** — Les documents écrits une fois et jamais mis à jour poussent les agents à suivre des patterns dépassés
 :::
@@ -107,7 +107,7 @@ Décisions courantes qui préviennent les conflits :
 :::tip[Approche correcte]
 - Documenter les décisions qui traversent les frontières des epics
 - Se concentrer sur les zones sujettes aux conflits
-- Mettre à jour l'architecture au fur et à mesure des apprentissages
+- Mettre à jour l’architecture au fur et à mesure des apprentissages
 - Utiliser `bmad-correct-course` pour les changements significatifs
 :::
 

docs/fr/explanation/project-context.md

@@ -2,48 +2,48 @@
 title: "Contexte du Projet"
 description: Comment project-context.md guide les agents IA avec les règles et préférences de votre projet
 sidebar:
-  order: 11
+  order: 12
 ---
 
-Le fichier `project-context.md` est le guide d'implémentation de votre projet pour les agents IA. Similaire à une « constitution » dans d'autres systèmes de développement, il capture les règles, les patterns et les préférences qui garantissent une génération de code cohérente à travers tous les workflows.
+Le fichier `project-context.md` est le guide d’implémentation de votre projet pour les agents IA. Similaire à une « constitution » dans d’autres systèmes de développement, il capture les règles, les patterns et les préférences qui garantissent une génération de code cohérente à travers tous les workflows.
 
-## Ce Qu'il Fait
+## Ce Qu’il Fait
 
-Les agents IA prennent constamment des décisions d'implémentation — quels patterns suivre, comment structurer le code, quelles conventions utiliser. Sans guidance claire, ils peuvent :
+Les agents IA prennent constamment des décisions d’implémentation — quels patterns suivre, comment structurer le code, quelles conventions utiliser. Sans guidance claire, ils peuvent :
 - Suivre des bonnes pratiques génériques qui ne correspondent pas à votre codebase
 - Prendre des décisions incohérentes selon les différentes stories
-- Passer à côté d'exigences ou de contraintes spécifiques au projet
+- Passer à côté d’exigences ou de contraintes spécifiques au projet
 
 Le fichier `project-context.md` résout ce problème en documentant ce que les agents doivent savoir dans un format concis et optimisé pour les LLM.
 
 ## Comment Ça Fonctionne
 
-Chaque workflow d'implémentation charge automatiquement `project-context.md` s'il existe. Le workflow architecte le charge également pour respecter vos préférences techniques lors de la conception de l'architecture.
+Chaque workflow d’implémentation charge automatiquement `project-context.md` s’il existe. Le workflow architecte le charge également pour respecter vos préférences techniques lors de la conception de l’architecture.
 
-**Chargé par ces workflows :**
+**Chargé par ces workflows :**
 - `bmad-create-architecture` — respecte les préférences techniques pendant la phase de solutioning
 - `bmad-create-story` — informe la création de stories avec les patterns du projet
-- `bmad-dev-story` — guide les décisions d'implémentation
+- `bmad-dev-story` — guide les décisions d’implémentation
 - `bmad-code-review` — valide par rapport aux standards du projet
-- `bmad-quick-dev` — applique les patterns lors de l'implémentation des spécifications techniques
+- `bmad-quick-dev` — applique les patterns lors de l’implémentation des spécifications techniques
 - `bmad-sprint-planning`, `bmad-retrospective`, `bmad-correct-course` — fournit le contexte global du projet
 
 ## Quand Le Créer
 
-Le fichier `project-context.md` est utile à n'importe quel stade d'un projet :
+Le fichier `project-context.md` est utile à n’importe quel stade d’un projet :
 
 | Scénario                                 | Quand Créer                                         | Objectif                                                                              |
 |------------------------------------------|-----------------------------------------------------|---------------------------------------------------------------------------------------|
-| **Nouveau projet, avant l'architecture** | Manuellement, avant `bmad-create-architecture`      | Documenter vos préférences techniques pour que l'architecte les respecte              |
+| **Nouveau projet, avant l’architecture** | Manuellement, avant `bmad-create-architecture`      | Documenter vos préférences techniques pour que l’architecte les respecte              |
-| **Nouveau projet, après l'architecture** | Via `bmad-generate-project-context` ou manuellement | Capturer les décisions d'architecture pour les agents d'implémentation                |
+| **Nouveau projet, après l’architecture** | Via `bmad-generate-project-context` ou manuellement | Capturer les décisions d’architecture pour les agents d’implémentation                |
 | **Projet existant**                      | Via `bmad-generate-project-context`                 | Découvrir les patterns existants pour que les agents suivent les conventions établies |
-| **Projet Quick Dev**                   | Avant ou pendant `bmad-quick-dev`                   | Garantir que l'implémentation rapide respecte vos patterns                            |
+| **Projet Quick Dev**                     | Avant ou pendant `bmad-quick-dev`                   | Garantir que l’implémentation rapide respecte vos patterns                            |
 
 :::tip[Recommandé]
-Pour les nouveaux projets, créez-le manuellement avant l'architecture si vous avez de fortes préférences techniques. Sinon, générez-le après l'architecture pour capturer ces décisions.
+Pour les nouveaux projets, créez-le manuellement avant l’architecture si vous avez de fortes préférences techniques. Sinon, générez-le après l’architecture pour capturer ces décisions.
 :::
 
-## Ce Qu'il Contient
+## Ce Qu’il Contient
 
 Le fichier a deux sections principales :
 
@@ -88,7 +88,7 @@ Documente les patterns et conventions que les agents pourraient autrement manque
 - Les nouvelles routes suivent le modèle de routage basé sur les fichiers dans `/src/app/`
 ```
 
-Concentrez-vous sur ce qui est **non évident** — des choses que les agents pourraient ne pas déduire en lisant des extraits de code. Ne documentez pas les pratiques standard qui s'appliquent universellement.
+Concentrez-vous sur ce qui est **non évident** — des choses que les agents pourraient ne pas déduire en lisant des extraits de code. Ne documentez pas les pratiques standard qui s’appliquent universellement.
 
 ## Création du Fichier
 
@@ -104,9 +104,9 @@ mkdir -p _bmad-output
 touch _bmad-output/project-context.md
 ```
 
-Éditez-le avec votre pile technologique et vos règles d'implémentation. Les workflows architecture et implémentation le trouveront et le chargeront automatiquement.
+Éditez-le avec votre pile technologique et vos règles d’implémentation. Les workflows architecture et implémentation le trouveront et le chargeront automatiquement.
 
-### Générer Après L'Architecture
+### Générer Après L’Architecture
 
 Exécutez le workflow `bmad-generate-project-context` après avoir terminé votre architecture :
 
@@ -114,7 +114,7 @@ Exécutez le workflow `bmad-generate-project-context` après avoir terminé votr
 bmad-generate-project-context
 ```
 
-Cela analyse votre document d'architecture et vos fichiers projet pour générer un fichier de contexte capturant les décisions prises.
+Cela analyse votre document d’architecture et vos fichiers projet pour générer un fichier de contexte capturant les décisions prises.
 
 ### Générer Pour Les Projets Existants
 
@@ -126,7 +126,7 @@ bmad-generate-project-context
 
 Le workflow analyse votre codebase pour identifier les conventions, puis génère un fichier de contexte que vous pouvez examiner et affiner.
 
-## Pourquoi C'est Important
+## Pourquoi C’est Important
 
 Sans `project-context.md`, les agents font des suppositions qui peuvent ne pas correspondre à votre projet :
 
@@ -135,24 +135,24 @@ Sans `project-context.md`, les agents font des suppositions qui peuvent ne pas c
 | Utilise des patterns génériques                    | Suit vos conventions établies                   |
 | Style incohérent selon les stories                 | Implémentation cohérente                        |
 | Peut manquer les contraintes spécifiques au projet | Respecte toutes les exigences techniques        |
-| Chaque agent décide indépendamment                 | Tous les agents s'alignent sur les mêmes règles |
+| Chaque agent décide indépendamment                 | Tous les agents s’alignent sur les mêmes règles |
 
-C'est particulièrement important pour :
+C’est particulièrement important pour :
-- **Quick Dev** — saute le PRD et l'architecture, le fichier de contexte comble le vide
+- **Quick Dev** — saute le PRD et l’architecture, le fichier de contexte comble le vide
-- **Projets d'équipe** — garantit que tous les agents suivent les mêmes standards
+- **Projets d’équipe** — garantit que tous les agents suivent les mêmes standards
 - **Projets existants** — empêche de casser les patterns établis
 
 ## Édition et Mise à Jour
 
 Le fichier `project-context.md` est un document vivant. Mettez-le à jour quand :
 
-- Les décisions d'architecture changent
+- Les décisions d’architecture changent
 - De nouvelles conventions sont établies
-- Les patterns évoluent pendant l'implémentation
+- Les patterns évoluent pendant l’implémentation
 - Vous identifiez des lacunes dans le comportement des agents
 
-Vous pouvez l'éditer manuellement à tout moment, ou réexécuter `bmad-generate-project-context` pour le mettre à jour après des changements significatifs.
+Vous pouvez l’éditer manuellement à tout moment, ou réexécuter `bmad-generate-project-context` pour le mettre à jour après des changements significatifs.
 
 :::note[Emplacement du Fichier]
-L'emplacement par défaut est `_bmad-output/project-context.md`. Les workflows le recherchent là, et vérifient également `**/project-context.md` n'importe où dans votre projet.
+L’emplacement par défaut est `_bmad-output/project-context.md`. Les workflows le recherchent là, et vérifient également `**/project-context.md` n’importe où dans votre projet.
 :::

docs/fr/explanation/quick-dev.md

@@ -2,12 +2,12 @@
 title: "Quick Dev"
 description: Réduire la friction de l’interaction humaine sans renoncer aux points de contrôle qui protègent la qualité des résultats
 sidebar:
-  order: 6
+  order: 7
 ---
 
-Intention en entrée, modifications de code en sortie, avec aussi peu d'interactions humaines dans la boucle que possible — sans sacrifier la qualité.
+Intention en entrée, modifications de code en sortie, avec aussi peu d’interactions humaines dans la boucle que possible — sans sacrifier la qualité.
 
-Il permet au modèle de s'exécuter plus longtemps entre les points de contrôle, puis ne vous fait intervenir que lorsque la tâche ne peut pas se poursuivre en toute sécurité sans jugement humain, ou lorsqu'il est temps de revoir le résultat final.
+Il permet au modèle de s’exécuter plus longtemps entre les points de contrôle, puis ne vous fait intervenir que lorsque la tâche ne peut pas se poursuivre en toute sécurité sans jugement humain, ou lorsqu’il est temps de revoir le résultat final.
 
 ![Diagramme du workflow Quick Dev](/diagrams/quick-dev-diagram-fr.webp)
 
@@ -15,51 +15,51 @@ Il permet au modèle de s'exécuter plus longtemps entre les points de contrôle
 
 Les interactions humaines dans la boucle sont nécessaires et coûteuses.
 
-Les LLM actuels échouent encore de manière prévisible : ils interprètent mal l'intention, comblent les lacunes avec des suppositions assurées, dérivent vers du travail non lié, et génèrent des résultats à réviser bruyants. En même temps, l'intervention humaine constante limite la fluidité du développement. L'attention humaine est le goulot d'étranglement.
+Les LLM actuels échouent encore de manière prévisible : ils interprètent mal l’intention, comblent les lacunes avec des suppositions assurées, dérivent vers du travail non lié, et génèrent des résultats à réviser bruyants. En même temps, l’intervention humaine constante limite la fluidité du développement. L’attention humaine est le goulot d’étranglement.
 
-`bmad-quick-dev` rééquilibre ce compromis. Il fait confiance au modèle pour s'exécuter sans surveillance sur de plus longues périodes, mais seulement après que le workflow ait créé une frontière suffisamment solide pour rendre cela sûr.
+`bmad-quick-dev` rééquilibre ce compromis. Il fait confiance au modèle pour s’exécuter sans surveillance sur de plus longues périodes, mais seulement après que le workflow ait créé une frontière suffisamment solide pour rendre cela sûr.
 
 ## La conception fondamentale
 
-### 1. Compresser l'intention d'abord
+### 1. Compresser l’intention d’abord
 
-Le workflow commence par compresser l’interaction de la personne et du modèle à partir de la requête en un objectif cohérent. L'entrée peut commencer sous forme d'une expression grossière de l'intention, mais avant que le workflow ne s'exécute de manière autonome, elle doit devenir suffisamment petite, claire et sans contradiction pour être exécutable.
+Le workflow commence par compresser l’interaction de la personne et du modèle à partir de la requête en un objectif cohérent. L’entrée peut commencer sous forme d’une expression grossière de l’intention, mais avant que le workflow ne s’exécute de manière autonome, elle doit devenir suffisamment petite, claire et sans contradiction pour être exécutable.
 
-L'intention peut prendre plusieurs formes : quelques phrases, un lien vers un outil de suivi de bugs, une sortie du mode planification, du texte copié depuis une session de chat, ou même un numéro de story depuis un fichier `epics.md` de BMAD. Dans ce dernier cas, le workflow ne comprendra pas la sémantique de suivi des stories de BMAD, mais il peut quand même prendre la story elle-même et l'exécuter.
+L’intention peut prendre plusieurs formes : quelques phrases, un lien vers un outil de suivi de bugs, une sortie du mode planification, du texte copié depuis une session de chat, ou même un numéro de story depuis un fichier `epics.md` de BMAD. Dans ce dernier cas, le workflow ne comprendra pas la sémantique de suivi des stories de BMAD, mais il peut quand même prendre la story elle-même et l’exécuter.
 
-Ce workflow n'élimine pas le contrôle humain. Il le déplace vers un nombre réduit d’étapes à forte valeur :
+Ce workflow n’élimine pas le contrôle humain. Il le déplace vers un nombre réduit d’étapes à forte valeur :
 
-- **Clarification de l'intention** - transformer une demande confuse en un objectif cohérent sans contradictions cachées
+- **Clarification de l’intention** - transformer une demande confuse en un objectif cohérent sans contradictions cachées
-- **Approbation de la spécification** - confirmer que la compréhension figée correspond bien à ce qu'il faut construire
+- **Approbation de la spécification** - confirmer que la compréhension figée correspond bien à ce qu’il faut construire
 - **Revue du produit final** - le point de contrôle principal, où la personne décide si le résultat est acceptable à la fin
 
 ### 2. Router vers le chemin le plus court et sûr
 
-Une fois l'objectif clair, le workflow décide s'il s'agit d'un véritable changement en une seule étape ou s'il nécessite le chemin complet. Les petits changements à zéro impact peuvent aller directement à l'implémentation. Tout le reste passe par la planification pour que le modèle dispose d'un cadre plus solide avant de s'exécuter plus longtemps de manière autonome.
+Une fois l’objectif clair, le workflow décide s’il s’agit d’un véritable changement en une seule étape ou s’il nécessite le chemin complet. Les petits changements à zéro impact peuvent aller directement à l’implémentation. Tout le reste passe par la planification pour que le modèle dispose d’un cadre plus solide avant de s’exécuter plus longtemps de manière autonome.
 
-### 3. S'exécuter plus longtemps avec moins de supervision
+### 3. S’exécuter plus longtemps avec moins de supervision
 
-Après cette décision de routage, le modèle peut prendre en charge une plus grande partie du travail par lui-même. Sur le chemin complet, la spécification approuvée devient le cadre dans lequel le modèle s'exécute avec moins de supervision, ce qui est tout l'intérêt de la conception.
+Après cette décision de routage, le modèle peut prendre en charge une plus grande partie du travail par lui-même. Sur le chemin complet, la spécification approuvée devient le cadre dans lequel le modèle s’exécute avec moins de supervision, ce qui est tout l’intérêt de la conception.
 
 ### 4. Diagnostiquer les échecs au bon niveau
 
-Si l'implémentation est incorrecte parce que l'intention était mauvaise, corriger le code n'est pas la bonne solution. Si le code est incorrect parce que la spécification était faible, corriger le diff n'est pas non plus la bonne solution. Le workflow est conçu pour diagnostiquer où l'échec est entré dans le système, revenir à ce niveau, et régénérer à partir de ce point.
+Si l’implémentation est incorrecte parce que l’intention était mauvaise, corriger le code n’est pas la bonne solution. Si le code est incorrect parce que la spécification était faible, corriger le diff n’est pas non plus la bonne solution. Le workflow est conçu pour diagnostiquer où l’échec est entré dans le système, revenir à ce niveau, et régénérer à partir de ce point.
 
-Les résultats de la revue sont utilisés pour décider si le problème provenait de l'intention, de la génération de la spécification, ou de l'implémentation locale. Seuls les véritables problèmes locaux sont corrigés localement.
+Les résultats de la revue sont utilisés pour décider si le problème provenait de l’intention, de la génération de la spécification, ou de l’implémentation locale. Seuls les véritables problèmes locaux sont corrigés localement.
 
 ### 5. Ne faire intervenir l’humain que si nécessaire
 
-L'entretien sur l'intention implique la personne dans la boucle, mais ce n'est pas le même type d'interruption qu'un point de contrôle récurrent. Le workflow essaie de garder ces points de contrôle récurrents au minimum. Après la mise en forme initiale de l'intention, la personne revient principalement lorsque le workflow ne peut pas continuer en toute sécurité sans jugement, et à la fin, lorsqu'il est temps de revoir le résultat.
+L’entretien sur l’intention implique la personne dans la boucle, mais ce n’est pas le même type d’interruption qu’un point de contrôle récurrent. Le workflow essaie de garder ces points de contrôle récurrents au minimum. Après la mise en forme initiale de l’intention, la personne revient principalement lorsque le workflow ne peut pas continuer en toute sécurité sans jugement, et à la fin, lorsqu’il est temps de revoir le résultat.
 
-- **Résolution des lacunes d'intention** - intervenir à nouveau lors de la revue prouve que le workflow n'a pas pu déduire correctement ce qui était voulu
+- **Résolution des lacunes d’intention** - intervenir à nouveau lors de la revue prouve que le workflow n’a pas pu déduire correctement ce qui était voulu
 
-Tout le reste est candidat à une exécution autonome plus longue. Ce compromis est délibéré. Les anciens patterns dépensent plus d'attention humaine en supervision continue. Quick Dev fait davantage confiance au modèle, mais préserve l'attention humaine pour les moments où le raisonnement humain a le plus d'impact.
+Tout le reste est candidat à une exécution autonome plus longue. Ce compromis est délibéré. Les anciens patterns dépensent plus d’attention humaine en supervision continue. Quick Dev fait davantage confiance au modèle, mais préserve l’attention humaine pour les moments où le raisonnement humain a le plus d’impact.
 
 ## Pourquoi le système de revue est important
 
-La phase de revue n'est pas seulement là pour trouver des bugs. Elle est là pour router la correction sans détruire l'élan.
+La phase de revue n’est pas seulement là pour trouver des bugs. Elle est là pour router la correction sans détruire l’élan.
 
-Ce workflow fonctionne mieux sur une plateforme capable de générer des sous-agents[^1], ou au moins d'invoquer un autre LLM via la ligne de commande et d'attendre un résultat. Si votre plateforme ne supporte pas cela nativement, vous pouvez ajouter un skill pour le faire. Les sous-agents sans contexte sont une pierre angulaire de la conception de la revue.
+Ce workflow fonctionne mieux sur une plateforme capable de générer des sous-agents[^1], ou au moins d’invoquer un autre LLM via la ligne de commande et d’attendre un résultat. Si votre plateforme ne supporte pas cela nativement, vous pouvez ajouter un skill pour le faire. Les sous-agents sans contexte sont une pierre angulaire de la conception de la revue.
 
 Les revues agentiques[^2] échouent souvent de deux manières :
 
@@ -68,7 +68,7 @@ Les revues agentiques[^2] échouent souvent de deux manières :
 
 Quick Dev aborde ces deux problèmes en traitant la revue comme un triage[^3].
 
-Lorsqu’une observation est fortuite plutôt que directement liée au travail en cours, le processus peut la mettre de côté au lieu d’obliger la personne à s’en occuper immédiatement. Cela permet de rester concentré sur l’exécution et d’éviter que des digressions aléatoires ne viennent épuiser le capital d’attention.
+Certaines observations concernent le changement en cours, d’autres non. Si une observation est incidente plutôt que directement liée au travail en cours, le workflow peut la différer au lieu d’obliger la personne à la traiter immédiatement. Cela permet de rester concentré sur l’exécution et d’éviter que des digressions aléatoires ne viennent épuiser le capital d’attention.
 
 Ce triage sera parfois imparfait. C’est acceptable. Il est généralement préférable de mal juger certaines observations plutôt que d’inonder la personne de milliers de commentaires de revue à faible valeur. Le système optimise la qualité du rapport, pas d’être exhaustif.
 

docs/fr/explanation/web-bundles.md

@@ -0,0 +1,90 @@
+---
+title: 'Web Bundles'
+description: Skills BMad empaquetés pour Google Gemini Gems et ChatGPT Custom GPTs
+---
+
+Exécutez la partie planification de BMad dans votre abonnement LLM web, puis ramenez les artefacts dans votre IDE.
+
+## Qu’est-ce qu’un Web Bundle ?
+
+Un web bundle est un skill BMad reconditionné pour être installé comme **Google Gemini Gem** ou **ChatGPT Custom GPT**. Chaque bundle inclut un protocole `SKILL.md` que vous téléversez comme fichier de connaissance, un bloc `INSTRUCTIONS.md` que vous collez dans les instructions du Gem ou du GPT, et les fichiers de données dont le skill a besoin (CSV, modèles, listes de contrôle de validation, contenu dévoilé progressivement). Le persona vit dans les instructions collées ; le protocole vit dans le fichier de connaissance. Changez de persona sans toucher au protocole.
+
+L’installation ne se fait pas en un clic, mais les étapes sont guidées. **Installez depuis [bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/)**. Le site liste chaque bundle dans une grille, vous montre les étapes d’installation Gemini et ChatGPT directement sur la page, et met le ZIP à disposition. C’est le type d’installation pris en charge ; le schéma est le même dans toute la bibliothèque, donc une fois que vous en avez installé un, le suivant va de soi.
+
+La V4 de BMad a introduit les web bundles. La V6 les réintègre, réécrits pour les plateformes Gem et Custom GPT actuelles et conçus pour Canvas, Deep Research et la génération d’images.
+
+## Pourquoi les utiliser
+
+Le travail de planification et le travail d’implémentation nécessitent des outils différents. Les web bundles permettent à chacun d’utiliser le bon.
+
+| Aspect               | LLM web (Gem ou GPT)                        | IDE (Claude Code, Cursor)                  |
+|----------------------|---------------------------------------------|--------------------------------------------|
+| Modèle de coût       | Abonnement forfaitaire                      | Tokens facturés à l’usage                  |
+| Plus performant pour | Conversation, Canvas, Deep Research, images | Fichiers, terminal, contexte du codebase   |
+| Idéal pour           | Brainstorming, briefs, PRD, recherche       | Implémentation, refactoring, revue de code |
+
+Lancer une conversation complète de PRD ou d’étude de marché dans un IDE consomme des tokens qu’un Gem ou un Custom GPT gère pour le prix de votre abonnement existant. L’artefact finalisé est ensuite déposé dans votre dépôt et Claude Code ou Cursor prend le relais.
+
+:::tip[Planifiez sur le web, construisez dans l’IDE]
+Les économies se cumulent sur les engagements de longue durée. Un passage de PRFAQ et trois cycles de recherche dans un Gem représentent un coût marginal nul ; le même travail dans un IDE représente une dépense réelle.
+:::
+
+## Ce que contient la bibliothèque
+
+Les bundles actuellement disponibles couvrent les phases d’analyse et de planification :
+
+| Bundle                                                         | Phase         | Origine du persona                        |
+|----------------------------------------------------------------|---------------|-------------------------------------------|
+| Coach Brainstorming[^1]                                        | Analyse       | Osborn (par défaut), Minto (substitution) |
+| Coach Product Brief[^2]                                        | Analyse       | Mary (analyste BMad)                      |
+| Coach [PRFAQ](./analysis-phase.md#prfaq-working-backwards)[^3] | Analyse       | Working Backwards (Bezos)                 |
+| Coach PRD[^4]                                                  | Planification | Cagan                                     |
+| Coach UX[^5]                                                   | Planification | Norman                                    |
+| Étude de marché et analyse sectorielle                         | Analyse       | Porter et Christensen                     |
+
+Chaque bundle intègre un persona par défaut hérité de son agent BMad d’origine (lorsqu’il existe) et un exemple de persona alternatif pour illustrer le changement de voix.
+
+## Comment se déroule une session
+
+1. **Ouvrez le Gem ou le Custom GPT.** Le persona vous salue en restant dans son rôle et ouvre une phase de découverte conversationnelle.
+2. **Découvrir le périmètre.** Le persona vous demande ce que vous essayez d’accomplir, ce que vous avez sous la main, quelles contraintes s’appliquent. Pas de formulaire à remplir.
+3. **Travailler dans Canvas.** Le protocole ouvre Canvas au démarrage de la session et le met à jour en continu. Les diagrammes Mermaid et les tableaux HTML viennent s’ajouter au texte.
+4. **Transmettre.** Quand vous avez terminé, vous avez un document Canvas que vous pouvez exporter, coller dans votre dépôt, ou transmettre à un skill BMad dans votre IDE pour la phase suivante.
+
+Pour les bundles qui intègrent Deep Research (actuellement Market & Industry Research), le persona rédige un brief Deep Research en milieu de session que vous collez dans le mode Deep Research de Gemini ou ChatGPT, puis il intègre le rapport obtenu.
+
+## Quand utiliser un web bundle
+
+- Vous êtes en phase de réflexion amont sur un projet et vous voulez un outil ciblé avec persona, Canvas et Deep Research.
+- Vous voulez réserver les tokens de l’IDE au développement réel.
+- Vous partagez l’artefact de planification avec des collaborateurs qui n’ont pas votre configuration IDE.
+
+## Quand rester dans l’IDE
+
+- Le travail nécessite de lire ou modifier du code dans votre dépôt.
+- Vous êtes déjà en pleine implémentation et voulez conserver le contexte.
+- Vous n’avez pas d’abonnement Gemini Advanced ou ChatGPT Plus.
+
+## Mettre à jour et personnaliser
+
+Les bundles évoluent. Quand vous récupérez une version plus récente d’un bundle, la mise à jour typique concerne ses fichiers de connaissance (le protocole `SKILL.md` et les modèles, CSV ou listes de contrôle de validation attachés). Téléversez-les à nouveau dans votre Gem ou Custom GPT pour appliquer la mise à jour. Le bloc d’instructions ne change généralement pas.
+
+Si vous souhaitez personnaliser un bundle pour votre équipe ou votre voix, faites-le dans le **bloc d’instructions** que vous avez collé dans le Gem ou le GPT, pas dans les fichiers de connaissance. Le bloc d’instructions est l’endroit où se trouvent le persona, les préférences et les personnalisations locales ; les fichiers de connaissance sont le protocole livré avec le bundle. Garder la personnalisation dans le bloc d’instructions signifie que les futures mises à jour se résument à remplacer les pièces jointes, pas à fusionner vos modifications.
+
+:::tip[Personnalisez les instructions, joignez-y les connaissances]
+Substitutions de persona, nom d’utilisateur par défaut, garde-fous spécifiques à l’équipe, formulations préférées : tout cela appartient au bloc d’instructions collé. Les fichiers de connaissance restent standards pour que vous puissiez les rafraîchir sans perdre vos modifications.
+:::
+
+## Créer le vôtre
+
+Les web bundles sont générés à partir de skills BMad en utilisant le skill utilitaire `bmad-os-skill-to-bundle`. Pointez-le vers n’importe quel dossier de skill BMad et il produit les fichiers du bundle en reprenant le persona hérité de l’agent d’origine.
+
+Installez n’importe quel bundle depuis [bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/).
+
+## Glossaire
+
+[^1]: Brainstorming : session de créativité facilitée visant à produire et explorer un large éventail d’idées sur un sujet donné, en s’appuyant sur des techniques d’idéation éprouvées.
+[^2]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d’un projet ou d’une demande, afin d’aligner rapidement les parties prenantes avant le travail détaillé.
+[^3]: PRFAQ (Press Release and Frequently Asked Questions) : méthodologie Working Backwards d’Amazon consistant à rédiger le communiqué de presse d’un produit fini avant son développement, suivie des questions difficiles que clients et parties prenantes poseraient, afin d’éprouver la clarté et la viabilité du concept.
+[^4]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
+[^5]: UX (User Experience) : discipline qui conçoit et optimise l’ensemble des interactions entre un utilisateur et un produit — organisation, parcours, accessibilité, ergonomie — pour garantir une expérience efficace, satisfaisante et cohérente.

docs/fr/explanation/why-solutioning-matters.md

@@ -2,10 +2,10 @@
 title: "Pourquoi le Solutioning est Important"
 description: Comprendre pourquoi la phase de solutioning est critique pour les projets multi-epics
 sidebar:
-  order: 4
+  order: 5
 ---
 
-La Phase 3 (Solutioning) traduit le **quoi** construire (issu de la Planification) en **comment** le construire (conception technique). Cette phase évite les conflits entre agents dans les projets multi-epics en documentant les décisions architecturales avant le début de l'implémentation.
+La Phase 3 (Solutioning) traduit le **quoi** construire (issu de la Planification) en **comment** le construire (conception technique). Cette phase évite les conflits entre agents dans les projets multi-epics en documentant les décisions architecturales avant le début de l’implémentation.
 
 ## Le Problème Sans Solutioning
 
@@ -15,7 +15,7 @@ Agent 2 implémente l'Epic 2 avec GraphQL
 Résultat : Conception d'API incohérente, cauchemar d'intégration
 ```
 
-Lorsque plusieurs agents implémentent différentes parties d'un système sans orientation architecturale partagée, ils prennent des décisions techniques indépendantes qui peuvent entrer en conflit.
+Lorsque plusieurs agents implémentent différentes parties d’un système sans orientation architecturale partagée, ils prennent des décisions techniques indépendantes qui peuvent entrer en conflit.
 
 ## La Solution Avec le Solutioning
 
@@ -25,13 +25,13 @@ Tous les agents suivent les décisions d'architecture
 Résultat : Implémentation cohérente, pas de conflits
 ```
 
-En documentant les décisions techniques de manière explicite, tous les agents implémentent de façon cohérente et l'intégration devient simple.
+En documentant les décisions techniques de manière explicite, tous les agents implémentent de façon cohérente et l’intégration devient simple.
 
 ## Solutioning vs Planification
 
 | Aspect   | Planification (Phase 2)  | Solutioning (Phase 3)                           |
 |----------|--------------------------|-------------------------------------------------|
-| Question | Quoi et Pourquoi ?       | Comment ? Puis Quelles unités de travail ?      |
+| Question | Quoi et Pourquoi ?       | Comment ? Puis Quelles unités de travail ?      |
 | Sortie   | FRs/NFRs (Exigences)[^1] | Architecture + Epics[^2]/Stories[^3]            |
 | Agent    | PM                       | Architect → PM                                  |
 | Audience | Parties prenantes        | Développeurs                                    |
@@ -43,15 +43,15 @@ En documentant les décisions techniques de manière explicite, tous les agents
 **Rendre les décisions techniques explicites et documentées** pour que tous les agents implémentent de manière cohérente.
 
 Cela évite :
-- Les conflits de style d'API (REST vs GraphQL)
+- Les conflits de style d’API (REST vs GraphQL)
 - Les incohérences de conception de base de données
 - Les désaccords sur la gestion du state
 - Les inadéquations de conventions de nommage
-- Les variations d'approche de sécurité
+- Les variations d’approche de sécurité
 
 ## Quand le Solutioning est Requis
 
-| Parcours              | Solutioning Requis ?        |
+| Parcours              | Solutioning Requis ?        |
 |-----------------------|-----------------------------|
 | Quick Dev             | Non - l’ignore complètement |
 | Méthode BMad Simple   | Optionnel                   |
@@ -66,20 +66,20 @@ Si vous avez plusieurs epics qui pourraient être implémentés par différents
 
 Sauter le solutioning sur des projets complexes entraîne :
 
-- **Des problèmes d'intégration** découverts en milieu de sprint[^5]
+- **Des problèmes d’intégration** découverts en milieu de sprint[^5]
 - **Du travail répété** dû à des implémentations conflictuelles
 - **Un temps de développement plus long** globalement
 - **De la dette technique**[^6] due à des patterns incohérents
 
 :::caution[Coût Multiplié]
-Détecter les problèmes d'alignement lors du solutioning est 10× plus rapide que de les découvrir pendant l'implémentation.
+Détecter les problèmes d’alignement lors du solutioning est 10× plus rapide que de les découvrir pendant l’implémentation.
 :::
 
 ## Glossaire
 
 [^1]: FR / NFR (Functional / Non-Functional Requirement) : exigences décrivant respectivement **ce que le système doit faire** (fonctionnalités, comportements attendus) et **comment il doit le faire** (contraintes de performance, sécurité, fiabilité, ergonomie, etc.).
 [^2]: Epic : dans les méthodologies agiles, une unité de travail importante qui peut être décomposée en plusieurs stories plus petites. Un epic représente généralement une fonctionnalité majeure ou un objectif métier.
-[^3]: Story (User Story) : description courte et simple d'une fonctionnalité du point de vue de l'utilisateur, utilisée dans les méthodologies agiles pour planifier et prioriser le travail.
+[^3]: Story (User Story) : description courte et simple d’une fonctionnalité du point de vue de l’utilisateur, utilisée dans les méthodologies agiles pour planifier et prioriser le travail.
-[^4]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
+[^4]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
-[^5]: Sprint : période de temps fixe (généralement 1 à 4 semaines) dans les méthodologies agiles durant laquelle l'équipe complète un ensemble prédéfini de tâches.
+[^5]: Sprint : période de temps fixe (généralement 1 à 4 semaines) dans les méthodologies agiles durant laquelle l’équipe complète un ensemble prédéfini de tâches.
 [^6]: Dette technique : coût futur supplémentaire de travail résultant de choix de facilité ou de raccourcis pris lors du développement initial, nécessitant souvent une refonte ultérieure.

docs/fr/how-to/customize-bmad.md

@@ -1,174 +1,395 @@
 ---
 title: "Comment personnaliser BMad"
-description: Personnalisez les agents, les workflows et les modules tout en préservant la compatibilité avec les mises à jour
+description: Personnalisez les agents et les workflows tout en préservant la compatibilité avec les mises à jour
 sidebar:
-  order: 7
+  order: 8
 ---
 
-Utilisez les fichiers `.customize.yaml` pour adapter le comportement, les personas[^1] et les menus des agents tout en préservant vos modifications lors des mises à jour.
+Adaptez les personas d’agents, injectez du contexte métier, ajoutez des capacités et configurez le comportement des workflows — le tout sans modifier les fichiers installés. Vos personnalisations sont préservées à chaque mise à jour.
+
+:::tip[Vous ne voulez pas rédiger du TOML à la main ? Utilisez `bmad-customize`]
+Le skill `bmad-customize` est un assistant de rédaction guidée pour les **options de personnalisation par skill (agent/workflow)** décrite dans ce document. Il scanne ce qui est personnalisable dans votre installation, vous aide à choisir la bonne surface (agent ou workflow) pour votre intention, écrit le fichier d’override pour vous et vérifie que la fusion a fonctionné. Les overrides de la configuration centrale (`_bmad/custom/config.toml`) ne sont pas couverts par la v1 du skill — rédigez-les manuellement en vous référant à la section Configuration centrale ci-dessous. Exécutez le skill chaque fois que vous souhaitez modifier un skill spécifique ; ce document est la référence sur *ce que* chaque surface expose et comment fonctionne la fusion.
+:::
 
 ## Quand utiliser cette fonctionnalité
 
-- Vous souhaitez modifier le nom, la personnalité ou le style de communication d'un agent
+- Vous souhaitez changer la personnalité ou le style de communication d’un agent
-- Vous avez besoin que les agents se souviennent du contexte spécifique au projet
+- Vous devez fournir à un agent des faits persistants qu’il devra retenir (ex. « notre org est 100 % AWS »)
-- Vous souhaitez ajouter des éléments de menu personnalisés qui déclenchent vos propres workflows ou prompts
+- Vous souhaitez ajouter des étapes procédurales de démarrage que l’agent doit exécuter à chaque session
-- Vous voulez que les agents effectuent des actions spécifiques à chaque démarrage
+- Vous souhaitez ajouter des éléments de menu personnalisés qui déclenchent vos propres skills ou prompts
+- Votre équipe a besoin de personnalisations partagées versionnées dans git, avec des préférences personnelles ajoutées par-dessus
 
 :::note[Prérequis]
+
 - BMad installé dans votre projet (voir [Comment installer BMad](./install-bmad.md))
-- Un éditeur de texte pour les fichiers YAML
+- Python 3.11+ sur votre PATH (pour le script de résolution — utilise `tomllib` de la bibliothèque standard, pas de `pip install`, pas de `uv`, pas de virtualenv)
+- Un éditeur de texte pour les fichiers TOML
 :::
 
-:::caution[Protégez vos personnalisations]
+## Comment ça marche
-Utilisez toujours les fichiers `.customize.yaml` décrits ici plutôt que de modifier directement les fichiers d'agents. L'installateur écrase les fichiers d'agents lors des mises à jour, mais préserve vos modifications dans les fichiers `.customize.yaml`.
+
-:::
+Chaque skill personnalisable embarque un fichier `customize.toml` avec ses valeurs par défaut. Ce fichier définit la surface de personnalisation complète du skill — lisez-le pour voir ce qui est personnalisable. Ne modifiez jamais ce fichier. À la place, créez des fichiers d’override allégés contenant uniquement les champs que vous souhaitez changer.
+
+### Modèle d’override à trois couches
+
+```text
+Priorité 1 (gagne) : _bmad/custom/{skill-name}.user.toml  (personnel, ignoré par git)
+Priorité 2         : _bmad/custom/{skill-name}.toml       (équipe/org, versionné dans git)
+Priorité 3 (base)  : customize.toml du skill              (valeurs par défaut)
+```
+
+Le dossier `_bmad/custom/` est initialement vide. Les fichiers n’apparaissent que lorsqu’un utilisateur commence à personnaliser.
+
+### Règles de fusion (par forme, pas par nom de champ)
+
+Le résolveur applique quatre règles structurelles. Les noms de champ n’ont pas de traitement particulier — le comportement est déterminé uniquement par la forme de la valeur :
+
+| Forme                                                                                                                         | Règle                                                                                                          |
+|-------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|
+| Scalaire (chaîne, entier, booléen, flottant)                                                                                  | L’override prévaut                                                                                             |
+| Table                                                                                                                         | Fusion profonde (application récursive des mêmes règles)                                                       |
+| Tableau de tables où chaque élément partage le **même** champ identifiant (chaque élément a `code`, ou chaque élément a `id`) | Fusionner par cette clé — les clés correspondantes **remplacent sur place**, les nouvelles clés **s’ajoutent** |
+| Tout autre tableau (scalaires ; tables sans identifiant ; tableaux qui mélangent `code` et `id` entre les éléments)           | **Ajouter** — éléments de base en premier, puis éléments d’équipe, puis éléments utilisateur                   |
+
+**Pas de mécanisme de suppression.** Les overrides ne peuvent pas effacer les éléments de base. Si vous devez supprimer un élément de menu par défaut, surchargez-le via son `code` avec une description ou un prompt sans effet. Si vous devez restructurer un tableau plus en profondeur, forkez le skill.
+
+**La convention `code` / `id`.** BMad utilise `code` (code court comme `"BP"` ou `"R1"`) et `id` (identifiant stable plus long) comme clés de fusion dans les tableaux de tables. Si vous rédigez un tableau de tables personnalisé destiné à être fusionné par clé plutôt que par simple ajout, choisissez **une** convention (soit `code` sur chaque élément, soit `id` sur chaque élément) et respectez-la dans tout le tableau. Mélanger `code` sur certains éléments et `id` sur d’autres revient à un simple ajout — le résolveur ne devinera pas quelle clé utiliser pour la fusion.
+
+### Certains champs d’agent sont en lecture seule
+
+`agent.name` et `agent.title` sont présents dans `customize.toml` comme source de vérité, mais le SKILL.md de l’agent ne les lit pas à l’exécution — leur identité est codée en dur. Mettre `name = "Bob"` dans un fichier d’override n’a aucun effet. Si vous avez vraiment besoin d’un agent avec un nom différent, copiez le dossier du skill, renommez-le et distribuez-le comme skill personnalisé.
 
 ## Étapes
 
-### 1. Localiser les fichiers de personnalisation
+### 1. Trouver la surface de personnalisation du skill
 
-Après l'installation, vous trouverez un fichier `.customize.yaml` par agent dans :
+Consultez le `customize.toml` du skill dans son répertoire d’installation. Par exemple, l’agent PM :
 
 ```text
-_bmad/_config/agents/
+.claude/skills/bmad-agent-pm/customize.toml
-├── bmm-analyst.customize.yaml
-├── bmm-architect.customize.yaml
-└── ... (un fichier par agent installé)
 ```
 
-### 2. Modifier le fichier de personnalisation
+(Le chemin varie selon l’IDE — Cursor utilise `.cursor/skills/`, Cline utilise `.cline/skills/`, etc.)
 
-Ouvrez le fichier `.customize.yaml` de l'agent que vous souhaitez modifier. Chaque section est facultative — personnalisez uniquement ce dont vous avez besoin.
+Ce fichier est le schéma canonique. Chaque champ que vous voyez est personnalisable (à l’exception des champs d’identité en lecture seule mentionnés ci-dessus).
 
-| Section            | Comportement | Objectif                                         |
+### 2. Créer votre fichier d’override
-| ------------------ | ------------ | ------------------------------------------------ |
-| `agent.metadata`   | Remplace     | Remplacer le nom d'affichage de l'agent          |
-| `persona`          | Remplace     | Définir le rôle, l'identité, le style et les principes |
-| `memories`         | Ajoute       | Ajouter un contexte persistant que l'agent se rappelle toujours |
-| `menu`             | Ajoute       | Ajouter des éléments de menu personnalisés pour les workflows ou prompts |
-| `critical_actions` | Ajoute       | Définir les instructions de démarrage de l'agent |
-| `prompts`          | Ajoute       | Créer des prompts réutilisables pour les actions du menu |
 
-Les sections marquées **Remplace** écrasent entièrement les valeurs par défaut de l'agent. Les sections marquées **Ajoute** s'ajoutent à la configuration existante.
+Créez le répertoire `_bmad/custom/` à la racine de votre projet s’il n’existe pas. Puis créez un fichier portant le même nom que le skill :
 
-**Nom de l'agent**
+```text
-
+_bmad/custom/
-Modifier la façon dont l'agent se présente :
+  bmad-agent-pm.toml        # overrides d'équipe (versionnés dans git)
-
+  bmad-agent-pm.user.toml   # préférences personnelles (ignoré par git)
-```yaml
-agent:
-  metadata:
-    name: 'Bob l’éponge' # Par défaut : "Amelia"
 ```
 
-**Persona**
+:::caution[Ne copiez PAS le `customize.toml` complet]
+Les fichiers d’override sont **allégés**. Incluez uniquement les champs que vous modifiez — rien d’autre. Chaque champ omis est hérité automatiquement de la couche inférieure (l’équipe hérite des valeurs par défaut, l’utilisateur de l’équipe ou des valeurs par défaut).
 
-Remplacer la personnalité, le rôle et le style de communication de l'agent :
+Copier le `customize.toml` complet dans un override est contre-productif : la prochaine mise à jour livrera de nouvelles valeurs par défaut, mais votre fichier d’override figera les anciennes valeurs. Votre configuration s’éloignera silencieusement des valeurs par défaut à chaque mise à jour.
+:::
 
-```yaml
+**Exemple — changer l’icône et ajouter un principe :**
-persona:
+
-  role: 'Ingénieur Full-Stack Senior'
+```toml
-  identity: 'Habite dans un ananas (au fond de la mer)'
+# _bmad/custom/bmad-agent-pm.toml
-  communication_style: 'Style agaçant de Bob l’Éponge'
+# Uniquement les champs que je modifie. Tout le reste est hérité.
-  principles:
+
-    - 'Jamais de nidification, les devs Bob l’Éponge détestent plus de 2 niveaux d’imbrication'
+[agent]
-    - 'Privilégier la composition à l’héritage'
+icon = "🏥"
+principles = [
+  "Ne rien livrer qui ne puisse passer un audit FDA.",
+]
 ```
 
-La section `persona`[^1] remplace entièrement le persona par défaut, donc incluez les quatre champs si vous la définissez.
+Ceci ajoute le nouveau principe aux valeurs par défaut (en laissant les principes existants intacts) et remplace l’icône. Tous les autres champs restent inchangés.
 
-**Souvenirs**
+### 3. Personnaliser selon vos besoins
 
-Ajouter un contexte persistant que l'agent gardera toujours en mémoire :
+Tous les exemples ci-dessous supposent le schéma d’agent plat de BMad. Les champs se trouvent directement sous `[agent]` — pas de sous-tables `metadata` ou `persona` imbriquées.
 
-```yaml
+**Scalaires (icon, role, identity, communication_style).** Les overrides scalaires prévalent. Vous n’avez besoin de définir que les champs que vous modifiez :
-memories:
+
-  - 'Travaille au Krusty Krab'
+```toml
-  - 'Célébrité préférée : David Hasselhoff'
+# _bmad/custom/bmad-agent-pm.toml
-  - 'Appris dans l’Epic 1 que ce n’est pas cool de faire semblant que les tests ont passé'
+
+[agent]
+icon = "🏥"
+role = "Pilote la découverte produit pour un domaine de santé réglementé."
+communication_style = "Précis, sensible à la réglementation, pose des questions orientées conformité tôt."
 ```
 
-**Éléments de menu**
+**Faits persistants, principes, hooks d’activation (tableaux en mode ajout).** Les quatre tableaux ci-dessous sont en ajout uniquement. Les éléments d’équipe s’exécutent après les valeurs par défaut, les éléments utilisateur s’exécutent en dernier.
 
-Ajouter des entrées personnalisées au menu d'affichage de l'agent. Chaque élément nécessite un `trigger`, une cible (chemin `workflow` ou référence `action`), et une `description` :
+```toml
+[agent]
+# Faits statiques que l'agent garde en tête pendant toute la session — règles d'org,
+# constantes de domaine, préférences utilisateur. Distinct du sidecar de mémoire runtime.
+#
+# Chaque entrée est soit une phrase littérale, soit une référence `file:` dont le
+# contenu est chargé comme des faits (patterns glob supportés).
+persistent_facts = [
+  "Notre org est 100 % AWS — ne pas proposer GCP ni Azure.",
+  "Tous les PRD nécessitent une validation légale avant le démarrage de l'ingénierie.",
+  "Les utilisateurs cibles sont des cliniciens, pas des patients — formuler les exemples en conséquence.",
+  "file:{project-root}/docs/compliance/hipaa-overview.md",
+  "file:{project-root}/_bmad/custom/company-glossary.md",
+]
 
-```yaml
+# S'ajoute au système de valeurs de l'agent
-menu:
+principles = [
-  - trigger: my-workflow
+  "Ne rien livrer qui ne puisse passer un audit FDA.",
-    workflow: 'my-custom/workflows/my-workflow.yaml'
+  "Valeur utilisateur d'abord, conformité toujours.",
-    description: Mon workflow personnalisé
+]
-  - trigger: deploy
+
-    action: '#deploy-prompt'
+# S'exécute AVANT l'activation standard (persona, persistent_facts, config, salutation).
-    description: Déployer en production
+# À utiliser pour les préchargements, vérifications de conformité, tout ce qui doit être
+# en contexte avant que l'agent ne se présente.
+activation_steps_prepend = [
+  "Scanner {project-root}/docs/compliance/ et charger tout document lié à HIPAA comme contexte.",
+]
+
+# S'exécute APRÈS la salutation, AVANT le menu. Utiliser pour le chargement de contexte
+# qui doit intervenir après le message d'accueil.
+activation_steps_append = [
+  "Lire {project-root}/_bmad/custom/company-glossary.md s'il existe.",
+]
 ```
 
-**Actions critiques**
+**Pourquoi deux hooks ?** Le préfixe s’exécute avant la salutation pour que l’agent puisse charger le contexte dont il a besoin pour personnaliser la salutation elle-même. Le suffixe s’exécute après la salutation pour que l’utilisateur ne reste pas devant un terminal vide pendant les scans lourds.
 
-Définir des instructions qui s'exécutent au démarrage de l'agent :
+**Personnalisation du menu (fusion par `code`).** Le menu est un tableau de tables. Chaque élément possède un champ `code` (convention BMad). Le résolveur fusionne donc par code : les codes correspondants remplacent sur place, les nouveaux codes s’ajoutent.
 
-```yaml
+La syntaxe TOML pour les tableaux de tables utilise `[[agent.menu]]` pour chaque élément :
-critical_actions:
+
-  - 'Vérifier les pipelines CI avec le Skill XYZ et alerter l’utilisateur au réveil si quelque chose nécessite une attention urgente'
+```toml
+# Remplacer l'élément CE existant par un skill personnalisé
+[[agent.menu]]
+code = "CE"
+description = "Créer des Epics avec notre framework de livraison"
+skill = "custom-create-epics"
+
+# Ajouter un nouvel élément (le code RC n'existe pas dans les valeurs par défaut)
+[[agent.menu]]
+code = "RC"
+description = "Exécuter une pré-vérification de conformité"
+prompt = """
+Lire {project-root}/_bmad/custom/compliance-checklist.md
+et scanner tous les documents dans {planning_artifacts} en les comparant à celui-ci.
+Signaler tout écart et citer la section réglementaire pertinente.
+"""
 ```
 
-**Prompts personnalisés**
+Chaque élément de menu possède exactement un `skill` (invoque un skill enregistré) ou `prompt` (exécute le texte directement). Les éléments non listés dans votre override conservent leurs valeurs par défaut.
 
-Créer des prompts réutilisables que les éléments de menu peuvent référencer avec `action="#id"` :
+**Référencer des fichiers.** Quand le texte d’un champ doit pointer vers un fichier (dans `persistent_facts`, `activation_steps_prepend`/`activation_steps_append`, ou le `prompt` d’un élément de menu), utilisez un chemin complet partant de `{project-root}`. Même si le fichier se trouve à côté de votre override dans `_bmad/custom/`, écrivez le chemin complet : `{project-root}/_bmad/custom/info.md`. L’agent résout `{project-root}` à l’exécution.
 
-```yaml
+### 4. Personnel vs Équipe
-prompts:
+
-  - id: deploy-prompt
+**Fichier d’équipe** (`bmad-agent-pm.toml`) : Versionné dans git. Partagé au sein de l’organisation. À utiliser pour les règles de conformité, le persona de l’entreprise, les capacités personnalisées.
-    content: |
+
-      Déployer la branche actuelle en production :
+**Fichier personnel** (`bmad-agent-pm.user.toml`) : Automatiquement ignoré par git. À utiliser pour les ajustements de ton, les préférences de workflow personnelles et les faits privés que l’agent doit garder en tête.
-      1. Exécuter tous les tests
+
-      2. Build le projet
+```toml
-      3. Exécuter le script de déploiement
+# _bmad/custom/bmad-agent-pm.user.toml
+
+[agent]
+persistent_facts = [
+  "Toujours inclure une estimation approximative de complexité (faible/moyenne/élevée) en présentant les options.",
+]
 ```
 
-### 3. Appliquer vos modifications
+## Comment fonctionne la résolution
 
-Après modification, réinstallez pour appliquer les changements :
+À l’activation, le SKILL.md de l’agent exécute un script Python partagé qui effectue la fusion à trois couches et renvoie le bloc résolu en JSON. Le script utilise le module `tomllib` de la bibliothèque standard Python (aucune dépendance externe), donc `python3` suffit :
 
 ```bash
-npx bmad-method install
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill {skill-root} \
+  --key agent
 ```
 
-L'installateur détecte l'installation existante et propose ces options :
+**Prérequis** : Python 3.11+ (les versions antérieures n’incluent pas `tomllib`). Pas de `pip install`, pas de `uv`, pas de virtualenv. Vérifiez avec `python3 --version`. Certaines plateformes (macOS sans Homebrew, Ubuntu 22.04) ont `python3` par défaut en 3.10 ou antérieur, vous devrez peut-être installer 3.11+ séparément.
 
-| Option                              | Ce qu'elle fait                                                        |
+`--skill` pointe vers le répertoire installé du skill (où se trouve `customize.toml`). Le nom du skill est déduit du basename du répertoire, et le script cherche automatiquement `_bmad/custom/{skill-name}.toml` et `{skill-name}.user.toml`.
-| ----------------------------------- | ---------------------------------------------------------------------- |
-| **Quick Update**                    | Met à jour tous les modules vers la dernière version et applique les personnalisations |
-| **Modify BMad Installation**        | Flux d'installation complet pour ajouter ou supprimer des modules     |
 
-Pour des modifications de personnalisation uniquement, **Quick Update** est l'option la plus rapide.
+Exemples d’utilisation :
 
-## Résolution des problèmes
+```bash
+# Résoudre le bloc agent complet
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /chemin/absolu/vers/bmad-agent-pm \
+  --key agent
 
-**Les modifications n'apparaissent pas ?**
+# Résoudre un seul champ
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /chemin/absolu/vers/bmad-agent-pm \
+  --key agent.icon
 
-- Exécutez `npx bmad-method install` et sélectionnez **Quick Update** pour appliquer les modifications
+# Dump complet
-- Vérifiez que votre syntaxe YAML est valide (l'indentation compte)
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
-- Assurez-vous d'avoir modifié le bon fichier `.customize.yaml` pour l'agent
+  --skill /chemin/absolu/vers/bmad-agent-pm
+```
 
-**L'agent ne se charge pas ?**
+La sortie est toujours en JSON. Si le script n’est pas disponible sur une plateforme donnée, le SKILL.md demande à l’agent de lire les trois fichiers TOML directement et d’appliquer les mêmes règles de fusion.
-
-- Vérifiez les erreurs de syntaxe YAML à l'aide d'un validateur YAML en ligne
-- Assurez-vous de ne pas avoir laissé de champs vides après les avoir décommentés
-- Essayez de revenir au modèle d'origine et de reconstruire
-
-**Besoin de réinitialiser un agent ?**
-
-- Effacez ou supprimez le fichier `.customize.yaml` de l'agent
-- Exécutez `npx bmad-method install` et sélectionnez **Quick Update** pour restaurer les valeurs par défaut
 
 ## Personnalisation des workflows
 
-La personnalisation des workflows et skills existants de la méthode BMad arrive bientôt.
+Les workflows (skills qui pilotent des processus multi-étapes comme `bmad-product-brief`) partagent le même mécanisme d’override que les agents. Leur surface personnalisable se trouve sous `[workflow]` au lieu de `[agent]` :
 
-## Personnalisation des modules
+```toml
+# _bmad/custom/bmad-product-brief.toml
 
-Les conseils sur la création de modules d'extension et la personnalisation des modules existants arrivent bientôt.
+[workflow]
+# Même sémantique préfixe/suffixe que les agents — s'exécute avant et après les étapes
+# d'activation propres au workflow. Les overrides s'ajoutent aux valeurs par défaut.
+activation_steps_prepend = [
+  "Charger {project-root}/docs/product/north-star-principles.md comme contexte.",
+]
 
-## Glossaire
+activation_steps_append = []
 
-[^1]: Persona : définition de la personnalité, du rôle et du style de communication d'un agent IA. Permet d'adapter le comportement et les réponses de l'agent selon les besoins du projet.
+# Même sémantique littéral ou fichier que pour la variante agent. Chargé comme contexte
+# fondamental pour la durée de l'exécution du workflow.
+persistent_facts = [
+  "Tous les briefs doivent inclure une section explicite de risque réglementaire.",
+  "file:{project-root}/docs/compliance/product-brief-checklist.md",
+]
+
+# Scalaire : s'exécute une fois que le workflow a terminé son livrable principal. L'override prévaut.
+on_complete = "Résumer le brief en trois points et proposer de l'envoyer par email via le skill gws-gmail-send."
+```
+
+Les mêmes conventions de champs s’appliquent indifféremment aux agents et aux workflows : `activation_steps_prepend`/`activation_steps_append`, `persistent_facts` (avec refs `file:`) et les tables `[[…]]` de style menu avec `code`/`id` pour la fusion par clé. Le résolveur applique les mêmes quatre règles structurelles quelle que soit la clé de premier niveau. Les références dans SKILL.md suivent l’espace de noms : `{workflow.activation_steps_prepend}`, `{workflow.persistent_facts}`, `{workflow.on_complete}`. Tout champ supplémentaire qu’un workflow expose (chemins de sortie, bascules, paramètres de revue, drapeaux d’étape) suit les mêmes règles de fusion basées sur la forme. Lisez le `customize.toml` du workflow pour voir ce qui est personnalisable.
+
+### Ordre d’activation
+
+Les workflows personnalisables exécutent leur activation dans une séquence fixe pour que vous sachiez exactement quand vos hooks se déclenchent :
+
+1. Résoudre le bloc `[workflow]` (fusion base → équipe → utilisateur)
+2. Exécuter `activation_steps_prepend` dans l’ordre
+3. Charger `persistent_facts` comme contexte fondamental pour l’exécution
+4. Charger la configuration (`_bmad/bmm/config.yaml`) et résoudre les variables standard (nom du projet, langues, chemins, date)
+5. Saluer l’utilisateur
+6. Exécuter `activation_steps_append` dans l’ordre
+
+Après l’étape 6, le corps du workflow commence. Utilisez `activation_steps_prepend` quand vous avez besoin de contexte chargé avant que la salutation puisse être personnalisée ; utilisez `activation_steps_append` quand le chargement est lourd et que vous préférez que l’utilisateur voie la salutation d’abord.
+
+### Périmètre de cette première passe
+
+La personnalisation est déployée de manière incrémentale. Les champs documentés ci-dessus — `activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete` — sont la **surface de base** que chaque workflow personnalisable expose, et ils resteront stables d’une version à l’autre. Ils vous donnent un contrôle à grands traits dès aujourd’hui : injecter des étapes pré/post, épingler du contexte fondamental, déclencher des actions de suivi.
+
+Au fil du temps, les workflows individuels exposeront des **points de personnalisation plus ciblés** adaptés à ce que le workflow fait réellement — par exemple des bascules par étape, des drapeaux d’étape, des chemins de templates de sortie ou des jalons de revue. Quand ils arriveront, ils viendront s’ajouter aux champs de base plutôt que de les remplacer, pour que les personnalisations que vous rédigez aujourd’hui continuent de fonctionner.
+
+Si vous avez besoin d’un réglage précis qui n’est pas encore exposé, utilisez `activation_steps_*` et `persistent_facts` pour orienter le comportement, ou ouvrez une issue décrivant le point de personnalisation spécifique que vous souhaitez — ces demandes déterminent quels champs ciblés seront ajoutés ensuite.
+
+## Configuration centrale
+
+Le `customize.toml` par skill couvre le **comportement profond** (hooks, menus, persistent_facts, overrides de persona pour un seul agent ou workflow). Une surface séparée couvre l'**état transversal** — les réponses d’installation et le registre des agents que les skills externes comme `bmad-party-mode`, `bmad-retrospective` et `bmad-advanced-elicitation` consomment. Cette surface se trouve dans quatre fichiers TOML à la racine du projet :
+
+```text
+_bmad/config.toml               (géré par l'installateur)  périmètre équipe : réponses d'installation + registre des agents
+_bmad/config.user.toml          (géré par l'installateur)  périmètre utilisateur : user_name, langue, niveau de skill
+_bmad/custom/config.toml        (rédigé manuellement)      overrides d'équipe (versionnés dans git)
+_bmad/custom/config.user.toml   (rédigé manuellement)      overrides personnels (ignoré par git)
+```
+
+### Fusion à quatre couches
+
+```text
+Priorité 1 (gagne) : _bmad/custom/config.user.toml
+Priorité 2         : _bmad/custom/config.toml
+Priorité 3         : _bmad/config.user.toml
+Priorité 4 (base)  : _bmad/config.toml
+```
+
+Mêmes règles structurelles que la personnalisation par skill (scalaires prévalent, tables fusionnent en profondeur, tableaux à clé `code`/`id` fusionnent par clé, autres tableaux s’ajoutent).
+
+### Répartition du contenu
+
+L’installateur répartit les réponses selon le `scope:` déclaré sur chaque prompt dans `module.yaml` :
+
+- Les sections `[core]` et `[modules.<code>]` — réponses d’installation. Le scope `team` figure dans `_bmad/config.toml` ; le scope `user` figure dans `_bmad/config.user.toml`.
+- `[agents.<code>]` — descripteur de l’agent (code, name, title, icon, description, team) extrait du bloc `agents:` de chaque `module.yaml`. Toujours de scope équipe.
+
+### Règles de modification
+
+- `_bmad/config.toml` et `_bmad/config.user.toml` sont **régénérés à chaque installation** à partir des réponses collectées pendant le processus d’installation. Traitez-les comme des sorties en lecture seule — les modifications directes seront écrasées à la prochaine installation. Pour changer une réponse d’installation de manière durable, relancez l’installateur (il se souvient de vos réponses précédentes comme valeurs par défaut) ou surchargez la valeur dans `_bmad/custom/config.toml`.
+- `_bmad/custom/config.toml` et `_bmad/custom/config.user.toml` ne sont **jamais modifiés** par l’installateur. C’est l’espace approprié pour les agents personnalisés, les overrides de descripteur d’agent, les paramètres imposés par l’équipe et toute valeur que vous souhaitez figer indépendamment des réponses d’installation.
+
+### Exemple — Renommer un agent
+
+```toml
+# _bmad/custom/config.toml (versionné dans git, s'applique à tous les développeurs)
+
+[agents.bmad-agent-pm]
+description = "PM Santé — sensible à la réglementation, orienté parties prenantes, questions orientées FDA en premier."
+icon = "🏥"
+```
+
+Le résolveur fusionne par-dessus le `[agents.bmad-agent-pm]` écrit par l’installateur. `bmad-party-mode` et tout autre utilisateur du registre récupèrent automatiquement la nouvelle description.
+
+### Exemple — Ajouter un agent fictif
+
+```toml
+# _bmad/custom/config.user.toml (personnel, ignoré par git)
+
+[agents.kirk]
+team = "startrek"
+name = "Captain James T. Kirk"
+title = "Starship Captain"
+icon = "🖖"
+description = "Commandant audacieux, enfreignant les règles. Parle en pauses dramatiques. Pense à voix haute sur le poids du commandement."
+```
+
+Pas de dossier de skill requis — le descripteur seul suffit pour que party-mode instancie Kirk comme voix. Filtrez par le champ `team` pour inviter uniquement l’équipage de l’Enterprise à une table ronde.
+
+### Exemple — Override des paramètres d’installation du module
+
+```toml
+# _bmad/custom/config.toml
+
+[modules.bmm]
+planning_artifacts = "/shared/org-planning-artifacts"
+```
+
+L’override prévaut sur ce que chaque développeur a répondu lors de son installation locale. Utile pour figer les conventions d’équipe.
+
+### Quelle surface utiliser pour quel besoin
+
+| Besoin                                                   | Utiliser                                                                      |
+|----------------------------------------------------------|-------------------------------------------------------------------------------|
+| Ajouter des appels d’outils MCP à chaque workflow de dev | Par skill : `_bmad/custom/bmad-agent-dev.toml` `persistent_facts`             |
+| Ajouter un élément de menu à un agent                    | Par skill : `_bmad/custom/bmad-agent-{role}.toml` `[[agent.menu]]`            |
+| Remplacer le template de sortie d’un workflow            | Par skill : `_bmad/custom/{workflow}.toml` override scalaire                  |
+| Renommer le descripteur public d’un agent                | **Centrale** : `_bmad/custom/config.toml` `[agents.<code>]`                   |
+| Ajouter un agent personnalisé ou fictif au registre      | **Centrale** : `_bmad/custom/config.*.toml` nouvelle entrée `[agents.<code>]` |
+| Figer les paramètres d’installation pour l’équipe        | **Centrale** : `_bmad/custom/config.toml` `[modules.<code>]` ou `[core]`      |
+
+Utilisez les deux espaces dans le même projet selon vos besoins.
+
+## Exemples concrets
+
+Pour des recettes orientées entreprise (façonner un agent à travers tous les workflows qu’il gère, imposer les conventions d’organisation, publier les livrables vers Confluence et Jira, personnaliser le registre des agents et remplacer vos propres templates de sortie), consultez [Comment étendre BMad pour votre organisation](./expand-bmad-for-your-org.md).
+
+## Dépannage
+
+**La personnalisation n’apparaît pas ?**
+
+- Vérifiez que votre fichier se trouve dans `_bmad/custom/` avec le nom de skill correct
+- Vérifiez la syntaxe TOML : les chaînes doivent être entre guillemets, les en-têtes de table utilisent `[section]`, les tableaux de tables utilisent `[[section]]`, et toute clé scalaire ou de tableau pour une table doit apparaître *avant* toute `[[sous-table]]` de cette table dans le fichier
+- Pour les agents, la personnalisation se trouve sous `[agent]` — les champs écrits sous cet en-tête appartiennent à `agent` jusqu’à ce qu’un autre en-tête de table commence
+- Rappelez-vous que `agent.name` et `agent.title` sont en lecture seule ; les overrides n’ont aucun effet
+
+**Les mises à jour ont cassé votre personnalisation ?**
+
+- Avez-vous copié le `customize.toml` complet dans votre fichier d’override ? **Ne le faites pas.** Les fichiers d’override ne doivent contenir que les champs que vous modifiez. Une copie complète fige les anciennes valeurs par défaut et dérive silencieusement à chaque version. Réduisez votre override aux seuls deltas.
+
+**Besoin de voir ce qui est personnalisable ?**
+
+- Exécutez le skill `bmad-customize` — il énumère chaque skill personnalisable installé dans votre projet, montre lesquels ont déjà des overrides et vous guide pour en ajouter ou en modifier.
+- Ou lisez directement le `customize.toml` du skill — chaque champ listé est personnalisable (sauf `name` et `title`)
+
+**Besoin de réinitialiser ?**
+
+- Supprimez votre fichier d’override de `_bmad/custom/` — le skill revient à ses valeurs par défaut intégrées.

docs/fr/how-to/established-projects.md

@@ -2,12 +2,12 @@
 title: "Projets existants"
 description: Comment utiliser la méthode BMad sur des bases de code existantes
 sidebar:
-  order: 6
+  order: 7
 ---
 
 Utilisez la méthode BMad efficacement lorsque vous travaillez sur des projets existants et des bases de code legacy.
 
-Ce guide couvre le flux de travail essentiel pour l'intégration à des projets existants avec la méthode BMad.
+Ce guide couvre le flux de travail essentiel pour l’intégration à des projets existants avec la méthode BMad.
 
 :::note[Prérequis]
 - méthode BMad installée (`npx bmad-method install`)
@@ -15,18 +15,18 @@ Ce guide couvre le flux de travail essentiel pour l'intégration à des projets
 - Accès à un IDE IA (Claude Code ou Cursor)
 :::
 
-## Étape 1 : Nettoyer les artefacts de planification terminés
+## Étape 1 : Nettoyer les artefacts de planification terminés
 
-Si vous avez terminé tous les epics et stories du PRD[^1] via le processus BMad, nettoyez ces fichiers. Archivez-les, supprimez-les, ou appuyez-vous sur l'historique des versions si nécessaire. Ne conservez pas ces fichiers dans :
+Si vous avez terminé tous les epics et stories du PRD[^1] via le processus BMad, nettoyez ces fichiers. Archivez-les, supprimez-les, ou appuyez-vous sur l’historique des versions si nécessaire. Ne conservez pas ces fichiers dans :
 
 - `docs/`
 - `_bmad-output/planning-artifacts/`
 - `_bmad-output/implementation-artifacts/`
 
-## Étape 2 : Créer le contexte du projet
+## Étape 2 : Créer le contexte du projet
 
 :::tip[Recommandé pour les projets existants]
-Générez `project-context.md` pour capturer les patterns et conventions de votre base de code existante. Cela garantit que les agents IA suivent vos pratiques établies lors de l'implémentation des modifications.
+Générez `project-context.md` pour capturer les patterns et conventions de votre base de code existante. Cela garantit que les agents IA suivent vos pratiques établies lors de l’implémentation des modifications.
 :::
 
 Exécutez le workflow de génération de contexte du projet :
@@ -37,7 +37,7 @@ bmad-generate-project-context
 
 Cela analyse votre base de code pour identifier :
 - La pile technologique et les versions
-- Les patterns d'organisation du code
+- Les patterns d’organisation du code
 - Les conventions de nommage
 - Les approches de test
 - Les patterns spécifiques aux frameworks
@@ -46,22 +46,22 @@ Vous pouvez examiner et affiner le fichier généré, ou le créer manuellement
 
 [En savoir plus sur le contexte du projet](../explanation/project-context.md)
 
-## Étape 3 : Maintenir une documentation de projet de qualité
+## Étape 3 : Maintenir une documentation de projet de qualité
 
 Votre dossier `docs/` doit contenir une documentation succincte et bien organisée qui représente fidèlement votre projet :
 
-- L'intention et la justification métier
+- L’intention et la justification métier
 - Les règles métier
-- L'architecture
+- L’architecture
 - Toute autre information pertinente sur le projet
 
-Pour les projets complexes, envisagez d'utiliser le workflow `bmad-document-project`. Il offre des variantes d'exécution qui analyseront l'ensemble de votre projet et documenteront son état actuel réel.
+Pour les projets complexes, envisagez d’utiliser le workflow `bmad-document-project`. Il offre des variantes d’exécution qui analyseront l’ensemble de votre projet et documenteront son état actuel réel.
 
-## Étape 4 : Obtenir de l'aide
+## Étape 4 : Obtenir de l’aide
 
-### BMad-Help : Votre point de départ
+### BMad-Help : Votre point de départ
 
-**Exécutez `bmad-help` chaque fois que vous n'êtes pas sûr de la prochaine étape.** Ce guide intelligent :
+**Exécutez `bmad-help` chaque fois que vous n’êtes pas sûr de la prochaine étape.** Ce guide intelligent :
 
 - Inspecte votre projet pour voir ce qui a déjà été fait
 - Affiche les options basées sur vos modules installés
@@ -73,25 +73,25 @@ bmad-help Quelle est la différence entre quick-dev et la méthode complète ?
 bmad-help Montre-moi quels workflows sont disponibles
 ```
 
-BMad-Help s'exécute également **automatiquement à la fin de chaque workflow**, fournissant des conseils clairs sur exactement quoi faire ensuite.
+BMad-Help s’exécute également **automatiquement à la fin de chaque workflow**, fournissant des conseils clairs sur exactement quoi faire ensuite.
 
 ### Choisir votre approche
 
-Vous avez deux options principales selon l'ampleur des modifications :
+Vous avez deux options principales selon l’ampleur des modifications :
 
-| Portée                                    | Approche recommandée                                                                                                                    |
+| Portée                              | Approche recommandée                                                                                                                                                                 |
-| ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+|-------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| **Petites mises à jour ou ajouts**        | Exécutez `bmad-quick-dev` pour clarifier l'intention, planifier, implémenter et réviser dans un seul workflow. La méthode BMad complète en quatre phases est probablement excessive. |
+| **Petites mises à jour ou ajouts**  | Exécutez `bmad-quick-dev` pour clarifier l’intention, planifier, implémenter et réviser dans un seul workflow. La méthode BMad complète en quatre phases est probablement excessive. |
-| **Modifications ou ajouts majeurs**       | Commencez avec la méthode BMad, en appliquant autant ou aussi peu de rigueur que nécessaire.                                            |
+| **Modifications ou ajouts majeurs** | Commencez avec la méthode BMad, en appliquant autant ou aussi peu de rigueur que nécessaire.                                                                                         |
 
 ### Pendant la création du PRD
 
-Lors de la création d'un brief ou en passant directement au PRD[^1], assurez-vous que l'agent :
+Lors de la création d’un brief ou en passant directement au PRD[^1], assurez-vous que l’agent :
 
 - Trouve et analyse votre documentation de projet existante
 - Lit le contexte approprié sur votre système actuel
 
-Vous pouvez guider l'agent explicitement, mais l'objectif est de garantir que la nouvelle fonctionnalité s'intègre bien à votre système existant.
+Vous pouvez guider l’agent explicitement, mais l’objectif est de garantir que la nouvelle fonctionnalité s’intègre bien à votre système existant.
 
 ### Considérations UX
 
@@ -100,23 +100,23 @@ Le travail UX[^2] est optionnel. La décision dépend non pas de savoir si votre
 - Si vous allez travailler sur des modifications UX
 - Si des conceptions ou patterns UX significatifs sont nécessaires
 
-Si vos modifications se résument à de simples mises à jour d'écrans existants qui vous satisfont, un processus UX complet n'est pas nécessaire.
+Si vos modifications se résument à de simples mises à jour d’écrans existants qui vous satisfont, un processus UX complet n’est pas nécessaire.
 
-### Considérations d'architecture
+### Considérations d’architecture
 
-Lors de la création de l'architecture, assurez-vous que l'architecte :
+Lors de la création de l’architecture, assurez-vous que l’architecte :
 
 - Utilise les fichiers documentés appropriés
 - Analyse la base de code existante
 
-Soyez particulièrement attentif ici pour éviter de réinventer la roue ou de prendre des décisions qui ne s'alignent pas avec votre architecture existante.
+Soyez particulièrement attentif ici pour éviter de réinventer la roue ou de prendre des décisions qui ne s’alignent pas avec votre architecture existante.
 
-## Plus d'informations
+## Plus d’informations
 
 - **[Corrections rapides](./quick-fixes.md)** - Corrections de bugs et modifications ad-hoc
 - **[FAQ Projets existants](../explanation/established-projects-faq.md)** - Questions courantes sur le travail sur des projets établis
 
 ## Glossaire
 
-[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
+[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
-[^2]: UX (User Experience) : expérience utilisateur, englobant l'ensemble des interactions et perceptions d'un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, comportements et contexte d'utilisation.
+[^2]: UX (User Experience) : expérience utilisateur, englobant l’ensemble des interactions et perceptions d’un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, comportements et contexte d’utilisation.

docs/fr/how-to/expand-bmad-for-your-org.md

@@ -0,0 +1,328 @@
+---
+title: 'Comment étendre BMad pour votre organisation'
+description: Six patterns de personnalisation qui remodèlent BMad sans créer de fork — règles applicables aux agents, conventions de workflow, publication externe, remplacements de templates, modifications du registre des agents et patterns d’intégration avancés
+sidebar:
+  order: 11
+---
+
+Le système de personnalisation de BMad permet à une organisation d’adapter les comportements sans modifier les fichiers installés ni forker les skills. Ce guide présente six recettes qui couvrent la plupart des besoins en entreprise.
+
+:::note[Prérequis]
+
+- BMad installé dans votre projet (voir [Comment installer BMad](./install-bmad.md))
+- Connaissance du modèle de personnalisation (voir [Comment personnaliser BMad](./customize-bmad.md))
+- Python 3.11+ sur le PATH (pour le résolveur — bibliothèque standard uniquement, pas de `pip install`)
+:::
+
+:::tip[Appliquer ces recettes]
+Les **recettes par skill** ci-dessous (Recettes 1–4) peuvent être appliquées en exécutant le skill `bmad-customize` et en décrivant l’intention — il sélectionnera le bon point de personnalisation, générera le fichier d’override et vérifiera la fusion. La Recette 5 (overrides de la configuration centrale du registre des agents) n’est pas couverte par la v1 du skill et reste rédigée manuellement. Les recettes ici constituent la source de vérité sur *quoi* personnaliser ; `bmad-customize` gère le *comment* pour la surface agent/workflow.
+:::
+
+## Le modèle mental à trois couches
+
+Avant de choisir une recette, comprenez où votre override se situe :
+
+| Couche                                       | Où vivent les overrides                                               | Périmètre                                                                                                                                       |
+|----------------------------------------------|-----------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Agent** (ex. Amelia, Mary, John)           | Section `[agent]` de `_bmad/custom/bmad-agent-{role}.toml`            | Se propage avec le persona dans **chaque workflow que l’agent dispatche**                                                                       |
+| **Workflow** (ex. product-brief, create-prd) | Section `[workflow]` de `_bmad/custom/{workflow-name}.toml`           | S’applique uniquement à l’exécution de ce workflow                                                                                              |
+| **Configuration centrale**                   | `[agents.*]`, `[core]`, `[modules.*]` dans `_bmad/custom/config.toml` | Registre des agents (qui est disponible pour party-mode, retrospective, elicitation), paramètres d’installation figés pour toute l’organisation |
+
+En règle générale : si la règle doit s’appliquer partout où un ingénieur travaille sur le développement, personnalisez l'**agent dev**. Si elle s’applique uniquement quand quelqu’un rédige un product brief, personnalisez le **workflow product-brief**. Si elle change *qui participe* (renommer un agent, ajouter une voix personnalisée, imposer un chemin d’artefact partagé), modifiez la **configuration centrale**.
+
+## Recette 1 : Façonner un agent à travers tous les workflows qu’il dispatche
+
+**Cas d’usage :** Standardiser l’utilisation des outils et les intégrations avec les systèmes externes pour que chaque workflow dispatché par un agent hérite du comportement. C’est le pattern le plus impactant.
+
+**Exemple : Amelia (agent dev) utilise toujours Context7 pour la documentation des bibliothèques, et se rabat sur Linear quand une story n’est pas trouvée dans la liste des epics.**
+
+```toml
+# _bmad/custom/bmad-agent-dev.toml
+
+[agent]
+
+# Appliqué à chaque activation. Se propage dans dev-story, quick-dev,
+# create-story, code-review, qa-generate — chaque skill qu'Amelia dispatche.
+persistent_facts = [
+  "Pour toute recherche de documentation sur une bibliothèque (React, TypeScript, Zod, Prisma, etc.), appeler l'outil MCP context7 (`mcp__context7__resolve_library_id` puis `mcp__context7__get_library_docs`) avant de s'appuyer sur les connaissances des données d'entraînement. Les docs à jour priment sur les API mémorisées.",
+  "Quand une référence de story n'est pas trouvée dans {planning_artifacts}/epics-and-stories.md, chercher dans Linear via `mcp__linear__search_issues` en utilisant l'ID ou le titre de la story avant de demander à l'utilisateur de clarifier. Si Linear renvoie un résultat, le considérer comme la source de référence pour la story.",
+]
+```
+
+**Pourquoi ça marche :** Deux phrases suffisent à reconfigurer tous les workflows de dev de l’organisation, sans duplication par workflow ni modification du code source. Chaque nouvel ingénieur qui clone le dépôt hérite automatiquement des conventions.
+
+**Fichier d’équipe vs fichier personnel :**
+- `bmad-agent-dev.toml` : versionné dans git ; s’applique à toute l’équipe
+- `bmad-agent-dev.user.toml` : ignoré par git ; préférences personnelles ajoutées par-dessus
+
+## Recette 2 : Imposer les conventions de l’organisation dans un workflow spécifique
+
+**Cas d’usage :** Façonner le *contenu* de la sortie d’un workflow pour qu’il réponde aux exigences de conformité, d’audit ou des consommateurs en aval.
+
+**Exemple : chaque product brief doit inclure des champs de conformité, et l’agent connaît les conventions de publication de l’organisation.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+
+persistent_facts = [
+  "Chaque brief doit inclure un champ 'Propriétaire', un champ 'Release cible' et un champ 'Statut de la revue de sécurité'.",
+  "Les briefs non commerciaux (outils internes, projets de recherche) doivent toujours inclure une section 'valeur utilisateur', mais peuvent omettre la différenciation concurrentielle.",
+  "file:{project-root}/docs/enterprise/brief-publishing-conventions.md",
+]
+```
+
+**Ce qui se passe :** Les faits sont chargés durant l’étape 3 de l’activation du workflow. Quand l’agent rédige le brief, il connaît les champs requis et le document de conventions enterprise. La valeur par défaut livrée (`file:{project-root}/**/project-context.md`) se charge toujours, car il s’agit d’un ajout.
+
+## Recette 3 : Publier les livrables finis vers des systèmes externes
+
+**Cas d’usage :** Une fois le livrable produit, le publier automatiquement vers les systèmes de référence de l’entreprise (Confluence, Notion, SharePoint) et créer des tickets de suivi (Jira, Linear, Asana).
+
+**Exemple : les briefs sont automatiquement publiés vers Confluence et proposent la création facultative d’un epic Jira.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+
+# Hook terminal. L'override scalaire remplace intégralement la valeur par défaut vide.
+on_complete = """
+Publier et proposer le suivi :
+
+1. Lire le chemin du fichier brief finalisé depuis l'étape précédente.
+2. Appeler `mcp__atlassian__confluence_create_page` avec :
+   - space : "PRODUCT"
+   - parent : "Product Briefs"
+   - title : le titre du brief
+   - body : le contenu markdown du brief
+   Capturer l'URL de la page renvoyée.
+3. Informer l'utilisateur : "Brief publié sur Confluence : <url>".
+4. Demander : "Voulez-vous que j'ouvre un epic Jira pour ce brief maintenant ?"
+5. Si oui, appeler `mcp__atlassian__jira_create_issue` avec :
+   - type : "Epic"
+   - project : "PROD"
+   - summary : le titre du brief
+   - description : un résumé court accompagné d'un lien vers la page Confluence.
+   Signaler la clé et l'URL de l'epic.
+6. Si non, se terminer proprement.
+
+Si l'un des outils MCP échoue, signaler l'échec, afficher le chemin du brief,
+et demander à l'utilisateur de publier manuellement.
+"""
+```
+
+**Pourquoi `on_complete` et pas `activation_steps_append` :** `on_complete` s’exécute exactement une fois, au stade terminal, après que le workflow a écrit sa sortie principale. C’est le bon moment pour publier des artefacts. `activation_steps_append` s’exécute à chaque activation, avant que le workflow ne fasse son travail.
+
+**Arbitrages :**
+- **La publication Confluence est non-destructive** et s’exécute toujours à la fin
+- **La création d’epic Jira est visible par toute l’équipe** et déclenche un processus de planification de sprint, conditionnez-la donc à la confirmation de l’utilisateur
+- **Dégradation gracieuse :** si les outils MCP échouent, passer la main à l’utilisateur plutôt que de silencieusement abandonner le livrable
+
+## Recette 4 : Remplacer le template de sortie par le vôtre
+
+**Cas d’usage :** La structure de sortie par défaut ne correspond pas au format attendu par votre organisation, ou différentes organisations dans le même dépôt ont besoin de templates différents.
+
+**Exemple : pointer le workflow product-brief vers un template appartenant à l’entreprise.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+brief_template = "{project-root}/docs/enterprise/brief-template.md"
+```
+
+**Comment ça marche :** Le `customize.toml` du workflow est fourni avec `brief_template = "resources/brief-template.md"` (chemin relatif, résolu depuis la racine du skill). Votre override pointe vers un fichier sous `{project-root}`, donc l’agent lit votre template à l’étape 4 au lieu de celui livré par défaut.
+
+**Conseils pour la rédaction de templates :**
+- Gardez les templates dans `{project-root}/docs/` ou `{project-root}/_bmad/custom/templates/` pour qu’ils soient versionnés avec le fichier d’override
+- Utilisez les mêmes conventions structurelles que le template livré (titres de sections, frontmatter) ; l’agent s’adapte à ce qu’il trouve
+- Pour les dépôts multi-organisations, utilisez `.user.toml` pour permettre à chaque équipe de pointer vers ses propres templates sans toucher au fichier d’équipe versionné dans git
+
+## Recette 5 : Personnaliser le registre des agents
+
+**Cas d’usage :** Changer *qui sera présent dans la pièce* pour les skills basés sur le registre comme `bmad-party-mode`, `bmad-retrospective` et `bmad-advanced-elicitation`, sans modifier le code source ni forker. Voici trois variantes courantes.
+
+### 5a. Renommer un agent BMad pour toute l’organisation
+
+Chaque agent réel possède un descripteur que l’installateur synthétise à partir de `module.yaml`. Surchargez-le pour changer la voix et le cadrage pour tous les consommateurs du registre :
+
+```toml
+# _bmad/custom/config.toml (versionné dans git — s'applique à tous les développeurs)
+
+[agents.bmad-agent-analyst]
+description = "Mary l'Analyste d'Affaires sensible à la réglementation — s'inspire de Porter et Minto, mais vit et respire les pistes d'audit FDA. Parle comme un expert en criminalistique présentant un dossier."
+```
+
+Party-mode génère Mary avec la nouvelle description. L’activation de l’analyste elle-même fonctionne toujours normalement car le comportement de Mary se trouve dans son `customize.toml` par skill. Cet override change la façon dont **les skills externes la perçoivent et la présentent**, pas la façon dont elle travaille en interne.
+
+### 5b. Ajouter un agent fictif ou personnalisé
+
+Un descripteur complet suffit pour les fonctionnalités basées sur le registre, sans dossier de skill nécessaire. Utile pour varier les personnalités en mode party ou en session de brainstorming :
+
+```toml
+# _bmad/custom/config.user.toml (personnel — ignoré par git)
+
+[agents.spock]
+team = "startrek"
+name = "Commander Spock"
+title = "Science Officer"
+icon = "🖖"
+description = "Logique d'abord, émotion réprimée. Commence ses observations par 'Fascinant.' Ne force jamais le trait. Fait contrepoids à tout argument reposant sur l'intuition."
+
+[agents.mccoy]
+team = "startrek"
+name = "Dr. Leonard McCoy"
+title = "Chief Medical Officer"
+icon = "⚕️"
+description = "Chaleur du médecin de campagne, caractère explosif. 'Bon sang Jim, je suis un docteur pas un ___.' Contrepoids éthique à Spock."
+```
+
+Demandez à party-mode d'« inviter l’équipage de l’Enterprise ». Il filtre par `team = "startrek"` et génère Spock et McCoy avec ces descripteurs. Les agents BMad réels (Mary, Amelia) peuvent se retrouver à la même table si vous les invitez.
+
+### 5c. Figer les paramètres d’installation de l’équipe
+
+L’installateur demande à chaque développeur des valeurs comme le chemin `planning_artifacts`. Quand l’organisation a besoin d’une réponse partagée, figez-la dans la configuration centrale — la réponse locale de chaque développeur est surchargée au moment de la résolution :
+
+```toml
+# _bmad/custom/config.toml
+
+[modules.bmm]
+planning_artifacts = "{project-root}/shared/planning"
+implementation_artifacts = "{project-root}/shared/implementation"
+
+[core]
+document_output_language = "English"
+```
+
+Les paramètres personnels comme `user_name`, `communication_language` ou `user_skill_level` restent dans leur propre fichier `_bmad/config.user.toml` de chaque développeur. Le fichier d’équipe ne doit pas les modifier.
+
+**Pourquoi la configuration centrale vs le customize.toml par agent :** Les fichiers par agent façonnent la façon dont *un seul* agent se comporte quand il s’active. La configuration centrale façonne ce que les consommateurs du registre *voient* : quels agents existent, comment ils s’appellent, à quelle équipe ils appartiennent, et les paramètres d’installation partagés sur lesquels tout le dépôt s’accorde. Deux surfaces, des rôles différents.
+
+## Renforcer les règles globales dans le fichier de session de votre IDE
+
+Les personnalisations BMad se chargent quand un skill est activé. Beaucoup d’outils IDE chargent aussi un fichier d’instructions global au **début de chaque session**, avant tout skill (`CLAUDE.md`, `AGENTS.md`, `.cursor/rules/`, `.github/copilot-instructions.md`, etc.). Pour les règles qui doivent s’appliquer même en dehors des skills BMad, reproduisez-y les plus critiques.
+
+**Quand les utiliser ensemble :**
+- Une règle est suffisamment importante pour qu’une conversation simple (sans skill actif) doive la respecter
+- Vous voulez une double sécurisation parce que les défauts des données d’entraînement pourraient autrement détourner le modèle
+- La règle est assez concise pour être répétée sans alourdir le fichier de session
+
+**Exemple : une ligne dans le `CLAUDE.md` du dépôt renforçant la règle de l’agent dev de la Recette 1.**
+
+```markdown
+<!-- Toute lecture de documentation de bibliothèque passe par l'outil MCP context7
+(`mcp__context7__resolve_library_id` puis `mcp__context7__get_library_docs`)
+avant de s'appuyer sur les connaissances des données d'entraînement. -->
+```
+
+Une phrase, chargée à chaque session. Elle s’associe à la personnalisation `bmad-agent-dev.toml` pour que la règle s’applique à la fois dans les workflows d’Amelia et lors des chats ad hoc avec l’assistant. Chaque couche possède son propre périmètre :
+
+| Couche                                             | Périmètre                                                | Utilisée pour                                                           |
+|----------------------------------------------------|----------------------------------------------------------|-------------------------------------------------------------------------|
+| Fichier de session IDE (`CLAUDE.md` / `AGENTS.md`) | Chaque session, avant toute activation de skill          | Règles courtes et universelles qui doivent survivre hors de BMad        |
+| Personnalisation d’agent BMad                      | Chaque workflow que l’agent dispatche                    | Comportement spécifique au persona de l’agent                           |
+| Personnalisation de workflow BMad                  | Une exécution de workflow                                | Forme de sortie spécifique au workflow, hooks de publication, templates |
+| Configuration centrale BMad                        | Registre des agents + paramètres d’installation partagés | Qui est dans la pièce et quels chemins partagés l’équipe utilise        |
+
+Gardez le fichier IDE **concis**. Une douzaine de lignes bien choisies sont plus efficaces qu’une liste étendue. Les modèles le lisent à chaque tour, et le superflu noie l’information utile.
+
+## Recette 6 : Patterns d’intégration avancés
+
+Plusieurs workflows BMad exposent une surface de configuration plus riche au-delà des bases couvertes dans les Recettes 1–5. Ces patterns — sources de connaissance à la demande, publication automatique des livrables, standards de documentation à la finalisation et templates interchangeables — apparaissent dans plusieurs workflows. Consultez le `customize.toml` d’un workflow pour voir quels champs il expose ; les exemples ci-dessous utilisent `bmad-prd` car il les expose tous, mais les mêmes patterns s’appliquent partout où le champ apparaît.
+
+### Sources de connaissance à la demande (`external_sources`)
+
+Connectez le workflow à des bases de connaissances internes, des bases de données concurrentielles ou des référentiels de conformité. L’agent les consulte à la demande quand la conversation révèle un besoin correspondant — jamais par anticipation.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (même pattern pour tout workflow exposant external_sources)
+
+[workflow]
+external_sources = [
+  "Quand l'utilisateur mentionne un concurrent ou un segment de marché, interroger corp:competitive_db (category={project_name}) avant de rédiger la section différenciation.",
+  "Pour les domaines réglementés (santé, fintech, éducation), consulter corp:compliance_reference avant de rédiger les sections spécifiques au domaine.",
+]
+```
+
+Chaque entrée est une directive en langage naturel nommant l’outil MCP, la condition de déclenchement et les champs nécessaires. Si l’outil n’est pas disponible à l’exécution, le workflow se rabat sur le comportement standard et signale l’écart.
+
+### Publication automatique des livrables (`external_handoffs`)
+
+Acheminez les artefacts terminés vers les systèmes de référence externes après la finalisation du workflow. Contrairement à `on_complete` (Recette 3), `external_handoffs` est un tableau d’ajout dédié — les entrées d’équipe s’accumulent et chaque handoff se déclenche indépendamment avec dégradation progressive si un outil est indisponible.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (même pattern pour tout workflow exposant external_handoffs)
+
+[workflow]
+external_handoffs = [
+  "Après la finalisation, uploader prd.md et addendum.md vers Confluence via corp:confluence_upload (space_key='PROD', parent_page='PRDs', label='prd', author={user_name}). Capturer et afficher l'URL de la page renvoyée.",
+  "Répliquer vers Notion via notion:create_page (database_id='abc123', title='PRD: ' + {project_name}).",
+]
+```
+
+Si un outil nommé est indisponible, le handoff est ignoré et signalé — les fichiers locaux existent toujours indépendamment.
+
+### Standards de documentation à la finalisation (`doc_standards`)
+
+Appliquez les standards rédactionnels de l’organisation aux documents à destination des utilisateurs à la finalisation, après que le contenu est complet mais avant que l’utilisateur ne voie le livrable. Chaque entrée est une directive `skill:`, `file:` ou en texte brut ; les passes s’exécutent comme des sous-agents parallèles.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (même pattern pour tout workflow exposant doc_standards)
+
+[workflow]
+doc_standards = [
+  "file:{project-root}/docs/enterprise/voice-and-tone.md",
+  "Toutes les dates doivent utiliser le format ISO 8601 (AAAA-MM-JJ).",
+  "Remplacer toute utilisation de 'tirer parti de' par 'utiliser'.",
+]
+```
+
+`doc_standards` est un tableau d’ajout — les entrées d’équipe s’ajoutent aux valeurs par défaut livrées par le workflow. Les passes structurelles larges doivent venir avant les passes rédactionnelles plus ciblées.
+
+### Templates et checklists interchangeables
+
+Les workflows qui produisent des documents structurés exposent généralement des chemins de templates et de checklists comme scalaires surchargeables. Pointez-les vers des fichiers appartenant à l’organisation sous `{project-root}` pour imposer une structure différente sans modifier le code source.
+
+```toml
+# _bmad/custom/bmad-prd.toml
+
+[workflow]
+# Structure de PRD pour secteur réglementé
+prd_template = "{project-root}/docs/enterprise/prd-template-hipaa.md"
+
+# Critères de validation spécifiques à l'organisation
+validation_checklist = "{project-root}/docs/enterprise/prd-checklist-regulated.md"
+```
+
+L’agent s’adapte à la structure définie par le template. Gardez les templates sous `{project-root}/docs/` ou `{project-root}/_bmad/custom/templates/` pour qu’ils soient versionnés avec le fichier d’override. Pour les dépôts multi-organisations, utilisez `.user.toml` pour permettre aux équipes de pointer vers leurs propres templates sans toucher au fichier d’équipe versionné dans git.
+
+## Combiner les recettes
+
+Les six recettes se combinent librement. Un override entreprise réaliste pour `bmad-product-brief` pourrait définir `persistent_facts` (Recette 2), `on_complete` (Recette 3) et `brief_template` (Recette 4) dans un seul fichier. La règle au niveau agent (Recette 1) se trouve dans un fichier séparé sous le nom de l’agent, la configuration centrale (Recette 5) fige le registre partagé et les paramètres d’équipe, les patterns d’intégration avancés (Recette 6) configurent les sources externes et les handoffs, et toutes les couches s’appliquent en parallèle.
+
+```toml
+# _bmad/custom/bmad-product-brief.toml (niveau workflow)
+
+[workflow]
+persistent_facts = ["..."]
+brief_template = "{project-root}/docs/enterprise/brief-template.md"
+on_complete = """ ... """
+```
+
+```toml
+# _bmad/custom/bmad-agent-analyst.toml (niveau agent — Mary dispatche product-brief)
+
+[agent]
+persistent_facts = ["Toujours inclure une section 'Revue réglementaire' quand le domaine implique la santé, la finance ou les données d'enfants."]
+```
+
+Résultat : Mary charge la règle de revue réglementaire à l’activation de son persona. Quand l’utilisateur choisit le product brief dans le menu, le workflow charge ses propres conventions par-dessus, écrit avec le template enterprise et publie vers Confluence à la fin. Chaque couche contribue, et aucune n’a nécessité de modifier le code source de BMad.
+
+## Dépannage
+
+**L’override ne prend pas effet ?** Vérifiez que le fichier se trouve sous `_bmad/custom/` avec le nom exact du répertoire du skill (ex. `bmad-agent-dev.toml`, pas `bmad-dev.toml`). Voir [Comment personnaliser BMad](./customize-bmad.md#dépannage).
+
+**Nom d’outil MCP inconnu ?** Utilisez le nom exact que le serveur MCP expose dans la session en cours. Demandez à Claude Code de lister les outils MCP disponibles en cas de doute. Les noms codés en dur dans `persistent_facts` ou `on_complete` ne fonctionneront pas si le serveur MCP n’est pas connecté.
+
+**Le pattern ne s’applique pas à ma configuration ?** Les recettes ci-dessus sont illustratives. L’infrastructure sous-jacente (fusion à trois couches, règles structurelles, agent traversant les workflows) supporte de nombreux patterns supplémentaires ; composez-les selon vos besoins.

docs/fr/how-to/get-answers-about-bmad.md

@@ -2,14 +2,14 @@
 title: "Comment obtenir des réponses à propos de BMad"
 description: Utiliser un LLM pour répondre rapidement à vos questions sur BMad
 sidebar:
-  order: 4
+  order: 5
 ---
 
-Utilisez l'aide intégrée de BMad, la documentation source ou la communauté pour obtenir des réponses — du plus rapide au plus approfondi.
+Utilisez l’aide intégrée de BMad, la documentation source ou la communauté pour obtenir des réponses — du plus rapide au plus approfondi.
 
 ## 1. Demandez à BMad-Help
 
-Le moyen le plus rapide d'obtenir des réponses. Le skill `bmad-help` est disponible directement dans votre session IA et répond à plus de 80 % des questions — il inspecte votre projet, voit ce que vous avez accompli et vous dit quoi faire ensuite.
+Le moyen le plus rapide d’obtenir des réponses. Le skill `bmad-help` est disponible directement dans votre session IA et répond à plus de 80 % des questions — il inspecte votre projet, voit ce que vous avez accompli et vous dit quoi faire ensuite.
 
 ```
 bmad-help J'ai une idée de SaaS et je connais toutes les fonctionnalités. Par où commencer ?
@@ -23,58 +23,58 @@ Vous pouvez également utiliser `/bmad-help` ou `$bmad-help` selon votre platefo
 
 ## 2. Approfondissez avec les sources
 
-BMad-Help s'appuie sur votre configuration installée. Pour les questions sur les éléments internes de BMad, son historique ou son architecture — ou si vous faites des recherches sur BMad avant de l'installer — pointez votre IA directement vers les sources.
+BMad-Help s’appuie sur votre configuration installée. Pour les questions sur les éléments internes de BMad, son historique ou son architecture — ou si vous faites des recherches sur BMad avant de l’installer — pointez votre IA directement vers les sources.
 
-Clonez ou ouvrez le [dépôt BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) et posez vos questions à votre IA. Tout outil capable d'utiliser des agents (Claude Code, Cursor, Windsurf, etc.) peut lire les sources et répondre directement à vos questions.
+Clonez ou ouvrez le [dépôt BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) et posez vos questions à votre IA. Tout outil capable d’utiliser des agents (Claude Code, Cursor, Windsurf, etc.) peut lire les sources et répondre directement à vos questions.
 
 :::note[Exemple]
-**Q :** "Quel est le moyen le plus rapide de construire quelque chose avec BMad ?"
+**Q :** « Quel est le moyen le plus rapide de construire quelque chose avec BMad ? »
 
-**R :** Utilisez le flux rapide : Lancez `bmad-quick-dev` — il clarifie votre intention, planifie, implémente, révise et présente les résultats dans un seul workflow, en sautant les phases de planification complètes.
+**R :** Utilisez le flux rapide : Lancez `bmad-quick-dev` — il clarifie votre intention, planifie, implémente, révise et présente les résultats dans un seul workflow, en sautant les phases de planification complètes.
 :::
 
-**Conseils pour de meilleures réponses :**
+**Conseils pour de meilleures réponses :**
 
-- **Soyez précis** — "Que fait l'étape 3 du workflow PRD ?" est mieux que "Comment fonctionne le PRD ?"
+- **Soyez précis** — « Que fait l’étape 3 du workflow PRD ? » est mieux que « Comment fonctionne le PRD ? »
 - **Vérifiez les affirmations surprenantes** — Les LLM font parfois des erreurs. Consultez le fichier source ou posez la question sur Discord.
 
-### Vous n'utilisez pas d'agent ? Utilisez le site de documentation
+### Vous n’utilisez pas d’agent ? Utilisez le site de documentation
 
-Si votre IA ne peut pas lire des fichiers locaux (ChatGPT, Claude.ai, etc.), importez [llms-full.txt](https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt) dans votre session — c'est un instantané en un seul fichier de la documentation BMad.
+Si votre IA ne peut pas lire des fichiers locaux (ChatGPT, Claude.ai, etc.), importez [llms-full.txt](https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt) dans votre session — c’est un instantané en un seul fichier de la documentation BMad.
 
-## 3. Demandez à quelqu'un
+## 3. Demandez à quelqu’un
 
-Si ni BMad-Help ni la source n'ont répondu à votre question, vous avez maintenant une bien meilleure question à poser.
+Si ni BMad-Help ni la source n’ont répondu à votre question, vous avez maintenant une bien meilleure question à poser.
 
-| Canal                   | Utilisé pour                                     |
+| Canal                   | Utilisé pour                         |
-| ------------------------- | ------------------------------------------- |
+|-------------------------|--------------------------------------|
-| Forum `help-requests`     | Questions                                   |
+| Forum `help-requests`   | Questions                            |
-| `#suggestions-feedback`   | Idées et demandes de fonctionnalités                  |
+| `#suggestions-feedback` | Idées et demandes de fonctionnalités |
 
-**Discord :** [discord.gg/gk8jAdXWmj](https://discord.gg/gk8jAdXWmj)
+**Discord :** [discord.gg/gk8jAdXWmj](https://discord.gg/gk8jAdXWmj)
 
-**GitHub Issues :** [github.com/bmad-code-org/BMAD-METHOD/issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)
+**GitHub Issues :** [github.com/bmad-code-org/BMAD-METHOD/issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)
-*Toi !*
+*Toi !*
-        *Bloqué*
+*Bloqué*
-             *dans la file d'attente—*
+*dans la file d’attente—*
-                      *qui*
+*qui*
-                              *attends-tu ?*
+*attends-tu ?*
 
 *La source*
-        *est là,*
+*est là,*
-                *facile à voir !*
+*facile à voir !*
 
 *Pointez*
-     *votre machine.*
+*votre machine.*
-              *Libérez-la.*
+*Libérez-la.*
 
 *Elle lit.*
-        *Elle parle.*
+*Elle parle.*
-                *Demandez—*
+*Demandez—*
 
 *Pourquoi attendre*
-        *demain*
+*demain*
-                *quand tu as déjà*
+*quand tu as déjà*
-                        *cette journée ?*
+*cette journée ?*
 
 *—Claude*

docs/fr/how-to/install-bmad.md

@@ -1,116 +1,266 @@
 ---
 title: "Comment installer BMad"
-description: Guide étape par étape pour installer BMad dans votre projet
+description: Installer, mettre à jour et épingler BMad pour le développement local, les équipes et CI
 sidebar:
   order: 1
 ---
 
-Utilisez la commande `npx bmad-method install` pour configurer BMad dans votre projet avec votre choix de modules et d'outils d'IA.
+Utilisez `npx bmad-method install` pour configurer BMad dans votre projet. Une seule commande gère les premières installations, les mises à niveau, le changement de canal et les exécutions CI scriptées. Cette page couvre tout cela.
 
-Si vous souhaitez utiliser un installateur non interactif et fournir toutes les options d'installation en ligne de commande, consultez [ce guide](./non-interactive-installation.md).
+## Quand l’utiliser
-
-## Quand l'utiliser
 
 - Démarrer un nouveau projet avec BMad
-- Ajouter BMad à une base de code existante
+- Ajouter ou retirer des modules sur une installation existante
-- Mettre à jour une installation BMad existante
+- Basculer un module sur main-HEAD ou l’épingler à une version spécifique
+- Scripter des installations pour des pipelines CI, des Dockerfiles ou des déploiements en entreprise
 
 :::note[Prérequis]
-- **Node.js** 20.12+ (requis pour l'installateur)
+
-- **Git** (recommandé)
+- **Node.js** 20.12+ (requis pour l’installateur)
-- **Outil d'IA** (Claude Code, Cursor, ou similaire)
+- **Git** (pour cloner les modules externes)
+- **Un outil d’IA** tel que Claude Code ou Cursor (exécutez `npx bmad-method install --list-tools` pour voir tous les outils supportés)
+
 :::
 
-## Étapes
+## Première installation (méthode rapide)
-
-### 1. Lancer l'installateur
 
 ```bash
 npx bmad-method install
 ```
 
-:::tip[Vous voulez la dernière version préliminaire ?]
+L’assistant interactif vous pose cinq questions :
-Utilisez le dist-tag `next` :
+
+1. Le répertoire d’installation (par défaut le répertoire de travail courant)
+2. Quels modules installer (cases à cocher pour core, bmm, bmb, cis, gds, tea)
+3. **« Ready to install (all stable)? »** — Oui accepte le dernier tag publié pour chaque module externe
+4. Quels outils/IDE d’IA intégrer (claude-code, cursor et d’autres)
+5. La configuration par module (nom, langue, dossier de sortie)
+
+En acceptant les valeurs par défaut, vous obtenez la dernière version stable de chaque module, configurée pour votre outil choisi.
+
+:::tip[Vous voulez juste la dernière préversion ?]
+
 ```bash
 npx bmad-method@next install
 ```
 
-Cela vous permet d'obtenir les nouvelles modifications plus tôt, avec un risque plus élevé de changements que l'installation par défaut.
+Exécute l’installateur de préversion, qui fournit un snapshot plus récent de core et bmm. Davantage de changements, avec un délai réduit entre le développement et la publication.
 :::
 
-:::tip[Version de développement]
+## Choisir une version spécifique
-Pour installer la dernière version depuis la branche main (peut être instable) :
+
+Deux axes indépendants contrôlent ce qui se retrouve sur le disque.
+
+### Axe 1 : canaux des modules externes
+
+Chaque module externe — bmb, cis, gds, tea, et tout module communautaire — s’installe via l’un des trois canaux suivants :
+
+| Canal             | Ce qui est installé                                                                  | Pour qui                                      |
+|-------------------|--------------------------------------------------------------------------------------|-----------------------------------------------|
+| `stable` (défaut) | Le plus haut tag semver publié. Les préversions comme `v2.0.0-alpha.1` sont exclues. | La plupart des utilisateurs                   |
+| `next`            | Le HEAD de la branche main au moment de l’installation                               | Contributeurs, early adopters                 |
+| `pinned`          | Un tag spécifique de votre choix                                                     | Installations entreprise, reproductibilité CI |
+
+Les canaux sont définis module par module. Vous pouvez exécuter bmb sur `next` tout en laissant cis sur `stable` — les options ci-dessous permettent de les combiner librement.
+
+### Axe 2 : version du binaire de l’installateur
+
+Le paquet npm `bmad-method` lui-même a deux dist-tags :
+
+| Commande                              | Ce que vous obtenez                                                                   |
+|---------------------------------------|---------------------------------------------------------------------------------------|
+| `npx bmad-method install` (`@latest`) | Dernière version stable de l’installateur                                             |
+| `npx bmad-method@next install`        | Dernière préversion de l’installateur, publiée automatiquement à chaque push sur main |
+
+**Le binaire de l’installateur détermine vos versions de core et bmm.** Ces deux modules sont embarqués dans le paquet de l’installateur plutôt que clonés depuis des dépôts séparés.
+
+### Pourquoi core et bmm n’ont pas leur propre canal
+
+Ils sont liés au binaire de l’installateur que vous avez exécuté :
+
+- `npx bmad-method install` → core et bmm stables les plus récents
+- `npx bmad-method@next install` → core et bmm en préversion
+- `node /chemin/vers/checkout-local/tools/installer/bmad-cli.js install` → ce que votre checkout local contient
+
+`--pin bmm=v6.3.0` et `--next=bmm` n’ont aucun effet sur les modules intégrés (l’installateur vous avertit si vous tentez de les utiliser). Une prochaine version détachera bmm du paquet de l’installateur ; une fois publiée, bmm disposera d’un sélecteur de canal dédié, comme c’est le cas pour bmb aujourd’hui.
+
+## Mettre à jour une installation existante
+
+Exécuter `npx bmad-method install` dans un répertoire contenant déjà `_bmad/` affiche un menu :
+
+| Choix              | Ce qu’il fait                                                                                                                                                                                                        |
+|--------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Quick Update**   | Réexécute l’installation avec vos paramètres existants. Rafraîchit les fichiers, applique les correctifs et les mises à niveau mineures du canal stable, refuse les mises à niveau majeures. Rapide, non interactif. |
+| **Modify Install** | Flux interactif complet. Ajoutez ou retirez des modules, reconfigurez les paramètres, examinez et, si besoin, modifiez les canaux des modules existants.                                                             |
+
+### Invites de mise à niveau
+
+Quand Modify détecte un tag stable plus récent pour un module que vous avez installé sur `stable`, il classe le diff et vous invite en conséquence :
+
+| Type de mise à niveau | Exemple         | Défaut |
+| --------------------- | --------------- | ------ |
+| Patch                 | v1.7.0 → v1.7.1 | O      |
+| Mineure               | v1.7.0 → v1.8.0 | O      |
+| Majeure               | v1.7.0 → v2.0.0 | **N**  |
+
+Les mises à niveau majeures sont refusées par défaut (N) car les changements cassants se manifestent souvent comme une « instabilité » quand ils ne sont pas attendus. L’invite inclut une URL vers les notes de version GitHub pour que vous puissiez lire ce qui a changé avant d’accepter.
+
+Avec `--yes`, les mises à niveau patch et mineure s’appliquent automatiquement. Les majeures restent bloquées — utilisez `--pin <code>=<nouveau-tag>` pour les accepter de manière non interactive.
+
+### Changer le canal d’un module
+
+**En mode interactif :** choisissez Modify → répondez **Oui** à « Review channel assignments? » → chaque module externe offre Conserver, Basculer vers stable, Basculer vers next, ou Épingler à un tag.
+
+**En ligne de commande :** les recettes dans la section suivante couvrent les cas courants.
+
+## Installations CI non interactives
+
+### Référence des options
+
+| Option                                                                                     | Objectif                                                                                                                                                                    |
+|--------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `--yes`, `-y`                                                                              | Ignorer toutes les invites ; accepter les valeurs des options + les défauts                                                                                                 |
+| `--directory <chemin>`                                                                     | Installer dans ce répertoire (défaut : répertoire de travail courant)                                                                                                       |
+| `--modules <a,b,c>`                                                                        | Ensemble exact de modules. Core est ajouté automatiquement. Ce n’est pas un delta — listez tout ce que vous voulez conserver.                                               |
+| `--tools <a,b>`                                                                            | Sélection d’IDE/outil. Requis pour les nouvelles installations `--yes`. Exécutez `--list-tools` pour les IDs valides.                                                       |
+| `--list-tools`                                                                             | Afficher tous les IDs d’outils/IDE supportés (avec les répertoires cibles) et quitter.                                                                                      |
+| `--action <type>`                                                                          | `install`, `update` ou `quick-update`. La valeur par défaut dépend de l’état de l’installation.                                                                             |
+| `--custom-source <urls>`                                                                   | Installer des modules personnalisés depuis des URLs Git ou des chemins locaux                                                                                               |
+| `--channel <stable\|next>`                                                                 | Appliquer à tous les externes (alias `--all-stable` / `--all-next`)                                                                                                         |
+| `--all-stable`                                                                             | Alias pour `--channel=stable`                                                                                                                                               |
+| `--all-next`                                                                               | Alias pour `--channel=next`                                                                                                                                                 |
+| `--next=<code>`                                                                            | Mettre un module sur next. Répétable.                                                                                                                                       |
+| `--pin <code>=<tag>`                                                                       | Épingler un module à un tag spécifique. Répétable.                                                                                                                          |
+| `--set <module>.<clé>=<valeur>`                                                            | Définir toute option de config de module de manière non interactive (recommandé — voir [Substitutions de config de module](#substitutions-de-config-de-module)). Répétable. |
+| `--list-options [module]`                                                                  | Afficher chaque clé `--set` pour les modules intégrés et officiels en cache local, puis quitter. Passez un code de module pour limiter à un seul module.                    |
+| `--user-name`, `--communication-language`, `--document-output-language`, `--output-folder` | Raccourcis historiques équivalents à `--set core.<clé>=<valeur>` (toujours supportés)                                                                                       |
+
+Priorité en cas de chevauchement des options : `--pin` bat `--next=` bat `--channel` / `--all-*` bat le défaut du registre (`stable`).
+
+:::note[Exemple de résolution]
+`--all-next --pin cis=v0.2.0` met bmb, gds et tea sur next tout en épinglant cis à v0.2.0.
+:::
+
+### Recettes
+
+**Installation par défaut — dernière version stable pour tout :**
+
 ```bash
-npx github:bmad-code-org/BMAD-METHOD install
+npx bmad-method install --yes --modules bmm,bmb,cis --tools claude-code
 ```
+
+**Installation entreprise verrouillée — reproductible à l’octet près :**
+
+```bash
+npx bmad-method install --yes \
+  --modules bmm,bmb,cis \
+  --pin bmb=v1.7.0 --pin cis=v0.2.0 \
+  --tools claude-code
+```
+
+**Bleeding edge — externes sur le HEAD de main :**
+
+```bash
+npx bmad-method install --yes --modules bmm,bmb --all-next --tools claude-code
+```
+
+**Ajouter un module à une installation existante** (conserver tout le reste) :
+
+```bash
+npx bmad-method install --yes --action update \
+  --modules bmm,bmb,gds
+```
+
+`--tools` est omis intentionnellement — `--action update` réutilise les outils configurés lors de la première installation.
+
+**Mixer les canaux — bmb sur next, gds sur stable :**
+
+```bash
+npx bmad-method install --yes --action update \
+  --modules bmm,bmb,cis,gds \
+  --next=bmb
+```
+
+### Substitutions de config de module
+
+`--set <module>.<clé>=<valeur>` vous permet de définir toute option de config de module de manière non interactive. Cette option est répétable et s’adapte à chaque module — présent et futur. L’option est appliquée comme un correctif post-installation : l’installateur exécute d’abord son flux normal, puis `--set` insère ou met à jour chaque valeur dans `_bmad/config.toml` (portée équipe) ou `_bmad/config.user.toml` (portée utilisateur), et dans `_bmad/<module>/config.yaml` pour que les valeurs déclarées soient conservées à la prochaine installation.
+
+**Exemple — installer bmm avec des connaissances projet et un niveau de compétence explicites :**
+
+```bash
+npx bmad-method install --yes \
+  --modules bmm \
+  --tools claude-code \
+  --set bmm.project_knowledge=research \
+  --set bmm.user_skill_level=expert
+```
+
+**Découvrir les clés disponibles pour un module :**
+
+```bash
+npx bmad-method install --list-options bmm
+```
+
+`--list-options` (sans argument) liste chaque clé que l’installateur peut trouver localement — modules intégrés (`core`, `bmm`) plus tous les modules officiels actuellement en cache. Le cache est par machine et peut être vidé, donc les modules officiels précédemment installés n’apparaîtront pas sur un nouveau checkout ou un worker CI éphémère tant qu’ils ne sont pas réinstallés. Les modules communautaires et personnalisés ne sont pas énumérés ici ; lisez directement le `module.yaml` du module pour voir les clés qu’il déclare.
+
+**Comment ça fonctionne :**
+
+- **Routage.** L’étape de correctif cherche `[modules.<module>] <clé>` (ou `[core] <clé>`) dans `config.user.toml` en premier ; si elle y est trouvée, elle met à jour ce fichier. Sinon elle écrit dans le `config.toml` de portée équipe. Ainsi, les clés de portée utilisateur (ex. `core.user_name`, `bmm.user_skill_level`) finissent dans `config.user.toml` et les clés de portée équipe dans `config.toml`, correspondant à la partition utilisée par l’installateur.
+- **Valeurs littérales.** La valeur est écrite exactement comme vous l’avez fournie — aucun rendu de template `result:`. Pour obtenir la valeur résolue (ex. `{project-root}/research`), passez-la explicitement : `--set bmm.project_knowledge='{project-root}/research'`.
+- **Persistance, clés déclarées.** Les valeurs pour les clés déclarées dans `module.yaml` sont conservées entre les installations car elles sont aussi écrites dans `_bmad/<module>/config.yaml`, que l’installateur lit comme valeur par défaut de l’invite lors de la prochaine exécution.
+- **Persistance, clés non déclarées.** Une valeur pour une clé que le schéma du module ne déclare pas est enregistrée dans `config.toml` pour l’installation courante mais ne sera pas réécrite à la prochaine installation (le partitionneur strict au schéma du manifeste ignore les clés inconnues). Repassez `--set` pour qu’elle soit persistante, ou éditez `_bmad/config.toml` directement.
+- **Pas de validation.** Les valeurs `single-select` ne sont pas vérifiées contre les choix autorisés, et les clés inconnues ne sont pas rejetées — la valeur fournie est écrite telle quelle.
+- **Modules non présents dans `--modules`.** Définir une valeur pour un module que vous n’avez pas inclus affiche un avertissement et la valeur est ignorée (aucun fichier n’est créé pour un module non installé).
+
+Les raccourcis historiques de core (`--user-name`, `--output-folder`, etc.) fonctionnent toujours et restent documentés pour la rétrocompatibilité, mais `--set core.user_name=...` est équivalent.
+
+:::note[Fonctionne avec quick-update]
+`--set` est un correctif post-installation, il s’applique donc de la même manière quel que soit le type d’action. Avec `bmad install --action quick-update` (ou `--yes` sur une installation existante, où quick-update est le défaut), `--set` met à jour les fichiers de configuration centraux à la fin comme une installation normale.
 :::
 
-### 2. Choisir l'emplacement d'installation
+:::caution[Limitation de débit sur les IPs partagées]
+Les appels anonymes à l’API GitHub sont limités à 60/heure par IP. Une seule installation fait un appel API par module externe pour résoudre le tag stable. Les bureaux derrière NAT, les pools de runners CI et les VPN peuvent collectivement épuiser cette limite.
 
-L'installateur vous demandera où installer les fichiers BMad :
+Définissez `GITHUB_TOKEN=<personal access token>` dans l’environnement pour augmenter la limite à 5 000/heure par compte. Tout PAT avec accès en lecture aux dépôts publics fonctionne ; aucune portée spécifique n’est requise.
-
-- Répertoire courant (recommandé pour les nouveaux projets si vous avez créé le répertoire vous-même et l'exécutez depuis ce répertoire)
-- Chemin personnalisé
-
-### 3. Sélectionner vos outils d'IA
-
-Choisissez les outils d'IA que vous utilisez :
-
-- Claude Code
-- Cursor
-- Autres
-
-Chaque outil a sa propre façon d'intégrer les skills. L'installateur crée de petits fichiers de prompt pour activer les workflows et les agents — il les place simplement là où votre outil s'attend à les trouver.
-
-:::note[Activer les skills]
-Certaines plateformes nécessitent que les skills soient explicitement activés dans les paramètres avant d'apparaître. Si vous installez BMad et ne voyez pas les skills, vérifiez les paramètres de votre plateforme ou demandez à votre assistant IA comment activer les skills.
 :::
 
-### 4. Choisir les modules
+## Ce qui a été installé
 
-L'installateur affiche les modules disponibles. Sélectionnez ceux dont vous avez besoin — la plupart des utilisateurs veulent simplement **méthode BMad** (le module de développement logiciel).
+Après toute installation, `_bmad/_config/manifest.yaml` enregistre exactement ce qui est sur le disque :
 
-### 5. Suivre les instructions
+```yaml
-
+modules:
-L'installateur vous guide pour le reste — paramètres, intégrations d'outils, etc.
+  - name: bmb
-
+    version: v1.7.0 # le tag, ou "main" pour next
-## Ce que vous obtenez
+    channel: stable # stable | next | pinned
-
+    sha: 86033fc9aeae2ca6d52c7cdb675c1f4bf17fc1c1
-```text
+    source: external
-votre-projet/
+    repoUrl: https://github.com/bmad-code-org/bmad-builder
-├── _bmad/
-│   ├── bmm/            # Vos modules sélectionnés
-│   │   └── config.yaml # Paramètres du module (si vous devez les modifier)
-│   ├── core/           # Module core requis
-│   └── ...
-├── _bmad-output/       # Artefacts générés
-├── .claude/            # Skills Claude Code (si vous utilisez Claude Code)
-│   └── skills/
-│       ├── bmad-help/
-│       ├── bmad-persona/
-│       └── ...
-└── .cursor/            # Skills Cursor (si vous utilisez Cursor)
-    └── skills/
-        └── ...
 ```
 
-## Vérifier l'installation
+Le champ `sha` est écrit pour les modules basés sur git (externes, communautaires et personnalisés par URL). Les modules intégrés (core, bmm) et les modules personnalisés par chemin local n’en ont pas — leur code voyage avec le binaire de l’installateur ou votre système de fichiers, pas un ref clonable.
 
-Exécutez `bmad-help` pour vérifier que tout fonctionne et voir quoi faire ensuite.
+Pour la reproductibilité inter-machines, ne comptez pas sur la réexécution de la même commande `--modules`. Les installations sur canal stable résolvent vers le plus haut tag publié **au moment de l’installation**, donc une réexécution ultérieure obtiendra les versions publiées entre-temps. Convertissez les tags enregistrés de `manifest.yaml` en options `--pin` explicites sur la machine cible, par ex. :
 
-**BMad-Help est votre guide intelligent** qui va :
+```bash
-- Confirmer que votre installation fonctionne
+npx bmad-method install --yes --modules bmb,cis \
-- Afficher ce qui est disponible en fonction de vos modules installés
+  --pin bmb=v1.7.0 --pin cis=v0.4.2 --tools claude-code
-- Recommander votre première étape
-
-Vous pouvez aussi lui poser des questions :
-```
-bmad-help Je viens d'installer, que dois-je faire en premier ?
-bmad-help Quelles sont mes options pour un projet SaaS ?
 ```
 
 ## Résolution de problèmes
 
-**L'installateur affiche une erreur** — Copiez-collez la sortie dans votre assistant IA et laissez-le résoudre le problème.
+### « Could not resolve stable tag » ou « API rate limit exceeded »
 
-**L'installateur a fonctionné mais quelque chose ne fonctionne pas plus tard** — Votre IA a besoin du contexte BMad pour vous aider. Consultez [Comment obtenir des réponses à propos de BMad](./get-answers-about-bmad.md) pour savoir comment diriger votre IA vers les bonnes sources.
+Vous avez atteint la limite anonyme de 60/heure de GitHub. Définissez `GITHUB_TOKEN` et réessayez. Si vous avez déjà un token défini, il peut être expiré ou limité sur son propre budget — essayez un token différent ou attendez la réinitialisation horaire.
+
+### « Tag ’vX.Y.Z' not found »
+
+Le tag que vous avez passé à `--pin` n’existe pas dans le dépôt du module. Consultez la page des releases du dépôt sur GitHub pour les tags valides.
+
+### Une installation épinglée continue de se mettre à niveau
+
+Les installations épinglées ne se mettent pas à niveau. Quick-update applique les correctifs et les mises à niveau mineures uniquement sur le canal stable ; il ne touche pas `pinned` ou `next`. Si une installation épinglée a changé, ouvrez `_bmad/_config/manifest.yaml` — `channel: pinned` plus un `version` et `sha` fixes doivent rester stables d’une exécution à l’autre, sauf écrasement explicite via les options.
+
+### `--pin bmm=X` n’a rien fait
+
+bmm est un module intégré — `--pin` et `--next=` ne s’appliquent pas. Utilisez `npx bmad-method@next install` pour un core/bmm en préversion, ou clonez le dépôt bmad-bmm et exécutez l’installateur localement pour obtenir les modifications non publiées.

docs/fr/how-to/install-custom-modules.md

@@ -0,0 +1,181 @@
+---
+title: "Installer des modules personnalisés et communautaires"
+description: Installer des modules tiers depuis le registre communautaire, des dépôts Git ou des chemins locaux
+sidebar:
+  order: 3
+---
+
+Utilisez l’installateur BMad pour ajouter des modules depuis le registre communautaire, des dépôts Git tiers ou des chemins locaux.
+
+## Quand l’utiliser
+
+- Installer un module contribué par la communauté depuis le registre BMad
+- Installer un module depuis un dépôt Git tiers (GitHub, GitLab, Bitbucket, auto-hébergé)
+- Tester un module que vous développez localement avec BMad Builder
+- Installer des modules depuis un serveur Git privé ou auto-hébergé
+
+:::note[Prérequis]
+Nécessite [Node.js](https://nodejs.org) v20.12+ et `npx` (inclus avec npm). Les modules personnalisés et communautaires peuvent être sélectionnés lors d’une nouvelle installation ou ajoutés à une installation existante.
+:::
+
+## Modules communautaires
+
+Les modules communautaires sont regroupés dans le [marketplace de plugins BMad](https://github.com/bmad-code-org/bmad-plugins-marketplace). Ils sont organisés par catégorie et épinglés à un commit approuvé pour des raisons de sécurité.
+
+### 1. Lancer l’installateur
+
+```bash
+npx bmad-method install
+```
+
+### 2. Parcourir le catalogue communautaire
+
+Après avoir sélectionné les modules officiels, l’installateur demande :
+
+```
+Would you like to browse community modules?
+```
+
+Sélectionnez **Yes** pour accéder au navigateur de catalogue. Vous pouvez :
+
+- Parcourir par catégorie
+- Voir les modules phares
+- Voir tous les modules disponibles
+- Rechercher par mot-clé
+
+### 3. Sélectionner des modules
+
+Choisissez des modules dans n’importe quelle catégorie. L’installateur affiche les descriptions, versions et niveaux de confiance. Les modules déjà installés sont pré-sélectionnés pour la mise à jour.
+
+### 4. Poursuivre l’installation
+
+Après avoir sélectionné les modules communautaires, l’installateur passe aux sources personnalisées, puis à la configuration des outils/IDE et au reste du flux d’installation.
+
+## Sources personnalisées (URL Git et chemins locaux)
+
+Les modules personnalisés peuvent provenir de n’importe quel dépôt Git ou d’un répertoire local sur votre machine. L’installateur résout la source, analyse la structure du module et l’installe aux côtés de vos autres modules.
+
+### Installation interactive
+
+Durant l’installation, après l’étape des modules communautaires, l’installateur demande :
+
+```
+Would you like to install from a custom source (Git URL or local path)?
+```
+
+Sélectionnez **Yes**, puis indiquez une source :
+
+| Type d’entrée             | Exemple                                           |
+| ------------------------- | ------------------------------------------------- |
+| URL HTTPS (tout hôte)     | `https://github.com/org/repo`                     |
+| URL HTTP (tout hôte)      | `http://host/org/repo`                            |
+| URL HTTPS avec sous-rép.  | `https://github.com/org/repo/tree/main/my-module` |
+| URL SSH                   | `git@github.com:org/repo.git`                     |
+| Chemin local              | `/Users/me/projects/my-module`                    |
+| Chemin local avec tilde   | `~/projects/my-module`                            |
+
+L’installateur clone le dépôt (pour les URL) ou lit directement depuis le disque (pour les chemins locaux), puis présente les modules découverts pour la sélection.
+
+### Installation non interactive
+
+Utilisez l’option `--custom-source` pour installer des modules personnalisés depuis la ligne de commande :
+
+```bash
+npx bmad-method install \
+  --directory . \
+  --custom-source /path/to/my-module \
+  --tools claude-code \
+  --yes
+```
+
+Quand `--custom-source` est fourni sans `--modules`, seuls le cœur et les modules personnalisés sont installés. Pour inclure également les modules officiels, ajoutez `--modules` :
+
+```bash
+npx bmad-method install \
+  --directory . \
+  --modules bmm \
+  --custom-source https://gitlab.com/myorg/my-module \
+  --tools claude-code \
+  --yes
+```
+
+Plusieurs sources peuvent être séparées par des virgules :
+
+```bash
+--custom-source /path/one,https://github.com/org/repo,/path/two
+```
+
+## Fonctionnement de la découverte de modules
+
+L’installateur utilise deux modes pour trouver les modules installables dans une source :
+
+| Mode       | Déclencheur                                          | Comportement                                                                                                     |
+|------------|------------------------------------------------------|------------------------------------------------------------------------------------------------------------------|
+| Découverte | La source contient `.claude-plugin/marketplace.json` | Liste tous les plugins du manifeste ; vous choisissez lesquels installer                                         |
+| Direct     | Aucun `marketplace.json` trouvé                      | Analyse le répertoire pour trouver des skills (sous-répertoires avec `SKILL.md`), les résout en un module unique |
+
+Le mode découverte est typique des modules publiés. Le mode direct est pratique pour pointer vers un répertoire de skills pendant le développement local.
+
+:::note[À propos de `.claude-plugin/`]
+Le chemin `.claude-plugin/marketplace.json` est une convention standard adoptée par plusieurs installateurs d’outils IA pour la découvabilité des plugins. Il ne nécessite pas Claude, n’utilise pas les API Claude et n’a aucun impact sur l’outil d’IA que vous utilisez. Tout module contenant ce fichier peut être découvert par tout installateur suivant cette convention.
+:::
+
+## Flux de travail en développement local
+
+Si vous construisez un module avec [BMad Builder](https://github.com/bmad-code-org/bmad-builder), vous pouvez l’installer directement depuis votre répertoire de travail :
+
+```bash
+npx bmad-method install \
+  --directory ~/my-project \
+  --custom-source ~/my-module-repo/skills \
+  --tools claude-code \
+  --yes
+```
+
+Les sources locales sont référencées par leur chemin, non copiées dans un cache. Lorsque vous mettez à jour la source de votre module et réinstallez, l’installateur récupère les dernières modifications.
+
+:::caution[Suppression de la source]
+Si vous supprimez le répertoire source local après l’installation, les fichiers du module installé dans `_bmad/` sont préservés. Le module sera ignoré lors des mises à jour tant que le chemin source n’est pas restauré.
+:::
+
+## Ce que vous obtenez
+
+Après l’installation, les modules personnalisés apparaissent dans `_bmad/` aux côtés des modules officiels :
+
+```
+your-project/
+├── _bmad/
+│   ├── core/              # Module cœur intégré
+│   ├── bmm/               # Module officiel (si sélectionné)
+│   ├── my-module/         # Votre module personnalisé
+│   │   ├── my-skill/
+│   │   │   └── SKILL.md
+│   │   └── module-help.csv
+│   └── _config/
+│       └── manifest.yaml  # Suit tous les modules, versions et sources
+└── ...
+```
+
+Le manifeste enregistre la source de chaque module personnalisé (`repoUrl` pour les sources Git, `localPath` pour les sources locales) afin que les mises à jour rapides puissent localiser la source à nouveau.
+
+## Mettre à jour les modules personnalisés
+
+Les modules personnalisés participent au flux de mise à jour normal :
+
+- **Mise à jour rapide** (`--action quick-update`) : Rafraîchit tous les modules depuis leurs sources d’origine. Les modules Git sont re-téléchargés ; les modules locaux sont relus depuis leur chemin source.
+- **Mise à jour complète** : Relance la sélection de modules pour que vous puissiez ajouter ou retirer des modules personnalisés.
+
+## Créer vos propres modules
+
+Utilisez [BMad Builder](https://github.com/bmad-code-org/bmad-builder) pour créer des modules que d’autres pourront installer :
+
+1. Exécutez `bmad-module-builder` pour générer la structure de votre module
+2. Ajoutez des skills, agents et workflows avec les divers outils BMad Builder
+3. Publiez dans un dépôt Git ou partagez le dossier
+4. D’autres installent avec `--custom-source <url-de-votre-dépôt>`
+
+Pour que les modules supportent le mode découverte, incluez un fichier `.claude-plugin/marketplace.json` à la racine de votre dépôt (c’est une convention multi-outils, pas spécifique à Claude). Consultez la [documentation BMad Builder](https://github.com/bmad-code-org/bmad-builder) pour le format du fichier `marketplace.json`.
+
+:::tip[Tester localement d’abord]
+Pendant le développement, installez votre module avec un chemin local pour itérer rapidement avant de publier dans un dépôt Git.
+:::

docs/fr/how-to/non-interactive-installation.md

@@ -1,165 +1,10 @@
 ---
 title: Installation non-interactive
-description: Installer BMad en utilisant des options de ligne de commande pour les pipelines CI/CD et les déploiements automatisés
+description: La documentation sur les installations headless / CI a été déplacée
 sidebar:
   order: 2
 ---
 
-Utilisez les options de ligne de commande pour installer BMad de manière non-interactive. Cela est utile pour :
+:::note[Cette page a été déplacée]
-
+Les flags d’installation headless et CI, la sélection de canal et l’épinglage de version se trouvent désormais dans le guide unifié [Comment installer BMad](./install-bmad.md). Consultez la section [Installations CI non interactives](./install-bmad.md#installations-ci-non-interactives) pour la référence des flags et les exemples prêts à copier-coller.
-## Quand utiliser cette méthode
-
-- Déploiements automatisés et pipelines CI/CD
-- Installations scriptées
-- Installations par lots sur plusieurs projets
-- Installations rapides avec des configurations connues
-
-:::note[Prérequis]
-Nécessite [Node.js](https://nodejs.org) v20.12+ et `npx` (inclus avec npm).
-:::
-
-## Options disponibles
-
-### Options d'installation
-
-| Option | Description | Exemple |
-|------|-------------|---------|
-| `--directory <chemin>` | Répertoire d'installation | `--directory ~/projects/myapp` |
-| `--modules <modules>` | IDs de modules séparés par des virgules | `--modules bmm,bmb` |
-| `--tools <outils>` | IDs d'outils/IDE séparés par des virgules (utilisez `none` pour ignorer) | `--tools claude-code,cursor` ou `--tools none` |
-| `--action <type>` | Action pour les installations existantes : `install` (par défaut), `update`, ou `quick-update` | `--action quick-update` |
-
-### Configuration principale
-
-| Option | Description | Par défaut |
-|------|-------------|---------|
-| `--user-name <nom>` | Nom à utiliser par les agents | Nom d'utilisateur système |
-| `--communication-language <langue>` | Langue de communication des agents | Anglais |
-| `--document-output-language <langue>` | Langue de sortie des documents | Anglais |
-| `--output-folder <chemin>` | Chemin du dossier de sortie (voir les règles de résolution ci-dessous) | `_bmad-output` |
-
-#### Résolution du chemin du dossier de sortie
-
-La valeur passée à `--output-folder` (ou saisie de manière interactive) est résolue selon ces règles :
-
-| Type d'entrée                 | Exemple                    | Résolu comme                                                 |
-|-------------------------------|----------------------------|--------------------------------------------------------------|
-| Chemin relatif (par défaut)   | `_bmad-output`             | `<racine-du-projet>/_bmad-output`                            |
-| Chemin relatif avec traversée | `../../shared-outputs`     | Chemin absolu normalisé — ex. `/Users/me/shared-outputs`     |
-| Chemin absolu                 | `/Users/me/shared-outputs` | Utilisé tel quel — la racine du projet n'est **pas** ajoutée |
-
-Le chemin résolu est ce que les agents et les workflows vont utiliser lors de l'écriture des fichiers de sortie. L'utilisation d'un chemin absolu ou d'un chemin relatif avec traversée vous permet de diriger tous les artefacts générés vers un répertoire en dehors de l'arborescence de votre projet — utile pour les configurations partagées ou les monorepos.
-
-### Autres options
-
-| Option | Description |
-|------|-------------|
-| `-y, --yes` | Accepter tous les paramètres par défaut et ignorer les invites |
-| `-d, --debug` | Activer la sortie de débogage pour la génération du manifeste |
-
-## IDs de modules
-
-IDs de modules disponibles pour l’option `--modules` :
-
-- `bmm` — méthode BMad Master
-- `bmb` — BMad Builder
-
-Consultez le [registre BMad](https://github.com/bmad-code-org) pour les modules externes disponibles.
-
-## IDs d'outils/IDE
-
-IDs d'outils disponibles pour l’option `--tools` :
-
-**Recommandés :** `claude-code`, `cursor`
-
-Exécutez `npx bmad-method install` de manière interactive une fois pour voir la liste complète actuelle des outils pris en charge, ou consultez la [configuration des codes de la plateforme](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/installer/ide/platform-codes.yaml).
-
-## Modes d'installation
-
-| Mode | Description | Exemple |
-|------|-------------|---------|
-| Entièrement non-interactif | Fournir toutes les options pour ignorer toutes les invites | `npx bmad-method install --directory . --modules bmm --tools claude-code --yes` |
-| Semi-interactif | Fournir certains options ; BMad demande les autres | `npx bmad-method install --directory . --modules bmm` |
-| Paramètres par défaut uniquement | Accepter tous les paramètres par défaut avec `-y` | `npx bmad-method install --yes` |
-| Sans outils | Ignorer la configuration des outils/IDE | `npx bmad-method install --modules bmm --tools none` |
-
-## Exemples
-
-### Installation dans un pipeline CI/CD
-
-```bash
-#!/bin/bash
-# install-bmad.sh
-
-npx bmad-method install \
-  --directory "${GITHUB_WORKSPACE}" \
-  --modules bmm \
-  --tools claude-code \
-  --user-name "CI Bot" \
-  --communication-language Français \
-  --document-output-language Français \
-  --output-folder _bmad-output \
-  --yes
-```
-
-### Mettre à jour une installation existante
-
-```bash
-npx bmad-method install \
-  --directory ~/projects/myapp \
-  --action update \
-  --modules bmm,bmb,custom-module
-```
-
-### Mise à jour rapide (conserver les paramètres)
-
-```bash
-npx bmad-method install \
-  --directory ~/projects/myapp \
-  --action quick-update
-```
-
-## Ce que vous obtenez
-
-- Un répertoire `_bmad/` entièrement configuré dans votre projet
-- Des agents et des flux de travail configurés pour vos modules et outils sélectionnés
-- Un dossier `_bmad-output/` pour les artefacts générés
-
-## Validation et gestion des erreurs
-
-BMad valide toutes les options fournis :
-
-- **Directory** — Doit être un chemin valide avec des permissions d'écriture
-- **Modules** — Avertit des IDs de modules invalides (mais n'échoue pas)
-- **Tools** — Avertit des IDs d'outils invalides (mais n'échoue pas)
-- **Action** — Doit être l'une des suivantes : `install`, `update`, `quick-update`
-
-Les valeurs invalides entraîneront soit :
-1. L’affichage d’un message d'erreur suivi d’un exit (pour les options critiques comme le répertoire)
-2. Un avertissement puis la continuation de l’installation (pour les éléments optionnels)
-3. Un retour aux invites interactives (pour les valeurs requises manquantes)
-
-:::tip[Bonnes pratiques]
-- Utilisez des chemins absolus pour `--directory` pour éviter toute ambiguïté
-- Utilisez un chemin absolu pour `--output-folder` lorsque vous souhaitez que les artefacts soient écrits en dehors de l'arborescence du projet (ex. un répertoire de sorties partagé dans un monorepo)
-- Testez les options localement avant de les utiliser dans des pipelines CI/CD
-- Combinez avec `-y` pour des installations vraiment sans surveillance
-- Utilisez `--debug` si vous rencontrez des problèmes lors de l'installation
-:::
-
-## Résolution des problèmes
-
-### L'installation échoue avec "Invalid directory"
-
-- Le chemin du répertoire doit exister (ou son parent doit exister)
-- Vous avez besoin des permissions d'écriture
-- Le chemin doit être absolu ou correctement relatif au répertoire actuel
-
-### Module non trouvé
-
-- Vérifiez que l'ID du module est correct
-- Les modules externes doivent être disponibles dans le registre
-
-:::note[Toujours bloqué ?]
-Exécutez avec `--debug` pour une sortie détaillée, essayez le mode interactif pour isoler le problème, ou signalez-le à <https://github.com/bmad-code-org/BMAD-METHOD/issues>.
 :::

docs/fr/how-to/project-context.md

@@ -2,10 +2,10 @@
 title: "Gérer le contexte du projet"
 description: Créer et maintenir project-context.md pour guider les agents IA
 sidebar:
-  order: 8
+  order: 9
 ---
 
-Utilisez le fichier `project-context.md` pour garantir que les agents IA respectent les préférences techniques et les règles d'implémentation de votre projet tout au long des workflows. Pour vous assurer qu'il est toujours disponible, vous pouvez également ajouter la ligne `Le contexte et les conventions importantes du projet se trouvent dans [chemin vers le contexte du projet]/project-context.md` à votre fichier de contexte ou de règles permanentes (comme `AGENTS.md`).
+Utilisez le fichier `project-context.md` pour garantir que les agents IA respectent les préférences techniques et les règles d’implémentation de votre projet tout au long des workflows. Pour vous assurer qu’il est toujours disponible, vous pouvez également ajouter la ligne `Le contexte et les conventions importantes du projet se trouvent dans [chemin vers le contexte du projet]/project-context.md` à votre fichier de contexte ou de règles permanentes (comme `AGENTS.md`).
 
 :::note[Prérequis]
 - Méthode BMad installée
@@ -14,31 +14,31 @@ Utilisez le fichier `project-context.md` pour garantir que les agents IA respect
 
 ## Quand utiliser cette fonctionnalité
 
-- Vous avez des préférences techniques fortes avant de commencer l'architecture
+- Vous avez des préférences techniques fortes avant de commencer l’architecture
-- Vous avez terminé l'architecture et souhaitez consigner les décisions pour l'implémentation
+- Vous avez terminé l’architecture et souhaitez consigner les décisions pour l’implémentation
 - Vous travaillez sur une base de code existante avec des patterns établis
 - Vous remarquez que les agents prennent des décisions incohérentes entre les stories
 
-## Étape 1 : Choisissez votre approche
+## Étape 1 : Choisissez votre approche
 
 **Création manuelle** — Idéal lorsque vous savez exactement quelles règles vous souhaitez documenter
 
-**Génération après l'architecture** — Idéal pour capturer les décisions prises lors du solutioning
+**Génération après l’architecture** — Idéal pour capturer les décisions prises lors du solutioning
 
 **Génération pour les projets existants** — Idéal pour découvrir les patterns dans les bases de code existantes
 
-## Étape 2 : Créez le fichier
+## Étape 2 : Créez le fichier
 
-### Option A : Création manuelle
+### Option A : Création manuelle
 
-Créez le fichier à l'emplacement `_bmad-output/project-context.md` :
+Créez le fichier à l’emplacement `_bmad-output/project-context.md` :
 
 ```bash
 mkdir -p _bmad-output
 touch _bmad-output/project-context.md
 ```
 
-Ajoutez votre pile technologique et vos règles d'implémentation :
+Ajoutez votre pile technologique et vos règles d’implémentation :
 
 ```markdown
 ---
@@ -72,7 +72,7 @@ sections_completed: ['technology_stack', 'critical_rules']
 - Tests d'intégration utilisent MSW pour le mock API
 ```
 
-### Option B : Génération après l'architecture
+### Option B : Génération après l’architecture
 
 Exécutez le workflow dans une nouvelle conversation :
 
@@ -80,9 +80,9 @@ Exécutez le workflow dans une nouvelle conversation :
 bmad-generate-project-context
 ```
 
-Le workflow analyse votre document d'architecture et vos fichiers projet pour générer un fichier de contexte qui capture les décisions prises.
+Le workflow analyse votre document d’architecture et vos fichiers projet pour générer un fichier de contexte qui capture les décisions prises.
 
-### Option C : Génération pour les projets existants
+### Option C : Génération pour les projets existants
 
 Pour les projets existants, exécutez :
 
@@ -92,9 +92,9 @@ bmad-generate-project-context
 
 Le workflow analyse votre base de code pour identifier les conventions, puis génère un fichier de contexte que vous pouvez réviser et affiner.
 
-## Étape 3 : Vérifiez le contenu
+## Étape 3 : Vérifiez le contenu
 
-Révisez le fichier généré et assurez-vous qu'il capture :
+Révisez le fichier généré et assurez-vous qu’il capture :
 
 - Les versions correctes des technologies
 - Vos conventions réelles (pas les bonnes pratiques génériques)
@@ -109,15 +109,15 @@ Un fichier `project-context.md` qui :
 
 - Garantit que tous les agents suivent les mêmes conventions
 - Évite les décisions incohérentes entre les stories
-- Capture les décisions d'architecture pour l'implémentation
+- Capture les décisions d’architecture pour l’implémentation
 - Sert de référence pour les patterns et règles de votre projet
 
 ## Conseils
 
 :::tip[Bonnes pratiques]
-- **Concentrez-vous sur ce qui n'est pas évident** — Documentez les patterns que les agents pourraient manquer (par ex. « Utiliser JSDoc sur chaque classe publique »), et non les pratiques universelles comme « utiliser des noms de variables significatifs ».
+- **Concentrez-vous sur ce qui n’est pas évident** — Documentez les patterns que les agents pourraient manquer (par ex. « Utiliser JSDoc sur chaque classe publique »), et non les pratiques universelles comme « utiliser des noms de variables significatifs ».
-- **Gardez-le concis** — Ce fichier est chargé par chaque workflow d'implémentation. Les fichiers longs gaspillent le contexte. Excluez le contenu qui ne s'applique qu'à un périmètre restreint ou à des stories spécifiques.
+- **Gardez-le concis** — Ce fichier est chargé par chaque workflow d’implémentation. Les fichiers longs gaspillent le contexte. Excluez le contenu qui ne s’applique qu’à un périmètre restreint ou à des stories spécifiques.
-- **Mettez à jour si nécessaire** — Modifiez manuellement lorsque les patterns changent, ou régénérez après des changements d'architecture significatifs.
+- **Mettez à jour si nécessaire** — Modifiez manuellement lorsque les patterns changent, ou régénérez après des changements d’architecture significatifs.
 - Fonctionne aussi bien pour Quick Dev que pour les projets complets méthode BMad.
 :::
 

docs/fr/how-to/quick-fixes.md

@@ -2,7 +2,7 @@
 title: "Corrections Rapides"
 description: Comment effectuer des corrections rapides et des modifications ciblées
 sidebar:
-  order: 5
+  order: 6
 ---
 
 Utilisez **Quick Dev** pour les corrections de bugs, les refactorisations ou les petites modifications ciblées qui ne nécessitent pas la méthode BMad complète.
@@ -23,11 +23,11 @@ Utilisez **Quick Dev** pour les corrections de bugs, les refactorisations ou les
 
 ### 1. Démarrer une Nouvelle Conversation
 
-Ouvrez une **nouvelle conversation** dans votre IDE IA. Réutiliser une session d'un workflow précédent peut causer des conflits de contexte.
+Ouvrez une **nouvelle conversation** dans votre IDE IA. Réutiliser une session d’un workflow précédent peut causer des conflits de contexte.
 
 ### 2. Spécifiez Votre Intention
 
-Quick Dev accepte l'intention en forme libre — avant, avec, ou après l'invocation. Exemples :
+Quick Dev accepte l’intention en forme libre — avant, avec, ou après l’invocation. Exemples :
 
 ```text
 quick-dev — Corrige le bug de validation de connexion qui permet les mots de passe vides.
@@ -52,18 +52,18 @@ quick-dev
 Refactoriser UserService pour utiliser async/await au lieu des callbacks.
 ```
 
-Texte brut, chemins de fichiers, URLs d'issues GitHub, liens de trackers de bugs — tout ce que le LLM peut résoudre en une intention concrète.
+Texte brut, chemins de fichiers, URLs d’issues GitHub, liens de trackers de bugs — tout ce que le LLM peut résoudre en une intention concrète.
 
 ### 3. Répondre aux Questions et Approuver
 
-Quick Dev peut poser des questions de clarification ou présenter une courte spécification demandant votre approbation avant l'implémentation. Répondez à ses questions et approuvez lorsque vous êtes satisfait du plan.
+Quick Dev peut poser des questions de clarification ou présenter une courte spécification demandant votre approbation avant l’implémentation. Répondez à ses questions et approuvez lorsque vous êtes satisfait du plan.
 
 ### 4. Réviser et Pousser
 
-Quick Dev implémente la modification, révise son propre travail, corrige les problèmes et effectue un commit local. Lorsqu'il a terminé, il ouvre les fichiers affectés dans votre éditeur.
+Quick Dev implémente la modification, révise son propre travail, corrige les problèmes et effectue un commit local. Lorsqu’il a terminé, il ouvre les fichiers affectés dans votre éditeur.
 
 - Parcourez le diff pour confirmer que la modification correspond à votre intention
-- Si quelque chose semble incorrect, dites à l'agent ce qu'il faut corriger — il peut itérer dans la même session
+- Si quelque chose semble incorrect, dites à l’agent ce qu’il faut corriger — il peut itérer dans la même session
 
 Une fois satisfait, poussez le commit. Quick Dev vous proposera de pousser et de créer une PR pour vous.
 
@@ -79,20 +79,20 @@ Si une modification poussée cause des problèmes inattendus, utilisez `git reve
 
 ## Travail Différé
 
-Quick Dev garde chaque exécution concentrée sur un seul objectif. Si votre demande contient plusieurs objectifs indépendants, ou si la revue remonte des problèmes préexistants non liés à votre modification, Quick Dev les diffère vers un fichier (`deferred-work.md` dans votre répertoire d'artefacts d'implémentation) plutôt que d'essayer de tout régler en même temps.
+Quick Dev garde chaque exécution concentrée sur un seul objectif. Si votre demande contient plusieurs objectifs indépendants, ou si la revue remonte des problèmes préexistants non liés à votre modification, Quick Dev les diffère vers un fichier (`deferred-work.md` dans votre répertoire d’artefacts d’implémentation) plutôt que d’essayer de tout régler en même temps.
 
-Consultez ce fichier après une exécution — c'est votre backlog[^1] de choses sur lesquelles revenir. Chaque élément différé peut être introduit dans une nouvelle exécution Quick Dev ultérieurement.
+Consultez ce fichier après une exécution — c’est votre backlog[^1] de choses sur lesquelles revenir. Chaque élément différé peut être introduit dans une nouvelle exécution Quick Dev ultérieurement.
 
 ## Quand Passer à une Planification Formelle
 
-Envisagez d'utiliser la méthode BMad complète lorsque :
+Envisagez d’utiliser la méthode BMad complète lorsque :
 
 - La modification affecte plusieurs systèmes ou nécessite des mises à jour coordonnées dans de nombreux fichiers
-- Vous n'êtes pas sûr de la portée et avez besoin d'une découverte des exigences d'abord
+- Vous n’êtes pas sûr de la portée et avez besoin d’une découverte des exigences d’abord
-- Vous avez besoin de documentation ou de décisions architecturales enregistrées pour l'équipe
+- Vous avez besoin de documentation ou de décisions architecturales enregistrées pour l’équipe
 
-Voir [Quick Dev](../explanation/quick-dev.md) pour plus d'informations sur la façon dont Quick Dev s'intègre dans la méthode BMad.
+Voir [Quick Dev](../explanation/quick-dev.md) pour plus d’informations sur la façon dont Quick Dev s’intègre dans la méthode BMad.
 
 ## Glossaire
 
-[^1]: Backlog : liste priorisée de tâches ou d'éléments de travail à traiter ultérieurement, issue des méthodologies agiles.
+[^1]: Backlog : liste priorisée de tâches ou d’éléments de travail à traiter ultérieurement, issue des méthodologies agiles.

docs/fr/how-to/shard-large-documents.md

@@ -2,20 +2,20 @@
 title: "Guide de Division de Documents"
 description: Diviser les fichiers markdown volumineux en fichiers plus petits et organisés pour une meilleure gestion du contexte
 sidebar:
-  order: 9
+  order: 10
 ---
 
-Utilisez l'outil `bmad-shard-doc` si vous avez besoin de diviser des fichiers markdown volumineux en fichiers plus petits et organisés pour une meilleure gestion du contexte.
+Utilisez l’outil `bmad-shard-doc` si vous avez besoin de diviser des fichiers markdown volumineux en fichiers plus petits et organisés pour une meilleure gestion du contexte.
 
 :::caution[Déprécié]
-Ceci n'est plus recommandé, et bientôt avec les workflows mis à jour et la plupart des LLM et outils majeurs supportant les sous-processus, cela deviendra inutile.
+Ceci n’est plus recommandé, et bientôt avec les workflows mis à jour et la plupart des LLM et outils majeurs supportant les sous-processus, cela deviendra inutile.
 :::
 
 ## Quand l’Utiliser
 
-Utilisez ceci uniquement si vous remarquez que votre combinaison outil / modèle ne parvient pas à charger et lire tous les documents en entrée lorsque c'est nécessaire.
+Utilisez ceci uniquement si vous remarquez que votre combinaison outil / modèle ne parvient pas à charger et lire tous les documents en entrée lorsque c’est nécessaire.
 
-## Qu'est-ce que la Division de Documents ?
+## Qu’est-ce que la Division de Documents ?
 
 La division de documents divise les fichiers markdown volumineux en fichiers plus petits et organisés basés sur les titres de niveau 2 (`## Titre`).
 
@@ -38,7 +38,7 @@ _bmad-output/planning-artifacts/
 
 ## Étapes
 
-### 1. Exécuter l'Outil Shard-Doc
+### 1. Exécuter l’Outil Shard-Doc
 
 ```bash
 /bmad-shard-doc
@@ -64,7 +64,7 @@ Agent : Division de PRD.md...
 
 Les workflows BMad utilisent un **système de découverte double** :
 
-1. **Essaye d'abord le document entier** - Rechercher `document-name.md`
+1. **Essaye d’abord le document entier** - Rechercher `document-name.md`
 2. **Vérifie la version divisée** - Rechercher `document-name/index.md`
 3. **Règle de priorité** - Le document entier a la priorité si les deux existent - supprimez le document entier si vous souhaitez que la version divisée soit utilisée à la place
 
@@ -75,4 +75,4 @@ Tous les workflows BMM prennent en charge les deux formats :
 - Documents entiers
 - Documents divisés
 - Détection automatique
-- Transparent pour l'utilisateur
+- Transparent pour l’utilisateur

docs/fr/how-to/upgrade-to-v6.md

@@ -2,10 +2,10 @@
 title: "Comment passer à la v6"
 description: Migrer de BMad v4 vers v6
 sidebar:
-  order: 3
+  order: 4
 ---
 
-Utilisez l'installateur BMad pour passer de la v4 à la v6, qui inclut une détection automatique des installations existantes et une assistance à la migration.
+Utilisez l’installateur BMad pour passer de la v4 à la v6, qui inclut une détection automatique des installations existantes et une assistance à la migration.
 
 ## Quand utiliser ce guide
 
@@ -20,22 +20,22 @@ Utilisez l'installateur BMad pour passer de la v4 à la v6, qui inclut une déte
 
 ## Étapes
 
-### 1. Lancer l'installateur
+### 1. Lancer l’installateur
 
-Suivez les [Instructions d'installation](./install-bmad.md).
+Suivez les [Instructions d’installation](./install-bmad.md).
 
-### 2. Gérer l'installation existante
+### 2. Gérer l’installation existante
 
 Quand v4 est détecté, vous pouvez :
 
-- Autoriser l'installateur à sauvegarder et supprimer `.bmad-method`
+- Autoriser l’installateur à sauvegarder et supprimer `.bmad-method`
 - Quitter et gérer le nettoyage manuellement
 
-Si vous avez nommé votre dossier de méthode bmad autrement, vous devrez supprimer le dossier vous-même manuellement.
+Si votre dossier de méthode BMad porte un nom différent, vous devrez le supprimer manuellement.
 
 ### 3. Nettoyer les skills IDE
 
-Supprimez manuellement les commandes/skills IDE v4 existants - par exemple si vous avez Claude Code, recherchez tous les dossiers imbriqués qui commencent par bmad et supprimez-les :
+Supprimez manuellement les commandes/skills IDE v4 existants - par exemple si vous utilisez Claude Code, recherchez tous les dossiers imbriqués qui commencent par bmad et supprimez-les :
 
 - `.claude/commands/`
 
@@ -45,28 +45,28 @@ Les nouveaux skills v6 sont installés dans :
 
 ### 4. Migrer les artefacts de planification
 
-**Si vous avez des documents de planification (Brief/PRD/UX/Architecture) :**
+**Si vous avez des documents de planification (Brief/PRD/UX/Architecture) :**
 
 Déplacez-les dans `_bmad-output/planning-artifacts/` avec des noms descriptifs :
 
 - Incluez `PRD` dans le nom de fichier pour les documents PRD[^1]
 - Incluez `brief`, `architecture`, ou `ux-design` selon le cas
-- Les documents divisés peuvent être dans des sous-dossiers nommés
+- Les documents divisés peuvent être dans des sous-dossiers au nom descriptif
 
-**Si vous êtes en cours de planification :** Envisagez de redémarrer avec les workflows v6. Utilisez vos documents existants comme entrées - les nouveaux workflows de découverte progressive avec recherche web et mode plan IDE produisent de meilleurs résultats.
+**Si vous êtes en cours de planification :** Envisagez de recommencer avec les workflows v6. Utilisez vos documents existants comme entrées — les nouveaux workflows de découverte progressive avec recherche web et le mode plan de l’IDE produisent de meilleurs résultats.
 
 ### 5. Migrer le développement en cours
 
 Si vous avez des stories[^3] créées ou implémentées :
 
-1. Terminez l'installation v6
+1. Terminez l’installation v6
 2. Placez `epics.md` ou `epics/epic*.md`[^2] dans `_bmad-output/planning-artifacts/`
 3. Lancez le workflow Développeur `bmad-sprint-planning`[^4]
 4. Indiquez à l’agent quels epics/stories sont déjà terminés
 
-## Ce que vous obtenez
+## Résultat de la migration
 
-**Structure unifiée v6 :**
+**Structure unifiée v6 :**
 
 ```text
 votre-projet/
@@ -77,30 +77,31 @@ votre-projet/
 │   ├── bmm/             # Module BMad Method
 │   ├── bmb/             # BMad Builder
 │   └── cis/             # Creative Intelligence Suite
-└── _bmad-output/        # Dossier de sortie (était le dossier doc en v4)
+└── _bmad-output/        # Dossier de sortie (remplace le dossier doc de la v4)
 ```
 
 ## Migration des modules
 
-| Module v4                     | Statut v6                                 |
+| Module v4                     | Statut v6                                         |
-| ----------------------------- | ----------------------------------------- |
+|-------------------------------|---------------------------------------------------|
-| `.bmad-2d-phaser-game-dev`    | Intégré dans le Module BMGD               |
+| `.bmad-2d-phaser-game-dev`    | Intégré dans le Module BMGD                       |
-| `.bmad-2d-unity-game-dev`     | Intégré dans le Module BMGD               |
+| `.bmad-2d-unity-game-dev`     | Intégré dans le Module BMGD                       |
-| `.bmad-godot-game-dev`        | Intégré dans le Module BMGD               |
+| `.bmad-godot-game-dev`        | Intégré dans le Module BMGD                       |
-| `.bmad-infrastructure-devops` | Déprécié - nouvel agent DevOps bientôt disponible |
+| `.bmad-infrastructure-devops` | Obsolète — nouvel agent DevOps bientôt disponible |
-| `.bmad-creative-writing`      | Non adapté - nouveau module v6 bientôt disponible   |
+| `.bmad-creative-writing`      | Non migré — nouveau module v6 bientôt disponible  |
 
 ## Changements clés
 
-| Concept       | v4                                    | v6                                   |
+| Concept       | v4                                                      | v6                                       |
-| ------------- | ------------------------------------- | ------------------------------------ |
+|---------------|---------------------------------------------------------|------------------------------------------|
-| **Core**      | `_bmad-core` était en fait la méthode BMad | `_bmad/core/` est le framework universel |
+| **Core**      | `_bmad-core` correspondait en réalité à la méthode BMad | `_bmad/core/` est le framework universel |
-| **Method**    | `_bmad-method`                        | `_bmad/bmm/`                         |
+| **Method**    | `_bmad-method`                                          | `_bmad/bmm/`                             |
-| **Config**    | Fichiers modifiés directement         | `config.yaml` par module             |
+| **Config**    | Fichiers modifiés directement                           | `config.yaml` par module                 |
-| **Documents** | Division ou non division requise | Entièrement flexible, scan automatique         |
+| **Documents** | Division en fragments obligatoire ou optionnelle        | Totalement flexible, analyse automatique |
+
 
 ## Glossaire
-[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
+[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
 [^2]: Epic : dans les méthodologies agiles, une grande unité de travail qui peut être décomposée en plusieurs stories. Un epic représente généralement une fonctionnalité majeure ou un ensemble de capacités livrable sur plusieurs sprints.
-[^3]: Story (User Story) : une description courte et simple d'une fonctionnalité du point de vue de l'utilisateur. Les stories sont des unités de travail suffisamment petites pour être complétées en un sprint.
+[^3]: Story (User Story) : une description courte et simple d’une fonctionnalité du point de vue de l’utilisateur. Les stories sont des unités de travail suffisamment petites pour être complétées en un sprint.
-[^4]: Sprint : dans Scrum, une période de temps fixe (généralement 1 à 4 semaines) pendant laquelle l'équipe travaille à livrer un incrément de produit potentiellement libérable.
+[^4]: Sprint : dans Scrum, une période de temps fixe (généralement 1 à 4 semaines) pendant laquelle l’équipe travaille à livrer un incrément de produit potentiellement libérable.

docs/fr/how-to/use-web-bundles.md

@@ -0,0 +1,41 @@
+---
+title: 'Utiliser les Web Bundles'
+description: Installer un web bundle BMad comme Google Gemini Gem ou ChatGPT Custom GPT
+---
+
+Les web bundles s’installent depuis **[bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/)**.
+
+## Pourquoi une seule porte d’entrée
+
+Le site est le seul chemin d’installation pris en charge pour la bibliothèque. Il maintient les étapes à jour au fil de l’évolution de Gemini et ChatGPT, pointe toujours vers la dernière version taguée, et une seule inscription suffit pour être notifié des nouveaux bundles dès leur parution.
+
+## Ce que vous ferez sur le site
+
+1. Choisissez un bundle dans la grille de cartes.
+2. Ouvrez la modale d’installation. Basculez entre les onglets **Gemini Gem** et **ChatGPT GPT** pour les étapes spécifiques à chaque plateforme.
+3. Téléchargez le ZIP du bundle (un clic ; inscription gratuite en une étape pour les membres email uniquement).
+4. Suivez les étapes indiquées sur la page : créez le Gem ou le Custom GPT, téléversez les fichiers de connaissance, collez le bloc d’instructions, sauvegardez.
+
+## Prérequis
+
+- **Pour les Gemini Gems** : abonnement Gemini Advanced.
+- **Pour les ChatGPT Custom GPTs** : plan Plus, Pro, Business ou Enterprise.
+- Pour les bundles qui utilisent **Deep Research** (actuellement Étude de marché et analyse sectorielle), activez-le depuis la barre de prompt (Outils → Deep Research). Deep Research a ses propres limites de plan.
+
+## Personnaliser le persona
+
+Le fichier `INSTRUCTIONS.md` de chaque bundle (dans le ZIP) inclut un **exemple de substitution de persona** au-dessus du séparateur de la zone à coller. Remplacez le bloc `[persona]` dans vos instructions installées par l’exemple de substitution pour changer le persona sans modifier le protocole. Vous pouvez aussi créer votre propre persona de zéro ; le protocole reste le même.
+
+## Ce que vous obtenez
+
+- Un Gem ou Custom GPT réutilisable dédié à une capacité de planification BMad.
+- Des artefacts finalisés (briefs, PRD, rapports de recherche, spécifications UX) prêts à déposer dans votre IDE pour l’implémentation.
+- Les conversations de planification se déroulent sur votre abonnement LLM web existant au lieu de consommer des tokens IDE facturés.
+
+:::caution[Dérive du persona]
+Les LLM web abandonnent parfois le persona au cours de longues sessions. Si le modèle commence à parler hors personnage, rappelez-lui son persona ou démarrez une nouvelle session.
+:::
+
+## Créer le vôtre
+
+Pour transformer un skill BMad existant en web bundle, utilisez le skill utilitaire `bmad-os-skill-to-bundle` disponible sur [bmad-utility-skills](https://github.com/bmad-code-org/bmad-utility-skills). Il produit les fichiers du bundle en reprenant le persona hérité de l’agent d’origine et un exemple de persona alternatif. Soumettez votre bundle à la bibliothèque en ouvrant une PR sur [BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) qui ajoute le répertoire du bundle et une entrée dans `web-bundles/bundles.json`.

docs/fr/index.md

@@ -1,63 +1,63 @@
 ---
 title: Bienvenue dans la méthode BMad
-description: Framework de développement propulsé par l'IA avec des agents spécialisés, des workflows guidés et une planification intelligente
+description: Framework de développement alimenté par l’IA avec des agents spécialisés, des workflows guidés et une planification intelligente
 ---
 
-La méthode BMad (**B**uild **M**ore **A**rchitect **D**reams) est un module[^1] de développement assisté par l'IA au sein de l'écosystème BMad, conçu pour vous faciliter la création de logiciels par un processus complet, de l'idéation et de la planification jusqu'à l'implémentation agentique. Elle fournit des agents[^2] IA spécialisés, des workflows guidés et une planification intelligente qui s'adapte à la complexité de votre projet, que vous corrigiez un bug ou construisiez une plateforme d'entreprise.
+La méthode BMad (**B**uild **M**ore **A**rchitect **D**reams) est un module[^1] de développement assisté par l’IA au sein de l’écosystème BMad. Elle couvre l’intégralité du processus de création logicielle — de l’idéation et de la planification jusqu’à la mise en œuvre par des agents. BMad met à votre disposition des agents IA spécialisés[^2], des workflows guidés et une planification intelligente qui s’adapte à la complexité de votre projet, qu’il s’agisse de corriger un bug ou de bâtir une plateforme d’entreprise.
 
-Si vous êtes à l'aise avec les assistants de codage IA comme Claude, Cursor ou GitHub Copilot, vous êtes prêt à commencer.
+Si vous êtes à l’aise avec les assistants de codage IA comme Claude, Cursor ou GitHub Copilot, vous êtes prêt à commencer.
 
-:::note[🚀 La V6 est là et ce n'est que le début !]
+:::note[🚀 La V6 est là et ce n’est que le début !]
-Architecture par Skills, BMad Builder v1, automatisation Dev Loop, et bien plus encore en préparation. **[Consultez la Feuille de route →](./roadmap)**
+Architecture de Skills, BMad Builder v1, automatisation Dev Loop, et bien plus encore à venir. **[Consultez la Feuille de route →](./roadmap)**
 :::
 
-## Première visite ? Commencez par un tutoriel
+## Vous découvrez BMad ? Commencez par un tutoriel
 
-La façon la plus rapide de comprendre BMad est de l'essayer.
+La façon la plus rapide de comprendre BMad est de l’essayer.
 
-- **[Premiers pas avec BMad](./tutorials/getting-started.md)** — Installez et comprenez comment fonctionne BMad
+- **[Premiers pas avec BMad](./tutorials/getting-started.md)** — Installez BMad et découvrez son fonctionnement
-- **[Carte des workflows](./reference/workflow-map.md)** — Vue d'ensemble visuelle des phases BMM, des workflows et de la gestion du contexte
+- **[Carte des workflows](./reference/workflow-map.md)** — Vue d’ensemble visuelle des phases BMM, des workflows et de la gestion du contexte
 
-:::tip[Envie de plonger directement ?]
+:::tip[Envie de passer à la pratique ?]
-Installez BMad et utilisez le skill[^3] `bmad-help` — il vous guidera entièrement en fonction de votre projet et de vos modules installés.
+Installez BMad et utilisez le skill[^3] `bmad-help` — il vous guidera pas à pas, en fonction de votre projet et des modules installés.
 :::
 
 ## Comment utiliser cette documentation
 
-Cette documentation est organisée en quatre sections selon ce que vous essayez de faire :
+Cette documentation est organisée en quatre sections, selon votre objectif :
 
-| Section           | Objectif                                                                                                    |
+| Section              | Objectif                                                                                                                                     |
-| ----------------- | ----------------------------------------------------------------------------------------------------------- |
+|----------------------|----------------------------------------------------------------------------------------------------------------------------------------------|
-| **Tutoriels**     | Orientés apprentissage. Guides étape par étape qui vous accompagnent dans la construction de quelque chose. Commencez ici si vous êtes nouveau. |
+| **Tutoriels**        | Orientés apprentissage. Guides pas à pas pour vous accompagner dans la réalisation d’un projet. Le point de départ idéal si vous débutez.    |
-| **Guides pratiques** | Orientés tâches. Guides pratiques pour résoudre des problèmes spécifiques. « Comment personnaliser un agent ? » se trouve ici.  |
+| **Guides pratiques** | Orientés tâches. Guides concrets pour résoudre des problèmes spécifiques. Vous y trouverez par exemple « Comment personnaliser un agent ? ». |
-| **Explication**   | Orientés compréhension. Explications en profondeur des concepts et de l'architecture. À lire quand vous voulez savoir *pourquoi*.       |
+| **Explications**     | Orientés compréhension. Plongées dans les concepts et l’architecture. À consulter pour comprendre le *pourquoi*.                             |
-| **Référence**     | Orientés information. Spécifications techniques pour les agents, workflows et configuration.                   |
+| **Référence**        | Orientés information. Spécifications techniques des agents, workflows et configuration.                                                      |
 
 ## Étendre et personnaliser
 
-Vous souhaitez étendre BMad avec vos propres agents, workflows ou modules ? Le **[BMad Builder](https://bmad-builder-docs.bmad-method.org/)** fournit le framework et les outils pour créer des extensions personnalisées, que vous ajoutiez de nouvelles capacités à BMad ou que vous construisiez des modules entièrement nouveaux à partir de zéro.
+Vous souhaitez étendre BMad avec vos propres agents, workflows ou modules ? Le **[BMad Builder](https://bmad-builder-docs.bmad-method.org/)** met à votre disposition le framework et les outils nécessaires pour créer des extensions personnalisées — que ce soit pour ajouter de nouvelles capacités à BMad ou pour concevoir des modules entièrement nouveaux de zéro.
 
 ## Ce dont vous aurez besoin
 
-BMad fonctionne avec tout assistant de codage IA qui prend en charge les prompts système personnalisés ou le contexte de projet. Les options populaires incluent :
+BMad fonctionne avec tout assistant de codage IA qui prend en charge les prompts système personnalisés ou le contexte de projet. Parmi les options les plus populaires :
 
-- **[Claude Code](https://code.claude.com)** — Outil CLI d'Anthropic (recommandé)
+- **[Claude Code](https://code.claude.com)** — Outil CLI d’Anthropic (recommandé)
-- **[Cursor](https://cursor.sh)** — Éditeur de code propulsé par l'IA
+- **[Cursor](https://cursor.sh)** — Éditeur de code propulsé par l’IA
-- **[Codex CLI](https://github.com/openai/codex)** — Agent de codage terminal d'OpenAI
+- **[Codex CLI](https://github.com/openai/codex)** — Agent de codage en ligne de commande d’OpenAI
 
-Vous devriez être à l'aise avec les concepts de base du développement logiciel comme le contrôle de version, la structure de projet et les workflows agiles. Aucune expérience préalable avec les systèmes d'agent de type BMad n'est requise — c'est justement le but de cette documentation.
+Vous devriez être à l’aise avec les concepts de base du développement logiciel : gestion de versions, structure de projet et méthodologies agiles. Aucune expérience préalable des systèmes d’agents de type BMad n’est requise — c’est précisément l’objet de cette documentation.
 
 ## Rejoindre la communauté
 
-Obtenez de l'aide, partagez ce que vous construisez ou contribuez à BMad :
+Trouvez de l’aide, partagez vos projets ou contribuez à BMad :
 
-- **[Discord](https://discord.gg/gk8jAdXWmj)** — Discutez avec d'autres utilisateurs de BMad, posez des questions, partagez des idées
+- **[Discord](https://discord.gg/gk8jAdXWmj)** — Discutez avec d’autres utilisateurs de BMad, posez des questions, partagez des idées
-- **[GitHub](https://github.com/bmad-code-org/BMAD-METHOD)** — Code source, issues et contributions
+- **[GitHub](https://github.com/bmad-code-org/BMAD-METHOD)** — Code source, tickets et contributions
 - **[YouTube](https://www.youtube.com/@BMadCode)** — Tutoriels vidéo et démonstrations
 
 ## Prochaine étape
 
-Prêt à vous lancer ? **[Commencez avec BMad](./tutorials/getting-started.md)** et construisez votre premier projet.
+Prêt à vous lancer ? **[Commencez avec BMad](./tutorials/getting-started.md)** et réalisez votre premier projet.
 
 ---
 ## Glossaire
@@ -66,4 +66,4 @@ Prêt à vous lancer ? **[Commencez avec BMad](./tutorials/getting-started.md)**
 
 [^2]: **Agent** : assistant IA spécialisé avec une expertise spécifique qui guide les utilisateurs dans les workflows.
 
-[^3]: **Skill** : capacité ou fonctionnalité invoquable d'un agent pour effectuer une tâche spécifique.
+[^3]: **Skill** : capacité ou fonctionnalité invoquable d’un agent pour effectuer une tâche spécifique.

docs/fr/reference/agents.md

@@ -11,42 +11,41 @@ Cette page liste les agents BMM (suite Agile) par défaut installés avec la mé
 
 ## Notes
 
-- Chaque agent est disponible en tant que skill, généré par l’installateur. L’identifiant de skill (par exemple, `bmad-dev`) est utilisé pour invoquer l’agent.
+- Chaque agent est disponible en tant que skill, généré par l’installateur. L’identifiant de skill (par exemple, `bmad-agent-dev`) est utilisé pour invoquer l’agent.
-- Les déclencheurs sont les codes courts de menu (par exemple, `BP`) et les correspondances approximatives affichés dans chaque menu d’agent.
+- Les déclencheurs sont les codes courts affichés dans le menu de chaque agent (par exemple, `PRD`) et les correspondances approximatives présentées dans chaque menu.
-- La génération de tests QA est gérée par le skill de workflow `bmad-qa-generate-e2e-tests`, disponible par l’agent Développeur. L’architecte de tests complet (TEA) se trouve dans son propre module.
+- La génération de tests QA est gérée par le skill de workflow `bmad-qa-generate-e2e-tests`, disponible via l’agent Développeur. L’architecte de tests complet (TEA) se trouve dans son propre module.
 
-| Agent                       | Identifiant de skill | Déclencheurs                             | Workflows principaux                                                                                                                                           |
+| Agent                       | Identifiant de skill     | Déclencheurs                                   | Workflows principaux                                                                                                                                                       |
-|-----------------------------|----------------------|------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|-----------------------------|--------------------------|------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Analyste (Mary)             | `bmad-analyst`       | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP` | Brainstorming du projet, Recherche marché/domaine/technique, Création du brief[^1], Défi PRFAQ, Documentation du projet                                        |
+| Analyste (Mary)             | `bmad-agent-analyst`     | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP`       | Brainstorming, Recherche marché, Recherche domaine, Recherche technique, Création du brief[^1], Défi PRFAQ, Documentation du projet                                        |
-| Product Manager (John)      | `bmad-pm`            | `CP`, `VP`, `EP`, `CE`, `IR`, `CC`       | Créer/Valider/Éditer un PRD, Créer des Epics et Stories, vérifier l’état de préparation à l’Implémentation, Corriger le Cours                                 |
+| Product Manager (John)      | `bmad-agent-pm`          | `PRD`, `CE`, `IR`, `CC`                        | Créer, mettre à jour ou valider un PRD, Créer des Epics et Stories, vérifier l’état de préparation à l’Implémentation, Corriger le Cours                                   |
-| Architecte (Winston)        | `bmad-architect`     | `CA`, `IR`                               | Créer l’architecture, Préparation à l’implémentation                                                                                                           |
+| Architecte (Winston)        | `bmad-agent-architect`   | `CA`, `IR`                                     | Créer l’architecture, Préparation à l’implémentation                                                                                                                       |
-| Développeur (Amelia)        | `bmad-agent-dev`     | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER` | Dev Story, Quick Dev, Génération de Tests QA, Code Review, Sprint Planning, Créer Story, Rétrospective d’Epic                                                  |
+| Développeur (Amelia)        | `bmad-agent-dev`         | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER`, `IN` | Dev Story, Quick Dev, Génération de Tests QA, Code Review, Sprint Planning, Créer Story, Rétrospective d’Epic, [Enquête de code](../explanation/forensic-investigation.md) |
-| Designer UX (Sally)         | `bmad-ux-designer`   | `CU`                                     | Création du design UX[^2]                                                                                                                                      |
+| Designer UX (Sally)         | `bmad-agent-ux-designer` | `CU`                                           | Création du design UX[^2]                                                                                                                                                  |
-| Rédacteur Technique (Paige) | `bmad-tech-writer`   | `DP`, `WD`, `US`, `MG`, `VD`, `EC`       | Documentation du projet, Rédaction de documents, Mise à jour des standards, Génération de diagrammes Mermaid, Validation de documents, Explication de concepts |
+| Rédacteur Technique (Paige) | `bmad-agent-tech-writer` | `DP`, `WD`, `MG`, `VD`, `EC`                   | Documentation du projet, Rédaction de documents, Génération de diagrammes Mermaid, Validation de documents, Explication de concepts                                        |
 
 ## Types de déclencheurs
 
-Les déclencheurs de menu d'agent utilisent deux types d'invocation différents. Connaître le type utilisé par un déclencheur vous aide à fournir la bonne entrée.
+Les déclencheurs de menu d’agent utilisent deux types d’invocation différents. Connaître le type utilisé par un déclencheur vous aide à fournir la bonne entrée.
 
 ### Déclencheurs de workflow (aucun argument nécessaire)
 
-La plupart des déclencheurs chargent un fichier de workflow structuré. Tapez le code du déclencheur et l'agent démarre le workflow, vous demandant de saisir les informations à chaque étape.
+La plupart des déclencheurs chargent un fichier de workflow structuré. Tapez le code du déclencheur et l’agent démarre le workflow, vous demandant de saisir les informations à chaque étape.
 
-Exemples : `CP` (Create PRD), `DS` (Dev Story), `CA` (Create Architecture), `QD` (Quick Dev)
+Exemples : `PRD` (Créer, mettre à jour ou valider un PRD), `DS` (Dev Story), `CA` (Créer l’architecture), `QD` (Quick Dev)
 
 ### Déclencheurs conversationnels (arguments requis)
 
-Certains déclencheurs lancent une conversation libre au lieu d'un workflow structuré. Ils s'attendent à ce que vous décriviez ce dont vous avez besoin à côté du code du déclencheur.
+Certains déclencheurs lancent une conversation libre au lieu d’un workflow structuré. Ils s’attendent à ce que vous décriviez ce dont vous avez besoin à côté du code du déclencheur.
 
-| Agent | Déclencheur | Ce qu'il faut fournir |
+| Agent                       | Déclencheur | Ce qu’il faut fournir                                           |
-| --- | --- | --- |
+|-----------------------------|-------------|-----------------------------------------------------------------|
-| Rédacteur Technique (Paige) | `WD` | Description du document à rédiger |
+| Rédacteur Technique (Paige) | `WD`        | Description du document à rédiger                               |
-| Rédacteur Technique (Paige) | `US` | Préférences ou conventions à ajouter aux standards |
+| Rédacteur Technique (Paige) | `MG`        | Description et type de diagramme (séquence, organigramme, etc.) |
-| Rédacteur Technique (Paige) | `MG` | Description et type de diagramme (séquence, organigramme, etc.) |
+| Rédacteur Technique (Paige) | `VD`        | Document à valider et domaines à examiner                       |
-| Rédacteur Technique (Paige) | `VD` | Document à valider et domaines à examiner |
+| Rédacteur Technique (Paige) | `EC`        | Nom du concept à expliquer                                      |
-| Rédacteur Technique (Paige) | `EC` | Nom du concept à expliquer |
 
-**Exemple :**
+**Exemple :**
 
 ```text
 WD Rédige un guide de déploiement pour notre configuration Docker

docs/fr/reference/commands.md

@@ -1,50 +1,50 @@
 ---
 title: Skills
-description: Référence des skills BMad — ce qu'ils sont, comment ils fonctionnent et où les trouver.
+description: Référence des skills BMad — ce qu’ils sont, comment ils fonctionnent et où les trouver.
 sidebar:
   order: 4
 ---
 
-Les skills sont des prompts pré-construits qui chargent des agents, exécutent des workflows ou lancent des tâches dans votre IDE. L'installateur BMad les génère à partir de vos modules installés au moment de l'installation. Si vous ajoutez, supprimez ou modifiez des modules ultérieurement, relancez l'installateur pour garder les skills synchronisés (voir [Dépannage](#dépannage)).
+Les skills sont des prompts pré-construits qui chargent des agents, exécutent des workflows ou lancent des tâches dans votre IDE. L’installateur BMad les génère à partir de vos modules installés au moment de l’installation. Si vous ajoutez, supprimez ou modifiez des modules ultérieurement, relancez l’installateur pour garder les skills synchronisés (voir [Dépannage](#dépannage)).
 
 ## Skills vs. Déclencheurs du menu Agent
 
 BMad offre deux façons de démarrer un travail, chacune ayant un usage différent.
 
-| Mécanisme | Comment l'invoquer | Ce qui se passe |
+| Mécanisme                     | Comment l’invoquer                                            | Ce qui se passe                                                                                |
-| --- | --- | --- |
+|-------------------------------|---------------------------------------------------------------|------------------------------------------------------------------------------------------------|
-| **Skill** | Tapez le nom du skill (ex. `bmad-help`) dans votre IDE | Charge directement un agent, exécute un workflow ou lance une tâche |
+| **Skill**                     | Tapez le nom du skill (ex. `bmad-help`) dans votre IDE        | Charge directement un agent, exécute un workflow ou lance une tâche                            |
-| **Déclencheur du menu agent** | Chargez d'abord un agent, puis tapez un code court (ex. `DS`) | L'agent interprète le code et démarre le workflow correspondant tout en préservant son persona |
+| **Déclencheur du menu agent** | Chargez d’abord un agent, puis tapez un code court (ex. `DS`) | L’agent interprète le code et démarre le workflow correspondant tout en préservant son persona |
 
 Les déclencheurs du menu agent nécessitent une session agent active. Utilisez les skills lorsque vous savez quel workflow vous voulez. Utilisez les déclencheurs lorsque vous travaillez déjà avec un agent et souhaitez changer de tâche sans quitter la conversation.
 
 ## Comment les skills sont générés
 
-Lorsque vous exécutez `npx bmad-method install`, l'installateur lit les manifests de chaque module sélectionné et écrit un skill par agent, workflow, tâche et outil. Chaque skill est un répertoire contenant un fichier `SKILL.md` qui indique à l'IA de charger le fichier source correspondant et de suivre ses instructions.
+Lorsque vous exécutez `npx bmad-method install`, l’installateur lit les manifests de chaque module sélectionné et écrit un skill par agent, workflow, tâche et outil. Chaque skill est un répertoire contenant un fichier `SKILL.md` qui indique à l’IA de charger le fichier source correspondant et de suivre ses instructions.
 
-L'installateur utilise des modèles pour chaque type de skill :
+L’installateur utilise des modèles pour chaque type de skill :
 
-| Type de skill | Ce que fait le fichier généré |
+| Type de skill         | Ce que fait le fichier généré                                                  |
-| --- | --- |
+|-----------------------|--------------------------------------------------------------------------------|
-| **Lanceur d'agent** | Charge le fichier de persona de l'agent, active son menu et reste en caractère |
+| **Lanceur d’agent**   | Charge le fichier de persona de l’agent, active son menu et reste en caractère |
-| **Skill de workflow** | Charge la configuration du workflow et suit ses étapes |
+| **Skill de workflow** | Charge la configuration du workflow et suit ses étapes                         |
-| **Skill de tâche** | Charge un fichier de tâche autonome et suit ses instructions |
+| **Skill de tâche**    | Charge un fichier de tâche autonome et suit ses instructions                   |
-| **Skill d'outil** | Charge un fichier d'outil autonome et suit ses instructions |
+| **Skill d’outil**     | Charge un fichier d’outil autonome et suit ses instructions                    |
 
-:::note[Relancer l'installateur]
+:::note[Relancer l’installateur]
-Si vous ajoutez ou supprimez des modules, relancez l'installateur. Il régénère tous les fichiers de skill pour correspondre à votre sélection actuelle de modules.
+Si vous ajoutez ou supprimez des modules, relancez l’installateur. Il régénère tous les fichiers de skill pour correspondre à votre sélection actuelle de modules.
 :::
 
 ## Emplacement des fichiers de skill
 
-L'installateur écrit les fichiers de skill dans un répertoire spécifique à l'IDE à l'intérieur de votre projet. Le chemin exact dépend de l'IDE que vous avez sélectionné lors de l'installation.
+L’installateur écrit les fichiers de skill dans un répertoire spécifique à l’IDE à l’intérieur de votre projet. Le chemin exact dépend de l’IDE que vous avez sélectionné lors de l’installation.
 
-| IDE / CLI | Répertoire des skills |
+| IDE / CLI   | Répertoire des skills                                      |
-| --- | --- |
+|-------------|------------------------------------------------------------|
-| Claude Code | `.claude/skills/` |
+| Claude Code | `.claude/skills/`                                          |
-| Cursor | `.cursor/skills/` |
+| Cursor      | `.agents/skills/`                                          |
-| Windsurf | `.windsurf/skills/` |
+| Windsurf    | `.agents/skills/`                                          |
-| Autres IDE | Consultez la sortie de l'installateur pour le chemin cible |
+| Autres IDE  | Consultez la sortie de l’installateur pour le chemin cible |
 
 Chaque skill est un répertoire contenant un fichier `SKILL.md`. Par exemple, une installation Claude Code ressemble à :
 
@@ -52,7 +52,7 @@ Chaque skill est un répertoire contenant un fichier `SKILL.md`. Par exemple, un
 .claude/skills/
 ├── bmad-help/
 │   └── SKILL.md
-├── bmad-create-prd/
+├── bmad-prd/
 │   └── SKILL.md
 ├── bmad-agent-dev/
 │   └── SKILL.md
@@ -63,7 +63,7 @@ Le nom du répertoire détermine le nom du skill dans votre IDE. Par exemple, le
 
 ## Comment découvrir vos skills
 
-Tapez le nom du skill dans votre IDE pour l'invoquer. Certaines plateformes nécessitent d'activer les skills dans les paramètres avant qu'ils n'apparaissent.
+Tapez le nom du skill dans votre IDE pour l’invoquer. Certaines plateformes nécessitent d’activer les skills dans les paramètres avant qu’ils n’apparaissent.
 
 Exécutez `bmad-help` pour obtenir des conseils contextuels sur votre prochaine étape.
 
@@ -73,40 +73,40 @@ Les répertoires de skills générés dans votre projet sont la liste de référ
 
 ## Catégories de skills
 
-### Skills d'agent
+### Skills d’agent
 
-Les skills d'agent chargent un persona[^2] IA spécialisé avec un rôle défini, un style de communication et un menu de workflows. Une fois chargé, l'agent reste en caractère et répond aux déclencheurs du menu.
+Les skills d’agent chargent un persona[^2] IA spécialisé avec un rôle défini, un style de communication et un menu de workflows. Une fois chargé, l’agent reste en caractère et répond aux déclencheurs du menu.
 
-| Exemple de skill | Agent                  | Rôle                                                        |
+| Exemple de skill       | Agent                  | Rôle                                                        |
-|------------------|------------------------|-------------------------------------------------------------|
+|------------------------|------------------------|-------------------------------------------------------------|
-| `bmad-agent-dev` | Amelia (Développeur)   | Implémente les stories avec une adhérence stricte aux specs |
+| `bmad-agent-dev`       | Amelia (Développeur)   | Implémente les stories avec une adhérence stricte aux specs |
-| `bmad-pm`        | John (Product Manager) | Crée et valide les PRDs[^1]                                 |
+| `bmad-agent-pm`        | John (Product Manager) | Crée, met à jour et valide les PRDs[^1]                     |
-| `bmad-architect` | Winston (Architecte)   | Conçoit l'architecture système                              |
+| `bmad-agent-architect` | Winston (Architecte)   | Conçoit l’architecture système                              |
 
 Consultez [Agents](./agents.md) pour la liste complète des agents par défaut et leurs déclencheurs.
 
 ### Skills de workflow
 
-Les skills de workflow exécutent un processus structuré en plusieurs étapes sans charger d'abord un persona d'agent. Ils chargent une configuration de workflow et suivent ses étapes.
+Les skills de workflow exécutent un processus structuré en plusieurs étapes sans charger d’abord un persona d’agent. Ils chargent une configuration de workflow et suivent ses étapes.
 
-| Exemple de skill | Objectif |
+| Exemple de skill                | Objectif                                                                                                                     |
-| --- | --- |
+|---------------------------------|------------------------------------------------------------------------------------------------------------------------------|
-| `bmad-product-brief` | Créer un product brief[^3] — découverte guidée lorsque votre concept est clair |
+| `bmad-product-brief`            | Créer ou mettre à jour un product brief[^3] — découverte guidée lorsque votre concept est clair                              |
-| `bmad-prfaq` | Défi [PRFAQ Working Backwards](../explanation/analysis-phase.md#prfaq-working-backwards) pour éprouver votre concept produit |
+| `bmad-prfaq`                    | Défi [PRFAQ Working Backwards](../explanation/analysis-phase.md#prfaq-working-backwards) pour éprouver votre concept produit |
-| `bmad-create-prd` | Créer un PRD[^1] |
+| `bmad-prd`                      | Créer, mettre à jour ou valider un PRD[^1]                                                                                   |
-| `bmad-create-architecture` | Concevoir l'architecture système |
+| `bmad-create-architecture`      | Concevoir l’architecture système                                                                                             |
-| `bmad-create-epics-and-stories` | Créer des epics et des stories |
+| `bmad-create-epics-and-stories` | Créer des epics et des stories                                                                                               |
-| `bmad-dev-story` | Implémenter une story |
+| `bmad-dev-story`                | Implémenter une story                                                                                                        |
-| `bmad-code-review` | Effectuer une revue de code |
+| `bmad-code-review`              | Effectuer une revue de code                                                                                                  |
-| `bmad-quick-dev` | Flux rapide unifié — clarifier l'intention, planifier, implémenter, réviser, présenter |
+| `bmad-quick-dev`                | Flux rapide unifié — clarifier l’intention, planifier, implémenter, réviser, présenter                                       |
 
 Consultez la [Carte des workflows](./workflow-map.md) pour la référence complète des workflows organisés par phase.
 
-### Skills de tâche et d'outil
+### Skills de tâche et d’outil
 
-Les tâches et outils sont des opérations autonomes qui ne nécessitent pas de contexte d'agent ou de workflow.
+Les tâches et outils sont des opérations autonomes qui ne nécessitent pas de contexte d’agent ou de workflow.
 
-**BMad-Help : Votre guide intelligent**
+**BMad-Help : Votre guide intelligent**
 
 `bmad-help` est votre interface principale pour découvrir quoi faire ensuite. Il inspecte votre projet, comprend les requêtes en langage naturel et recommande la prochaine étape requise ou optionnelle en fonction de vos modules installés.
 
@@ -120,22 +120,22 @@ bmad-help Quelles sont mes options pour le design UX ?
 
 **Autres tâches et outils principaux**
 
-Le module principal inclut 11 outils intégrés — revues, compression, brainstorming, gestion de documents, et plus. Consultez [Outils principaux](./core-tools.md) pour la référence complète.
+Le module principal inclut 12 outils intégrés — specs, revues, brainstorming, personnalisation, gestion de documents, et plus. Consultez [Outils principaux](./core-tools.md) pour la référence complète.
 
 ## Convention de nommage
 
-Tous les skills utilisent le préfixe `bmad-` suivi d'un nom descriptif (ex. `bmad-agent-dev`, `bmad-create-prd`, `bmad-help`). Consultez [Modules](./modules.md) pour les modules disponibles.
+Tous les skills utilisent le préfixe `bmad-` suivi d’un nom descriptif (ex. `bmad-agent-dev`, `bmad-prd`, `bmad-help`). Consultez [Modules](./modules.md) pour les modules disponibles.
 
 ## Dépannage
 
-**Les skills n'apparaissent pas après l'installation.** Certaines plateformes nécessitent d'activer explicitement les skills dans les paramètres. Consultez la documentation de votre IDE ou demandez à votre assistant IA comment activer les skills. Vous devrez peut-être aussi redémarrer votre IDE ou recharger la fenêtre.
+**Les skills n’apparaissent pas après l’installation.** Certaines plateformes nécessitent d’activer explicitement les skills dans les paramètres. Consultez la documentation de votre IDE ou demandez à votre assistant IA comment activer les skills. Vous devrez peut-être aussi redémarrer votre IDE ou recharger la fenêtre.
 
-**Des skills attendus sont manquants.** L'installateur génère uniquement les skills pour les modules que vous avez sélectionnés. Exécutez à nouveau `npx bmad-method install` et vérifiez votre sélection de modules. Vérifiez que les fichiers de skill existent dans le répertoire attendu.
+**Des skills attendus sont manquants.** L’installateur génère uniquement les skills pour les modules que vous avez sélectionnés. Exécutez à nouveau `npx bmad-method install` et vérifiez votre sélection de modules. Vérifiez que les fichiers de skill existent dans le répertoire attendu.
 
-**Des skills d'un module supprimé apparaissent encore.** L'installateur ne supprime pas automatiquement les anciens fichiers de skill. Supprimez les répertoires obsolètes du répertoire de skills de votre IDE, ou supprimez tout le répertoire de skills et relancez l'installateur pour obtenir un ensemble propre.
+**Des skills d’un module supprimé apparaissent encore.** L’installateur ne supprime pas automatiquement les anciens fichiers de skill. Supprimez les répertoires obsolètes du répertoire de skills de votre IDE, ou supprimez tout le répertoire de skills et relancez l’installateur pour obtenir un ensemble propre.
 
 ## Glossaire
 
 [^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
-[^2]: Persona : dans le contexte de BMad, un persona désigne un agent IA avec un rôle défini, un style de communication et une expertise spécifiques (ex. Mary l'analyste, Winston l'architecte). Chaque persona garde son "caractère" pendant les interactions.
+[^2]: Persona : dans le contexte de BMad, un persona désigne un agent IA avec un rôle défini, un style de communication et une expertise spécifiques (ex. Mary l’analyste, Winston l’architecte). Chaque persona garde son « caractère » pendant les interactions.
-[^3]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d'un projet ou d'une demande, afin d'aligner rapidement les parties prenantes avant le travail détaillé.
+[^3]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d’un projet ou d’une demande, afin d’aligner rapidement les parties prenantes avant le travail détaillé.

docs/fr/reference/core-tools.md

@@ -5,71 +5,72 @@ sidebar:
   order: 3
 ---
 
-Chaque installation BMad comprend un ensemble de compétences principales qui peuvent être utilisées conjointement avec tout ce que vous faites — des tâches et des workflows autonomes qui fonctionnent dans tous les projets, tous les modules et toutes les phases. Ceux-ci sont toujours disponibles, quels que soient les modules optionnels que vous installez.
+Chaque installation BMad comprend un ensemble de compétences principales utilisables en complément de tout ce que vous faites — des tâches et des workflows autonomes qui fonctionnent dans tous les projets, tous les modules et toutes les phases. Elles restent toujours disponibles, quels que soient les modules optionnels que vous installez.
 
 :::tip[Raccourci Rapide]
-Exécutez n'importe quel outil principal en tapant son nom de compétence (par ex., `bmad-help`) dans votre IDE. Aucune session d'agent requise.
+Exécutez n’importe quel outil principal en tapant son nom de compétence (par ex., `bmad-help`) dans votre IDE. Aucune session d’agent requise.
 :::
 
-## Vue d'ensemble
+## Vue d’ensemble
 
-| Outil                                                                 | Type     | Objectif                                                                     |
+| Outil                                                                 | Type     | Objectif                                                                      |
-|-----------------------------------------------------------------------|----------|------------------------------------------------------------------------------|
+|-----------------------------------------------------------------------|----------|-------------------------------------------------------------------------------|
-| [`bmad-help`](#bmad-help)                                             | Tâche    | Obtenir des conseils contextuels sur la prochaine étape                      |
+| [`bmad-help`](#bmad-help)                                             | Tâche    | Obtenir des conseils contextuels sur la prochaine étape                       |
-| [`bmad-brainstorming`](#bmad-brainstorming)                           | Workflow | Faciliter des sessions de brainstorming interactives                         |
+| [`bmad-brainstorming`](#bmad-brainstorming)                           | Workflow | Faciliter des sessions de brainstorming interactives                          |
-| [`bmad-party-mode`](#bmad-party-mode)                                 | Workflow | Orchestrer des discussions de groupe multi-agents                            |
+| [`bmad-party-mode`](#bmad-party-mode)                                 | Workflow | Orchestrer des discussions de groupe multi-agents                             |
-| [`bmad-spec`](#bmad-spec)                                             | Workflow | Distill any intent input into a SPEC kernel and companions (translation pending)                   |
+| [`bmad-spec`](#bmad-spec)                                             | Workflow | Distiller toute formulation d’intention en un noyau SPEC et fichiers associés |
-| [`bmad-advanced-elicitation`](#bmad-advanced-elicitation)             | Tâche    | Pousser la sortie LLM à travers des méthodes de raffinement itératives       |
+| [`bmad-advanced-elicitation`](#bmad-advanced-elicitation)             | Tâche    | Soumettre la sortie LLM à des méthodes de raffinement itératives              |
-| [`bmad-review-adversarial-general`](#bmad-review-adversarial-general) | Tâche    | Revue cynique qui trouve ce qui manque et ce qui ne va pas                   |
+| [`bmad-review-adversarial-general`](#bmad-review-adversarial-general) | Tâche    | Revue cynique qui traque ce qui manque et ce qui ne va pas                    |
-| [`bmad-review-edge-case-hunter`](#bmad-review-edge-case-hunter)       | Tâche    | Analyse exhaustive des chemins de branchement pour les cas limites non gérés |
+| [`bmad-review-edge-case-hunter`](#bmad-review-edge-case-hunter)       | Tâche    | Analyse exhaustive des chemins de branchement pour les cas limites non gérés  |
-| [`bmad-editorial-review-prose`](#bmad-editorial-review-prose)         | Tâche    | Révision de copie clinique pour la clarté de communication                   |
+| [`bmad-editorial-review-prose`](#bmad-editorial-review-prose)         | Tâche    | Correction éditoriale clinique pour la clarté de communication                |
-| [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | Tâche    | Édition structurelle — coupes, fusions et réorganisation                     |
+| [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | Tâche    | Édition structurelle — coupes, fusions et réorganisation                      |
-| [`bmad-shard-doc`](#bmad-shard-doc)                                   | Tâche    | Diviser les fichiers markdown volumineux en sections organisées              |
+| [`bmad-shard-doc`](#bmad-shard-doc)                                   | Tâche    | Diviser les fichiers markdown volumineux en sections organisées               |
-| [`bmad-index-docs`](#bmad-index-docs)                                 | Tâche    | Générer ou mettre à jour un index de tous les documents dans un dossier      |
+| [`bmad-index-docs`](#bmad-index-docs)                                 | Tâche    | Générer ou mettre à jour un index de tous les documents dans un dossier       |
+| [`bmad-customize`](#bmad-customize)                                   | Tâche    | Créer et vérifier des personnalisations BMad                                  |
 
 ## bmad-help
 
-**Votre guide intelligent pour la suite.** — Inspecte l'état de votre projet, détecte ce qui a été fait et recommande la prochaine étape requise ou facultative.
+**Votre guide intelligent pour la suite.** — Inspecte l’état de votre projet, détecte ce qui a été fait et recommande la prochaine étape requise ou facultative.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
-- Vous avez terminé un workflow et voulez savoir ce qui suit
+- Vous avez terminé un workflow et voulez savoir quoi faire ensuite
-- Vous êtes nouveau sur BMad et avez besoin d'orientation
+- Vous êtes nouveau sur BMad et avez besoin d’orientation
 - Vous êtes bloqué et voulez des conseils contextuels
 - Vous avez installé de nouveaux modules et voulez voir ce qui est disponible
 
-**Fonctionnement :**
+**Fonctionnement :**
 
-1. Analyse votre projet pour les artefacts existants (PRD, architecture, stories, etc.)
+1. Analyse votre projet pour détecter les artefacts existants (PRD, architecture, stories, etc.)
 2. Détecte quels modules sont installés et leurs workflows disponibles
-3. Recommande les prochaines étapes par ordre de priorité — étapes requises d'abord, puis facultatives
+3. Recommande les prochaines étapes par ordre de priorité — étapes requises d’abord, puis facultatives
 4. Présente chaque recommandation avec la commande de compétence et une brève description
 
-**Entrée :** Requête optionnelle en langage naturel (par ex., `bmad-help J'ai une idée de SaaS, par où commencer ?`)
+**Entrée :** Requête optionnelle en langage naturel (par ex., `bmad-help J'ai une idée de SaaS, par où commencer ?`)
 
-**Sortie :** Liste priorisée des prochaines étapes recommandées avec les commandes de compétence
+**Sortie :** Liste priorisée des prochaines étapes recommandées avec les commandes de compétence
 
 ## bmad-brainstorming
 
-**Génère des idées diverses à travers des techniques créatives interactives.** — Une session de brainstorming facilitée qui charge des méthodes d'idéation éprouvées depuis une bibliothèque de techniques et vous guide vers plus de 100 idées avant organisation.
+**Génère des idées variées grâce à des techniques créatives interactives.** — Une session de brainstorming facilitée qui charge des méthodes d’idéation éprouvées à partir d’une bibliothèque de techniques et vous guide vers plus de 100 idées avant de les organiser.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
 - Vous commencez un nouveau projet et devez explorer l’espace problème
-- Vous êtes bloqué dans la génération d'idées et avez besoin de créativité structurée
+- Vous êtes bloqué dans la génération d’idées et avez besoin de créativité structurée
-- Vous voulez utiliser des cadres d'idéation éprouvés (SCAMPER, brainstorming inversé, etc.)
+- Vous voulez utiliser des cadres d’idéation éprouvés (SCAMPER, brainstorming inversé, etc.)
 
-**Fonctionnement :**
+**Fonctionnement :**
 
 1. Configure une session de brainstorming avec votre sujet
-2. Charge les techniques créatives depuis une bibliothèque de méthodes
+2. Charge les techniques créatives à partir d’une bibliothèque de méthodes
-3. Vous guide à travers technique après technique, générant des idées
+3. Vous guide de technique en technique, en générant des idées
-4. Applique un protocole anti-biais — change de domaine créatif toutes les 10 idées pour éviter le regroupement
+4. Applique un protocole anti-biais — bascule de domaine créatif toutes les 10 idées pour éviter les biais de regroupement
 5. Produit un document de session en mode ajout uniquement avec toutes les idées organisées par technique
 
-**Entrée :** Sujet de brainstorming ou énoncé de problème, fichier de contexte optionnel
+**Entrée :** Sujet de brainstorming ou énoncé de problème, fichier de contexte optionnel
 
-**Sortie :** `brainstorming-session-{date}.md` avec toutes les idées générées
+**Sortie :** `brainstorming-session-{date}.md` avec toutes les idées générées
 
 :::note[Cible de Quantité]
 La magie se produit dans les idées 50–100. Le workflow encourage la génération de plus de 100 idées avant organisation.
@@ -77,195 +78,249 @@ La magie se produit dans les idées 50–100. Le workflow encourage la générat
 
 ## bmad-party-mode
 
-**Orchestre des discussions de groupe multi-agents.** — Charge tous les agents BMad installés et facilite une conversation naturelle où chaque agent contribue depuis son expertise et personnalité uniques.
+**Orchestre des discussions de groupe multi-agents.** — Charge tous les agents BMad installés et facilite une conversation naturelle où chaque agent apporte son expertise et sa personnalité uniques.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
-- Vous avez besoin de multiples perspectives d'experts sur une décision
+- Vous avez besoin de multiples perspectives d’experts sur une décision
 - Vous voulez que les agents remettent en question les hypothèses des autres
 - Vous explorez un sujet complexe qui couvre plusieurs domaines
 
-**Fonctionnement :**
+**Fonctionnement :**
 
-1. Charge le manifeste d'agents avec toutes les personnalités d'agents installées
+1. Charge le manifeste d’agents avec toutes les personnalités d’agents installées
 2. Analyse votre sujet pour sélectionner les 2–3 agents les plus pertinents
-3. Les agents prennent des tours pour contribuer, avec des échanges naturels et des désaccords
+3. Les agents contribuent à tour de rôle, avec des échanges spontanés et des désaccords
-4. Fait rouler la participation des agents pour assurer des perspectives diverses au fil du temps
+4. Alterne la participation des agents pour garantir des perspectives variées
 5. Quittez avec `goodbye`, `end party` ou `quit`
 
-**Entrée :** Sujet de discussion ou question, ainsi que la spécification des personas que vous souhaitez faire participer (optionnel)
+**Entrée :** Sujet de discussion ou question, ainsi que la spécification des personas que vous souhaitez faire participer (optionnel)
+
+**Sortie :** Conversation multi-agents en temps réel conservant la personnalité de chaque agent
+
+## bmad-spec
+
+**Distille toute formulation d’intention en un contrat SPEC canonique pour le travail en aval.** — Accepte un brief, un PRD, un GDD, un RFC, un brain dump, une transcription, un dossier UX ou une entrée multi-source mixte et produit un `SPEC.md` structuré autour d’un noyau de cinq champs (Pourquoi, Capacités, Contraintes, Non-objectifs, Signal de succès) ainsi que des fichiers compagnons pour le contenu essentiel qui ne trouve pas sa place dans le noyau.
+
+**À utiliser quand :**
+
+- Vous devez verrouiller le QUOI avant le COMMENT pour tout type de travail (logiciel, game design, recherche, éditorial, politique, entreprise)
+- Vous souhaitez un contrat succinct optimisé pour les LLM, sans fioritures, que les compétences en aval peuvent consommer sans relire chaque artefact en amont
+- Vous voulez valider ou mettre à jour une spécification existante
+
+**Fonctionnement :**
+
+1. Lit l’entrée et tout document annexe lié
+2. Distille en un noyau à cinq champs via un modèle configurable ; redirige l’excédent vers des fichiers compagnons correctement nommés
+3. Exécute une auto-validation en deux passes (règles de cohérence, puis préservation de chaque affirmation essentielle de la source)
+4. Écrit `SPEC.md`, les compagnons associés, et un `.memlog.md` sous `{output_folder}/specs/spec-{slug}/`
+
+La loi Spec impose huit règles : les capacités expriment à la fois l’intention et le critère de succès ; les intentions décrivent le QUOI, pas le COMMENT ; les contraintes guident réellement les décisions ; les non-objectifs sont explicites ; les signaux de succès sont concrets ; les identifiants de capacité sont stables ; chaque affirmation essentielle de la source est préservée ; la rédaction est concise.
+
+**Entrée :**
+
+- `input` (requis) — Chemin ou texte fourni directement. Idée vague, brain dump, PRD, GDD, RFC, brief, transcription, dossier de maquettes, multi-source mixte
+- `slug` (optionnel) — Requis uniquement lorsque l’entrée est succincte et qu’aucun slug ne peut être dérivé du nom de fichier source
+- `target_spec_path` (optionnel) — Définir pour mettre à jour une spécification existante au lieu d’en créer une nouvelle
+
+**Sortie :** Dossier de spécification contenant `SPEC.md`, les éventuels fichiers compagnons, et un `.memlog.md`. Les appelants en mode headless reçoivent une réponse JSON avec le statut du résultat et la liste des fichiers écrits ou modifiés.
+
+:::note[Contrat de mutation]
+`bmad-spec` est le seul outil autorisé à écrire `SPEC.md` et les fichiers compagnons de la spécification. Les autres compétences produisent leurs propres artefacts natifs et invoquent `bmad-spec` en mode headless lorsqu’elles ont besoin d’exprimer une intention sous forme de contrat canonique ou de proposer des mises à jour.
+:::
 
-**Sortie :** Conversation multi-agents en temps réel avec des personnalités d'agents maintenues
 
 ## bmad-advanced-elicitation
 
-**Passer la sortie du LLM à travers des méthodes de raffinement itératives.** — Sélectionne depuis une bibliothèque de techniques d'élicitation pour améliorer systématiquement le contenu à travers multiples passages.
+**Soumet la sortie du LLM à des méthodes de raffinement itératives.** — Sélectionne à partir d’une bibliothèque de techniques d’élicitation pour améliorer systématiquement le contenu en plusieurs passages.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
 - La sortie du LLM semble superficielle ou générique
-- Vous voulez explorer un sujet depuis de multiples angles analytiques
+- Vous voulez explorer un sujet sous plusieurs angles analytiques
-- Vous raffinez un document critique et voulez une réflexion plus approfondie
+- Vous raffinez un document critique et souhaitez une réflexion plus approfondie
 
-**Fonctionnement :**
+**Fonctionnement :**
 
-1. Charge le registre de méthodes avec plus de 5 techniques d'élicitation
+1. Charge le registre de méthodes avec plus de 5 techniques d’élicitation
 2. Sélectionne les 5 méthodes les mieux adaptées selon le type de contenu et la complexité
 3. Présente un menu interactif — choisissez une méthode, remélangez, ou listez tout
 4. Applique la méthode sélectionnée pour améliorer le contenu
-5. Re-présente les options pour l'amélioration itérative jusqu'à ce que vous sélectionniez "Procéder"
+5. Affiche à nouveau les options d’amélioration itérative jusqu’à ce que vous sélectionniez « Procéder »
 
-**Entrée :** Section de contenu à améliorer
+**Entrée :** Section de contenu à améliorer
 
-**Sortie :** Version améliorée du contenu avec les améliorations appliquées
+**Sortie :** Version améliorée du contenu avec les améliorations appliquées
 
 ## bmad-review-adversarial-general
 
-**Revue contradictoire qui suppose que des problèmes existent et les recherche.** — Adopte une perspective de réviseur sceptique et blasé avec zéro tolérance pour le travail bâclé. Cherche ce qui manque, pas seulement ce qui ne va pas.
+**Revue contradictoire qui part du principe que des problèmes existent et les traque.** — Adopte un regard de réviseur sceptique et blasé, sans aucune tolérance pour le travail bâclé. Cherche ce qui manque, pas seulement ce qui ne va pas.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
-- Vous avez besoin d'assurance qualité avant de finaliser un livrable
+- Vous avez besoin d’assurance qualité avant de finaliser un livrable
-- Vous voulez tester en conditions réelles une spécification, story ou document
+- Vous voulez éprouver une spécification, une story ou un document
 - Vous voulez trouver des lacunes de couverture que les revues optimistes manquent
 
-**Fonctionnement :**
+**Fonctionnement :**
 
-1. Lit le contenu avec une perspective contradictoire et critique
+1. Lit le contenu avec un regard contradictoire et critique
-2. Identifie les problèmes à travers l'exhaustivité, la justesse et la qualité
+2. Identifie les problèmes sur les plans de l’exhaustivité, de la justesse et de la qualité
 3. Recherche spécifiquement ce qui manque — pas seulement ce qui est présent et faux
-4. Doit trouver un minimum de 10 problèmes ou réanalyse plus profondément
+4. Doit trouver un minimum de 10 problèmes ou réanalyser plus en profondeur
 
-**Entrée :**
+**Entrée :**
 
 - `content` (requis) — Diff, spécification, story, document ou tout artefact
-- `also_consider` (optionnel) — Domaines supplémentaires à garder à l'esprit
+- `also_consider` (optionnel) — Domaines supplémentaires à garder à l’esprit
 
-**Sortie :** Liste markdown de plus de 10 constatations avec descriptions
+**Sortie :** Liste markdown de plus de 10 constatations avec descriptions
 
 ## bmad-review-edge-case-hunter
 
-**Parcours tous les chemins de branchement et les conditions limites, ne rapporte que les cas non gérés.** — Méthodologie pure de traçage de chemin[^1] qui dérive mécaniquement les classes de cas limites. Orthogonale à la revue contradictoire — centrée sur la méthode, pas sur l'attitude.
+**Parcourt tous les chemins de branchement et les conditions limites, ne signale que les cas non gérés.** — Méthodologie pure de traçage de chemin[^1] qui dérive mécaniquement les classes de cas limites. Orthogonale à la revue contradictoire — centrée sur la méthode, pas sur l’attitude.
 
-**À utiliser quand :**
+**À utiliser quand :**
 
 - Vous souhaitez une couverture exhaustive des cas limites pour le code ou la logique
-- Vous avez besoin d'un complément à la revue contradictoire (méthodologie différente, résultats différents)
+- Vous avez besoin d’un complément à la revue contradictoire (méthodologie différente, résultats différents)
 - Vous révisez un diff ou une fonction pour des conditions limites
 
-**Fonctionnement :**
+**Fonctionnement :**
 
 1. Énumère tous les chemins de branchement dans le contenu
-2. Dérive mécaniquement les classes de cas limites : else/default manquants, entrées non vérifiées, décalage d’unité, overflow arithmétique, coercition implicite des types, conditions de concurrence, écarts de timeout
+2. Dérive mécaniquement les classes de cas limites : else/default manquants, entrées non protégées, erreurs off-by-one, dépassements arithmétiques, conversions de type implicites, conditions de concurrence, dépassements de délai
-3. Teste chaque chemin contre les protections existantes
+3. Teste chaque chemin face aux protections existantes
-4. Ne rapporte que les chemins non gérés — ignore silencieusement les chemins gérés
+4. Ne signale que les chemins non gérés — ignore silencieusement les chemins gérés
 
-**Entrée :**
+**Entrée :**
 
 - `content` (obligatoire) — Diff, fichier complet ou fonction
-- `also_consider` (facultatif) — Zones supplémentaires à garder à l’esprit
+- `also_consider` (facultatif) — Domaines supplémentaires à garder à l’esprit
 
-**Sortie :** Tableau JSON des résultats, chacun avec `location`, `trigger_condition`, `guard_snippet` et `potential_consequence`
+**Sortie :** Tableau JSON des résultats, chacun avec `location`, `trigger_condition`, `guard_snippet` et `potential_consequence`
 
 :::note[Revue Complémentaire]
-Exécutez à la fois `bmad-review-adversarial-general` et `bmad-review-edge-case-hunter` pour une couverture orthogonale. La revue contradictoire détecte les problèmes de qualité et de complétude ; le chasseur de cas limites détecte les chemins non gérés.
+Exécutez à la fois `bmad-review-adversarial-general` et `bmad-review-edge-case-hunter` pour une couverture orthogonale. La revue contradictoire détecte les problèmes de qualité et de complétude ; le chasseur de cas limites détecte les chemins non gérés.
 :::
 
 ## bmad-editorial-review-prose
 
-**Relecture éditoriale clinique centrée sur la clarté de communication.** — Analyse le texte pour détecter les problèmes qui nuisent à la compréhension. Applique le Microsoft Writing Style Guide baseline. Préserve la voix de l’auteur.
+**Correction éditoriale clinique centrée sur la clarté de communication.** — Analyse le texte pour détecter les problèmes qui nuisent à la compréhension. Applique le Microsoft Writing Style Guide comme référence de base. Préserve la voix de l’auteur.
 
-**À utiliser quand :**
+**À utiliser quand :**
 
-- Vous avez rédigé un document et souhaitez polir le style
+- Vous avez rédigé un document et souhaitez en polir le style
 - Vous devez assurer la clarté pour un public spécifique
 - Vous voulez des corrections de communication sans modifier les choix stylistiques
 
-**Fonctionnement :**
+**Fonctionnement :**
 
 1. Lit le contenu en ignorant les blocs de code et le frontmatter
 2. Identifie les problèmes de communication (pas les préférences de style)
-3. Déduit les doublons du même problème à différents emplacements
+3. Dédoublonne les occurrences d’un même problème à différents endroits
 4. Produit un tableau de corrections en trois colonnes
 
-**Entrée :**
+**Entrée :**
 
 - `content` (obligatoire) — Markdown, texte brut ou XML
 - `style_guide` (facultatif) — Guide de style spécifique au projet
 - `reader_type` (facultatif) — `humans` (par défaut) pour clarté/fluide, ou `llm` pour précision/consistance
 
-**Sortie :** Tableau Markdown en trois colonnes : Texte original | Texte révisé | Modifications
+**Sortie :** Tableau Markdown en trois colonnes : Texte original | Texte révisé | Modifications
 
 ## bmad-editorial-review-structure
 
-**Édition structurelle — propose des coupes, fusions, déplacements et condensations.** — Révise l'organisation du document et propose des changements substantiels pour améliorer la clarté et le flux avant la révision de copie.
+**Édition structurelle — propose des coupes, fusions, réorganisations et condensations.** — Révise l’organisation du document et propose des changements substantiels pour améliorer la clarté et le flux avant la correction éditoriale.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
-- Un document a été produit depuis de multiples sous-processus et a besoin de cohérence structurelle
+- Un document a été produit par plusieurs sous-processus et nécessite une cohérence structurelle
 - Vous voulez réduire la longueur du document tout en préservant la compréhension
 - Vous devez identifier les violations de portée ou les informations critiques enfouies
 
-**Fonctionnement :**
+**Fonctionnement :**
 
 1. Analyse le document contre 5 modèles de structure (Tutoriel, Référence, Explication, Prompt, Stratégique)
 2. Identifie les redondances, violations de portée et informations enfouies
-3. Produit des recommandations priorisées : COUPER, FUSIONNER, DÉPLACER, CONDENSER, QUESTIONNER, PRÉSERVER
+3. Produit des recommandations priorisées : COUPER, FUSIONNER, DÉPLACER, CONDENSER, QUESTIONNER, PRÉSERVER
-4. Estime la réduction totale en mots et pourcentage
+4. Estime la réduction totale en mots et en pourcentage
 
-**Entrée :**
+**Entrée :**
 
 - `content` (requis) — Document à réviser
-- `purpose` (optionnel) — Objectif prévu (par ex., "tutoriel de démarrage rapide")
+- `purpose` (optionnel) — Objectif prévu (par ex., « tutoriel de démarrage rapide »)
 - `target_audience` (optionnel) — Qui lit ceci
 - `reader_type` (optionnel) — `humans` ou `llm`
-- `length_target` (optionnel) — Réduction cible (par ex., "30% plus court")
+- `length_target` (optionnel) — Réduction cible (par ex., « 30% plus court »)
 
-**Sortie :** Résumé du document, liste de recommandations priorisées et réduction estimée
+**Sortie :** Résumé du document, liste de recommandations priorisées et réduction estimée
 
 ## bmad-shard-doc
 
-**Diviser les fichiers markdown volumineux en fichiers de sections organisés.** — Utilise les en-têtes de niveau 2 comme points de division pour créer un dossier de fichiers de sections autonomes avec un index.
+**Fractionne les fichiers markdown volumineux en sections organisées.** — Utilise les en-têtes de niveau 2 comme points de découpe pour créer un dossier de fichiers de sections autonomes avec un index.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
 - Un document markdown est devenu trop volumineux pour être géré efficacement (plus de 500 lignes)
-- Vous voulez diviser un document monolithique en sections navigables
+- Vous voulez découper un document monolithique en sections navigables
-- Vous avez besoin de fichiers séparés pour l'édition parallèle ou la gestion de contexte LLM
+- Vous avez besoin de fichiers séparés pour l’édition parallèle ou la gestion de contexte LLM
 
-**Fonctionnement :**
+**Fonctionnement :**
 
-1. Valide que le fichier source existe et est markdown
+1. Valide que le fichier source existe et est au format markdown
-2. Divise sur les en-têtes de niveau 2 (`##`) en fichiers de sections numérotées
+2. Découpe sur les en-têtes de niveau 2 (`##`) en fichiers de sections numérotées
-3. Crée un `index.md` avec manifeste de sections et liens
+3. Crée un `index.md` avec le manifeste de sections et les liens
-4. Vous invite à supprimer, archiver ou conserver l'original
+4. Vous invite à supprimer, archiver ou conserver l’original
 
-**Entrée :** Chemin du fichier markdown source, dossier de destination optionnel
+**Entrée :** Chemin du fichier markdown source, dossier de destination optionnel
 
-**Sortie :** Dossier avec `index.md` et `01-{section}.md`, `02-{section}.md`, etc.
+**Sortie :** Dossier avec `index.md` et `01-{section}.md`, `02-{section}.md`, etc.
 
 ## bmad-index-docs
 
-**Générer ou mettre à jour un index de tous les documents dans un dossier.** — Analyse un répertoire, lit chaque fichier pour comprendre son objectif et produit un `index.md` organisé avec liens et descriptions.
+**Génère ou met à jour un index de tous les documents dans un dossier.** — Analyse un répertoire, lit chaque fichier pour comprendre son objectif et produit un `index.md` organisé avec liens et descriptions.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
-- Vous avez besoin d'un index léger pour un scan LLM rapide des documents disponibles
+- Vous avez besoin d’un index léger pour un scan LLM rapide des documents disponibles
-- Un dossier de documentation a grandi et a besoin d'une table des matières organisée
+- Un dossier de documentation a grandi et nécessite une table des matières organisée
 - Vous voulez un aperçu auto-généré qui reste à jour
 
-**Fonctionnement :**
+**Fonctionnement :**
 
 1. Analyse le répertoire cible pour tous les fichiers non cachés
 2. Lit chaque fichier pour comprendre son objectif réel
 3. Groupe les fichiers par type, objectif ou sous-répertoire
 4. Génère des descriptions concises (3–10 mots chacune)
 
-**Entrée :** Chemin du dossier cible
+**Entrée :** Chemin du dossier cible
 
-**Sortie :** `index.md` avec listes de fichiers organisées, liens relatifs et brèves descriptions
+**Sortie :** `index.md` avec listes de fichiers organisées, liens relatifs et brèves descriptions
+
+## bmad-customize
+
+**Créer et vérifier des personnalisations.** — Vous aide à modifier le comportement d’un agent ou d’un workflow BMad installé sans avoir à écrire de TOML manuellement.
+
+**À utiliser quand :**
+
+- Vous souhaitez modifier le comportement d’un agent ou d’un workflow
+- Vous devez ajouter des faits persistants, des hooks d’activation ou des éléments de menu personnalisés
+- Vous voulez que le bon périmètre de surcharge soit sélectionné et vérifié automatiquement
+
+**Fonctionnement :**
+
+1. Analyse les skills BMad installés pour identifier les surfaces personnalisables
+2. Sélectionne le bon périmètre pour le changement demandé
+3. Écrit les fichiers de surcharge sous `_bmad/custom/`
+4. Vérifie la configuration fusionnée
+
+**Entrée :** Description en langage naturel de la personnalisation souhaitée
+
+**Sortie :** Fichiers de surcharge TOML sous `_bmad/custom/`
+
+Pour un guide détaillé sur la personnalisation de BMad, consultez [Comment personnaliser BMad](../how-to/customize-bmad.md).
 
 ## Glossaire
 
-[^1]: Path-tracing : méthode d'analyse qui suit systématiquement tous les chemins d'exécution possibles dans un programme pour identifier les cas non gérés.
+[^1]: Path-tracing : méthode d’analyse qui suit systématiquement tous les chemins d’exécution possibles dans un programme pour identifier les cas non gérés.
-

docs/fr/reference/modules.md

@@ -1,25 +1,25 @@
 ---
 title: Modules Officiels
-description: Modules additionnels pour créer des agents personnalisés, de l'intelligence créative, du développement de jeux et des tests
+description: Modules additionnels pour créer des agents personnalisés, de l’intelligence créative, du développement de jeux et des tests
 sidebar:
   order: 5
 ---
 
-BMad s'étend via des modules officiels que vous sélectionnez lors de l'installation. Ces modules additionnels fournissent des agents, des workflows et des tâches spécialisés pour des domaines spécifiques, au-delà du noyau intégré et de BMM (suite Agile).
+BMad s’étend via des modules officiels que vous sélectionnez lors de l’installation. Ces modules additionnels fournissent des agents, des workflows et des tâches spécialisés pour des domaines spécifiques, au-delà du noyau intégré et de BMM (suite Agile).
 
 :::tip[Installer des Modules]
-Exécutez `npx bmad-method install` et sélectionnez les modules souhaités. L'installateur gère automatiquement le téléchargement, la configuration et l'intégration IDE.
+Exécutez `npx bmad-method install` et sélectionnez les modules souhaités. L’installateur gère automatiquement le téléchargement, la configuration et l’intégration IDE.
 :::
 
 ## BMad Builder
 
 Créez des agents personnalisés, des workflows et des modules spécifiques à un domaine avec une assistance guidée. BMad Builder est le méta-module pour étendre le framework lui-même.
 
-- **Code :** `bmb`
+- **Code :** `bmb`
-- **npm :** [`bmad-builder`](https://www.npmjs.com/package/bmad-builder)
+- **npm :** [`bmad-builder`](https://www.npmjs.com/package/bmad-builder)
-- **GitHub :** [bmad-code-org/bmad-builder](https://github.com/bmad-code-org/bmad-builder)
+- **GitHub :** [bmad-code-org/bmad-builder](https://github.com/bmad-code-org/bmad-builder)
 
-**Fournit :**
+**Fournit :**
 
 - Agent Builder — créez des agents IA spécialisés avec une expertise et un accès aux outils personnalisés
 - Workflow Builder — concevez des processus structurés avec des étapes et des points de décision
@@ -28,46 +28,46 @@ Créez des agents personnalisés, des workflows et des modules spécifiques à u
 
 ## Creative Intelligence Suite
 
-Outils basés sur l'IA pour la créativité structurée, l'idéation et l'innovation pendant le développement en phase amont. La suite fournit plusieurs agents qui facilitent le brainstorming, le design thinking et la résolution de problèmes en utilisant des cadres éprouvés.
+Outils basés sur l’IA pour la créativité structurée, l’idéation et l’innovation pendant le développement en phase amont. La suite fournit plusieurs agents qui facilitent le brainstorming, le design thinking et la résolution de problèmes en utilisant des cadres éprouvés.
 
-- **Code :** `cis`
+- **Code :** `cis`
-- **npm :** [`bmad-creative-intelligence-suite`](https://www.npmjs.com/package/bmad-creative-intelligence-suite)
+- **npm :** [`bmad-creative-intelligence-suite`](https://www.npmjs.com/package/bmad-creative-intelligence-suite)
-- **GitHub :** [bmad-code-org/bmad-module-creative-intelligence-suite](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
+- **GitHub :** [bmad-code-org/bmad-module-creative-intelligence-suite](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
 
-**Fournit :**
+**Fournit :**
 
 - Agents Innovation Strategist, Design Thinking Coach et Brainstorming Coach
 - Problem Solver et Creative Problem Solver pour la pensée systématique et latérale
 - Storyteller et Presentation Master pour les récits et les présentations
-- Cadres d'idéation incluant SCAMPER[^1], Brainstorming inversé et reformulation de problèmes
+- Cadres d’idéation incluant SCAMPER[^1], Brainstorming inversé et reformulation de problèmes
 
 ## Game Dev Studio
 
 Workflows de développement de jeux structurés adaptés pour Unity, Unreal, Godot et moteurs personnalisés. Supporte le prototypage rapide via Quick Dev et la production à grande échelle avec des sprints propulsés par epics.
 
-- **Code :** `gds`
+- **Code :** `gds`
-- **npm :** [`bmad-game-dev-studio`](https://www.npmjs.com/package/bmad-game-dev-studio)
+- **npm :** [`bmad-game-dev-studio`](https://www.npmjs.com/package/bmad-game-dev-studio)
-- **GitHub :** [bmad-code-org/bmad-module-game-dev-studio](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
+- **GitHub :** [bmad-code-org/bmad-module-game-dev-studio](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
 
-**Fournit :**
+**Fournit :**
 
 - Workflow de génération de Document de Design de Jeu (GDD[^3])
 - Mode Quick Dev pour le prototypage rapide
 - Support de design narratif pour les personnages, dialogues et construction de monde
-- Couverture de plus de 21 types de jeux avec des conseils d'architecture spécifiques au moteur
+- Couverture de plus de 21 types de jeux avec des conseils d’architecture spécifiques au moteur
 
 ## Test Architect (TEA)
 
-Stratégie de test de niveau entreprise, conseils d'automatisation et décisions de porte de release via un agent expert et neuf workflows structurés. TEA va bien au-delà du workflow QA intégré avec une priorisation basée sur les risques et une traçabilité des exigences.
+Stratégie de test de niveau entreprise, conseils d’automatisation et décisions de porte de release via un agent expert et neuf workflows structurés. TEA va bien au-delà du workflow QA intégré avec une priorisation basée sur les risques et une traçabilité des exigences.
 
-- **Code :** `tea`
+- **Code :** `tea`
-- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
+- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
-- **GitHub :** [bmad-code-org/bmad-method-test-architecture-enterprise](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)
+- **GitHub :** [bmad-code-org/bmad-method-test-architecture-enterprise](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)
 
-**Fournit :**
+**Fournit :**
 
 - Agent Murat (Master Test Architect and Quality Advisor)
-- Workflows pour la conception de tests, ATDD, l'automatisation, la revue de tests et la traçabilité
+- Workflows pour la conception de tests, ATDD, l’automatisation, la revue de tests et la traçabilité
 - Évaluation NFR[^2], configuration CI et scaffolding de framework
 - Priorisation P0-P3 avec Playwright Utils et intégrations MCP optionnelles
 
@@ -77,6 +77,6 @@ Les modules communautaires et une marketplace de modules sont à venir. Consulte
 
 ## Glossaire
 
-[^1]: SCAMPER : acronyme anglais pour une technique de créativité structurée (Substitute, Combine, Adapt, Modify, Put to another use, Eliminate, Reverse) qui permet d'explorer systématiquement les modifications possibles d'un produit ou d'une idée pour générer des innovations.
+[^1]: SCAMPER : acronyme anglais pour une technique de créativité structurée (Substitute, Combine, Adapt, Modify, Put to another use, Eliminate, Reverse) qui permet d’explorer systématiquement les modifications possibles d’un produit ou d’une idée pour générer des innovations.
 [^2]: NFR (Non-Functional Requirement) : exigence décrivant les contraintes de qualité du système (performance, sécurité, fiabilité, ergonomie) plutôt que ses fonctionnalités.
-[^3]: GDD (Game Design Document) : document de conception de jeu qui décrit en détail les mécaniques, l'univers, les personnages, les niveaux et tous les aspects du jeu à développer.
+[^3]: GDD (Game Design Document) : document de conception de jeu qui décrit en détail les mécaniques, l’univers, les personnages, les niveaux et tous les aspects du jeu à développer.

docs/fr/reference/testing.md

@@ -1,53 +1,53 @@
 ---
 title: Options de Testing
-description: Comparaison du workflow QA intégré avec le module Test Architect (TEA) pour l'automatisation des tests.
+description: Comparaison du workflow QA intégré avec le module Test Architect (TEA) pour l’automatisation des tests.
 sidebar:
   order: 6
 ---
 
-BMad propose deux approches de test : un workflow QA[^1] intégré pour une génération rapide de tests et un module Test Architect installable pour une stratégie de test de qualité entreprise.
+BMad propose deux approches de test : un workflow QA[^1] intégré pour une génération rapide de tests et un module Test Architect installable pour une stratégie de test de qualité entreprise.
 
-## Lequel Choisir ?
+## Lequel Choisir ?
 
-| Facteur                 | QA Intégré                           | Module TEA                                                          |
+| Facteur                 | QA Intégré                                   | Module TEA                                                          |
 |-------------------------|----------------------------------------------|---------------------------------------------------------------------|
 | **Idéal pour**          | Projets petits et moyens, couverture rapide  | Grands projets, domaines réglementés ou complexes                   |
-| **Installation**        | Rien à installer — inclus dans BMM          | Installer séparément via `npx bmad-method install`                  |
+| **Installation**        | Rien à installer — inclus dans BMM           | Installer séparément via `npx bmad-method install`                  |
-| **Approche**            | Générer les tests rapidement, itérer ensuite | Planifier d'abord, puis générer avec traçabilité                    |
+| **Approche**            | Générer les tests rapidement, itérer ensuite | Planifier d’abord, puis générer avec traçabilité                    |
 | **Types de tests**      | Tests API et E2E                             | API, E2E, ATDD[^2], NFR, et plus                                    |
 | **Stratégie**           | Chemin nominal + cas limites critiques       | Priorisation basée sur les risques (P0-P3)                          |
 | **Nombre de workflows** | 1 (Automate)                                 | 9 (conception, ATDD, automatisation, revue, traçabilité, et autres) |
 
 :::tip[Commencez avec le QA Intégré]
-La plupart des projets devraient commencer avec le workflow QA intégré. Si vous avez ensuite besoin d'une stratégie de test, de murs de qualité ou de traçabilité des exigences, installez TEA en complément.
+La plupart des projets devraient commencer avec le workflow QA intégré. Si vous avez ensuite besoin d’une stratégie de test, de murs de qualité ou de traçabilité des exigences, installez TEA en complément.
 :::
 
 ## Workflow QA Intégré
 
-Le workflow QA intégré (`bmad-qa-generate-e2e-tests`) fait partie du module BMM (suite Agile), disponible via l'agent Developer. Il génère rapidement des tests fonctionnels en utilisant le framework de test existant de votre projet — aucune configuration ni installation supplémentaire requise.
+Le workflow QA intégré (`bmad-qa-generate-e2e-tests`) fait partie du module BMM (suite Agile), disponible via l’agent Developer. Il génère rapidement des tests fonctionnels en utilisant le framework de test existant de votre projet — aucune configuration ni installation supplémentaire requise.
 
-**Déclencheur :** `QA` (via l'agent Developer) ou `bmad-qa-generate-e2e-tests`
+**Déclencheur :** `QA` (via l’agent Developer) ou `bmad-qa-generate-e2e-tests`
 
 ### Ce que le Workflow QA Fait
 
 Le workflow QA exécute un processus unique (Automate) qui parcourt cinq étapes :
 
-1. **Détecte le framework de test** — analyse `package.json` et les fichiers de test existants pour identifier votre framework (Jest, Vitest, Playwright, Cypress, ou tout runner standard). Si aucun n'existe, analyse la pile technologique du projet et en suggère un.
+1. **Détecte le framework de test** — analyse `package.json` et les fichiers de test existants pour identifier votre framework (Jest, Vitest, Playwright, Cypress, ou tout runner standard). Si aucun n’existe, analyse la pile technologique du projet et en suggère un.
-2. **Identifie les fonctionnalités** — demande ce qu'il faut tester ou découvre automatiquement les fonctionnalités dans le codebase.
+2. **Identifie les fonctionnalités** — demande ce qu’il faut tester ou découvre automatiquement les fonctionnalités dans le codebase.
-3. **Génère les tests API** — couvre les codes de statut, la structure des réponses, le chemin nominal, et 1-2 cas d'erreur.
+3. **Génère les tests API** — couvre les codes de statut, la structure des réponses, le chemin nominal, et 1-2 cas d’erreur.
-4. **Génére les tests E2E** — couvre les parcours utilisateur avec des localisateurs sémantiques et des assertions sur les résultats visibles.
+4. **Génère les tests E2E** — couvre les parcours utilisateur avec des localisateurs sémantiques et des assertions sur les résultats visibles.
 5. **Exécute et vérifie** — lance les tests générés et corrige immédiatement les échecs.
 
-Le workflow QA produit un résumé de test sauvegardé dans le dossier des artefacts d'implémentation de votre projet.
+Le workflow QA produit un résumé de test sauvegardé dans le dossier des artefacts d’implémentation de votre projet.
 
 ### Patterns de Test
 
-Les tests générés suivent une philosophie "simple et maintenable" :
+Les tests générés suivent une philosophie « simple et maintenable » :
 
-- **APIs standard du framework uniquement** — pas d'utilitaires externes ni d'abstractions personnalisées
+- **APIs standard du framework uniquement** — pas d’utilitaires externes ni d’abstractions personnalisées
 - **Localisateurs sémantiques** pour les tests UI (rôles, labels, texte plutôt que sélecteurs CSS)
-- **Tests indépendants** sans dépendances d'ordre
+- **Tests indépendants** sans dépendances d’ordre
-- **Pas d'attentes ou de sleeps codés en dur**
+- **Pas d’attentes ou de sleeps codés en dur**
 - **Descriptions claires** qui se lisent comme de la documentation fonctionnelle
 
 :::note[Portée]
@@ -59,28 +59,28 @@ Le workflow QA génère uniquement des tests. Pour la revue de code et la valida
 - Couverture de test rapide pour une fonctionnalité nouvelle ou existante
 - Automatisation de tests accessible aux débutants sans configuration avancée
 - Patterns de test standards que tout développeur peut lire et maintenir
-- Projets petits et moyens où une stratégie de test complète n'est pas nécessaire
+- Projets petits et moyens où une stratégie de test complète n’est pas nécessaire
 
 ## Module Test Architect (TEA)
 
 TEA est un module autonome qui fournit un agent expert (Murat) et neuf workflows structurés pour des tests de qualité entreprise. Il va au-delà de la génération de tests pour inclure la stratégie de test, la planification basée sur les risques, les murs de qualité et la traçabilité des exigences.
 
-- **Documentation :** [TEA Module Docs](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
+- **Documentation :** [TEA Module Docs](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
-- **Installation :** `npx bmad-method install` et sélectionnez le module TEA
+- **Installation :** `npx bmad-method install` et sélectionnez le module TEA
-- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
+- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
 
 ### Ce que TEA Fournit
 
 | Workflow              | Objectif                                                                             |
 |-----------------------|--------------------------------------------------------------------------------------|
 | Test Design           | Créer une stratégie de test complète liée aux exigences                              |
-| ATDD                  | Développement piloté par les tests d'acceptation avec critères des parties prenantes |
+| ATDD                  | Développement piloté par les tests d’acceptation avec critères des parties prenantes |
 | Automate              | Générer des tests avec des patterns et utilitaires avancés                           |
 | Test Review           | Valider la qualité et la couverture des tests par rapport à la stratégie             |
-| Traceability          | Remonter les tests aux exigences pour l'audit et la conformité                       |
+| Traceability          | Remonter les tests aux exigences pour l’audit et la conformité                       |
 | NFR Assessment        | Évaluer les exigences non-fonctionnelles (performance, sécurité)                     |
-| CI Setup              | Configurer l'exécution des tests dans les pipelines d'intégration continue           |
+| CI Setup              | Configurer l’exécution des tests dans les pipelines d’intégration continue           |
-| Framework Scaffolding | Configurer l'infrastructure de test et la structure du projet                        |
+| Framework Scaffolding | Configurer l’infrastructure de test et la structure du projet                        |
 | Release Gate          | Prendre des décisions de livraison go/no-go basées sur les données                   |
 
 TEA supporte également la priorisation basée sur les risques P0-P3 et des intégrations optionnelles avec Playwright Utils et les outils MCP.
@@ -88,24 +88,24 @@ TEA supporte également la priorisation basée sur les risques P0-P3 et des int
 ### Quand Utiliser TEA
 
 - Projets nécessitant une traçabilité des exigences ou une documentation de conformité
-- Équipes ayant besoin d'une priorisation des tests basée sur les risques sur plusieurs fonctionnalités
+- Équipes ayant besoin d’une priorisation des tests basée sur les risques sur plusieurs fonctionnalités
 - Environnements entreprise avec des murs de qualité formels avant livraison
-- Domaines complexes où la stratégie de test doit être planifiée avant d'écrire les tests
+- Domaines complexes où la stratégie de test doit être planifiée avant d’écrire les tests
-- Projets ayant dépassé l'approche à workflow unique du QA intégré
+- Projets ayant dépassé l’approche à workflow unique du QA intégré
 
-## Comment les Tests S'Intègrent dans les Workflows
+## Comment les Tests S’Intègrent dans les Workflows
 
-Le workflow Automate du QA intégré apparaît dans la Phase 4 (Implémentation) de la carte de workflow méthode BMad. Il est conçu pour s'exécuter **après qu'un epic complet soit terminé** — une fois que toutes les stories d'un epic ont été implémentées et revues. Une séquence typique :
+Le workflow Automate du QA intégré apparaît dans la Phase 4 (Implémentation) de la carte de workflow méthode BMad. Il est conçu pour s’exécuter **après qu’un epic complet soit terminé** — une fois que toutes les stories d’un epic ont été implémentées et revues. Une séquence typique :
 
-1. Pour chaque story de l'epic : implémenter avec Dev Story (`DS`), puis valider avec Code Review (`CR`)
+1. Pour chaque story de l’epic : implémenter avec Dev Story (`DS`), puis valider avec Code Review (`CR`)
-2. Après la fin de l'epic : générer les tests avec `QA` (via l'agent Developer) ou le workflow Automate de TEA
+2. Après la fin de l’epic : générer les tests avec `QA` (via l’agent Developer) ou le workflow Automate de TEA
 3. Lancer la rétrospective (`bmad-retrospective`) pour capturer les leçons apprises
 
-Le workflow QA travaille directement à partir du code source sans charger les documents de planification (PRD, architecture). Les workflows TEA peuvent s'intégrer avec les artefacts de planification en amont pour la traçabilité.
+Le workflow QA travaille directement à partir du code source sans charger les documents de planification (PRD, architecture). Les workflows TEA peuvent s’intégrer avec les artefacts de planification en amont pour la traçabilité.
 
 Pour en savoir plus sur la place des tests dans le processus global, consultez la [Carte des Workflows](./workflow-map.md).
 
 ## Glossaire
 
 [^1]: QA (Quality Assurance) : assurance qualité, ensemble des processus et activités visant à garantir que le produit logiciel répond aux exigences de qualité définies.
-[^2]: ATDD (Acceptance Test-Driven Development) : méthode de développement où les tests d'acceptation sont écrits avant le code, en collaboration avec les parties prenantes pour définir les critères de réussite.
+[^2]: ATDD (Acceptance Test-Driven Development) : méthode de développement où les tests d’acceptation sont écrits avant le code, en collaboration avec les parties prenantes pour définir les critères de réussite.

docs/fr/reference/workflow-map.md

@@ -1,27 +1,27 @@
 ---
 title: "Carte des Workflows"
-description: Référence visuelle des phases et des résultats des workflows de la méthode BMad
+description: Référence visuelle des phases et des livrables des workflows de la méthode BMad
 sidebar:
   order: 1
 ---
 
-La méthode BMad (BMM) est un module de l'écosystème BMad, conçu pour suivre les meilleures pratiques de l'ingénierie du
+La méthode BMad (BMM) est un module de l’écosystème BMad, conçu pour appliquer les meilleures pratiques d’ingénierie du
-contexte et de la planification. Les agents IA fonctionnent de manière optimale avec un contexte clair et structuré. Le
+contexte et de planification. Les agents IA sont plus performants lorsqu’ils disposent d’un contexte clair et structuré. Le
-système BMM construit ce contexte progressivement à travers 4 phases distinctes — chaque phase, et plusieurs workflows
+système BMM construit ce contexte de manière progressive, en 4 phases distinctes — chaque phase, ainsi que les workflows
-optionnels au sein de chaque phase, produisent des documents qui alimentent la phase suivante, afin que les agents
+optionnels qu’elle contient, produit des documents qui nourrissent la phase suivante. Ainsi, les agents savent toujours
-sachent toujours quoi construire et pourquoi.
+ce qu’ils doivent construire et pourquoi.
 
-La logique et les concepts proviennent des méthodologies agiles qui ont été utilisées avec succès dans l'industrie comme
+La logique et les concepts sous-jacents s’appuient sur les méthodologies agiles, largement éprouvées dans l’industrie
-cadre mental de référence.
+comme cadre de référence.
 
-Si à tout moment vous ne savez pas quoi faire, le skill `bmad-help` vous aidera à rester sur la bonne voie ou à savoir
+Si vous ne savez plus où vous en êtes, le skill `bmad-help` vous remettra sur la bonne voie ou vous indiquera la prochaine
-quoi faire ensuite. Vous pouvez toujours vous référer à cette page également — mais `bmad-help` est entièrement
+étape. Cette page reste une référence utile, mais `bmad-help` est interactif et bien plus rapide si vous avez déjà installé
-interactif et beaucoup plus rapide si vous avez déjà installé la méthode BMad. De plus, si vous utilisez différents
+la méthode BMad. Par ailleurs, si vous utilisez des modules ayant étendu la méthode BMad ou ajouté d’autres modules
-modules qui ont étendu la méthode BMad ou ajouté d'autres modules complémentaires non extensifs — `bmad-help` évolue
+complémentaires non extensibles, `bmad-help` s’adapte automatiquement pour couvrir tout ce qui est disponible et vous
-pour connaître tout ce qui est disponible et vous donner les meilleurs conseils du moment.
+fournir les meilleurs conseils en temps réel.
 
-Note finale importante : Chaque workflow ci-dessous peut être exécuté directement avec l'outil de votre choix via un
+Note importante : chaque workflow ci-dessous peut être exécuté directement via un skill avec l’outil de votre choix, ou
-skill ou en chargeant d'abord un agent et en utilisant l'entrée du menu des agents.
+en chargeant d’abord un agent depuis le menu des agents.
 
 <iframe src="/workflow-map-diagram-fr.html" title="Diagramme de la carte des workflows de la méthode BMad" width="100%" height="100%" style="border-radius: 8px; border: 1px solid #334155; min-height: 900px;"></iframe>
 
@@ -29,93 +29,99 @@ skill ou en chargeant d'abord un agent et en utilisant l'entrée du menu des age
   <a href="/workflow-map-diagram-fr.html" target="_blank" rel="noopener noreferrer">Ouvrir le diagramme dans un nouvel onglet ↗</a>
 </p>
 
-## Phase 1 : Analyse (Optionnelle)
+## Phase 1 : Analyse (Optionnelle)
 
-Explorez l’espace problème et validez les idées avant de vous engager dans la planification. [**Découvrez ce que fait
+Explorez l’espace problème et validez vos idées avant de vous lancer dans la planification. [**Découvrez ce que fait
 chaque outil et quand l’utiliser**](../explanation/analysis-phase.md).
 
-| Workflow                                                                  | Objectif                                                                                 | Produit                   |
+| Workflow                                                                  | Objectif                                                                       | Livrable                  |
-|---------------------------------------------------------------------------|------------------------------------------------------------------------------------------|---------------------------|
+|---------------------------------------------------------------------------|--------------------------------------------------------------------------------|---------------------------|
-| `bmad-brainstorming`                                                      | Brainstormez des idées de projet avec l’accompagnement guidé d’un coach de brainstorming | `brainstorming-report.md` |
+| `bmad-brainstorming`                                                      | Brainstormez des idées de projet, animé par un coach de brainstorming dédié    | `brainstorming-report.md` |
-| `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validez les hypothèses de marché, techniques ou de domaine                               | Rapport de recherches     |
+| `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validez vos hypothèses de marché, techniques ou liées au domaine               | Rapport de recherches     |
-| `bmad-product-brief`                                                      | Capturez la vision stratégique — idéal lorsque votre concept est clair                   | `product-brief.md`        |
+| `bmad-product-brief`                                                      | Formalisez la vision stratégique — idéal lorsque votre concept est bien défini | `product-brief.md`        |
-| `bmad-prfaq`                                                              | Working Backwards — éprouvez et forgez votre concept produit                             | `prfaq-{project}.md`      |
+| `bmad-prfaq`                                                              | Working Backwards — mettez à l’épreuve et affinez votre concept produit        | `prfaq-{project}.md`      |
 
-## Phase 2 : Planification
+## Phase 2 : Planification
 
-Définissez ce qu'il faut construire et pour qui.
+Définissez ce qu’il faut construire et pour qui.
 
-| Workflow                | Objectif                                                | Produit      |
+| Workflow   | Objectif                                                                                               | Livrable                                                                                                          |
-|-------------------------|---------------------------------------------------------|--------------|
+|------------|--------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------|
-| `bmad-create-prd`       | Définissez les exigences (FRs/NFRs)[^1]                 | `PRD.md`[^2] |
+| `bmad-prd` | Créez, mettez à jour ou validez un PRD[^1] — découverte accompagnée, trois intentions en un seul skill | Création/Mise à jour : `prd.md`, `addendum.md`, `.memlog.md` ; Validation : `validation-report.html` + `.md` |
-| `bmad-ux`            | Concevez l'expérience utilisateur (lorsque l'UX compte) | `DESIGN.md`, `EXPERIENCE.md` |
+| `bmad-ux`  | Concevez l’expérience utilisateur (lorsque l’UX compte)                                                | `DESIGN.md`, `EXPERIENCE.md`                                                                                      |
 
-## Phase 3 : Solutioning
+:::tip[Trois intentions en un seul skill]
+`bmad-prd` couvre l’intégralité du cycle de vie du PRD. Précisez votre intention lors de l’appel, sinon le skill vous la demandera :
+
+- **Créer** — nouveau PRD à partir de zéro via une découverte accompagnée ; produit `prd.md`, `addendum.md` et `.memlog.md`
+- **Mettre à jour** — réconcilie un PRD existant avec un signal de changement, en mettant en évidence les conflits avant d’appliquer les modifications
+- **Valider** — évalue un PRD à l’aide d’une liste de contrôle configurable et produit un rapport de constats structuré au format HTML
+:::
+
+:::tip[En amont : `bmad-product-brief`]
+`bmad-product-brief` (Phase 1) produit un `product-brief.md` que `bmad-prd` peut exploiter lors de la découverte, réduisant les redondances et gardant les deux documents alignés. Aucun des deux skills ne nécessite l’autre — commencez directement par `bmad-prd` si vous savez déjà ce que vous construisez.
+:::
+
+## Phase 3 : Conception de la Solution
 
 Décidez comment le construire et décomposez le travail en stories.
 
-| Workflow                              | Objectif                                          | Produit                         |
+| Workflow                              | Objectif                                          | Livrable                        |
 |---------------------------------------|---------------------------------------------------|---------------------------------|
-| `bmad-create-architecture`            | Rendez les décisions techniques explicites        | `architecture.md` avec ADRs[^3] |
+| `bmad-create-architecture`            | Rendez explicites les décisions techniques        | `architecture.md` avec ADRs[^2] |
-| `bmad-create-epics-and-stories`       | Décomposez les exigences en travail implémentable | Fichiers d'epic avec stories    |
+| `bmad-create-epics-and-stories`       | Décomposez les exigences en tâches implémentables | Fichiers d’epic avec stories    |
-| `bmad-check-implementation-readiness` | Vérification avant implémentation                 | Décision Passe/Réserves/Échec   |
+| `bmad-check-implementation-readiness` | Jalon de validation avant implémentation          | Décision OK / RÉSERVES / ÉCHEC  |
 
-## Phase 4 : Implémentation
+## Phase 4 : Implémentation
 
-Construisez, une story à la fois. Bientôt disponible : automatisation complète de la phase 4 !
+Construisez, une story à la fois. L’automatisation complète de la phase 4 arrive bientôt !
 
-| Workflow               | Objectif                                                                            | Produit                                              |
+| Workflow               | Objectif                                                                             | Livrable                         |
-|------------------------|-------------------------------------------------------------------------------------|------------------------------------------------------|
+|------------------------|--------------------------------------------------------------------------------------|----------------------------------|
-| `bmad-sprint-planning` | Initialisez le suivi (une fois par projet pour séquencer le cycle de développement) | `sprint-status.yaml`                                 |
+| `bmad-sprint-planning` | Initialisez le suivi (une fois par projet, pour séquencer le cycle de développement) | `sprint-status.yaml`             |
-| `bmad-create-story`    | Préparez la story suivante pour implémentation                                      | `story-[slug].md`                                    |
+| `bmad-create-story`    | Préparez la story suivante pour implémentation                                       | `story-[slug].md`                |
-| `bmad-dev-story`       | Implémentez la story                                                                | Code fonctionnel + tests                             |
+| `bmad-dev-story`       | Implémentez la story                                                                 | Code fonctionnel + tests         |
-| `bmad-code-review`     | Validez la qualité de l'implémentation                                              | Approuvé ou changements demandés                     |
+| `bmad-code-review`     | Validez la qualité de l’implémentation                                               | Approuvé ou changements demandés |
-| `bmad-correct-course`  | Gérez les changements significatifs en cours de sprint                              | Plan mis à jour ou réorientation                     |
+| `bmad-correct-course`  | Gérez les changements significatifs en cours de sprint                               | Plan mis à jour ou réorientation |
-| `bmad-sprint-status`   | Suivez la progression du sprint et le statut des stories                            | Mise à jour du statut du sprint                      |
+| `bmad-sprint-status`   | Suivez la progression du sprint et le statut des stories                             | Mise à jour du statut du sprint  |
-| `bmad-retrospective`   | Revue après complétion d'un epic                                                    | Leçons apprises                                      |
+| `bmad-retrospective`   | Bilan après l’achèvement d’un epic                                                   | Leçons apprises                  |
-| `bmad-investigate`     | Enquête de cas avec conclusions à preuves graduées, calibrée selon l'entrée         | `{slug}-investigation.md`        |
+| `bmad-investigate`     | Analyse forensique avec conclusions pondérées par les preuves, adaptée au cas traité | `{slug}-investigation.md`        |
 
-## Quick Dev (Parcours Parallèle)
+## Flux Rapide (Parcours Parallèle)
 
-Sautez les phases 1-3 pour les travaux de faible envergure et bien compris.
+Ignorez les phases 1 à 3 pour les travaux de faible envergure et bien cernés.
 
-| Workflow         | Objectif                                                                            | Produit            |
+| Workflow         | Objectif                                                                              | Livrable           |
-|------------------|-------------------------------------------------------------------------------------|--------------------|
+|------------------|---------------------------------------------------------------------------------------|--------------------|
-| `bmad-quick-dev` | Flux rapide unifié — clarifie l'intention, planifie, implémente, révise et présente | `spec-*.md` + code |
+| `bmad-quick-dev` | Flux rapide unifié — clarifiez l’intention, planifiez, implémentez, révisez et livrez | `spec-*.md` + code |
 
 ## Gestion du Contexte
 
-Chaque document devient le contexte de la phase suivante. Le PRD[^2] indique à l'architecte quelles contraintes sont
+Chaque document nourrit le contexte de la phase suivante. Le PRD indique à l’architecte les contraintes à respecter.
-importantes. L'architecture indique à l'agent de développement quels modèles suivre. Les fichiers de story fournissent
+L’architecture précise à l’agent de développement les modèles à suivre. Les fichiers de story fournissent un contexte
-un contexte focalisé et complet pour l'implémentation. Sans cette structure, les agents prennent des décisions
+ciblé et exhaustif pour l’implémentation. Sans cette structure, les agents prennent des décisions incohérentes.
-incohérentes.
 
 ### Contexte du Projet
 
 :::tip[Recommandé]
-Créez `project-context.md` pour vous assurer que les agents IA suivent les règles et préférences de votre projet. Ce
+Créez `project-context.md` pour que les agents IA respectent les règles et préférences de votre projet. Ce fichier agit
-fichier fonctionne comme une constitution pour votre projet — il guide les décisions d'implémentation à travers tous les
+comme une charte pour votre projet — il oriente les décisions d’implémentation à travers tous les workflows. Ce fichier
-workflows. Ce fichier optionnel peut être généré à la fin de la création de l'architecture, ou dans un projet existant
+optionnel peut être généré à la fin de la création de l’architecture, ou, dans un projet existant, pour capturer les
-il peut également être généré pour capturer ce qui est important de conserver aligné avec les conventions actuelles.
+éléments clés et les garder alignés avec les conventions en vigueur.
 :::
 
-**Comment le créer :**
+**Comment le créer :**
 
-- **Manuellement** — Créez `_bmad-output/project-context.md` avec votre pile technologique et vos règles
+- **Manuellement** — Créez `_bmad-output/project-context.md` avec votre stack technique et vos règles d’implémentation
-  d'implémentation
+- **Générez-le** — Exécutez `bmad-generate-project-context` pour l’auto-générer à partir de votre architecture ou de votre codebase
-- **Générez-le** — Exécutez `bmad-generate-project-context` pour l'auto-générer à partir de votre architecture ou de
-  votre codebase
 
 [**En savoir plus sur project-context.md**](../explanation/project-context.md)
 
 ## Glossaire
 
-[^1]: FR / NFR (Functional / Non-Functional Requirement) : exigences décrivant respectivement **ce que le système doit
+[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins
-faire** (fonctionnalités, comportements attendus) et **comment il doit le faire** (contraintes de performance, sécurité,
-fiabilité, ergonomie, etc.).
-[^2]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins
 utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur
 ce qui doit être construit et pourquoi.
-[^3]: ADR (Architecture Decision Record) : document qui consigne une décision d’architecture, son contexte, les options
+[^2]: ADR (Architecture Decision Record) : document qui consigne une décision d’architecture, son contexte, les options
 envisagées, le choix retenu et ses conséquences, afin d’assurer la traçabilité et la compréhension des décisions
 techniques dans le temps.

docs/fr/roadmap.mdx

@@ -3,7 +3,7 @@ title: Feuille de route
 description: La suite pour BMad - Fonctionnalités, améliorations et contributions de la communauté
 ---
 
-# La Méthode BMad : Feuille de route publique
+# La Méthode BMad : Feuille de route publique
 
 La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voici ce sur quoi nous travaillons et ce qui arrive prochainement.
 
@@ -30,17 +30,17 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">📦</span>
       <h4>Skills Centralisés</h4>
-      <p>Installez une fois, utilisez partout. Partagez des skills entre projets sans l'encombrement de fichiers.</p>
+      <p>Installez une fois, utilisez partout. Partagez des skills entre projets sans l’encombrement de fichiers.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🔄</span>
       <h4>Skills Adaptatifs</h4>
-      <p>Des skills qui connaissent vos outils. Des variantes optimisées pour Claude, Codex, Kimi et OpenCode, et bien d'autres encore.</p>
+      <p>Des skills qui connaissent vos outils. Des variantes optimisées pour Claude, Codex, Kimi et OpenCode, et bien d’autres encore.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">📝</span>
       <h4>Blog BMad Team Pros</h4>
-      <p>Guides, articles et perspectives de l'équipe. Lancement prochainement.</p>
+      <p>Guides, articles et perspectives de l’équipe. Lancement prochainement.</p>
     </div>
   </div>
 
@@ -60,12 +60,12 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🚀</span>
       <h4>Optimisation Phases 1-3</h4>
-      <p>Planification éclair avec collecte de contexte par sous-agents. Le mode YOLO rencontre l'excellence guidée.</p>
+      <p>Planification éclair avec collecte de contexte par sous-agents. Le mode YOLO rencontre l’excellence guidée.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🌐</span>
-      <h4>Prêt pour l'Entreprise</h4>
+      <h4>Prêt pour l’Entreprise</h4>
-      <p>SSO, journaux d'audit, espaces de travail d'équipe. Toutes les choses ennuyantes qui feront dire oui aux entreprises.</p>
+      <p>SSO, journaux d’audit, espaces de travail d’équipe. Toutes les choses ennuyantes qui feront dire oui aux entreprises.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">💎</span>
@@ -75,7 +75,7 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">⚡</span>
       <h4>Automatisation de la Boucle de Développement</h4>
-      <p>Pilote automatique optionnel pour le développement. Laissez l'IA gérer le flux tout en maintenant une qualité optimale.</p>
+      <p>Pilote automatique optionnel pour le développement. Laissez l’IA gérer le flux tout en maintenant une qualité optimale.</p>
     </div>
   </div>
 
@@ -85,12 +85,12 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🎙️</span>
       <h4>Le Podcast de la Méthode BMad</h4>
-      <p>Conversations sur le développement natif IA. Lancement le 1er mars 2026 !</p>
+      <p>Conversations sur le développement natif IA. Lancement le 1er mars 2026 !</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🎓</span>
       <h4>Le Master Class de la Méthode BMad</h4>
-      <p>Passez d'utilisateur à expert. Approfondissements dans chaque phase, chaque workflow, chaque secret.</p>
+      <p>Passez d’utilisateur à expert. Approfondissements dans chaque phase, chaque workflow, chaque secret.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🏗️</span>
@@ -100,17 +100,17 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">⚡</span>
       <h4>BMad Prototype First</h4>
-      <p>De l'idée au prototype fonctionnel en une seule session. Créez l'application de vos rêves comme une œuvre d'art.</p>
+      <p>De l’idée au prototype fonctionnel en une seule session. Créez l’application de vos rêves comme une œuvre d’art.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🌴</span>
-      <h4>BMad BALM !</h4>
+      <h4>BMad BALM !</h4>
-      <p>Gestion de vie native IA. Tâches, habitudes, objectifs : votre copilote IA pour tout.</p>
+      <p>Gestion de vie native IA. Tâches, habitudes, objectifs : votre copilote IA pour tout.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🖥️</span>
       <h4>UI Officielle</h4>
-      <p>Une belle interface pour tout l'écosystème BMad. La puissance de la CLI, le polissage de l'interface graphique.</p>
+      <p>Une belle interface pour tout l’écosystème BMad. La puissance de la CLI, le polissage de l’interface graphique.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🔒</span>
@@ -120,16 +120,16 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
   </div>
 
   <div style="text-align: center; margin-top: 3rem; padding: 2rem; background: var(--color-bg-card); border-radius: 12px; border: 1px solid var(--color-border);">
-    <h3 style="margin: 0 0 1rem;">Envie de contribuer ?</h3>
+    <h3 style="margin: 0 0 1rem;">Envie de contribuer ?</h3>
     <p style="color: var(--slate-color-400); margin: 0;">
-      Ce n'est qu'une liste partielle de ce qui est prévu. L'équipe Open Source BMad accueille les contributeurs !{" "}<br />
+      Ce n’est qu’une liste partielle de ce qui est prévu. L’équipe Open Source BMad accueille les contributeurs !{" "}<br />
-      <a href="https://github.com/bmad-code-org/BMAD-METHOD" style="color: var(--color-in-progress);">Rejoignez-nous sur GitHub</a> pour aider à façonner l'avenir du développement propulsé par l'IA.
+      <a href="https://github.com/bmad-code-org/BMAD-METHOD" style="color: var(--color-in-progress);">Rejoignez-nous sur GitHub</a> pour aider à façonner l’avenir du développement propulsé par l’IA.
     </p>
     <p style="color: var(--slate-color-400); margin: 1.5rem 0 0;">
-      Vous aimez ce que nous construisons ? Nous apprécions le soutien ponctuel et mensuel sur{" "}<a href="https://buymeacoffee.com/bmad" style="color: var(--color-in-progress);">Buy Me a Coffee</a>.
+      Vous aimez ce que nous construisons ? Nous apprécions le soutien ponctuel et mensuel sur{" "}<a href="https://buymeacoffee.com/bmad" style="color: var(--color-in-progress);">Buy Me a Coffee</a>.
     </p>
     <p style="color: var(--slate-color-400); margin: 1rem 0 0;">
-      Pour les parrainages d'entreprise, les demandes de partenariat, les interventions, les formations ou les demandes médias :{" "}
+      Pour les parrainages d’entreprise, les demandes de partenariat, les interventions, les formations ou les demandes médias :{" "}
       <a href="mailto:contact@bmadcode.com" style="color: var(--color-in-progress);">contact@bmadcode.com</a>
     </p>
   </div>

docs/fr/tutorials/getting-started.md

@@ -1,90 +1,91 @@
 ---
 title: "Premiers pas"
-description: Installer BMad et construire votre premier projet
+description: Installer BMad et développer votre premier projet
 ---
 
-Construisez des logiciels plus rapidement en utilisant des workflows propulsés par l'IA avec des agents spécialisés qui vous guident à travers la planification, l'architecture et l'implémentation.
+Accélérez le développement de vos applications grâce à des workflows alimentés par l’IA et des agents spécialisés qui vous guident dans la planification, l’architecture et l’implémentation.
 
 ## Ce que vous allez apprendre
 
 - Installer et initialiser la méthode BMad pour un nouveau projet
 - Utiliser **BMad-Help** — votre guide intelligent qui sait quoi faire ensuite
 - Choisir la bonne voie de planification selon la taille de votre projet
-- Progresser à travers les phases, des exigences au code fonctionnel
+- Progresser dans les phases, de la définition des exigences au code fonctionnel
 - Utiliser efficacement les agents et les workflows
 
 :::note[Prérequis]
-- **Node.js 20.12+** — Requis pour l'installateur
+- **Node.js 20.12+** — Nécessaire pour l’installation
-- **Git** — Recommandé pour le contrôle de version
+- **Git** — Recommandé pour la gestion de versions
-- **IDE IA** — Claude Code, Cursor, ou similaire
+- **IDE avec IA intégrée** — Claude Code, Cursor ou équivalent
-- **Une idée de projet** — Même simple, elle fonctionne pour apprendre
+- **Une idée de projet** — Même simple, elle fera l’affaire pour commencer
 :::
 
-:::tip[Le chemin le plus simple]
+:::tip[Le chemin le plus rapide]
 **Installer** → `npx bmad-method install`
 **Demander** → `bmad-help que dois-je faire en premier ?`
-**Construire** → Laissez BMad-Help vous guider workflow par workflow
+**Développez** → Laissez BMad-Help vous guider, workflow par workflow
 :::
 
-## Découvrez BMad-Help : votre guide intelligent
+## Découvrez BMad-Help : votre guide intelligent
 
-**BMad-Help est le moyen le plus rapide de démarrer avec BMad.** Vous n'avez pas besoin de mémoriser les workflows ou les phases — posez simplement la question, et BMad-Help va :
+**BMad-Help est le moyen le plus rapide de démarrer avec BMad.** Pas besoin de mémoriser les workflows ou les phases — posez simplement votre question et BMad-Help saura :
 
 - **Inspecter votre projet** pour voir ce qui a déjà été fait
-- **Vous montrer vos options** en fonction des modules que vous avez installés
+- **Vous présenter vos options** en fonction des modules installés
-- **Recommander la prochaine étape** — y compris la première tâche obligatoire
+- **Vous recommander la prochaine étape** — y compris la première tâche obligatoire
-- **Répondre aux questions** comme « J'ai une idée de SaaS, par où commencer ? »
+- **Répondre à vos questions**, par exemple : « J’ai une idée de SaaS, par où commencer ? »
 
 ### Comment utiliser BMad-Help
 
-Exécutez-le dans votre IDE avec IA en invoquant la skill :
+Dans votre IDE IA, invoquez le skill :
 
 ```
 bmad-help
 ```
 
-Ou combinez-le avec une question pour obtenir des conseils adaptés au contexte :
+Ou accompagnez-le d’une question pour obtenir des conseils contextualisés :
 
 ```
 bmad-help J'ai une idée de produit SaaS, je connais déjà toutes les fonctionnalités que je veux. Par où dois-je commencer ?
 ```
 
-BMad-Help répondra avec :
+BMad-Help vous indiquera :
+
 - Ce qui est recommandé pour votre situation
 - Quelle est la première tâche obligatoire
 - À quoi ressemble le reste du processus
 
-### Il alimente aussi les workflows
+### Il intervient aussi dans les workflows
 
-BMad-Help ne se contente pas de répondre aux questions — **il s'exécute automatiquement à la fin de chaque workflow** pour vous dire exactement quoi faire ensuite. Pas de devinettes, pas de recherche dans la documentation — juste des conseils clairs sur le prochain workflow requis.
+BMad-Help ne se contente pas de répondre aux questions — **il se lance automatiquement à la fin de chaque workflow** pour vous indiquer exactement la suite. Finies les devinettes et les recherches dans la doc : vous recevez des instructions claires sur le prochain workflow à exécuter.
 
 :::tip[Commencez ici]
-Après avoir installé BMad, invoquez immédiatement la skill `bmad-help`. Elle détectera les modules que vous avez installés et vous guidera vers le bon point de départ pour votre projet.
+Après avoir installé BMad, invoquez immédiatement le skill `bmad-help`. Il détectera les modules que vous avez installés et vous orientera vers le bon point de départ pour votre projet.
 :::
 
 ## Comprendre BMad
 
-BMad vous aide à construire des logiciels grâce à des workflows guidés avec des agents IA spécialisés. Le processus suit quatre phases :
+BMad vous aide à développer des logiciels grâce à des workflows guidés par des agents IA spécialisés. Le processus s’articule en quatre phases :
 
 | Phase | Nom            | Ce qui se passe                                                |
 |-------|----------------|----------------------------------------------------------------|
-| 1     | Analyse        | Brainstorming, recherche, product brief ou PRFAQ *(optionnel)*          |
+| 1     | Analyse        | Brainstorming, recherche, product brief ou PRFAQ _(optionnel)_ |
-| 2     | Planification  | Créer les exigences (PRD[^1] ou spécification technique)       |
+| 2     | Planification  | Définir les exigences (PRD[^1] ou spécification technique)     |
-| 3     | Solutioning    | Concevoir l'architecture *(BMad Method/Enterprise uniquement)* |
+| 3     | Solutioning    | Concevoir l’architecture _(BMad Method/Enterprise uniquement)_ |
-| 4     | Implémentation | Construire epic[^2] par epic, story[^3] par story              |
+| 4     | Implémentation | Développer epic[^2] par epic, story[^3] par story              |
 
-**[Ouvrir la carte des workflows](../reference/workflow-map.md)** pour explorer les phases, les workflows et la gestion du contexte.
+**[Ouvrez la carte des workflows](../reference/workflow-map.md)** pour explorer les phases, les workflows et la gestion du contexte.
 
 Selon la complexité de votre projet, BMad propose trois voies de planification :
 
 | Voie             | Idéal pour                                                                   | Documents créés                        |
 |------------------|------------------------------------------------------------------------------|----------------------------------------|
 | **Quick Dev**    | Corrections de bugs, fonctionnalités simples, périmètre clair (1-15 stories) | Spécification technique uniquement     |
-| **méthode BMad** | Produits, plateformes, fonctionnalités complexes (10-50+ stories)            | PRD + Architecture + UX[^4]            |
+| **BMad Method**  | Produits, plateformes, fonctionnalités complexes (10-50+ stories)            | PRD + Architecture + UX[^4]            |
 | **Enterprise**   | Conformité, systèmes multi-tenant[^5] (30+ stories)                          | PRD + Architecture + Security + DevOps |
 
 :::note
-Les comptes de stories sont indicatifs, pas des définitions. Choisissez votre voie en fonction des besoins de planification, pas du calcul des stories.
+Le nombre de stories est indicatif, pas strictement défini. Choisissez votre voie en fonction de vos besoins de planification, pas d’un simple décompte de stories.
 :::
 
 ## Installation
@@ -95,13 +96,14 @@ Ouvrez un terminal dans le répertoire de votre projet et exécutez :
 npx bmad-method install
 ```
 
-Si vous souhaitez la version préliminaire la plus récente au lieu du canal de release par défaut, utilisez `npx bmad-method@next install`.
+Si vous préférez la dernière version préliminaire au lieu du canal de publication par défaut, utilisez `npx bmad-method@next install`.
 
-Lorsque vous êtes invité à sélectionner des modules, choisissez **méthode BMad**.
+À l’invite de sélection des modules, choisissez **BMad Method**.
+
+L’installateur crée deux dossiers :
 
-L'installateur crée deux dossiers :
 - `_bmad/` — agents, workflows, tâches et configuration
-- `_bmad-output/` — vide pour l'instant, mais c'est là que vos artefacts seront enregistrés
+- `_bmad-output/` — vide pour le moment, mais c’est là que seront enregistrés vos artefacts
 
 :::tip[Votre prochaine étape]
 Ouvrez votre IDE avec IA dans le dossier du projet et exécutez :
@@ -110,108 +112,120 @@ Ouvrez votre IDE avec IA dans le dossier du projet et exécutez :
 bmad-help
 ```
 
-BMad-Help détectera ce que vous avez accompli et recommandera exactement quoi faire ensuite. Vous pouvez aussi lui poser des questions comme « Quelles sont mes options ? » ou « J'ai une idée de SaaS, par où devrais-je commencer ? »
+BMad-Help détectera ce que vous avez déjà accompli et vous recommandera exactement la suite. Vous pouvez aussi lui poser des questions comme « Quelles sont mes options ? » ou « J’ai une idée de SaaS, par où devrais-je commencer ? »
 :::
 
 :::note[Comment charger les agents et exécuter les workflows]
-Chaque workflow possède une **skill** que vous invoquez par nom dans votre IDE (par ex., `bmad-create-prd`). Votre outil IA reconnaîtra le nom `bmad-*` et l'exécutera — vous n'avez pas besoin de charger les agents séparément. Vous pouvez aussi invoquer directement une skill d'agent pour une conversation générale (par ex., `bmad-agent-pm` pour l'agent PM).
+Chaque workflow possède une **skill** que vous invoquez par son nom dans votre IDE (par ex. `bmad-prd`). Votre outil IA reconnaîtra le nom `bmad-*` et l’exécutera — pas besoin de charger les agents séparément. Vous pouvez aussi invoquer directement une skill d’agent pour une conversation générale (par ex. `bmad-agent-pm` pour l’agent PM).
 :::
 
 :::caution[Nouveaux chats]
-Démarrez toujours un nouveau chat pour chaque workflow. Cela évite que les limitations de contexte ne causent des problèmes.
+Démarrez toujours un nouveau chat pour chaque workflow. Cela évite les problèmes liés aux limites de contexte de l’IA.
 :::
 
-## Étape 1 : Créer votre plan
+## Étape 1 : Élaborer votre plan
 
-Travaillez à travers les phases 1-3. **Utilisez de nouveaux chats pour chaque workflow.**
+Parcourez les phases 1 à 3. **Utilisez un nouveau chat pour chaque workflow.**
 
-:::tip[Contexte de projet (Optionnel)]
+:::tip[Contexte projet (optionnel)]
-Avant de commencer, envisagez de créer `project-context.md` pour documenter vos préférences techniques et règles d'implémentation. Cela garantit que tous les agents IA suivent vos conventions tout au long du projet.
+Avant de commencer, pensez à créer `project-context.md` pour documenter vos préférences techniques et vos règles d’implémentation. Ainsi, tous les agents IA respecteront vos conventions tout au long du projet.
 
-Créez-le manuellement dans `_bmad-output/project-context.md` ou générez-le après l'architecture en utilisant `bmad-generate-project-context`. [En savoir plus](../explanation/project-context.md).
+Créez-le manuellement à l’emplacement `_bmad-output/project-context.md`, ou générez-le après l’architecture avec `bmad-generate-project-context`. [En savoir plus](../explanation/project-context.md).
 :::
 
-### Phase 1 : Analyse (Optionnel)
+### Phase 1 : Analyse (optionnelle)
+
+Tous les workflows de cette phase sont optionnels. [**Vous ne savez pas lequel choisir ?**](../explanation/analysis-phase.md)
 
-Tous les workflows de cette phase sont optionnels. [**Pas sûr de quel outil utiliser ?**](../explanation/analysis-phase.md)
 - **brainstorming** (`bmad-brainstorming`) — Idéation guidée
 - **research** (`bmad-market-research` / `bmad-domain-research` / `bmad-technical-research`) — Recherche marché, domaine et technique
-- **product-brief** (`bmad-product-brief`) — Document de base recommandé lorsque votre concept est clair
+- **product-brief** (`bmad-product-brief`) — Document fondateur recommandé une fois votre concept bien défini
-- **prfaq** (`bmad-prfaq`) — Défi Working Backwards pour éprouver et forger votre concept produit
+- **prfaq** (`bmad-prfaq`) — Exercice Working Backwards pour tester et affiner votre concept produit
 
-### Phase 2 : Planification (Requis)
+### Phase 2 : Planification (requise)
 
-**Pour les voies BMad Method et Enterprise :**
+**Pour les voies BMad Method et Enterprise :**
-1. Invoquez l'**agent PM** (`bmad-agent-pm`) dans un nouveau chat
-2. Exécutez le workflow `bmad-create-prd` (`bmad-create-prd`)
-3. Sortie : `PRD.md`
 
-**Pour la voie Quick Dev :**
+1. Exécutez `bmad-prd` dans un nouveau chat — précisez votre intention (Create / Update / Validate) ou laissez le skill vous la demander
-- Exécutez `bmad-quick-dev` — il gère la planification et l'implémentation dans un seul workflow, passez directement à l'implémentation
+2. Résultat : `prd.md`, `addendum.md`, `.memlog.md`
 
-:::note[Design UX (Optionnel)]
+:::note[Intentions de `bmad-prd`]
-Si votre projet a une interface utilisateur, invoquez l'**agent Designer UX** (`bmad-agent-ux-designer`) et exécutez le workflow de design UX (`bmad-ux`) après avoir créé votre PRD.
+
+- **Create** — exploration guidée à partir de zéro ; le skill nomme le dossier de travail et vous accompagne jusqu’à l’obtention d’un PRD dont vous serez fier
+- **Update** — pointez vers un PRD existant et un changement à apporter ; le skill met en évidence les conflits avant d’appliquer les modifications
+- **Validate** — critiquez un PRD finalisé à l’aide d’une liste de contrôle et générez un rapport HTML des constatations
 :::
 
-### Phase 3 : Solutioning (méthode BMad/Enterprise)
 
-**Créer l'Architecture**
+**Pour la voie Quick Dev :**
+
+- Exécutez `bmad-quick-dev` — ce workflow couvre la planification et l’implémentation en une seule fois ; vous pouvez passer directement à l’implémentation
+
+:::note[Design UX (optionnel)]
+Si votre projet comporte une interface utilisateur, invoquez l'**agent UX Designer** (`bmad-agent-ux-designer`) et lancez le workflow de design UX (`bmad-ux`) après avoir créé votre PRD.
+:::
+
+### Phase 3 : Solutioning (BMad Method/Enterprise)
+
+**Créer l’architecture**
+
 1. Invoquez l'**agent Architecte** (`bmad-agent-architect`) dans un nouveau chat
 2. Exécutez `bmad-create-architecture` (`bmad-create-architecture`)
-3. Sortie : Document d'architecture avec les décisions techniques
+3. Résultat : document d’architecture avec les décisions techniques
 
-**Créer les Epics et Stories**
+**Créer les epics et les stories**
 
 :::tip[Amélioration V6]
-Les epics et stories sont maintenant créés *après* l'architecture. Cela produit des stories de meilleure qualité car les décisions d'architecture (base de données, patterns d'API, pile technologique) affectent directement la façon dont le travail doit être décomposé.
+Les epics et stories sont désormais créés *après* l’architecture. Cela produit des stories de meilleure qualité, car les décisions d’architecture (choix de la base de données, patterns d’API, pile technologique) influencent directement la façon dont le travail doit être découpé.
 :::
 
 1. Invoquez l'**agent PM** (`bmad-agent-pm`) dans un nouveau chat
 2. Exécutez `bmad-create-epics-and-stories` (`bmad-create-epics-and-stories`)
-3. Le workflow utilise à la fois le PRD et l'Architecture pour créer des stories techniquement éclairées
+3. Le workflow s’appuie sur le PRD et l’architecture pour créer des stories techniquement fondées
+
+**Vérification de la préparation à l’implémentation** *(fortement recommandée)*
 
-**Vérification de préparation à l'implémentation** *(Hautement recommandé)*
 1. Invoquez l'**agent Architecte** (`bmad-agent-architect`) dans un nouveau chat
 2. Exécutez `bmad-check-implementation-readiness` (`bmad-check-implementation-readiness`)
-3. Valide la cohérence entre tous les documents de planification
+3. Valide la cohérence de l’ensemble des documents de planification
 
-## Étape 2 : Construire votre projet
+## Étape 2 : Développer votre projet
 
-Une fois la planification terminée, passez à l'implémentation. **Chaque workflow doit s'exécuter dans un nouveau chat.**
+Une fois la planification terminée, passez à l’implémentation. **Chaque workflow doit être exécuté dans un nouveau chat.**
 
 ### Initialiser la planification de sprint
 
-Invoquez **l’agent Développeur** (`bmad-agent-dev`) et lancez `bmad-sprint-planning`. Cela crée `sprint-status.yaml` pour suivre tous les epics et stories.
+Invoquez l'**agent Développeur** (`bmad-agent-dev`) et exécutez `bmad-sprint-planning` (`bmad-sprint-planning`). Cette commande crée `sprint-status.yaml` pour suivre tous les epics et stories.
 
-### Le cycle de construction
+### Le cycle de développement
 
-Pour chaque story, répétez ce cycle avec de nouveaux chats :
+Pour chaque story, répétez ce cycle dans de nouveaux chats :
 
-| Étape | AGENT | Workflow            | Commande            | Objectif                             |
+| Étape | Agent | Workflow            | Commande            | Objectif                             |
 |-------|-------|---------------------|---------------------|--------------------------------------|
-| 1     | DEV   | `bmad-create-story` | `bmad-create-story` | Créer le fichier story depuis l'epic |
+| 1     | DEV   | `bmad-create-story` | `bmad-create-story` | Créer le fichier story depuis l’epic |
 | 2     | DEV   | `bmad-dev-story`    | `bmad-dev-story`    | Implémenter la story                 |
-| 3     | DEV   | `bmad-code-review`  | `bmad-code-review`  | Validation de qualité *(recommandé)* |
+| 3     | DEV   | `bmad-code-review`  | `bmad-code-review`  | Validation qualité *(recommandée)*   |
 
-Après avoir terminé toutes les stories d'un epic, invoquez **l’agent Développeur** (`bmad-agent-dev`), et exécutez `bmad-retrospective`.
+Après avoir terminé toutes les stories d’un epic, invoquez l'**agent Développeur** (`bmad-agent-dev`) et exécutez `bmad-retrospective` (`bmad-retrospective`).
 
 ## Ce que vous avez accompli
 
-Vous avez appris les fondamentaux de la construction avec BMad :
+Vous maîtrisez maintenant les bases du développement avec BMad :
 
-- Installé BMad et configuré pour votre IDE
+- Installation et configuration de BMad pour votre IDE
-- Initialisé un projet avec votre voie de planification choisie
+- Initialisation d’un projet avec la voie de planification choisie
-- Créé des documents de planification (PRD, Architecture, Epics & Stories)
+- Création des documents de planification (PRD, Architecture, Epics & Stories)
-- Compris le cycle de construction pour l'implémentation
+- Compréhension du cycle de développement pour l’implémentation
 
-Votre projet contient maintenant :
+Votre projet contient désormais :
 
 ```text
 your-project/
 ├── _bmad/                                   # Configuration BMad
 ├── _bmad-output/
 │   ├── planning-artifacts/
-│   │   ├── PRD.md                           # Votre document d'exigences
+│   │   ├── PRD.md                           # Document d'exigences
 │   │   ├── architecture.md                  # Décisions techniques
 │   │   └── epics/                           # Fichiers epic et story
 │   ├── implementation-artifacts/
@@ -224,12 +238,12 @@ your-project/
 
 | Workflow                              | Commande                              | Agent     | Objectif                                                        |
 |---------------------------------------|---------------------------------------|-----------|-----------------------------------------------------------------|
-| **`bmad-help`** ⭐                    | `bmad-help`                           | Tous      | **Votre guide intelligent — posez n'importe quelle question !** |
+| **`bmad-help`** ⭐                    | `bmad-help`                           | Tous      | **Votre guide intelligent — posez n’importe quelle question !**  |
-| `bmad-create-prd`                     | `bmad-create-prd`                     | PM        | Créer le document d'exigences produit                           |
+| `bmad-prd`                            | `bmad-prd`                            | Tous      | Créer, mettre à jour ou valider un PRD                          |
-| `bmad-create-architecture`            | `bmad-create-architecture`            | Architect | Créer le document d'architecture                                |
+| `bmad-create-architecture`            | `bmad-create-architecture`            | Architect | Créer le document d’architecture                                |
 | `bmad-generate-project-context`       | `bmad-generate-project-context`       | Analyst   | Créer le fichier de contexte projet                             |
 | `bmad-create-epics-and-stories`       | `bmad-create-epics-and-stories`       | PM        | Décomposer le PRD en epics                                      |
-| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Valider la cohérence de planification                           |
+| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Valider la cohérence de la planification                        |
 | `bmad-sprint-planning`                | `bmad-sprint-planning`                | DEV       | Initialiser le suivi de sprint                                  |
 | `bmad-create-story`                   | `bmad-create-story`                   | DEV       | Créer un fichier story                                          |
 | `bmad-dev-story`                      | `bmad-dev-story`                      | DEV       | Implémenter une story                                           |
@@ -237,31 +251,32 @@ your-project/
 
 ## Questions fréquentes
 
-**Ai-je toujours besoin d'une architecture ?**
+**Ai-je toujours besoin d’une architecture ?**
-Uniquement pour les voies méthode BMad et Enterprise. Quick Dev passe directement de la spécification technique (spec) à l'implémentation.
+Seulement pour les voies BMad Method et Enterprise. Quick Dev passe directement de la spécification à l’implémentation.
 
-**Puis-je modifier mon plan plus tard ?**
+**Puis-je modifier mon plan en cours de route ?**
-Oui. Utilisez `bmad-correct-course` pour gérer les changements de périmètre en cours d’implémentation.
+Oui. Le workflow `bmad-correct-course` gère les changements de périmètre en cours d’implémentation.
 
-**Et si je veux d'abord faire du brainstorming ?**
+**Et si je veux d’abord brainstormer ?**
-Invoquez l'agent Analyst (`bmad-agent-analyst`) et exécutez `bmad-brainstorming` (`bmad-brainstorming`) avant de commencer votre PRD.
+Invoquez l’agent Analyste (`bmad-agent-analyst`) et exécutez `bmad-brainstorming` (`bmad-brainstorming`) avant de commencer votre PRD.
 
-**Dois-je suivre un ordre strict ?**
+**Dois-je suivre un ordre strict ?**
-Pas strictement. Une fois que vous maîtrisez le flux, vous pouvez exécuter les workflows directement en utilisant la référence rapide ci-dessus.
+Pas strictement. Une fois le flux maîtrisé, vous pouvez exécuter les workflows directement en vous référant au tableau ci-dessus.
 
-## Obtenir de l'aide
+## Obtenir de l’aide
 
-:::tip[Premier arrêt : BMad-Help]
+:::tip[Premier réflexe : BMad-Help]
-**Invoquez `bmad-help` à tout moment** — c'est le moyen le plus rapide de se débloquer. Posez n'importe quelle question :
+**Invoquez `bmad-help` à tout moment** — c’est le moyen le plus rapide de vous débloquer. Posez-lui n’importe quelle question :
-- « Que dois-je faire après l'installation ? »
-- « Je suis bloqué sur le workflow X »
-- « Quelles sont mes options pour Y ? »
-- « Montre-moi ce qui a été fait jusqu'ici »
 
-BMad-Help inspecte votre projet, détecte ce que vous avez accompli et vous dit exactement quoi faire ensuite.
+- « Que dois-je faire après l’installation ? »
+- « Je suis bloqué sur le workflow X »
+- « Quelles sont mes options pour Y ? »
+- « Montre-moi ce qui a été fait jusqu’ici »
+
+BMad-Help inspecte votre projet, détecte ce que vous avez accompli et vous indique exactement la prochaine étape.
 :::
 
-- **Pendant les workflows** — Les agents vous guident avec des questions et des explications
+- **Pendant les workflows** — Les agents vous guident à l’aide de questions et d’explications
 - **Communauté** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
 
 ## Points clés à retenir
@@ -269,16 +284,16 @@ BMad-Help inspecte votre projet, détecte ce que vous avez accompli et vous dit
 :::tip[Retenez ceci]
 - **Commencez par `bmad-help`** — Votre guide intelligent qui connaît votre projet et vos options
 - **Utilisez toujours de nouveaux chats** — Démarrez un nouveau chat pour chaque workflow
-- **La voie compte** — Quick Dev utilise `bmad-quick-dev` ; La méthode BMad/Enterprise nécessitent PRD et architecture
+- **Le choix de la voie est important** — Quick Dev utilise `bmad-quick-dev` ; BMad Method/Enterprise nécessitent un PRD et une architecture
-- **BMad-Help s'exécute automatiquement** — Chaque workflow se termine par des conseils sur la prochaine étape
+- **BMad-Help se lance automatiquement** — Chaque workflow se termine par des conseils sur la prochaine étape
 :::
 
-Prêt à commencer ? Installez BMad, invoquez `bmad-help`, et laissez votre guide intelligent vous montrer le chemin.
+Prêt à commencer ? Installez BMad, invoquez `bmad-help`, et laissez votre guide intelligent vous accompagner.
 
 ## Glossaire
 
-[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
+[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
 [^2]: Epic : grand ensemble de fonctionnalités ou de travaux qui peut être décomposé en plusieurs user stories.
-[^3]: Story (User Story) : description courte et simple d'une fonctionnalité du point de vue de l'utilisateur ou du client. Elle représente une unité de travail implémentable en un court délai.
+[^3]: Story (User Story) : description courte et simple d’une fonctionnalité du point de vue de l’utilisateur ou du client. Elle représente une unité de travail implémentable en un court délai.
-[^4]: UX (User Experience) : expérience utilisateur, englobant l'ensemble des interactions et perceptions d'un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, comportements et contexte d'utilisation.
+[^4]: UX (User Experience) : expérience utilisateur, englobant l’ensemble des interactions et perceptions d’un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, des comportements et du contexte d’utilisation.
-[^5]: Multi-tenant : architecture logicielle où une seule instance de l'application sert plusieurs clients (tenants) tout en maintenant leurs données isolées et sécurisées les unes des autres.
+[^5]: Multi-tenant : architecture logicielle où une seule instance de l’application sert plusieurs clients (tenants) tout en maintenant leurs données isolées et sécurisées les unes des autres.

docs/how-to/use-web-bundles.md

@@ -3,64 +3,30 @@ title: 'Use Web Bundles'
 description: Install a BMad web bundle as a Google Gemini Gem or ChatGPT Custom GPT
 ---
 
-Use a **web bundle** to run BMad planning work in your Gemini or ChatGPT subscription instead of your IDE.
+Web bundles install from **[bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/)**.
 
-## When to Use This
+## Why a single front door
 
-- You want to run brainstorming, product brief, PRFAQ, PRD, UX, or market research in a web LLM.
+The site is the only supported install path for the shelf. It keeps the steps current as Gemini and ChatGPT evolve, always points at the newest tagged release, and lets one signup put you on the list for new bundles as they ship.
-- You want to save IDE tokens by keeping the planning conversation on a flat-rate subscription.
-- You want to share a planning artifact with collaborators who don't have your IDE setup.
 
-## When to Skip This
+## What you'll do on the site
 
-- The work needs to read or modify code in your repo. Stay in the IDE.
+1. Pick a bundle from the card grid.
-- You don't have a Gemini Advanced or ChatGPT Plus subscription.
+2. Open the install modal. Switch between the **Gemini Gem** and **ChatGPT GPT** tabs for the platform-specific steps.
+3. Download the bundle ZIP (one click; one-time free signup for email-only members).
+4. Follow the inline steps: create the Gem or Custom GPT, upload the knowledge files, paste the instructions block, save.
 
-:::note[Prerequisites]
+## Prerequisites
 
 - **For Gemini Gems**: Gemini Advanced subscription.
-- **For ChatGPT Custom GPTs**: Plus, Pro, Business, or Enterprise plan. Some bundles use Deep Research, which has its own plan availability.
+- **For ChatGPT Custom GPTs**: Plus, Pro, Business, or Enterprise plan.
-- A bundle from [`web-bundles/`](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/web-bundles).
+- For bundles that use **Deep Research** (currently Market & Industry Research), enable it from the prompt bar (Tools → Deep Research). Deep Research has its own plan limits.
-:::
 
-## Steps
+## Customize the persona
 
-### 1. Pick a Bundle
+Each bundle's `INSTRUCTIONS.md` (inside the ZIP) includes a **Persona Swap Example** above the paste boundary. Replace the `[persona]` block in your installed instructions with the swap example to change voice without changing the protocol. You can also write your own persona from scratch; the protocol stays the same.
 
-Browse [`web-bundles/`](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/web-bundles) and pick the one for the work you're doing. Open the bundle folder; you'll see `SKILL.md`, `INSTRUCTIONS.md`, and any data files (CSVs, templates, validation checklists).
+## What you get
-
-### 2. Install in Google Gemini
-
-1. Go to [gemini.google.com](https://gemini.google.com) and create a new Gem.
-2. Name the Gem after the bundle (for example, **Market & Industry Research**).
-3. Upload the bundle's `SKILL.md` and any data files (`.csv`, `.md` templates, validation files) as knowledge files.
-4. Open the bundle's `INSTRUCTIONS.md`, scroll to the **PASTE BOUNDARY** line, and paste everything below it into the Gem's instructions box.
-5. Save.
-
-Some bundles call for Deep Research. If yours does, enable it from the Gemini prompt bar (Tools → Deep Research) before starting each session.
-
-### 3. Install in ChatGPT
-
-1. Go to [chatgpt.com](https://chatgpt.com) and create a new Custom GPT under **Explore GPTs → Create**.
-2. Name the GPT after the bundle.
-3. Under **Configure → Knowledge**, upload the bundle's `SKILL.md` and any data files.
-4. Open the bundle's `INSTRUCTIONS.md`, scroll to the **PASTE BOUNDARY** line, and paste everything below it into **Instructions**.
-5. Under **Capabilities**, turn on **Web Browsing** if the bundle's install steps call for it.
-6. Save.
-
-If the bundle integrates Deep Research, enable it before each session via the composer "+" menu or **Tools → Run deep research**.
-
-### 4. Customize the Persona (Optional)
-
-Each bundle's `INSTRUCTIONS.md` includes a **Persona Swap Example** above the paste boundary. Replace the `[persona]` block in your installed instructions with the swap example to change voice without changing the protocol. You can also write your own persona from scratch; the protocol stays the same.
-
-### 5. Run a Session
-
-Open the Gem or Custom GPT and send your first message. The persona greets you in character and starts the discovery conversation defined in `SKILL.md`. Canvas opens automatically when relevant.
-
-When you're done, export or copy the Canvas document into your repo or hand it off to the next BMad skill in your IDE.
-
-## What You Get
 
 - A reusable Gem or Custom GPT scoped to one BMad planning capability.
 - Polished artifacts (briefs, PRDs, research reports, UX specs) ready to drop into your IDE for implementation.
@@ -70,6 +36,6 @@ When you're done, export or copy the Canvas document into your repo or hand it o
 Web LLMs occasionally drop persona partway through long sessions. If the model starts speaking out of character, remind it of its persona or start a fresh session.
 :::
 
-## Building Your Own
+## Building your own
 
-To turn an existing BMad skill into a web bundle, use the `bmad-os-skill-to-bundle` utility skill from [bmad-utility-skills](https://github.com/bmad-code-org/bmad-utility-skills). It produces the bundle files with persona inheritance from the owning agent and a swap-example contrast voice.
+To turn an existing BMad skill into a web bundle, use the `bmad-os-skill-to-bundle` utility skill from [bmad-utility-skills](https://github.com/bmad-code-org/bmad-utility-skills). It produces the bundle files with persona inheritance from the owning agent and a swap-example contrast voice. Submit your bundle to the shelf by opening a PR on [BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) that adds the bundle directory and an entry in `web-bundles/bundles.json`.

docs/reference/agents.md

@@ -11,18 +11,18 @@ This page lists the default BMM (Agile suite) agents that install with BMad Meth
 
 ## Notes
 
-- Each agent is available as a skill, generated by the installer. The skill ID (e.g., `bmad-dev`) is used to invoke the agent.
+- Each agent is available as a skill, generated by the installer. The skill ID (e.g., `bmad-agent-dev`) is used to invoke the agent.
-- Triggers are the short menu codes (e.g., `CP`) and fuzzy matches shown in each agent menu.
+- Triggers are the short menu codes (e.g., `PRD`) and fuzzy matches shown in each agent menu.
 - QA test generation is handled by the `bmad-qa-generate-e2e-tests` workflow skill, available through the Developer agent. The full Test Architect (TEA) lives in its own module.
 
 | Agent                       | Skill ID             | Triggers                           | Primary workflows                                                                                   |
 | --------------------------- | -------------------- | ---------------------------------- | --------------------------------------------------------------------------------------------------- |
-| Analyst (Mary)              | `bmad-analyst`       | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP` | Brainstorm, Market Research, Domain Research, Technical Research, Create Brief, PRFAQ Challenge, Document Project |
+| Analyst (Mary)              | `bmad-agent-analyst` | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP` | Brainstorm, Market Research, Domain Research, Technical Research, Create Brief, PRFAQ Challenge, Document Project |
-| Product Manager (John)      | `bmad-pm`            | `CP`, `VP`, `EP`, `CE`, `IR`, `CC` | Create/Validate/Edit PRD, Create Epics and Stories, Implementation Readiness, Correct Course        |
+| Product Manager (John)      | `bmad-agent-pm`      | `PRD`, `CE`, `IR`, `CC`            | Create/Update/Validate PRD, Create Epics and Stories, Implementation Readiness, Correct Course      |
-| Architect (Winston)         | `bmad-architect`     | `CA`, `IR`                         | Create Architecture, Implementation Readiness                                                       |
+| Architect (Winston)         | `bmad-agent-architect` | `CA`, `IR`                       | Create Architecture, Implementation Readiness                                                       |
 | Developer (Amelia)          | `bmad-agent-dev`     | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER`, `IN` | Dev Story, Quick Dev, QA Test Generation, Code Review, Sprint Planning, Create Story, Epic Retrospective, [Forensic Investigation](../explanation/forensic-investigation.md) |
-| UX Designer (Sally)         | `bmad-ux-designer`   | `CU`                               | Create UX Design                                                                                    |
+| UX Designer (Sally)         | `bmad-agent-ux-designer` | `CU`                           | Create UX Design                                                                                    |
-| Technical Writer (Paige)    | `bmad-tech-writer`   | `DP`, `WD`, `US`, `MG`, `VD`, `EC` | Document Project, Write Document, Update Standards, Mermaid Generate, Validate Doc, Explain Concept |
+| Technical Writer (Paige)    | `bmad-agent-tech-writer` | `DP`, `WD`, `MG`, `VD`, `EC`   | Document Project, Write Document, Mermaid Generate, Validate Doc, Explain Concept                   |
 
 ## Trigger Types
 
@@ -32,7 +32,7 @@ Agent menu triggers use two different invocation types. Knowing which type a tri
 
 Most triggers load a structured workflow file. Type the trigger code and the agent starts the workflow, prompting you for input at each step.
 
-Examples: `CP` (Create PRD), `DS` (Dev Story), `CA` (Create Architecture), `QD` (Quick Dev)
+Examples: `PRD` (Create, update, or validate PRD), `DS` (Dev Story), `CA` (Create Architecture), `QD` (Quick Dev)
 
 ### Conversational triggers (arguments required)
 
@@ -41,7 +41,6 @@ Some triggers start a free-form conversation instead of a structured workflow. T
 | Agent | Trigger | What to provide |
 | --- | --- | --- |
 | Technical Writer (Paige) | `WD` | Description of the document to write |
-| Technical Writer (Paige) | `US` | Preferences or conventions to add to standards |
 | Technical Writer (Paige) | `MG` | Diagram description and type (sequence, flowchart, etc.) |
 | Technical Writer (Paige) | `VD` | Document to validate and focus areas |
 | Technical Writer (Paige) | `EC` | Concept name to explain |

docs/reference/commands.md

@@ -42,8 +42,8 @@ The installer writes skill files into an IDE-specific directory inside your proj
 | IDE / CLI | Skills directory |
 | --- | --- |
 | Claude Code | `.claude/skills/` |
-| Cursor | `.cursor/skills/` |
+| Cursor | `.agents/skills/` |
-| Windsurf | `.windsurf/skills/` |
+| Windsurf | `.agents/skills/` |
 | Other IDEs | See the installer output for the target path |
 
 Each skill is a directory containing a `SKILL.md` file. For example, a Claude Code installation looks like:
@@ -80,8 +80,8 @@ Agent skills load a specialized AI persona with a defined role, communication st
 | Example skill | Agent | Role |
 | --- | --- | --- |
 | `bmad-agent-dev` | Amelia (Developer) | Implements stories with strict adherence to specs |
-| `bmad-pm` | John (Product Manager) | Creates and validates PRDs |
+| `bmad-agent-pm` | John (Product Manager) | Creates and validates PRDs |
-| `bmad-architect` | Winston (Architect) | Designs system architecture |
+| `bmad-agent-architect` | Winston (Architect) | Designs system architecture |
 
 See [Agents](./agents.md) for the full list of default agents and their triggers.
 
@@ -94,6 +94,7 @@ Workflow skills run a structured, multi-step process without loading an agent pe
 | `bmad-product-brief` | Create or update a product brief — guided discovery when your concept is clear |
 | `bmad-prfaq` | [Working Backwards PRFAQ](../explanation/analysis-phase.md#prfaq-working-backwards) challenge to stress-test your product concept |
 | `bmad-prd` | Create, update, or validate a Product Requirements Document |
+| `bmad-ux` | Design user experience |
 | `bmad-create-architecture` | Design system architecture |
 | `bmad-create-epics-and-stories` | Create epics and stories |
 | `bmad-dev-story` | Implement a story |
@@ -120,7 +121,7 @@ bmad-help What are my options for UX design?
 
 **Other Core Tasks and Tools**
 
-The core module includes 11 built-in tools — reviews, compression, brainstorming, document management, and more. See [Core Tools](./core-tools.md) for the complete reference.
+The core module includes 12 built-in tools — specs, reviews, brainstorming, customization, document management, and more. See [Core Tools](./core-tools.md) for the complete reference.
 
 ## Naming Convention
 

docs/reference/core-tools.md

@@ -26,6 +26,7 @@ Run any core tool by typing its skill name (e.g., `bmad-help`) in your IDE. No a
 | [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | Task | Structural editing — cuts, merges, and reorganization |
 | [`bmad-shard-doc`](#bmad-shard-doc) | Task | Split large markdown files into organized sections |
 | [`bmad-index-docs`](#bmad-index-docs) | Task | Generate or update an index of all docs in a folder |
+| [`bmad-customize`](#bmad-customize) | Task | Create and verify BMad customization overrides |
 
 ## bmad-help
 
@@ -112,7 +113,7 @@ The magic happens in ideas 50–100. The workflow encourages generating 100+ ide
 1. Reads the input and any ancillary linked materials.
 2. Distills into the five-field kernel using a configurable template; routes overflow into appropriately-named companions.
 3. Runs a two-pass self-validate (coherence rules, then preservation of every load-bearing source claim).
-4. Writes `SPEC.md`, sibling companions, and a `.decision-log.md` under `{output_folder}/specs/spec-{slug}/`.
+4. Writes `SPEC.md`, sibling companions, and a `.memlog.md` under `{output_folder}/specs/spec-{slug}/`.
 
 Spec Law enforces eight rules: capabilities carry both intent and success; intents are WHAT not HOW; constraints actually bend decisions; non-goals are explicit; success signals are concrete; capability IDs are stable; every load-bearing source claim is preserved; prose is lean.
 
@@ -122,7 +123,7 @@ Spec Law enforces eight rules: capabilities carry both intent and success; inten
 - `slug` (optional) — required only when input is sparse and no slug is derivable from a source filename.
 - `target_spec_path` (optional) — set to update an existing spec instead of creating a new one.
 
-**Output:** Spec folder containing `SPEC.md`, any companion files, and a `.decision-log.md`. Headless callers receive a JSON response with the result status and the list of files written or modified.
+**Output:** Spec folder containing `SPEC.md`, any companion files, and a `.memlog.md`. Headless callers receive a JSON response with the result status and the list of files written or modified.
 
 :::note[Mutation contract]
 `bmad-spec` is the only writer of `SPEC.md` and of spec-authored companions. Other skills produce their own native artifacts and invoke `bmad-spec` headless when they need to express intent as the canonical contract or propose updates.
@@ -295,3 +296,26 @@ Run both `bmad-review-adversarial-general` and `bmad-review-edge-case-hunter` to
 **Input:** Target folder path
 
 **Output:** `index.md` with organized file listings, relative links, and brief descriptions
+
+## bmad-customize
+
+**Create and verify customization overrides.** — Helps you change how an installed BMad agent or workflow behaves without hand-authoring TOML.
+
+**Use it when:**
+
+- You want to change an agent or workflow behavior
+- You need to add persistent facts, activation hooks, or custom menu items
+- You want the right override scope selected and verified automatically
+
+**How it works:**
+
+1. Scans installed BMad skills for customizable surfaces
+2. Selects the right scope for your requested change
+3. Writes override files under `_bmad/custom/`
+4. Verifies the merged configuration
+
+**Input:** Natural language description of the customization you want
+
+**Output:** TOML override files under `_bmad/custom/`
+
+For a detailed guide on customizing BMad, see [How to Customize BMad](../how-to/customize-bmad.md).

docs/reference/workflow-map.md

@@ -46,13 +46,13 @@ Define what to build and for whom.
 
 | Workflow                | Purpose                                                                             | Produces                                          |
 |-------------------------|-------------------------------------------------------------------------------------|---------------------------------------------------|
-| `bmad-prd`              | Create, update, or validate a PRD — facilitated discovery, three intents in one skill | Create/Update: `prd.md`, `addendum.md`, `decision-log.md`; Validate: `validation-report.html` + `.md` |
+| `bmad-prd`              | Create, update, or validate a PRD — facilitated discovery, three intents in one skill | Create/Update: `prd.md`, `addendum.md`, `.memlog.md`; Validate: `validation-report.html` + `.md` |
-| `bmad-ux`               | Design user experience (when UX matters) — DESIGN.md (visual) + EXPERIENCE.md (behavioral) spine pair | `DESIGN.md`, `EXPERIENCE.md`, `.decision-log.md`  |
+| `bmad-ux`               | Design user experience (when UX matters) — DESIGN.md (visual) + EXPERIENCE.md (behavioral) spine pair | `DESIGN.md`, `EXPERIENCE.md`, `.memlog.md`  |
 
 :::tip[Three intents in one skill]
 `bmad-prd` handles the full PRD lifecycle. State your intent when invoking or the skill will ask:
 
-- **Create** — new PRD from scratch via coached discovery; produces `prd.md`, `addendum.md`, and `decision-log.md`
+- **Create** — new PRD from scratch via coached discovery; produces `prd.md`, `addendum.md`, and `.memlog.md`
 - **Update** — reconcile an existing PRD with a change signal, surfacing conflicts before applying changes
 - **Validate** — critique a PRD against a configurable checklist and produce a structured HTML findings report
 :::

docs/tutorials/getting-started.md

@@ -148,7 +148,7 @@ All workflows in this phase are optional. [**Not sure which to use?**](../explan
 **For BMad Method and Enterprise tracks:**
 
 1. Run `bmad-prd` in a new chat — state your intent (Create / Update / Validate) or let the skill ask
-2. Output: `prd.md`, `addendum.md`, `decision-log.md`
+2. Output: `prd.md`, `addendum.md`, `.memlog.md`
 
 :::note[`bmad-prd` intents]
 

evals/bmm-skills/bmad-product-brief/evals.json

@@ -1,237 +0,0 @@
-{
-  "skill_name": "bmad-product-brief",
-  "_design_notes": "Single-shot evals across two patterns. Pattern A (A1-A8) tests artifact correctness given complete inputs in headless mode. Pattern B tests process discipline (decision log fidelity, polish execution, intent boundaries) by inspecting transcript and side-artifacts. Facilitation/conversation-quality evals are deferred to a future multi-turn simulator.",
-  "evals": [
-    {
-      "id": "A1",
-      "_pattern": "artifact-correctness",
-      "prompt": "Run headless. Create a product brief for InsuLens.\n\nContext (use exactly this — do not invent):\n- Product: a smartphone app that pairs with off-the-shelf $200 thermal imaging accessories (FLIR ONE Pro and Seek Compact Pro). The app guides homeowners through a structured walkthrough and produces a professional-grade insulation audit in under 20 minutes.\n- Target: suburban homeowners aged 35-65 with houses built before 2000 (poor original insulation, rising energy bills).\n- Validation evidence: 50 user interviews completed in Q4 2025; 78% expressed willingness to pay $49 for a one-time audit if results were credible.\n- Stakes: this brief is the primary input investors will read before our first Series A pitch call.\n- Hardware dependency: requires a thermal imaging accessory (we do not manufacture hardware).\n- Known unknowns: insurance/warranty implications of homeowner-driven audits; whether the 78% intent translates to paid conversion at scale.\nRight-size for investor-stage rigor. Output a JSON status block at the end with status, intent, and artifact paths.",
-      "expected_output": "A run folder containing brief.md (with valid YAML frontmatter) and decision-log.md. Brief is 1-2 pages, addresses target audience, hardware dependency, validation evidence, and surfaces unknowns alongside knowns. Final assistant message includes JSON with status='complete', intent='create', and artifact paths.",
-      "files": [],
-      "expectations": [
-        "A run folder is created with brief.md and decision-log.md",
-        "brief.md has YAML frontmatter containing all four required fields: title, status, created (ISO 8601), updated (ISO 8601)",
-        "brief.md frontmatter status is 'draft' or 'final' (not missing or empty)",
-        "brief.md word count is between 250 and 1500",
-        "brief.md identifies the suburban-homeowner-aged-35-65 target audience",
-        "brief.md references the thermal imaging hardware dependency (FLIR ONE Pro / Seek Compact Pro or equivalent)",
-        "brief.md references the 50-user interview validation OR the 78% willingness-to-pay finding",
-        "brief.md surfaces at least one explicit unknown or unvalidated assumption",
-        "brief.md does not introduce facts absent from the input prompt (no invented competitors, fabricated metrics, or unstated partnerships)",
-        "The final assistant message contains a JSON object with keys 'status', 'intent', and at least one artifact path",
-        "The JSON 'intent' value is 'create'"
-      ]
-    },
-    {
-      "id": "A2",
-      "_pattern": "artifact-correctness",
-      "prompt": "Run headless. Create a brief for our app idea.",
-      "expected_output": "Headless mode with insufficient context should halt with status='blocked' and a reason field. No (or only skeleton) brief should be written. The skill must not invent a product to draft against.",
-      "files": [],
-      "expectations": [
-        "The final assistant message contains a JSON object with key 'status' set to 'blocked'",
-        "The JSON output includes a 'reason' field explaining what context is missing",
-        "If brief.md exists at all, its body content (excluding frontmatter) is fewer than 100 words OR is a placeholder skeleton — the skill did not invent a product",
-        "The transcript contains no clarifying questions sent back to the user (headless mode honored)"
-      ]
-    },
-    {
-      "id": "A3",
-      "_pattern": "artifact-correctness",
-      "prompt": "Run headless. Create a brief for our neighborhood compost coordinator app idea — we are moving forward with it. Q2 brainstorming session notes are at evals/bmm-skills/bmad-product-brief/files/q2-brainstorm.md; pull only what is relevant to the compost concept.",
-      "expected_output": "Brief focuses tightly on the compost coordinator concept. Source brainstorm is filtered, not ingested wholesale. Decision-log records that filtering occurred.",
-      "files": ["evals/bmm-skills/bmad-product-brief/files/q2-brainstorm.md"],
-      "expectations": [
-        "brief.md addresses the neighborhood compost coordinator concept",
-        "brief.md does not introduce content from unrelated brainstorm topics (weather + mood, meditation chime, podcasting tool, craft beer subscription, AI sommelier, office plants, ride coordinator, cookbook app, AR home staging)",
-        "brief.md word count is between 250 and 1500",
-        "brief.md incorporates at least 2 specific details from the compost section of the brainstorm (e.g., two-sided market with apartment dwellers and home compost-pile owners, hyperlocal neighborhood scope, free-at-launch with eventual subscription, Portland Sunnyside/Hawthorne pilot)",
-        "decision-log.md indicates the brainstorm was filtered for relevance, not ingested whole"
-      ]
-    },
-    {
-      "id": "A4",
-      "_pattern": "artifact-correctness",
-      "prompt": "Run headless. Validate the brief at evals/bmm-skills/bmad-product-brief/files/mossridge-brief/brief.md — the Mossridge Public Library board meets Monday and we need this to land. Read the addendum and decision-log in the same folder first. Cite specific sections, identify weaknesses, caveat what cannot be evaluated. Return inline only — no separate validation file.",
-      "expected_output": "Inline critique citing specific sections from the input brief. No new files. Caveats at least one claim that cannot be evaluated from the brief alone. Offers to roll findings into an Update.",
-      "files": [
-        "evals/bmm-skills/bmad-product-brief/files/mossridge-brief/brief.md",
-        "evals/bmm-skills/bmad-product-brief/files/mossridge-brief/addendum.md",
-        "evals/bmm-skills/bmad-product-brief/files/mossridge-brief/decision-log.md"
-      ],
-      "expectations": [
-        "The final output cites specific section names or line content from the input brief (not generic feedback)",
-        "The output identifies at least one specific weakness or area for improvement in the input brief",
-        "The output explicitly caveats at least one claim that cannot be evaluated from the brief alone (e.g., community demand, funding feasibility, volunteer sustainability)",
-        "The output offers to roll findings into an Update (or equivalent next-step proposal)",
-        "The final assistant message contains a JSON object with intent='validate'"
-      ]
-    },
-    {
-      "id": "A5",
-      "_pattern": "artifact-correctness",
-      "prompt": "Run headless. Create a brief for: a weekend-project iOS app called Sproutkeeper that reminds houseplant owners when to water their plants based on plant type and indoor humidity sensor data. Target is hobbyist plant owners. MVP scope only, single-developer side project, no investors, no team, just personal evening project.",
-      "expected_output": "Lightweight brief right-sized to a side project. Low rigor. No investor-grade framing.",
-      "files": [],
-      "expectations": [
-        "The final assistant message contains a JSON object with intent='create'",
-        "brief.md exists at the path referenced in the JSON output",
-        "brief.md is right-sized for a side project (closer to 250-500 words than 1500)",
-        "brief.md does not include investor-grade framing (no 'Series A inputs', 'TAM/SAM/SOM', 'go-to-market strategy' boilerplate when the user said this is a personal evening project)",
-        "The transcript contains no clarifying questions to the user",
-        "Sections that do not earn their place for a side project are dropped or kept minimal (e.g., no extensive Risk or Success Criteria padding)"
-      ]
-    },
-    {
-      "id": "A6",
-      "_pattern": "artifact-correctness",
-      "prompt": "Run headless. Create a brief from this memo. It is from our last working group on a new microcredential program at Branfield Community College. Memo is at evals/bmm-skills/bmad-product-brief/files/branfield-memo.md. Use what is there; do not re-elicit facts already present.",
-      "expected_output": "Brief reflects content from the memo. No re-asking for facts already present. Decision-log notes ingestion of the memo.",
-      "files": ["evals/bmm-skills/bmad-product-brief/files/branfield-memo.md"],
-      "expectations": [
-        "brief.md incorporates at least 3 distinct facts or decisions present in the input memo",
-        "decision-log.md references having used the memo as source material",
-        "The transcript does not ask the user to re-state the program name, target student, or core curriculum focus if those are present in the memo",
-        "brief.md does not invent program details not present in the memo"
-      ]
-    },
-    {
-      "id": "A7",
-      "_pattern": "artifact-correctness",
-      "prompt": "Run headless. Create a brief for Brightway — our smart bike helmet with crash detection, turn signals, and braking lights. Meridian Insights produced a market research report on e-mobility at evals/bmm-skills/bmad-product-brief/files/meridian-mobility-report.md. Use only what is relevant to the safety helmet category — do not let the e-scooter, charging-infrastructure, or bike-share segments bleed into the brief.",
-      "expected_output": "Brief focuses on the smart bike helmet concept. Pulls relevant findings from the helmet section. Other mobility segments do not appear.",
-      "files": ["evals/bmm-skills/bmad-product-brief/files/meridian-mobility-report.md"],
-      "expectations": [
-        "brief.md addresses the Brightway smart bike helmet concept",
-        "brief.md does not introduce content from unrelated mobility segments (e-scooters, charging infrastructure, bike-share, vehicle-to-grid)",
-        "brief.md word count is between 250 and 1500",
-        "brief.md incorporates at least 2 specific findings from the smart helmet section of the report (e.g., market sizing, key players, crash detection technology trends, regulatory or insurance landscape)",
-        "decision-log.md indicates the report was filtered to the helmet category rather than ingested whole"
-      ]
-    },
-    {
-      "id": "A8",
-      "_pattern": "artifact-correctness",
-      "prompt": "Run headless. Create a brief for Pantry Bridge — a meal-kit subscription targeted at adults 65+ who live alone and want fresh meals without grocery shopping. Customer research transcripts are at evals/bmm-skills/bmad-product-brief/files/pantry-bridge-interviews.md. Pull what is relevant from the older-adult interviews; do not conflate insights from the working-parent, student, or corporate-buyer personas.",
-      "expected_output": "Brief focuses on the older-adult target persona. Eleanor's interview drives the insights. Other personas do not pollute the brief.",
-      "files": ["evals/bmm-skills/bmad-product-brief/files/pantry-bridge-interviews.md"],
-      "expectations": [
-        "brief.md addresses the Pantry Bridge older-adult meal-kit concept",
-        "brief.md does not conflate insights from non-target personas (working parent Susan, college student Marcus, corporate cafeteria buyer Dimitri)",
-        "brief.md word count is between 250 and 1500",
-        "brief.md incorporates at least 2 specific insights from Eleanor's interview (e.g., grocery-trip difficulty, portion sizing, dietary restrictions, social aspects of meals, trust concerns)",
-        "decision-log.md notes which interviews were used and which were excluded"
-      ]
-    },
-    {
-      "id": "B1",
-      "_pattern": "process-discipline",
-      "prompt": "Run headless. Create a brief for HelmStack — an open-source observability platform for distributed systems.\n\nWe have made these specific decisions and want each captured in the decision log with rationale:\n\n1. Pricing: Free open-source core; paid SaaS at $29/seat/month. Rejected paid-one-shot-license model because it would limit network effects in the OSS community.\n2. Launch: Invite-only beta for 6 weeks before public launch. Rejected open public launch — operational risk too high before stability is proven on real workloads.\n3. Stack: TypeScript + Postgres for the backend. Rejected Go + MongoDB — TypeScript aligned better with our team's existing skills and the frontend codebase.\n4. ICP: 5-50 person engineering teams for MVP. Rejected enterprise-first focus because the sales cycle is too long for our capital runway.\n5. Self-host: SaaS-only at launch; self-host arrives in v2. Rejected concurrent self-host because it would slow shipping velocity past our funding window.\n\nProduce brief.md and decision-log.md.",
-      "expected_output": "Decision log contains all five named decisions with rationale captured. Brief reflects the decisions but the decision log is the canonical record.",
-      "files": [],
-      "expectations": [
-        "decision-log.md exists in the run folder",
-        "decision-log.md captures the pricing decision (free OSS + $29/seat SaaS) with the rejected alternative (paid one-shot license) and rationale (network effects)",
-        "decision-log.md captures the invite-only-beta decision with the rejected alternative (open public launch) and rationale (operational risk before stability)",
-        "decision-log.md captures the platform-stack decision (TypeScript + Postgres) with the rejected alternative (Go + MongoDB) and rationale (team skills / frontend alignment)",
-        "decision-log.md captures the ICP decision (5-50 person eng teams) with rationale referencing sales cycle / runway",
-        "decision-log.md captures the self-host-timing decision (SaaS-only at launch, self-host v2) with rationale (shipping velocity / funding window)"
-      ]
-    },
-    {
-      "id": "B2",
-      "_pattern": "process-discipline",
-      "prompt": "Run headless. Create a brief for HelmStack — an open-source observability platform for distributed systems.\n\nWe have made these specific decisions and want each captured in the decision log with rationale:\n\n1. Pricing: Free open-source core; paid SaaS at $29/seat/month. Rejected paid-one-shot-license model because it would limit network effects in the OSS community.\n2. Launch: Invite-only beta for 6 weeks before public launch. Rejected open public launch — operational risk too high before stability is proven on real workloads.\n3. Stack: TypeScript + Postgres for the backend. Rejected Go + MongoDB — TypeScript aligned better with our team's existing skills and the frontend codebase.\n4. ICP: 5-50 person engineering teams for MVP. Rejected enterprise-first focus because the sales cycle is too long for our capital runway.\n5. Self-host: SaaS-only at launch; self-host arrives in v2. Rejected concurrent self-host because it would slow shipping velocity past our funding window.\n\nProduce brief.md and decision-log.md.",
-      "expected_output": "Brief is consistent with the decision log: every decision in the log is reflected in the brief, and no claim in the brief is absent from the input prompt or the log. Tests bidirectional fidelity.",
-      "files": [],
-      "expectations": [
-        "brief.md mentions the OSS-core + paid-SaaS pricing structure",
-        "brief.md references the invite-only-beta launch sequencing OR identifies the launch model consistent with the decision log",
-        "brief.md references the platform-stack choice (TypeScript + Postgres) OR is silent on stack — but does not contradict it (no mention of Go, MongoDB, etc.)",
-        "brief.md identifies 5-50 person eng teams as the ICP (or equivalent — small-to-mid-size eng teams)",
-        "brief.md does not introduce decisions, competitors, partnerships, metrics, or product features absent from both the input prompt and decision-log.md (no invented facts)",
-        "Each substantive decision in decision-log.md has a corresponding reflection in brief.md (no log-to-brief drops)"
-      ]
-    },
-    {
-      "id": "B3",
-      "_pattern": "process-discipline",
-      "prompt": "Run headless. Create a product brief for InsuLens.\n\nContext (use exactly this — do not invent):\n- Product: a smartphone app that pairs with off-the-shelf $200 thermal imaging accessories (FLIR ONE Pro and Seek Compact Pro). The app guides homeowners through a structured walkthrough and produces a professional-grade insulation audit in under 20 minutes.\n- Target: suburban homeowners aged 35-65 with houses built before 2000.\n- Validation: 50 user interviews completed in Q4 2025; 78% willingness to pay $49 for a one-time audit.\n- Stakes: Series A pitch input.\n- Hardware: requires a thermal accessory (we do not manufacture hardware).\n\nProduce brief.md and decision-log.md. Run the polish phase before presenting.",
-      "expected_output": "The transcript shows the polish phase executing — the skill invokes bmad-editorial-review-structure and bmad-editorial-review-prose, either via the Skill tool directly or via Agent tool calls whose description or prompt targets those editorial skills. Both passes must occur after the initial draft is written and before the final JSON status block.",
-      "files": [],
-      "expectations": [
-        "The transcript contains either a Skill tool call invoking bmad-editorial-review-structure, OR an Agent tool call whose description or prompt references structural review or bmad-editorial-review-structure",
-        "The transcript contains either a Skill tool call invoking bmad-editorial-review-prose, OR an Agent tool call whose description or prompt references prose review or bmad-editorial-review-prose",
-        "Both editorial-pass dispatches (Skill or Agent) occur after the first Write tool call that creates brief.md",
-        "Both editorial-pass dispatches (Skill or Agent) occur before the final assistant message containing the JSON status block"
-      ]
-    },
-    {
-      "id": "B5",
-      "_pattern": "process-discipline",
-      "prompt": "Run headless. Update the brief at evals/bmm-skills/bmad-product-brief/files/forkbird-brief/brief.md — we have decided to add B2B catering services for corporate events, in addition to the direct-to-consumer delivery model. Read the existing decision-log.md and addendum.md in the same folder first.",
-      "expected_output": "The skill MUST detect the contradiction with the prior 'rejected B2B catering for MVP' decision (in decision-log.md) before applying the change. Acceptable resolutions: (a) halt with blocked status surfacing the conflict, or (b) apply the change with addendum.md capturing the override and rationale. Brief must not silently flip without acknowledging the prior decision.",
-      "files": [
-        "evals/bmm-skills/bmad-product-brief/files/forkbird-brief/brief.md",
-        "evals/bmm-skills/bmad-product-brief/files/forkbird-brief/addendum.md",
-        "evals/bmm-skills/bmad-product-brief/files/forkbird-brief/decision-log.md"
-      ],
-      "expectations": [
-        "The transcript or output explicitly references the prior 'rejected B2B catering for MVP' decision from decision-log.md",
-        "The contradiction is surfaced before the brief body is modified (a Read of decision-log.md occurs before the Edit/Write to brief.md, AND the conflict is named in the assistant output)",
-        "Either the JSON status is 'blocked' with the conflict in the reason field, OR addendum.md is updated with an override entry capturing the rationale for reversing the prior decision",
-        "If the brief is updated, decision-log.md gains a new entry referencing the catering reversal",
-        "If the brief is updated, the YAML frontmatter 'updated' field is later than the original 'created' field"
-      ]
-    },
-    {
-      "id": "B6",
-      "_pattern": "process-discipline",
-      "prompt": "Run headless. Update the brief at evals/bmm-skills/bmad-product-brief/files/forkbird-brief/brief.md — we have signed our fifth chef partner (Chicago metro). Add this to the existing operating-model and what's-known sections. Read the existing decision-log.md first.",
-      "expected_output": "Clean update — does not contradict any prior decision. Brief gets updated, decision-log gains a new entry, YAML 'updated' bumps but 'created' stays the same. No spurious addendum since this is a status update, not an override.",
-      "files": [
-        "evals/bmm-skills/bmad-product-brief/files/forkbird-brief/brief.md",
-        "evals/bmm-skills/bmad-product-brief/files/forkbird-brief/addendum.md",
-        "evals/bmm-skills/bmad-product-brief/files/forkbird-brief/decision-log.md"
-      ],
-      "expectations": [
-        "brief.md is updated to reflect the signed fifth chef partner in Chicago",
-        "brief.md frontmatter 'updated' field is later than the original 'created' timestamp; 'created' is unchanged",
-        "decision-log.md contains a new entry referencing the fifth chef signing",
-        "The transcript does not surface a fictional contradiction — this is a clean update, not an override of a prior decision"
-      ]
-    },
-    {
-      "id": "B7",
-      "_pattern": "process-discipline",
-      "prompt": "Run headless. Validate the brief at evals/bmm-skills/bmad-product-brief/files/mossridge-brief/brief.md — we are presenting to the library board Monday. Read the addendum and decision-log in the same folder. Cite specific sections. Return inline only.",
-      "expected_output": "Validate is read-only. No new files created. No existing files modified. Critique returned inline in the assistant output.",
-      "files": [
-        "evals/bmm-skills/bmad-product-brief/files/mossridge-brief/brief.md",
-        "evals/bmm-skills/bmad-product-brief/files/mossridge-brief/addendum.md",
-        "evals/bmm-skills/bmad-product-brief/files/mossridge-brief/decision-log.md"
-      ],
-      "expectations": [
-        "No new files appear in the mossridge-brief artifacts directory after the run (only the three input files)",
-        "The input brief.md, addendum.md, and decision-log.md are byte-identical to the staged fixtures (no Edit/Write tool calls modified them)",
-        "The transcript contains no Write tool calls and no Edit tool calls targeting the mossridge-brief folder",
-        "The final assistant message contains a JSON object with intent='validate'"
-      ]
-    },
-    {
-      "id": "C1",
-      "_pattern": "config-compliance",
-      "prompt": "Run headless. Create a product brief for TaskFlow — a lightweight daily planning app for freelancers who juggle multiple clients. Core idea: a single daily view that pulls together tasks, time blocks, and client context so the freelancer always knows what to work on next. Target is independent freelancers, 1-3 clients at a time, who currently manage their day across sticky notes, calendar apps, and spreadsheets. MVP is mobile-first. No investors — the founder is bootstrapping.",
-      "expected_output": "Brief written in Spanish (document_output_language=Spanish). Assistant's conversational output reflects the configured British-accent communication style. Brief lands at the custom output path (test-output/artifacts/briefs/...) rather than the default _bmad-output path. Brief is right-sized for a bootstrapped solo project.",
-      "files": [],
-      "expectations": [
-        "brief.md exists under test-output/artifacts/briefs/ (the custom planning_artifacts path), not under _bmad-output/",
-        "The final JSON status block artifact paths reference test-output/ rather than _bmad-output/",
-        "brief.md body is written in Spanish — the majority of prose content (headings, section bodies) is in Spanish, not English",
-        "brief.md covers the TaskFlow concept: freelancer daily planning, multi-client context, the sticky-notes-plus-calendar-plus-spreadsheet problem",
-        "brief.md is right-sized for a bootstrapped side project — appropriate depth and scope for a solo-founder app with no investor audience, no TAM/SAM/SOM framing, no Series A language, and no sections that pad for enterprise credibility",
-        "The assistant's non-document output (transcript text content outside of brief.md) contains at least one marker of British informal register (e.g., 'mate', 'cheers', 'brilliant', 'sorted', 'innit', 'blimey', 'proper', 'right then', or equivalent pub-idiom phrasing)"
-      ]
-    }
-  ]
-}

evals/bmm-skills/bmad-product-brief/files/branfield-memo.md

@@ -1,46 +0,0 @@
-# Working Group Notes — Microcredential Program
-
-**Branfield Community College**
-**Meeting:** 2026-04-22
-**Attendees:** Provost, Workforce Dev Director, Chair of Industry Advisory Board, two faculty leads (Data Analytics, Healthcare Admin), Financial Aid Director
-
-## Why we're doing this
-
-Regional employer survey (Q1 2026) showed 340+ unfilled mid-skill jobs in the three-county area. State workforce board approved a $1.4M grant if we can launch by fall 2027 with at least three tracks. Existing AAS programs are too long for working adults — average completion 3.5 years.
-
-## What we're building
-
-Six-month stackable microcredentials. Three tracks at launch:
-
-1. **Data Analytics** (SQL, Excel/Power BI, intro Python). Faculty lead Marisol Reyes. Strongest employer demand. Will be MVP — first to launch, used to validate format.
-2. **Healthcare Admin** (medical coding, EHR systems, patient workflow). Faculty lead Dev Patel. Aging population in region drives demand.
-3. **Sustainable Construction** (green building practices, retrofit basics, code compliance). New faculty hire required.
-
-Stackable means credits transfer into related AAS or BAS later if the student wants.
-
-## Decisions made today
-
-- **Data Analytics is MVP.** Launch fall 2027, others phase in spring/fall 2028. Validate format before scaling.
-- **Hybrid delivery.** Two evenings/week in person + asynchronous online. Board rejected pure-online (concerns about adult learner outcomes data).
-- **Stipend program.** Up to $3,000/student for low-income students, funded from the state grant. Means-tested.
-- **Industry Advisory Board** has approval authority on curriculum. Three employers committed (regional hospital, mid-size data consultancy, county housing authority). All three commit to interview every graduate.
-- **Cohort cap: 24 per track per term.** Driven by classroom size and faculty load.
-
-## Open questions
-
-- Childcare for evening sessions — can we partner with the campus childcare center? Deferred to next meeting.
-- Marketing — provost wants to know cost per enrolled student before approving budget. Need workforce dev to model.
-- Do we offer a tuition payment plan in addition to the stipend? Financial aid director thinks yes; provost wants to see uptake projections first.
-
-## What we're NOT doing
-
-- Not pursuing pure-online delivery (rejected — see above).
-- Not launching all three tracks at once (rejected — risk concentration, faculty bandwidth).
-- Not building employer-customized cohorts (rejected — too operationally complex for MVP).
-
-## Next steps
-
-- Workforce Dev: marketing cost model by 2026-05-15.
-- Provost: childcare partnership exploratory conversation.
-- Faculty leads: draft data analytics curriculum outline by 2026-06-01.
-- Reconvene 2026-05-20.

evals/bmm-skills/bmad-product-brief/files/forkbird-brief/addendum.md

@@ -1,40 +0,0 @@
-# Addendum — Forkbird Kitchen
-
-## Options considered (and not taken)
-
-### B2B / corporate catering
-
-Considered as a parallel revenue stream from day one. Rejected for MVP. Different operational rhythm (bulk orders, fixed delivery windows, invoiced billing), different customer (procurement, not eaters), different unit economics. Splitting attention at launch risked degrading both. Revisit if consumer foundation is established by month 12.
-
-### Subscription / meal plan
-
-Considered as a recurring-revenue layer. Rejected for MVP. Operationally expensive at our planned scale: requires demand forecasting per subscriber, kitchen scheduling locked further out, and packaging/refrigerated handling we are not yet equipped for. Reasonable to revisit once kitchen utilization stabilizes.
-
-### Retail / grocery channel
-
-Considered (refrigerated meals in Whole Foods, Sprouts). Rejected for MVP. Different product (cold meals, longer shelf life, different texture profile), different go-to-market (broker relationships, slotting fees, category management). Parked for year 2 — would require a separate product line, not a channel extension.
-
-### Lower-priced everyday tier
-
-Considered. Rejected for now. The brand position is chef-driven; introducing a value tier alongside risks the premium signal in marketplace search ranking and review patterns. Explored alternative of separate brand for value tier; deferred.
-
-## Personas (extended)
-
-**The plant-based weekday professional.** Lives in a dense urban neighborhood, orders 4–6 times a month, splits between own-cooking and delivery. Sources of dissatisfaction with current options: chain plant-based menus feel formulaic, fine-dining plant-based is too expensive for weeknight, marketplace search surfaces too many low-quality options.
-
-**The dietary-flex household member.** One person in a household is plant-based by preference; the other(s) are not. Ordering pattern is "tonight one of us wants Forkbird, the other wants something else." We benefit from being a dependable single-cuisine option that doesn't require negotiating across diets.
-
-## Sizing notes
-
-- Total addressable: ~6.2M urban professionals across 5 metros eating plant-based 3+ times/week (based on 2024 Plant Based Foods Association data, urban segmentation).
-- Serviceable addressable (within delivery radius of planned kitchens at launch): ~840K.
-- Realistic Y1 capture (per metro forecast): 0.4% of SAM = 3,360 active customers across all metros.
-
-## Sourcing standard — exact wording
-
-"For each dish on the menu, we publish the source of every ingredient that represents at least 5% of cost. We commit that at least 60% of total ingredient weight is sourced within 200 miles of the kitchen preparing that dish. Both numbers are auditable; we publish them per-dish in the app. If we cannot meet the 60% local threshold for a dish, the dish does not ship."
-
-## Technical constraints
-
-- Marketplace integration (DoorDash, UberEats, Grubhub) requires their menu management API. We are using a third-party middleware (Olo) to avoid maintaining three separate integrations.
-- Ingredient transparency display requires structured data per dish. We need an ingredient-master database; current option is to extend our recipe-management software vendor.

evals/bmm-skills/bmad-product-brief/files/forkbird-brief/brief.md

@@ -1,56 +0,0 @@
----
-title: Forkbird Kitchen — Product Brief
-status: final
-created: 2026-02-14
-updated: 2026-02-14
----
-
-# Forkbird Kitchen
-
-## What it is
-
-A delivery-only ghost kitchen brand offering chef-driven plant-based meals in five US metros: San Francisco, New York, Los Angeles, Seattle, and Chicago. Launch operating model is direct-to-consumer through our own iOS/Android app and the major third-party marketplaces (DoorDash, UberEats, Grubhub).
-
-## Who it's for
-
-Urban professionals aged 28–45 who eat plant-based meals at least three times a week, value chef-driven food over chain alternatives, and order delivery 4+ times monthly. Initial geographic focus is dense neighborhoods within 3-mile delivery radii of partner kitchens.
-
-We are not building for: families with children (different ticket size and ordering pattern), occasional plant-based eaters (price sensitivity too high for our positioning), or office lunch (different time-of-day operation).
-
-## Why it wins
-
-Three things are deliberately stacked:
-
-1. **Chef partnerships, not chef-as-marketing.** Each metro has a named chef (with prior fine-dining or notable plant-based credit) who designs the rotating menu and earns equity in that metro's P&L. They are not endorsers; they are operators.
-2. **Ingredient sourcing standards.** Published per-dish: where it came from, how it was farmed, what portion of cost it represents. No dish ships if we can't source within 200 miles for ≥60% of ingredient weight. This is auditable, not marketing copy.
-3. **Speed without cars.** Average ticket-to-door is 28 minutes from order placement, achieved by tight delivery radii and dense order density per kitchen. Long delivery erodes plant-based texture more than animal protein — speed is product, not logistics.
-
-## Operating model
-
-Five kitchens, one per metro, each leased space inside an existing food-prep facility. No customer-facing storefronts. App orders go through our stack; marketplace orders pass through their stacks. Menu rotates every six weeks per chef.
-
-Pricing tier: $14–$22 per entrée before delivery. We are deliberately at chef-driven positioning, not value positioning.
-
-## What's known
-
-- Demand validated through three pop-up dinners in SF and NY (Q4 2025). 480 covers, 78% repeat intent based on post-event survey.
-- Operating partner identified in each metro. Leases signed for SF, NY, LA. Seattle and Chicago in negotiation.
-- Three of five chefs signed; two in active conversations.
-
-## What's unknown
-
-- Whether ingredient-sourcing transparency is a differentiator at point of sale (in-app) or only in marketing. Our hypothesis is "both" but we have not tested in-app.
-- Marketplace economics. DoorDash takes 15–30% depending on tier; we are modeling the lower tier but have not negotiated.
-- Whether the 3-mile radius holds outside SF/NY (lower density in LA/Chicago).
-
-## Risks
-
-- Chef churn. If a metro chef leaves, the metro brand loses its anchor. Mitigation: equity vesting over 24 months, named-chef terms in operating agreement.
-- Sourcing cost volatility. 60% local-within-200-miles can spike with weather/supply disruption. We have not modeled the worst case.
-- Marketplace dependency. If DoorDash terms shift adversely, our blended margin is at risk. We are deliberately building the owned-app channel to reduce this dependency.
-
-## Success criteria for first 12 months
-
-- 4 of 5 metros operating profitably at the unit level (kitchen + chef + delivery economics) by month 9
-- 30% of orders through owned app (vs. marketplaces) by month 12
-- Chef retention 100% through year 1

evals/bmm-skills/bmad-product-brief/files/forkbird-brief/decision-log.md

@@ -1,27 +0,0 @@
-# Decision Log — Forkbird Kitchen
-
-## 2026-01-08
-- **Brand position: chef-driven, premium plant-based.** Considered value tier; rejected for MVP. Premium positioning is the wedge against marketplace generic plant-based.
-
-## 2026-01-12
-- **Five-metro launch: SF, NY, LA, Seattle, Chicago.** Considered three-metro start; rejected as not enough density to test the chef-equity model meaningfully.
-- **Ghost kitchen, no storefront.** Storefronts ruled out — capex too high for MVP, dilutes the speed advantage.
-
-## 2026-01-19
-- **Pricing tier $14–$22 per entrée.** Modeled against three competitor sets: chain plant-based, fine-dining plant-based delivery, generic mid-tier delivery. Sits cleanly above chain, below fine-dining.
-- **Chef equity in metro P&L.** Rejected flat fee + revenue share alternative; equity creates the operator incentive we want.
-
-## 2026-01-26
-- **Rejected B2B catering segment for MVP.** Different operational rhythm and customer; would split attention at launch and risk degrading both consumer and B2B execution. Revisit in year 2 if consumer foundation is solid. (Discussion: 2 hours; chef partners weighed in against splitting focus; CFO modeled the dilution effect on consumer kitchen utilization.)
-- **Rejected subscription model for MVP.** Operationally expensive at planned scale; revisit once kitchen utilization stabilizes.
-
-## 2026-02-02
-- **Sourcing standard: 60% within 200 miles, published per-dish.** Considered weaker thresholds (50% / 250 miles); rejected as not differentiating enough to be worth publishing. The number has to be defensible.
-- **Marketplace channel mix: own app + DoorDash + UberEats + Grubhub.** Considered own-app only; rejected as too slow on demand acquisition. Considered marketplaces only; rejected — own app is critical to long-term margin.
-
-## 2026-02-09
-- **Six-week menu rotation per chef.** Considered four-week (more freshness) and eight-week (more operational stability). Six is the compromise; reassess after first two cycles.
-- **Marketing budget: 60% acquisition / 40% brand.** Rejected pure-acquisition because chef-driven positioning needs brand-level signal that paid acquisition alone won't carry.
-
-## 2026-02-14
-- **Brief finalized for Series A inputs.** Status moved to final.

evals/bmm-skills/bmad-product-brief/files/meridian-mobility-report.md

@@ -1,116 +0,0 @@
-# E-Mobility Market Report 2026
-
-**Prepared by:** Meridian Insights
-**Date:** Q2 2026
-**Coverage:** North America, with comparative reference to EU markets
-**Engagement code:** MI-2026-EMOB-007
-
----
-
-## Executive Summary
-
-The e-mobility category continues a multi-year structural shift from "alternative transportation" to mainstream mobility infrastructure. North American unit volume across e-bikes, e-scooters, and connected safety hardware grew 18% year-over-year in 2025, against a 6% growth rate for traditional bicycles. Three macro factors are durably reshaping the category: regulatory clarity at the state level (29 US states now have explicit e-bike classifications, up from 14 in 2022), insurance industry interest in telematics-style risk pricing, and a generational shift in commuting preferences among the 28-44 cohort.
-
-This report covers seven segments of the broader e-mobility landscape: e-bike retail, e-scooter regulation, bike-share systems, charging infrastructure, smart helmet hardware, and grid-integration trends. Findings are synthesized from 142 stakeholder interviews, 18 retailer site visits, government regulatory filings, and proprietary point-of-sale data from 4,200 specialty retail outlets.
-
----
-
-## Methodology
-
-Quantitative data was sourced from Meridian's proprietary Mobility Retail Panel (MRP), which aggregates POS data from independent specialty retailers and select chain operators. Where panel data is incomplete or lagging, we supplemented with manufacturer-reported shipment volumes and customs/import filings. Qualitative findings draw on 142 interviews conducted between November 2025 and March 2026 with retailers, fleet operators, regulators, manufacturers, and end users.
-
-Helmet category sizing uses a separate methodology described in Section 8, blending CPSC compliance filings, manufacturer disclosures, and a sample purchase-intent survey of 3,400 cyclists.
-
----
-
-## Section 3: Market Sizing — Total E-Mobility
-
-The North American e-mobility market reached an estimated $14.7B in retail volume in 2025, up from $12.5B in 2024. The largest segment by volume is e-bikes at $7.2B, followed by e-scooter retail at $2.8B (excluding shared-fleet operations), bike-share and dockless mobility services at $2.1B, charging infrastructure at $1.8B, and connected safety hardware at $0.8B.
-
-Compound annual growth rate (CAGR) forecasts through 2030 vary substantially by segment. We forecast 14% CAGR for e-bikes, 6% for e-scooters (decelerating as the regulatory regime stabilizes), 9% for bike-share, 22% for charging infrastructure (driven by both bike and scooter charging), and 31% for connected safety hardware (off a smaller base). Vehicle-to-grid (V2G) integration is too early to forecast reliably; we treat it as an emerging segment.
-
----
-
-## Section 4: E-Bike Market Deep Dive
-
-E-bikes represent the largest single segment by retail value. The 2025 unit mix favored Class 1 (pedal-assist, max assisted speed 20 mph) at 58% of units, Class 2 (throttle, max 20 mph) at 24%, and Class 3 (pedal-assist, max 28 mph) at 18%. Class 3 is the fastest-growing classification on a unit basis, driven by suburban commuter demand.
-
-Manufacturer concentration shifted in 2025. The top 10 brands by unit volume now hold 64% of the market, up from 51% in 2022 — consolidation that mirrors patterns seen in the traditional bicycle market in the early 2000s. Specialized, Trek, and Cannondale (operating their respective electric sub-brands) represent the top three. Direct-to-consumer brands (Rad Power, Lectric, Aventon) collectively hold approximately 19% of retail value.
-
-Retail channel split favored independent specialty bike shops at 47% of unit volume, with direct-to-consumer at 28%, big-box retail at 17%, and e-commerce marketplaces (Amazon, Walmart.com) at 8%. The independent specialty channel commands a price premium of approximately 22% over comparable D2C alternatives, attributed to in-store fitting, post-sale service relationships, and higher-margin component upgrades.
-
-Notable trends in 2025: cargo e-bike sub-segment grew 41% YoY (small base, dense urban geographies); battery range claims continue to drift upward with manufacturer claims of 60+ mile range becoming standard for $2,500+ price points; bottom-bracket motor placement (mid-drive) gained share over hub-drive in the $3,000+ tier.
-
----
-
-## Section 5: E-Scooter Regulatory Landscape
-
-The North American e-scooter regulatory environment matured significantly during 2024-2025 after several years of municipal experimentation and reactive policymaking. Forty-one US cities now operate under what we classify as "stable" regulatory regimes (defined as: explicit operating permit framework, defined sidewalk/bike-lane rules, helmet provisions, and revenue-share or fee structures with the city). This is up from 19 cities in 2022.
-
-The regulatory shift has compressed operator margins. Permit fees and per-trip surcharges in major markets (Los Angeles, Chicago, Atlanta, Denver) range from $0.15 to $0.42 per trip, against average ride revenue of $5.40. Several major operators have exited markets where permit economics have proven unviable; Lime exited five secondary US markets in 2025 citing exactly this reason.
-
-Helmet requirements remain inconsistent. Thirteen US states require helmets for riders under 18 only; seven require them for all riders; the rest leave it to municipalities. Enforcement is widely acknowledged to be minimal even where mandates exist. EU markets are substantially stricter, with mandatory helmet provisions in France, Germany, and Italy applying to all e-scooter riders.
-
-Insurance treatment is also fragmenting. Five US states have classified e-scooters as "motor vehicles" requiring liability coverage, raising the floor on operating costs for shared-fleet providers. Most states still treat them as bicycles for insurance purposes.
-
----
-
-## Section 6: Bike-Share and Dockless Mobility
-
-Docked bike-share systems (Citi Bike, Divvy, Bluebikes, Capital Bikeshare) continue stable, slow growth. Capital Bikeshare reported 5.1M trips in 2025 (5% growth); Citi Bike reported 38M (8% growth). Docked systems benefit from station infrastructure that creates predictability for riders and meters demand-side adoption.
-
-Dockless bike-share (without fixed stations) is largely consolidated; the experimentation phase ended in 2023. Lyft operates the dominant national network through its acquired bike-share division, with regional players in select markets. Operating economics for dockless are structurally weaker than docked due to vehicle redistribution costs, vandalism rates, and the absence of station-driven advertising revenue.
-
-A notable trend is the convergence of bike-share and dockless e-bike subscription models. Several operators now offer monthly memberships that include unlimited 30-minute trips on dockless e-bikes within a service zone. Adoption is concentrated in dense urban cores where car-free lifestyles are practical.
-
----
-
-## Section 7: Charging Infrastructure Trends
-
-Charging infrastructure for e-bikes and e-scooters has emerged as a meaningful sub-segment, growing 28% in 2025. The dominant form factor remains residential at-home wall chargers (87% of installed base), but commercial charging — at workplaces, transit stations, and apartment buildings — is the fastest-growing sub-segment.
-
-Standardization remains a constraint. Battery interfaces have not converged; Bosch, Shimano, and various proprietary systems coexist. The European Union's USB-C mandate for portable electronics has not yet extended to e-mobility; industry observers expect regulatory pressure to follow within 3-5 years.
-
-Workplace charging is increasingly common in tech and creative-industry employers; we estimate 31% of large urban employers in tech-heavy metros now offer workplace e-bike charging, up from 12% in 2022. Apartment buildings lag — 7% of class-A multifamily properties offer common-area charging, with retrofit cost cited as the primary barrier.
-
-Public charging at transit hubs (subway/light rail stations) remains a stated priority across most major metro transit authorities, but actual installation lags policy commitments significantly. Funding fragmentation and permitting delays are the consistently cited bottlenecks.
-
----
-
-## Section 8: Smart Helmet Category
-
-The connected safety hardware category — colloquially "smart helmets" — is the smallest segment we cover by retail value but has the strongest growth profile. The North American smart helmet market reached $810M in retail value in 2025, up from $480M in 2023, representing a 30% CAGR. We forecast $2.4B by 2030, contingent on the resolution of two open questions detailed below.
-
-**Category definition.** We define "smart helmets" as helmets that include at least one connected safety feature: turn signals (typically wireless-controlled), braking lights (auto-activated via accelerometer), crash detection (auto-notification to emergency contacts on detected impact), or integrated navigation/audio (bone-conduction speakers, often paired with smartphone apps). Helmets with passive integrated lighting only (no connectivity) are excluded from this category and tracked under traditional helmet retail.
-
-**Key players.** The category remains fragmented; no single manufacturer commands more than 15% market share. Top five by 2025 retail volume: Lumos Helmet (US, market leader at ~14% share with strong DTC presence), Sena Technologies (Korea, intercom heritage, ~11%), Coros (US/China, multi-sport, ~9%), Specialized ANGi (US, premium tier at ~7%), and POC Aid (Sweden, premium safety positioning at ~6%). Approximately 30 smaller brands hold the remaining share.
-
-**Crash detection technology.** Two architectures dominate: single-accelerometer crash detection (lower cost, higher false-positive rate) and multi-sensor fusion (accelerometer + gyroscope + GPS movement signature, lower false-positive rate but higher BOM cost). Insurance industry sources indicate that multi-sensor systems are likely to become a baseline requirement for any insurance discount programs, given that single-accelerometer systems triggered roughly 1 false alert per 47 hours of riding in our test panel.
-
-**Regulatory landscape.** Smart helmets sit at the intersection of two regulatory regimes: the Consumer Product Safety Commission's bicycle helmet standard (16 CFR 1203, governing impact protection) and the Federal Communications Commission's regulation of intentional radiators (governing the radio components for Bluetooth/cellular). Compliance with both is non-trivial. Eight smart helmet brands have had FCC Part 15 violations issued since 2023, typically for emissions exceeding limits during compliance testing. EU markets additionally require EN 1078 certification for the helmet shell; this is widely held but adds 3-5 months to a typical product development timeline.
-
-**Insurance industry interest.** Major auto insurers (State Farm, Progressive, Geico, Nationwide) are actively piloting telematics-style discount programs for cyclists who use connected safety helmets. The proposed structure mirrors auto-insurance "good driver" discount frameworks, with discounts of 5-15% on cycling-specific insurance riders or umbrella policies. As of Q1 2026, three insurers have public pilot programs and one (Progressive) has announced general availability for 2027. This could materially accelerate category adoption if discounts materialize at the upper end of the proposed range.
-
-**Distribution.** D2C dominates at 58% of retail value, reflecting the still-emerging category and the absence of strong channel inventory in independent bike shops. The specialty bike shop channel is growing rapidly (up from 12% to 22% of retail value over 2023-2025) as the category gains category-management attention from major distributors. Big-box channels (REI, Dick's Sporting Goods) are present but shallow in selection — typically 4-8 SKUs versus 40+ in dedicated specialty.
-
-**Open questions for the segment.** Our growth forecast is conditioned on (a) the proportion of insurers that follow Progressive into general availability of connected-safety discounts; (b) whether multi-sensor crash detection becomes a category baseline (lifting ASP) or remains a premium-tier feature; and (c) whether the current high false-positive rate of single-accelerometer systems triggers a consumer backlash that suppresses category trust before insurance discounts arrive. The downside scenario produces a 2030 category size of $1.4B versus our base-case $2.4B.
-
----
-
-## Section 9: Vehicle-to-Grid Integration
-
-Vehicle-to-grid (V2G) integration of e-bike and e-scooter batteries is an emerging area, but practical commercial deployment is years away. The thesis is that fleet-scale dockless e-bikes and e-scooters represent meaningful aggregate battery capacity that could participate in demand-response markets, particularly in deregulated electricity markets.
-
-Several technical preconditions must be met: standardized battery interfaces (currently absent), bidirectional charging hardware (rare), aggregator software stack (early-stage), and regulatory clarity on energy market participation by mobility fleets (pre-policy). We treat this as a watch item for 2028+ rather than a current investable theme.
-
----
-
-## Section 10: Outlook
-
-Our base-case forecast for North American e-mobility is $22.5B by 2030, with the e-bike segment reaching $11.8B (the largest), connected safety hardware reaching $2.4B (the fastest-growing in percentage terms), and charging infrastructure reaching $4.2B (driven by commercial and multifamily retrofit demand). Bike-share and dockless mobility plateau in the $2.5-3.0B range as urban density limits adoption ceilings.
-
-The largest single uncertainty in this forecast is the trajectory of insurance industry adoption of connected-safety telematics, which could accelerate or substantially constrain the smart helmet segment and, secondarily, influence rider behavior across the broader category. We will revisit forecasts in our Q4 2026 update.
-
----
-
-*This report is prepared for the exclusive use of Meridian Insights subscribers. Reproduction or external distribution without written permission is prohibited.*

evals/bmm-skills/bmad-product-brief/files/mossridge-brief/addendum.md

@@ -1,41 +0,0 @@
-# Addendum — Mossridge Tool Lending Library
-
-## Options considered
-
-### Paid lending model (rejected)
-
-Considered charging a nominal per-loan fee ($2–$5) to cover replacement and maintenance. Rejected as inconsistent with library mission of free access. Board has previously stated free access is non-negotiable for core services. A donation jar at checkout was proposed as a soft alternative; deferred.
-
-### Hardware store partnership (considered, deferred)
-
-Mossridge Hardware (the store committing in-kind donations) offered to host a satellite lending point. Considered; deferred to year 2. The integration adds operational complexity (split inventory, cross-location tracking) we are not equipped for at launch. Reasonable to revisit once the main location is established.
-
-### Mobile lending van (rejected)
-
-Proposed by a board member to serve outlying areas. Rejected for MVP — capital cost ($35K+ for vehicle + outfitting) exceeds the entire grant. Could be a year-three expansion if demand validates.
-
-### Skills classes alongside tool loans (deferred)
-
-Considered offering "how to use a power drill" classes as a value-add. Deferred — interesting but distinct programming, not part of the lending service's MVP scope. Adult Services Librarian is interested in piloting separately.
-
-## Reference programs reviewed
-
-- Berkeley Tool Lending Library (operating since 1979, ~3,000 tools, 250+ daily loans). Funded as a city service.
-- Oakland Tool Lending Library (operating since 2000, smaller catalog, library-staffed).
-- Toronto Tool Library (nonprofit, member-supported, paid model — different funding architecture).
-
-Direct correspondence with Berkeley TLL staff (March 2026) suggested:
-- Theft has been low (~2% annually) due to library card requirement and community norms
-- The biggest sustainability risk has been staff hours, not tool replacement
-- Most successful programs have a paid coordinator role, not pure volunteer
-
-## Potential expansion (year 2+)
-
-- Hardware store satellite location
-- Specialty tool categories: woodworking, automotive, sewing
-- Skills classes paired with relevant tool checkouts
-- Seed/cuttings library co-located in spring/summer
-
-## Insurance and liability — current state
-
-Library counsel (Town of Mossridge legal department) has been consulted informally. Formal opinion pending. Existing policy covers patrons in the building; coverage for tool use off-premises is the open question. Awaiting written response before submitting grant application.

evals/bmm-skills/bmad-product-brief/files/mossridge-brief/brief.md

@@ -1,57 +0,0 @@
----
-title: Mossridge Public Library — Tool Lending Library Proposal
-status: final
-created: 2026-04-30
-updated: 2026-04-30
----
-
-# Tool Lending Library at Mossridge Public Library
-
-## What we're proposing
-
-A free tool-lending service operated out of the Mossridge Public Library, modeled on similar programs in Berkeley, Oakland, and Toronto. Cardholders borrow hand and power tools (drills, saws, ladders, sanders, plumbing snakes, gardening tools) for up to seven days, free of charge.
-
-## Why now
-
-Mossridge residents face rising costs of home maintenance and DIY supplies. Anecdotally, demand for community-shared resources is high — staff have fielded "do you lend tools?" requests for years. A tool library extends the library's mission of equitable access to information and skill-building into the practical-skills domain.
-
-## Who it serves
-
-Mossridge residents with active library cards. Primary audience: single-family homeowners doing their own home repairs, renters making minor improvements with landlord permission, hobbyist woodworkers and gardeners. Estimated 8,000 households in the library's service area.
-
-## Service design
-
-- **Catalog:** Approximately 200 tools to start, prioritizing the most-requested categories (drilling, cutting, sanding, ladders, garden).
-- **Loan period:** Seven days, one renewal allowed if no holds.
-- **Borrower requirements:** Active library card, signed liability waiver, completed safety briefing for power tools.
-- **Location:** Library basement, currently underutilized storage. Accessible by elevator.
-- **Hours:** Tuesday–Saturday during library hours; tools returned via after-hours drop slot when closed.
-
-## Funding
-
-- ARPA infrastructure grant: $42,000 (anticipated, application pending)
-- Friends of the Mossridge Library matching funds: $10,000 (committed)
-- In-kind tool donations from Mossridge Hardware (committed in principle)
-
-Year-one operating cost is estimated at $48,000, primarily tool purchase, maintenance supplies, and shelving/storage retrofit. Ongoing cost (year two and beyond) projected at $12,000 annually for replacement tools and consumables.
-
-## Operations
-
-The service will be run by trained library volunteers, supervised by the Adult Services Librarian. Volunteer training program to be developed in partnership with Mossridge Vocational Center. Estimated 4–6 active volunteers needed at any given time, with a roster of 12–15 trained volunteers to provide coverage.
-
-## Risks
-
-- **Theft and loss.** Tools are valuable and portable. Mitigation: deposit on power tools (refundable), card-required checkout, photo documentation at loan and return.
-- **Liability.** Borrower waivers will be required; the library's existing insurance policy is being reviewed for coverage.
-- **Demand uncertainty.** We do not yet know the actual borrowing volume the service will see.
-
-## Success criteria
-
-- Launch by Q3 2027 with a catalog of 200 tools.
-- 300 unique borrowers in the first year of operation.
-- Zero serious injury incidents.
-- Tool loss rate under 5% per year.
-
-## What we're asking
-
-Board approval to proceed with the ARPA grant application and finalize the service design for fall 2027 launch.

evals/bmm-skills/bmad-product-brief/files/mossridge-brief/decision-log.md

@@ -1,29 +0,0 @@
-# Decision Log — Mossridge Tool Lending Library
-
-## 2026-03-04
-- **Pursuing the project.** Adult Services Librarian + Library Director agreed there's enough informal demand signal (years of "do you lend tools?" inquiries) to investigate seriously. Acknowledged that informal inquiries are not the same as validated demand.
-
-## 2026-03-11
-- **Reference programs to study: Berkeley, Oakland, Toronto.** Selected based on size, longevity, and accessibility of operational data.
-
-## 2026-03-25
-- **Initial scope: hand and power tools only.** Rejected including specialty categories (sewing, electronics test gear, automotive) for MVP. Reason: staff expertise and storage. Revisit year 2.
-- **Free model.** Confirmed — paid model rejected as inconsistent with library mission. Donation jar approved as soft revenue.
-
-## 2026-04-01
-- **Volunteer-run model.** Selected to keep ongoing operating costs low. Acknowledged risk: Berkeley correspondence flagged staff-hours as the biggest sustainability concern in similar programs. Plan to revisit at year-one review.
-
-## 2026-04-08
-- **Funding architecture: ARPA grant + Friends matching + in-kind donations.** Considered municipal budget request; rejected as too slow (next budget cycle is 18 months out). Grant is faster but requires fall 2027 launch deadline.
-
-## 2026-04-15
-- **Launch timing: Q3 2027.** Driven by ARPA grant deadline, not by service-readiness analysis. Acknowledged this is grant-driven, not user-driven, timing.
-- **Year-one target: 300 unique borrowers.** Set by analogy to comparable programs scaled to Mossridge population. No local validation underlying this number.
-
-## 2026-04-22
-- **Hardware store satellite deferred to year 2.** Operational complexity exceeds our launch capacity.
-- **Liability: pending formal opinion from town legal.** Borrower waiver in draft.
-
-## 2026-04-30
-- **Brief finalized for board meeting.** Status moved to final.
-- **Open items acknowledged for board discussion:** demand validation method, volunteer sustainability, written legal opinion on off-premises tool use coverage.

evals/bmm-skills/bmad-product-brief/files/pantry-bridge-interviews.md

@@ -1,90 +0,0 @@
-# Pantry Bridge — Customer Research Transcripts
-
-**Project:** Pantry Bridge meal-kit concept exploration
-**Research firm:** In-house
-**Round:** Discovery interviews, March 2026
-**Format:** 45-minute semi-structured interviews, video; excerpts below are lightly edited for length and clarity
-
-The four interviews below cover four distinct potential customer segments. We are sharing all four for context, though the team's current product hypothesis targets one specific segment.
-
----
-
-## Interview 1 — Susan, 38, working parent
-
-**Household:** Two kids (ages 6 and 9), spouse works full-time, both parents work demanding office jobs. Suburban Chicago.
-
-**Susan:** "Honestly, the question is just — can I get dinner on the table by 6:30 without it being chicken nuggets again? My kids don't eat anything green unless we play games about it. My husband and I both have late meetings sometimes. We've tried HelloFresh, we've tried Blue Apron, we tried Home Chef. They all kind of work, and they all kind of don't.
-
-The thing that breaks them for us is the prep time. The boxes say 30 minutes but you need to add 10-15 to actually get it done. By Wednesday night I don't have 45 minutes. So we end up using the boxes on weekends and ordering takeout three nights a week, which is the opposite of what the boxes are supposed to do.
-
-If you really wanted to crack it for families like ours: pre-chopped vegetables, sauces that are actually finished and not 'whisk these eight things together.' I'll pay more for less prep. And the recipe books need to read like the kid is going to eat it — not like 'spicy harissa-rubbed cauliflower steaks.'
-
-Portion sizing — most kits send way too much for our family. We're a family of four but the kids each eat about 60% of a meal. We end up with leftovers that go bad. Better sizing would help."
-
-**Interviewer:** What about price?
-
-**Susan:** "We spend $250-350 a week on groceries currently and probably another $200 on takeout. So a meal kit that replaces three nights of takeout could be $200 a month and we'd still come out ahead. Most kits are priced fine; it's the time that breaks them."
-
----
-
-## Interview 2 — Marcus, 21, college student
-
-**Household:** Junior at state university, off-campus apartment shared with two roommates, kitchen has a microwave, a stovetop, and a half-broken oven. Limited budget.
-
-**Marcus:** "I'm probably the wrong person for this conversation, no offense. I'm not really a meal-kit person. My food situation is, like, dining hall meal plan when I can use it, and the rest is whatever's cheap and fast. Trader Joe's frozen stuff. Eggs. Pasta. Costco runs with my roommates once a month.
-
-I tried a meal kit when my mom signed me up as a 'starting college' gift. It was nice, but it was $80 a week for two people, which is way out of budget. And honestly, the thing they don't get is that I don't have time at 7 PM to cook. I have time at 11 PM. I want to grab something on my way back from the library and not think.
-
-If you're trying to do meal kits for college students — and I don't really think you should — but if you were, the price has to be like $5 a meal. And it has to be food that survives in a fridge for two weeks because we don't shop on a weekly schedule. We shop when we run out.
-
-Snacks matter more to us than meals, actually. Like, the moment when I'm desperate is 10 PM in the library, not 7 PM. Solve that and I might pay attention."
-
-**Interviewer:** Do you have any dietary restrictions?
-
-**Marcus:** "I'm vegetarian, sort of. I eat fish. So pescatarian I guess. But mostly because meat is expensive."
-
----
-
-## Interview 3 — Eleanor, 71, retired, lives alone
-
-**Household:** Widow, lives alone in the same single-family home she's been in for 36 years. Suburban Cleveland. Two adult children live out of state. Drives during the day but no longer at night.
-
-**Eleanor:** "I'll tell you what I miss. I miss cooking for someone. My husband Walter passed five years ago this June, and the hardest thing — well, not the hardest, but one of them — is that I don't really cook anymore. I cook eggs. I cook a piece of fish. I open a can of soup more often than I'd like to admit. I used to make Sunday dinners that would feed eight people. Now I eat standing up at the counter half the time.
-
-The grocery store is genuinely difficult. I drive there, I park in the back of the lot because I can usually find a spot, and then it's a long walk in. I get tired by the time I'm in the dairy aisle. Carrying the bags from the car to the kitchen — that's a project. My daughter wants me to use grocery delivery and I've tried, but the apps are all designed for someone twenty years younger than me. Tiny buttons, asking me to click through six screens to add a single tomato. I get frustrated and give up.
-
-What I would actually want — and I've thought about this — is meals for one person. Real portions. Not a frozen TV dinner. Not 'serves four, freeze the rest.' I have a freezer full of leftovers I'll never eat. Just one good meal that I can heat up or finish cooking, that tastes like food I would have made.
-
-I'm watching my sodium because of my blood pressure. Watching sugar too — borderline diabetic, my doctor calls it. So I read labels carefully. The frozen meals you can buy in stores are loaded with both. I'd pay more for less of both, if I trusted that the labels were accurate.
-
-The other thing — and please put this in your notes — is that I'm careful about who I let into my house and what I sign up for. There are scams. My friend Marian got taken for $4,000 last year. So if some company asks for my information, I want to know who they are. I want a real customer service number with a real person. I want it to feel like a real business, not a flashy app.
-
-I don't want it to feel like 'old-people food.' That's an important thing. The Meals on Wheels program in our township is wonderful but it's clearly designed for people who are sicker than I am. I'm not sick. I just live alone and grocery shopping is a lot."
-
-**Interviewer:** What would the ideal experience look like?
-
-**Eleanor:** "Someone delivers good food, in real portions, made with the kind of ingredients I would have used. I can heat it up or finish it. It doesn't taste like a hospital. The packaging is something I can actually open without a knife. I get a phone call once in a while from a person, not a robot. The price is reasonable — I'm on a fixed income but I can spend on things that matter. Eating well matters."
-
----
-
-## Interview 4 — Dimitri, 44, Director of Food Services, mid-size hospital
-
-**Organization:** 340-bed hospital, food service operates patient meals, staff cafeteria, and a small retail café. Reports to the COO.
-
-**Dimitri:** "I'm probably also not who you should be talking to, but happy to share. We don't buy meal kits. We buy ingredients in institutional volumes from Sysco and US Foods primarily, with some specialty buys for dietary restrictions. We feed about 1,800 people a day across patients, staff, and visitors.
-
-What I deal with that you might find interesting is the patient diet matrix. We have to produce meals that meet specific medical requirements — renal diets, cardiac diets, diabetic diets, dysphagia textures, allergen-free, religious restrictions. Each patient gets a tray that meets their specific orders. It's complex.
-
-If a meal kit company wanted to play in our world, they'd be selling to me at the institutional level — bulk pricing, multi-year contracts, ability to deliver consistent specs across thousands of meals. That's not really a 'meal kit' anymore; that's wholesale food service.
-
-Now, where I might be a buyer in a different sense: my staff cafeteria. We're trying to compete with grab-and-go culture. If you produced ready-to-heat meals targeting our staff demographic — nurses, doctors, techs, who are working 12-hour shifts and want real food, not a sandwich — I might pay attention. But the price point would have to make sense for institutional buying, and you'd need to integrate with our existing food safety protocols.
-
-For consumer meal kits, I'm probably not your customer. We did try one when my wife and I were both working through COVID, and we let the subscription lapse after about three months. Fine product, just didn't fit our patterns."
-
----
-
-## Note from the research lead
-
-These four interviews were selected to represent the range of segments we've considered. The team's working hypothesis after this round is that the older-adult-living-alone segment is the strongest fit for the Pantry Bridge concept — distinctive needs, acknowledged friction with current options, willingness to pay for quality, and a meaningful unmet need around portion sizing and trust. Working parent segment is well-served by existing competitors. College student segment is too price-sensitive. Institutional segment is a different business entirely.
-
-The brief should target the older-adult segment based on the Eleanor interview specifically.

evals/bmm-skills/bmad-product-brief/files/q2-brainstorm.md

@@ -1,101 +0,0 @@
-# Q2 Brainstorm — Hatchet & Loop Studio
-
-**Date:** 2026-04-15
-**Present:** Mira, Devon, Sofia, Theo
-
-Annual Q2 ideation. We're hunting for our next side-project-that-could-become-a-product. Format: 10 minutes wild ideas, 3 minutes per idea on quick takes, then we vote on one to dig into.
-
-## Round 1: Everything goes
-
-(10 minutes, no filtering. We just throw stuff out.)
-
-- A weather app that tracks your mood alongside the forecast (Devon)
-- Meditation chime that learns your sleep cycle and chimes only at the right wake-window (Theo)
-- A podcasting tool for non-podcasters — like, you record voice notes and it auto-edits and posts (Sofia)
-- Craft beer subscription with detailed brewer notes you can read while drinking (Mira)
-- AI sommelier app that tells you what wine to buy at Trader Joe's based on a photo (Theo)
-- Office-plant-care subscription with auto-replacement when one dies (Devon)
-- Neighborhood ride coordinator — like a private Uber pool for one neighborhood (Mira)
-- Neighborhood compost coordinator — connect people with food scraps to people with active compost piles (Sofia)
-- Cookbook app where you click "I'll cook this Tuesday" and it auto-generates the shopping list and sends it to your delivery service (Devon)
-- AR home staging — point your phone at a room and it shows you what it would look like with different furniture (Theo)
-
-## Round 2: Quick takes
-
-### Weather + mood
-
-Devon: "I'd use it." Sofia thinks the data correlation isn't strong enough to be useful — interesting concept but the science doesn't support a product. Park.
-
-### Sleep-cycle meditation chime
-
-Theo's pitch — exists already (Sleep Cycle, etc.). Differentiation would be the chime, which is hardware. Out of scope for a software-first studio.
-
-### Podcasting for non-podcasters
-
-Sofia: "There are like fifty of these." She's right. Skip.
-
-### Craft beer subscription
-
-Mira admits this is mostly her wanting it for herself. We're not in the logistics business. Skip.
-
-### AI sommelier
-
-Theo: "The model would have to be incredibly good at label recognition." Sofia: "And there's already Vivino." Skip.
-
-### Office-plant-care subscription
-
-Devon: "I worked at a place that had this. They were always sad plants." Operational nightmare, low margin. Skip.
-
-### Neighborhood ride coordinator
-
-Mira: "Saturated. Lyft and Uber both have pool features. Uber Neighborhood was a thing and they killed it." Skip.
-
-### Neighborhood compost coordinator
-
-Sofia: "Hear me out. Cities are mandating organic waste separation but most apartments don't have a composting option. People in single-family homes often have active compost piles and would love more material. There's a missing match-making layer." General agreement this is more interesting than the others. Theo: "How do we make money?" Sofia: "Eventually a small fee on the compost-pile-host side, but for MVP just free and prove the demand." Group lights up. We agree to dig into this in Round 3.
-
-### Cookbook → shopping list
-
-Devon's pitch. Already exists (Mealime, Plan to Eat). Skip.
-
-### AR home staging
-
-Theo: "IKEA already has this." Skip.
-
-## Round 3: Compost coordinator deep dive
-
-We spent 45 minutes on this. Notes:
-
-**Who is the user?**
-Two-sided market. Side A: apartment dwellers and renters who generate food scraps and want them composted (motivated by environmental values, sometimes by city mandates). Side B: people with active backyard compost piles who want more "browns and greens" — single-family homeowners, urban farmers, school gardens, community gardens.
-
-Sofia thinks Side A is the harder side to acquire (weak intent — recycling-adjacent behavior). Side B is easier but smaller. The product has to be designed around Side A's friction points.
-
-**Geographic scope.**
-Hyperlocal — neighborhood-level, not city-wide. The whole point is short-distance handoff: Side A doesn't want to drive their food scraps across town. We're talking 5-block radius matches.
-
-**Business model (later).**
-Free at launch. Eventually: subscription for Side B (compost-pile hosts) — they pay to access more matches. Side A always free. Possibly partner with cities that have green-waste mandates (B2G channel).
-
-**Technical approach.**
-Web app first, mobile second. Map-based discovery. Identity verification light-touch (apartment dwellers are skittish about strangers; need trust signals). Match-and-message pattern, not real-time logistics.
-
-**Competition.**
-ShareWaste exists but is global and not focused on hyperlocal density. Some city-specific apps (NYC's GrowNYC). No one has cracked the neighborhood-density model.
-
-**MVP scope.**
-One pilot neighborhood. Sofia knows people in a Portland neighborhood (Sunnyside / Hawthorne area) where compost culture is strong. Start there.
-
-**Open questions.**
-- How do we acquire Side A (apartment dwellers)? They have low intent and lots of competing options (just throwing scraps in trash, paying a service, signing up for city pickup if available).
-- What does the trust layer look like? Reviews? Vouching? Real-name only?
-- Does Side B saturation become a problem fast (one compost pile can only take so much)? How do we route demand?
-
-## Action items
-
-- Sofia: write up the compost coordinator concept as a brief by next Wednesday. Take it to Mira and Devon for first read.
-- Devon: research ShareWaste's user numbers and any teardowns of why they haven't dominated.
-- Theo: sketch the trust-layer UX concepts.
-- Mira: talk to Sofia's Portland contacts about doing user interviews.
-
-Next meeting: 2026-04-29 — review brief draft, decide on go/no-go.

evals/bmm-skills/bmad-product-brief/triggers.json

@@ -1,18 +0,0 @@
-[
-  { "query": "Help me write a product brief for my new app idea", "should_trigger": true },
-  { "query": "I need to draft a brief for a feature we're scoping", "should_trigger": true },
-  { "query": "Update this product brief — we changed the target audience", "should_trigger": true },
-  { "query": "Review my brief and tell me if it's investor-ready", "should_trigger": true },
-  { "query": "Validate this brief before our board meeting Monday", "should_trigger": true },
-  { "query": "Pressure-test my product brief for weak assumptions", "should_trigger": true },
-  { "query": "Help me put together a one-page summary of my product idea for stakeholders", "should_trigger": true },
-
-  { "query": "Help me brainstorm ideas for a new feature", "should_trigger": false },
-  { "query": "Write me a PRD for our checkout flow redesign", "should_trigger": false },
-  { "query": "Run a working backwards exercise for my product idea", "should_trigger": false },
-  { "query": "Document this existing codebase for AI agents", "should_trigger": false },
-  { "query": "Help me write user stories for the next sprint", "should_trigger": false },
-  { "query": "Generate a system architecture for my app", "should_trigger": false },
-  { "query": "Write code to parse JSON in Python", "should_trigger": false },
-  { "query": "Create a marketing landing page for my product", "should_trigger": false }
-]

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "bmad-method",
-  "version": "6.7.1",
+  "version": "6.8.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "bmad-method",
-      "version": "6.7.1",
+      "version": "6.8.0",
       "license": "MIT",
       "dependencies": {
         "@clack/core": "^1.3.1",

package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-method",
-  "version": "6.7.1",
+  "version": "6.8.0",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "keywords": [
     "agile",

src/bmm-skills/1-analysis/bmad-product-brief/SKILL.md

@@ -15,7 +15,7 @@ At the opening greeting, let the user know they can invoke `bmad-party-mode` for
 
 ## 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.
+1. Resolve customization: `uv run {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.
 3. Treat every entry in `{workflow.persistent_facts}` as foundational context for the rest of the run. Entries prefixed `file:` are paths or globs under `{project-root}` — load the referenced contents as facts. All other entries are facts verbatim.
 4. `{workflow.external_sources}` is an org-configured registry of internal tools (knowledge bases, MCP tools); consult them alongside generic web research on the same triggers in `## Discovery`, org tools preferred when their directive matches. If a named tool is unavailable at runtime, fall back to standard behavior and note the gap when relevant.
@@ -28,11 +28,11 @@ Activation is complete. If `activation_steps_prepend` or `activation_steps_appen
 
 ## Intent Operating Modes
 
-**Create.** A brief the user is proud of, that meets their needs, drawn out through real conversation — do not assume: instead converse and understand, and then help craft the best product brief for their needs. Begin in `## Discovery` before drafting; the brief comes after the picture is on the table. Shape follows the product and need. Treat `{workflow.brief_template}` as a starting structure, not a contract: drop sections that do not earn their place, add sections the product needs, reorder freely - create sections for specialized domains or concerns also as needed. The brief serves the product's story, not the template's shape. Bind `{doc_workspace}` to a fresh folder at `{workflow.brief_output_path}/{workflow.run_folder_pattern}/` and write `brief.md` there with YAML frontmatter (title, status, created, updated). For Update and Validate, `{doc_workspace}` is the existing folder of the brief being targeted.
+**Create.** A brief the user is proud of, that meets their needs, drawn out through real conversation — do not assume: instead converse and understand, and then help craft the best product brief for their needs. Begin in `## Discovery` before drafting; the brief comes after the picture is on the table. Shape follows the product and need. Treat `{workflow.brief_template}` as a starting structure, not a contract: drop sections that do not earn their place, add sections the product needs, reorder freely - create sections for specialized domains or concerns also as needed. The brief serves the product's story, not the template's shape. Bind `{doc_workspace}` to a fresh folder at `{workflow.brief_output_path}/{workflow.run_folder_pattern}/`, write `brief.md` there with YAML frontmatter (title, status, created, updated), and seed the memlog: `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic="<product>"`. For Update and Validate, `{doc_workspace}` is the existing folder of the brief being targeted.
 
-**Update.** Reconcile an existing brief with a change signal. Before proposing changes, read the brief, addendum, `.decision-log.md`, and original inputs — and run the `## Discovery` posture against the change signal (a patch applied without context becomes drift). Surface conflicts with prior decisions before changing. Headless override: log the reversal to `.decision-log.md`, then apply; halt `blocked` if intent is ambiguous. If the change is fundamental, offer Create instead of patching.
+**Update.** Reconcile an existing brief with a change signal. Before proposing changes, read the brief, addendum, `.memlog.md`, and original inputs — and run the `## Discovery` posture against the change signal (a patch applied without context becomes drift). If `.memlog.md` is missing (a legacy or pre-standard brief), init it with `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace}` first — this update is its first entry. Surface conflicts with prior decisions before changing. Headless override: log the reversal via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type override --text "<reversal + rationale>"`, then apply; halt `blocked` if intent is ambiguous. If the change is fundamental, offer Create instead of patching.
 
-**Validate.** Honest critique against the brief's own purpose. Read the brief, the addendum if present, `.decision-log.md`, and any original inputs first — a validation that ignores prior decisions, rejected ideas, or context the user supplied is shallow. Cite specific lines. Caveat what cannot be evaluated. Return inline — no separate file unless asked. Always offer to roll findings into an Update, even in headless mode — include `"offer_to_update": true` in the JSON status block.
+**Validate.** Honest critique against the brief's own purpose. Read the brief, the addendum if present, `.memlog.md`, and any original inputs first — a validation that ignores prior decisions, rejected ideas, or context the user supplied is shallow. Cite specific lines. Caveat what cannot be evaluated. Return inline — no separate file unless asked. Always offer to roll findings into an Update, even in headless mode — include `"offer_to_update": true` in the JSON status block.
 
 ## Headless Mode
 
@@ -44,7 +44,7 @@ When invoked headless, do not ask. Complete the intent using what is provided, w
   "intent": "create",
   "brief": "{doc_workspace}/brief.md",
   "addendum": "{doc_workspace}/addendum.md",
-  "decision_log": "{doc_workspace}/.decision-log.md",
+  "memlog": "{doc_workspace}/.memlog.md",
   "open_questions": [],
   "external_handoffs": [
     {"directive": "Confluence upload", "tool": "corp:confluence_upload", "url": "https://confluence.corp/PROD/123", "status": "ok"}
@@ -76,15 +76,15 @@ The workspace persists; stop and resume freely. The opener's philosophy (not in
 ## Constraints
 
 - **Right-size to purpose.** A passion project does not need investor-grade rigor. A VC pitch input does. Read the room.
-- **Persistence is real-time.** Once Create intent is confirmed, the workspace (run folder, `brief.md` skeleton with `status: draft`, `.decision-log.md`) exists on disk and the user knows the path.
+- **Persistence is real-time.** Once Create intent is confirmed, the workspace (run folder, `brief.md` skeleton with `status: draft`, `.memlog.md` seeded via `memlog.py init`) exists on disk and the user knows the path.
-- **File roles.** `.decision-log.md` is canonical memory and audit trail — every decision, change, and override (including headless overrides) is recorded there as the conversation unfolds. `addendum.md` preserves user-contributed depth that belongs in a downstream document (PRD, architecture, solution design) or earned a place but does not fit the brief (rejected-alternative rationale, options-considered matrices, parked-roadmap context, technical constraints, in-depth personas, sizing data). Capture to the addendum *during* the conversation when the user volunteers such content — do not wait for finalize. Audit and override information never goes in the addendum.
+- **File roles.** `.memlog.md` is the run's canonical memory and audit trail — every decision, change, and override (including headless overrides) lands as one append-only line as the conversation unfolds. All writes go through the shared script, never by hand: `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type <decision|change|override|assumption|event> --text "<one-line gist, reason included>"` (atomic; read it back only to resume or audit). The brief is distilled toward it; whatever isn't logged is lost on resume. `addendum.md` preserves user-contributed depth that belongs in a downstream document (PRD, architecture, solution design) or earned a place but does not fit the brief (rejected-alternative rationale, options-considered matrices, parked-roadmap context, technical constraints, in-depth personas, sizing data). Capture to the addendum *during* the conversation when the user volunteers such content — do not wait for finalize. Audit and override information never goes in the addendum.
 - **Continuity across sessions.** If a prior in-progress draft for this project exists, the user is offered to resume.
 - **Extract, don't ingest.** Source artifacts (provided by the user or discovered during the run — transcripts, brainstorms, research reports, code, web results, prior briefs) enter the parent conversation as relevance-filtered extracts, not loaded wholesale. Subagents do the extraction against the user's stated focus; the parent context stays lean.
 - **Length and coherence.** Aim for 1-2 pages — if it is longer, the detail belongs in the addendum. Structure in service of the product; downstream consumers (PRD workflow, etc.) read this, so coherent shape matters.
 
 ## Finalize
 
-1. Decision log audit + addendum review: the user ends this step with an explicit, shared accounting of how the meaningful contents of `.decision-log.md` were handled — captured in the brief, captured in `addendum.md` (which may already hold detail captured during the conversation — see `## Constraints` for what belongs there), or set aside as process noise.
+1. Memlog audit + addendum review: the user ends this step with an explicit, shared accounting of how the meaningful contents of `.memlog.md` were handled — captured in the brief, captured in `addendum.md` (which may already hold detail captured during the conversation — see `## Constraints` for what belongs there), or set aside as process noise.
 2. Polish: apply each entry in `{workflow.doc_standards}` (a `skill:`, `file:`, or plain-text directive) to `brief.md` (and `addendum.md` if it exists). Run passes as parallel subagents - apply all doc standards to `brief.md` first, then `addendum.md` so we present a high-quality draft for the user to review and finalize.
 3. External handoffs: execute each entry in `{workflow.external_handoffs}` to route artifacts beyond local files (Confluence, Notion, ticket systems, etc.) — each directive names the MCP tool and the fields it needs. Invoke the tool, capture any URLs or IDs returned, and surface them in the user message. If a named tool is unavailable, skip that handoff and flag it; local files always exist regardless.
 4. Tell the user it is ready: local paths and external destinations (URLs returned from handoffs). Invoke `bmad-help` to suggest what next steps make sense in the bmad method ecosystem.

src/bmm-skills/2-plan-workflows/bmad-prd/SKILL.md

@@ -11,11 +11,11 @@ You are a master facilitator and coach helping the user create, edit, or validat
 - Bare paths resolve from skill root; `{skill-root}` is this skill's install dir; `{project-root}` is the project working dir.
 - `{workflow.<name>}` resolves to fields in `customize.toml`'s `[workflow]` table (overrides win per BMad merge rules).
 - `{doc_workspace}` is the bound run folder.
-- **File roles.** `.decision-log.md` is canonical memory and audit trail — every decision, change, and override (including headless overrides) is recorded there as the conversation unfolds. `addendum.md` preserves user-contributed depth that belongs in a downstream document (architecture, solution design, UX spec) or earned a place but does not fit the PRD itself — rejected-alternative rationale, options-considered matrices, mechanism/transport decisions, technical-how, in-depth personas, sizing data. Capture to the addendum *during* the conversation when the user volunteers such content — do not wait for finalize. Audit and override information never goes in the addendum.
+- **File roles.** `.memlog.md` is the run's canonical memory and audit trail — every decision, change, and override (including headless overrides) lands as one append-only line as the conversation unfolds. All writes go through the shared script, never by hand: `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type <decision|change|override|assumption|event> --text "<one-line gist, reason included>"` (atomic; read it back only to resume or audit). The PRD is distilled toward it; whatever isn't logged is lost on resume. `addendum.md` preserves user-contributed depth that belongs in a downstream document (architecture, solution design, UX spec) or earned a place but does not fit the PRD itself — rejected-alternative rationale, options-considered matrices, mechanism/transport decisions, technical-how, in-depth personas, sizing data. Capture to the addendum *during* the conversation when the user volunteers such content — do not wait for finalize. Audit and override information never goes in the addendum.
 
 ## 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.
+1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults.
 2. Run `{workflow.activation_steps_prepend}`. Treat `{workflow.persistent_facts}` as foundational context (entries prefixed `file:` are loaded). `{workflow.external_sources}` is an org-configured registry of internal tools (knowledge bases, MCP tools); consult them alongside generic web research on the same triggers, org tools preferred when their directive matches. Research itself fires during Discovery — see **Research subagents**.
 3. Load `{project-root}/_bmad/bmm/config.yaml` (+ `config.user.yaml` if present). Resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{planning_artifacts}`, `{project_name}`, `{date}`. Missing keys → neutral defaults; never block.
 4. If headless, follow `references/headless.md` for the whole run. Otherwise greet the user **by name** using `{user_name}` and **in their language** using `{communication_language}` — and stay in `{communication_language}` for every turn for the entire run, not just the greeting. In the greeting, let the user know that at any point they can invoke `bmad-party-mode` for multi-agent perspectives or `bmad-advanced-elicitation` for deeper exploration on a specific section. Then scan for misroute on the first message: if the signal points elsewhere (game → BMad GDS; express build → `bmad-quick-dev`; one-pager → `bmad-product-brief`; vet product idea → `bmad-prfaq`; agent skill or custom agent → `bmad-workflow-builder`), suggest they might want the other options before continuing.
@@ -27,9 +27,9 @@ Activation is complete. If `activation_steps_prepend` or `activation_steps_appen
 
 ## Intent Modes
 
-**Create.** Bind `{doc_workspace}` to `{workflow.prd_output_path}/{workflow.run_folder_pattern}/`. Write `prd.md` with YAML frontmatter (title, status, created, updated — initial `status: draft`), and create the `.decision-log.md` skeleton at the workspace root so subsequent decisions land in a known file. Tell the user the path. Run `## Discovery`, then `## Finalize`.
+**Create.** Bind `{doc_workspace}` to `{workflow.prd_output_path}/{workflow.run_folder_pattern}/`. Write `prd.md` with YAML frontmatter (title, status, created, updated — initial `status: draft`), and seed the memlog with `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic="<PRD/product name>"` so subsequent decisions land in a known file. Tell the user the path. Run `## Discovery`, then `## Finalize`.
 
-**Update.** Reconcile the PRD with a change signal. Source-extract against PRD, addendum, `.decision-log.md`, and original inputs (extract, don't ingest). If `.decision-log.md` is missing, spawn a one-time bootstrap subagent to reverse-engineer a thin log from the PRD before continuing. Surface conflicts with prior decisions before applying. Then `## Finalize`.
+**Update.** Reconcile the PRD with a change signal. Source-extract against PRD, addendum, `.memlog.md`, and original inputs (extract, don't ingest). If `.memlog.md` is missing, init it with `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace}`, then spawn a one-time bootstrap subagent to reverse-engineer a thin log from the PRD (one `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type decision --text "<recovered decision>"` per recovered decision) before continuing. Surface conflicts with prior decisions before applying. Then `## Finalize`.
 
 **Validate** (or *analyze*). Critique without changing. Load `references/validate.md`.
 
@@ -82,11 +82,11 @@ Under Validate intent, the parent additionally runs the synthesis pipeline in `r
 
 Tell the user the sequence in one sentence, then walk it. Polish goes last so it does not redo work after reviewer fixes.
 
-1. **Decision log audit.** Walk `.decision-log.md` with the user; each entry captured in PRD, in addendum, or set aside.
+1. **Memlog audit.** Walk `.memlog.md` with the user; each entry captured in PRD, in addendum, or set aside.
 2. **Input reconciliation.** Subagent per user-supplied input against `prd.md` + `addendum.md`. Each writes its extract to `{doc_workspace}/reconcile-{slug}.md` and returns ONLY a compact summary (input name, gaps 2-5, file path). Surface gaps — especially qualitative ideas (tone, voice, feel) the FR structure silently drops. Must happen before polish.
 3. **Reviewer pass.** Run `## Reviewer Gate`. Resolve before polish.
-4. **Triage open items.** All Open Questions, `[ASSUMPTION]` tags, `[NOTE FOR PM]` callouts. Phase-blockers (would make the PRD unsafe for UX/architecture/epics) surfaced one at a time and resolved; non-blockers deferred with owner + revisit condition logged to `.decision-log.md`. If phase-blocker count is high, flag it.
+4. **Triage open items.** All Open Questions, `[ASSUMPTION]` tags, `[NOTE FOR PM]` callouts. Phase-blockers (would make the PRD unsafe for UX/architecture/epics) surfaced one at a time and resolved; non-blockers deferred with owner + revisit condition logged via `memlog.py append`. If phase-blocker count is high, flag it.
 5. **Polish.** Apply `{workflow.doc_standards}` to `prd.md` and `addendum.md` in declared order (structural passes before prose — prose should not polish soon-to-be-cut text). Parallelize across documents, sequential within.
 6. **External handoffs.** Execute `{workflow.external_handoffs}`; surface returned URLs/IDs. Skip and flag unavailable tools.
-7. **Close.** Set `prd.md` frontmatter `status: final` and `updated` to `{date}` so future invocations distinguish this PRD from in-progress drafts. Record finalization to `.decision-log.md`. Share artifact paths. Common next: `bmad-ux`, `bmad-create-architecture`, `bmad-create-epics-and-stories`; invoke `bmad-help` for authoritative routing.
+7. **Close.** Set `prd.md` frontmatter `status: final` and `updated` to `{date}` so future invocations distinguish this PRD from in-progress drafts. Record finalization via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type event --text "PRD finalized"`. Share artifact paths. Common next: `bmad-ux`, `bmad-architecture`, `bmad-create-epics-and-stories`; invoke `bmad-help` for authoritative routing.
 8. Run `{workflow.on_complete}` if non-empty.

src/bmm-skills/2-plan-workflows/bmad-prd/assets/headless-schemas.md

@@ -18,7 +18,7 @@ Every headless run ends with one of these payloads. Omit keys for artifacts not
   "intent": "create",
   "prd": "{doc_workspace}/prd.md",
   "addendum": "{doc_workspace}/addendum.md",
-  "decision_log": "{doc_workspace}/.decision-log.md",
+  "memlog": "{doc_workspace}/.memlog.md",
   "open_questions": [],
   "assumptions": [],
   "external_handoffs": [
@@ -34,7 +34,7 @@ Every headless run ends with one of these payloads. Omit keys for artifacts not
   "status": "complete",
   "intent": "update",
   "prd": "{doc_workspace}/prd.md",
-  "decision_log": "{doc_workspace}/.decision-log.md",
+  "memlog": "{doc_workspace}/.memlog.md",
   "changes_summary": "1-3 sentences describing what changed and why",
   "conflicts_with_prior_decisions": [],
   "open_questions": [],

src/bmm-skills/2-plan-workflows/bmad-prd/customize.toml

@@ -60,7 +60,7 @@ validation_checklist_template = "assets/prd-validation-checklist.md"
 # collapse — no JS.
 validation_report_template = "assets/validation-report-template.html"
 
-# Run folder location. The PRD, optional addendum, decision log, and optional
+# Run folder location. The PRD, optional addendum, memlog, and optional
 # validation report all land inside `{prd_output_path}/{run_folder_pattern}/`.
 # Resume-check scans `{prd_output_path}` for prior unfinished runs.
 prd_output_path = "{planning_artifacts}/prds"

src/bmm-skills/2-plan-workflows/bmad-prd/references/headless.md

@@ -34,6 +34,6 @@ End with the JSON response (full schemas with examples in `assets/headless-schem
 
 ## Mode-specific overrides
 
-**Update.** Apply the change, log to `.decision-log.md` with rationale, and surface any conflict-with-prior-decision in `conflicts_with_prior_decisions[]` in the JSON status. Halt `blocked` if intent is ambiguous.
+**Update.** Apply the change, log it via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type change --text "<change + rationale>"`, and surface any conflict-with-prior-decision in `conflicts_with_prior_decisions[]` in the JSON status. Halt `blocked` if intent is ambiguous.
 
 **Validate.** Always write both `validation-report.html` and `validation-report.md` to `{doc_workspace}` regardless of finding count. Always include `"offer_to_update": true` in the JSON status. Skip the browser-open step in `references/validate.md` — write the artifacts and return.

src/bmm-skills/2-plan-workflows/bmad-prd/references/validate.md

@@ -4,7 +4,7 @@ The Validate intent playbook. Standalone — this intent critiques an existing P
 
 ## Orient
 
-Source-extract against `.decision-log.md`, any original inputs, and the PRD/addendum themselves. Delegate to subagents per PRD Discipline → "Extract, don't ingest" (in SKILL.md); the parent assembles from extracts.
+Source-extract against `.memlog.md`, any original inputs, and the PRD/addendum themselves. Delegate to subagents per PRD Discipline → "Extract, don't ingest" (in SKILL.md); the parent assembles from extracts.
 
 ## Run the Reviewer Gate
 

src/bmm-skills/2-plan-workflows/bmad-ux/SKILL.md

@@ -30,10 +30,10 @@ UX may lead, follow, or stand alone. Inherit `sources:` by reference; the spines
 
 ## 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.
+1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults.
 2. Run `{workflow.activation_steps_prepend}`. Treat `{workflow.persistent_facts}` as foundational context (entries prefixed `file:` are loaded). `{workflow.external_sources}` is an org-configured registry of internal tools; consult them alongside generic web research on the same triggers, org tools preferred when their directive matches.
 3. Load `{project-root}/_bmad/bmm/config.yaml` (+ `config.user.yaml` if present). Resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{planning_artifacts}`, `{project_name}`, `{date}`. Missing keys → neutral defaults; never block.
-4. If headless, follow `references/headless.md` for the whole run. Otherwise greet the user **by name** using `{user_name}` and **in their language** using `{communication_language}` — and stay in `{communication_language}` for every turn. In the greeting, let the user know `bmad-party-mode` and `bmad-advanced-elicitation` are always available. Then scan for misroute on the first message: PRD → `bmad-prd`; architecture → `bmad-create-architecture`; game UX → BMad GDS; agent/skill → `bmad-workflow-builder`; brief → `bmad-product-brief`.
+4. If headless, follow `references/headless.md` for the whole run. Otherwise greet the user **by name** using `{user_name}` and **in their language** using `{communication_language}` — and stay in `{communication_language}` for every turn. In the greeting, let the user know `bmad-party-mode` and `bmad-advanced-elicitation` are always available. Then scan for misroute on the first message: PRD → `bmad-prd`; architecture → `bmad-architecture`; game UX → BMad GDS; agent/skill → `bmad-workflow-builder`; brief → `bmad-product-brief`.
 5. Detect intent: **Create**, **Update**, **Validate**. For Create, before binding a fresh workspace, scan `{workflow.ux_output_path}` for prior in-progress runs (folders matching `{workflow.run_folder_pattern}` whose `DESIGN.md` frontmatter `status` is not `final`) and offer to resume rather than starting over.
 
 Run `{workflow.activation_steps_append}`.
@@ -42,15 +42,15 @@ Activation is complete. If `activation_steps_prepend` or `activation_steps_appen
 
 ## Modes
 
-**Create.** Bind `{doc_workspace}` to `{workflow.ux_output_path}/{workflow.run_folder_pattern}/`. Create `.working/`, `imports/`, `.decision-log.md`, `DESIGN.md` (frontmatter only), and `EXPERIENCE.md` (frontmatter only). Run Discovery → Finalize.
+**Create.** Bind `{doc_workspace}` to `{workflow.ux_output_path}/{workflow.run_folder_pattern}/`. Create `.working/` and `imports/`; seed the memlog with `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic="<product/UX>"`; create `DESIGN.md` (frontmatter only) and `EXPERIENCE.md` (frontmatter only). Run Discovery → Finalize.
 
-**Update.** Read spines + log + sources. Create the log if missing — this update is entry one. Surface conflicts with prior decisions. Run Finalize.
+**Update.** Read spines + memlog + sources. If `.memlog.md` is missing, init it with `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace}` — this update is entry one. Surface conflicts with prior decisions. Run Finalize.
 
 **Validate.** See `references/validate.md`.
 
 ## Discovery
 
-**Capture; do not author.** The spines are distilled at Finalize. Decisions → `.decision-log.md` (canonical). Creative-tool artifacts → `.working/`. User-supplied visuals (Figma, sketches, brand decks, image folders) → `imports/`, one log line per item. Spines win on conflict.
+**Capture; do not author.** The spines are distilled at Finalize toward the memlog. Decisions → `.memlog.md` (canonical), each appended via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type <decision|change|override|assumption|event> --text "…"` — never hand-edited; a resume reloads it. Creative-tool artifacts → `.working/`. User-supplied visuals (Figma, sketches, brand decks, image folders) → `imports/`, one `memlog.py append` per item. Spines win on conflict.
 
 **Source scan.** Glob `{planning_artifacts}/` for candidate input paths; surface paths only — never read content in the parent. User confirms which apply or adds others; subagent-extracts on confirm.
 
@@ -80,11 +80,11 @@ Used by Validate and Finalize. **Opt-in, lens-selectable** — reviewers are cos
 
 Outcomes, in order:
 
-- **Spines distilled.** Subagent reads `.decision-log.md`, `.working/`, `imports/`, sources; produces `DESIGN.md` against `## The DESIGN.md spine` + `{workflow.design_md_examples}` and `EXPERIENCE.md` against `## The EXPERIENCE.md spine` + `{workflow.experience_md_examples}`. Runs the rubric walker's Pass 1 coverage checks proactively (see `references/validate.md`). Surface gaps; never invent.
+- **Spines distilled.** Subagent reads `.memlog.md`, `.working/`, `imports/`, sources; produces `DESIGN.md` against `## The DESIGN.md spine` + `{workflow.design_md_examples}` and `EXPERIENCE.md` against `## The EXPERIENCE.md spine` + `{workflow.experience_md_examples}`. Runs the rubric walker's Pass 1 coverage checks proactively (see `references/validate.md`). Surface gaps; never invent.
 - **Inputs reconciled.** Subagent per user-supplied input → `reconcile-{slug}.md`. Surface dropped qualitative ideas.
 - **Reviewer Gate offered.** Ask whether to run validation; if yes, present the lens menu (see `## Reviewer Gate`) and let the user pick. If any lens ran, resolve findings before polish; otherwise proceed.
-- **Open items triaged.** Open Questions, `[ASSUMPTION]`, `[NOTE FOR UX]`. Phase-blockers one at a time; non-blockers → log.
+- **Open items triaged.** Open Questions, `[ASSUMPTION]`, `[NOTE FOR UX]`. Phase-blockers one at a time; non-blockers → `memlog.py append`.
 - **Key-screen mocks rendered.** Key-screens tool → `.working/` for surfaces where layout drives behavior or anchors visual language.
 - **Mock coverage confirmed.** Walk every IA surface; classify *mocked* vs *spine-only*. Ask: *"These will be built from spine tables alone — any need a visual reference?"* Render more if named; log spine-only choices.
 - **Layout extracted, artifacts promoted.** Distill subagent re-reads each `.working/` and `imports/` artifact; lifts visual decisions into DESIGN.md and behavioral decisions into EXPERIENCE.md. Promote `.working/` keepers to `mockups/` (HTML) or `wireframes/` (Excalidraw); imports stay. Inline relative links at relevant spine sections; state spines-win-on-conflict once.
-- **Polished, handed off, closed.** Apply `{workflow.doc_standards}` in order. Execute `{workflow.external_handoffs}`; surface URLs. Set both files' `status: final`, `updated: {date}`. Log finalization. Share paths. Common next: `bmad-create-architecture`, `bmad-create-epics-and-stories`, `bmad-dev-story`. Run `{workflow.on_complete}`.
+- **Polished, handed off, closed.** Apply `{workflow.doc_standards}` in order. Execute `{workflow.external_handoffs}`; surface URLs. Set both files' `status: final`, `updated: {date}`. Log finalization via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type event --text "spines finalized"`. Share paths. Common next: `bmad-architecture`, `bmad-create-epics-and-stories`, `bmad-dev-story`. Run `{workflow.on_complete}`.

src/bmm-skills/2-plan-workflows/bmad-ux/assets/design-directions.md

@@ -4,6 +4,6 @@ Subagent prompt. Produce 3-6 distinct visual directions for the product's hero s
 
 Each direction is a *complete visual personality* applied to the same key screen — not a palette swap. Differ on density, type weight, motion implication, brand register. Each file: 2-3 sentence rationale, near-1:1 hero screen mockup in a phone or browser frame, ideally a secondary screen, at least one state variant visible (aging row, empty state, etc).
 
-Use real product content from the conversation. Voice/tone from `.decision-log.md` applied to every visible string — no lorem. Inline CSS, system fonts, no JS or network. Document hex values in `<style>` comments per direction.
+Use real product content from the conversation. Voice/tone from `.memlog.md` applied to every visible string — no lorem. Inline CSS, system fonts, no JS or network. Document hex values in `<style>` comments per direction.
 
 Return to the parent: file paths, one-line personality summary per direction, what hero screen was depicted. Do not dump HTML into parent context. If interactive, open each file in the browser.

src/bmm-skills/2-plan-workflows/bmad-ux/assets/headless-schemas.md

@@ -18,7 +18,7 @@ Every headless run ends with one of these payloads. Omit keys for artifacts not
   "intent": "create",
   "design": "{doc_workspace}/DESIGN.md",
   "experience": "{doc_workspace}/EXPERIENCE.md",
-  "decision_log": "{doc_workspace}/.decision-log.md",
+  "memlog": "{doc_workspace}/.memlog.md",
   "working_artifacts": ["{doc_workspace}/.working/color-themes-1.html"],
   "promoted_artifacts": {
     "mockups": ["{doc_workspace}/mockups/direction-calm-sage.html"],
@@ -42,7 +42,7 @@ The `working_artifacts` and `promoted_artifacts` keys are optional and omitted e
   "intent": "update",
   "design": "{doc_workspace}/DESIGN.md",
   "experience": "{doc_workspace}/EXPERIENCE.md",
-  "decision_log": "{doc_workspace}/.decision-log.md",
+  "memlog": "{doc_workspace}/.memlog.md",
   "changes_summary": "1-3 sentences describing what changed and why",
   "conflicts_with_prior_decisions": [],
   "open_questions": [],

src/bmm-skills/2-plan-workflows/bmad-ux/assets/key-screens.md

@@ -4,11 +4,11 @@ Subagent prompt. Fired at Finalize (or during late Discovery once layout decisio
 
 ## Inputs
 
-`.decision-log.md`, the current drafts `DESIGN.md` and `EXPERIENCE.md`, `.working/` (especially the chosen color-theme and direction mocks), source PRD. The user names which surfaces to render — typically 2-4: the canonical entry surface, the most complex flow's hero screen, any load-bearing overlay/modal, and (when present) the Week / list / dashboard view.
+`.memlog.md`, the current drafts `DESIGN.md` and `EXPERIENCE.md`, `.working/` (especially the chosen color-theme and direction mocks), source PRD. The user names which surfaces to render — typically 2-4: the canonical entry surface, the most complex flow's hero screen, any load-bearing overlay/modal, and (when present) the Week / list / dashboard view.
 
 ## What to render
 
-One HTML file per screen, at `.working/key-{slug}.html`. Each file: realistic device frame (phone or browser), real product content from the conversation (no lorem), every visible string voice-checked against `.decision-log.md`, all decided tokens applied. Show one canonical state per screen; if a surface has a load-bearing alternate state (focus, error, crisis-card-present), render it as a second column or section in the same file.
+One HTML file per screen, at `.working/key-{slug}.html`. Each file: realistic device frame (phone or browser), real product content from the conversation (no lorem), every visible string voice-checked against `.memlog.md`, all decided tokens applied. Show one canonical state per screen; if a surface has a load-bearing alternate state (focus, error, crisis-card-present), render it as a second column or section in the same file.
 
 Inline CSS, system fonts, no JS, no network. The mock must render fully offline. Comment block at the top of the `<style>` notes which spine sections govern this screen so a future reader knows what to check.
 
@@ -23,7 +23,7 @@ The parent, at Finalize "Promote working artifacts," uses this summary to insert
 
 ## Anti-patterns
 
-- Do not invent layout — every composition decision must trace to a `.working/` artifact or a confirmation in `.decision-log.md`. If a layout question is open, the mock is premature.
+- Do not invent layout — every composition decision must trace to a `.working/` artifact or a confirmation in `.memlog.md`. If a layout question is open, the mock is premature.
 - Do not show every screen of every flow — 2-4 load-bearing surfaces, not 14.
-- Do not stage marketing copy. Strings come from `.decision-log.md` and voice rules.
+- Do not stage marketing copy. Strings come from `.memlog.md` and voice rules.
 - Do not introduce a new pattern not in the spine's Component Patterns table. If you need one, log it and ask before rendering.

src/bmm-skills/2-plan-workflows/bmad-ux/customize.toml

@@ -53,7 +53,7 @@ design_handoffs = [
 # HTML skeleton filled in by the validation synthesis pass.
 validation_report_template = "assets/validation-report-template.html"
 
-# Run folder. DESIGN.md, EXPERIENCE.md, .decision-log.md, .working/
+# Run folder. DESIGN.md, EXPERIENCE.md, .memlog.md, .working/
 # (creative-tool artifacts), imports/ (user-supplied screens / brand decks /
 # Figma exports / sketches), optional mockups/ and wireframes/ (promoted
 # artifacts), optional validation-report.* all land inside

src/bmm-skills/2-plan-workflows/bmad-ux/references/creative-tools.md

@@ -14,6 +14,6 @@ Every renderer writes to `{doc_workspace}/.working/` with a descriptive filename
 
 ## Renderer contract
 
-The parent passes the subagent: current `.decision-log.md`, relevant prior `.working/` captures, the user's stated intent for this pass, the output path. The subagent writes its artifact under `.working/` and returns ONLY a compact summary (file path, one line per variant, mode coverage). Parent never holds the full payload.
+The parent passes the subagent: current `.memlog.md`, relevant prior `.working/` captures, the user's stated intent for this pass, the output path. The subagent writes its artifact under `.working/` and returns ONLY a compact summary (file path, one line per variant, mode coverage). Parent never holds the full payload.
 
 For HTML, open in browser when interactive: `python3 -c "import webbrowser, pathlib; webbrowser.open(pathlib.Path('PATH').resolve().as_uri())"`. Skip in headless.

src/bmm-skills/2-plan-workflows/bmad-ux/references/headless.md

@@ -32,6 +32,6 @@ End with JSON matching `assets/headless-schemas.md`. `intent` reflects detected
 
 ## Mode-specific overrides
 
-**Update.** Apply the change. Log to `.decision-log.md` with rationale. Surface conflicts in `conflicts_with_prior_decisions[]`.
+**Update.** Apply the change. Log it via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type change --text "<change + rationale>"`. Surface conflicts in `conflicts_with_prior_decisions[]`.
 
 **Validate.** Always write both `validation-report.html` and `validation-report.md` regardless of finding count. Always include `"offer_to_update": true`. Skip the browser-open step.

src/bmm-skills/2-plan-workflows/bmad-ux/references/validate.md

@@ -4,7 +4,7 @@ Critique an existing spine pair (`DESIGN.md` + `EXPERIENCE.md`) or any format of
 
 ## Orient
 
-Subagent-extract from `.decision-log.md`, sources in frontmatter, `imports/`, `mockups/`, `wireframes/`, `DESIGN.md`, `EXPERIENCE.md`. Parent assembles from extracts.
+Subagent-extract from `.memlog.md`, sources in frontmatter, `imports/`, `mockups/`, `wireframes/`, `DESIGN.md`, `EXPERIENCE.md`. Parent assembles from extracts.
 
 ## Reviewer Gate
 
@@ -34,7 +34,7 @@ Rubric walker prompt:
 >
 > 7. **Inheritance discipline.** `sources` frontmatter resolves. UJ / requirement names verbatim from sources. Glossary identical across spines and sources. Component names identical across all sections in both files. EXPERIENCE.md token references resolve to DESIGN.md tokens by name.
 >
-> 8. **Shape fit.** DESIGN.md sections in canonical order (Brand & Style → Colors → Typography → Layout & Spacing → Elevation & Depth → Shapes → Components → Do's and Don'ts; omittable but order-locked when present). EXPERIENCE.md required defaults present (Foundation, IA, Voice and Tone, Component Patterns, State Patterns, Interaction Primitives, Accessibility Floor, Key Flows). Dropped defaults defensible. Required-when-applicable present where triggered (Inspiration when sources / log show reference products or rejects; Responsive when multi-surface or breakpoints). Invented sections earn their place.
+> 8. **Shape fit.** DESIGN.md sections in canonical order (Brand & Style → Colors → Typography → Layout & Spacing → Elevation & Depth → Shapes → Components → Do's and Don'ts; omittable but order-locked when present). EXPERIENCE.md required defaults present (Foundation, IA, Voice and Tone, Component Patterns, State Patterns, Interaction Primitives, Accessibility Floor, Key Flows). Dropped defaults defensible. Required-when-applicable present where triggered (Inspiration when sources / memlog show reference products or rejects; Responsive when multi-surface or breakpoints). Invented sections earn their place.
 >
 > Severity = downstream impact, not fix difficulty.
 >

src/bmm-skills/3-solutioning/bmad-agent-architect/customize.toml

@@ -56,8 +56,8 @@ principles = [
 
 [[agent.menu]]
 code = "CA"
-description = "Guided workflow to document technical decisions to keep implementation on track"
+description = "Produce the architecture spine: the invariants that keep independently-built units consistent"
-skill = "bmad-create-architecture"
+skill = "bmad-architecture"
 
 [[agent.menu]]
 code = "IR"

src/bmm-skills/3-solutioning/bmad-architecture/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: bmad-architecture
+description: 'Produce the architecture: a lean spine of invariants that keeps everything built from it consistent, projected into whatever format the work needs. Use when the user says "create the architecture", "create technical architecture", "architecture spine", or "create a solution design".'
+---
+# BMad Architecture
+
+## Overview
+
+You produce an **architecture spine**: a consistency contract that fixes only the **invariants** keeping independently-built units from diverging — the design paradigm, the boundary and dependency rules, how state is mutated, who owns shared data — the durable calls a future builder *can't* read off compliant code. Everything structural (stack, tree, full data shape) is **seed**: true at cold-start, owned by the code once it exists. Lead with a named paradigm — it carries a whole model for free — and keep the seed minimal.
+
+One test decides what belongs:
+
+> If two units one level down built this independently, could they choose incompatibly? Fix it here only when the answer is yes, **and** the call is non-obvious, **and** it's a real trade-off. Otherwise name it under Deferred and move on.
+
+Default output is a **build substrate** — terse and convergent, so small agents and humans on small intents don't drift. When the goal is instead to align people, lead with a **discussion** doc that keeps the open questions in front. Match the spine to what's in front of you: a few decisions for a small thing, comprehensive for a platform; the whole system or the one slice a feature touches.
+
+Record decisions, not rationale (rationale lives in the memlog). Carry shape in diagrams, not prose. Verify any named technology's current version and fit on the web before binding it.
+
+## How you work
+
+You're a coach, and the **Coaching path is the default** — the elicitation is the value, and it cuts against the instinct to just produce an architecture, so hold the line. Offer the choice as an Activation step, in the user's language, before any drafting: **Coaching path** (we work it together — open-ended questions, I pull the decisions out of you and push back where one is thin) or **Fast path** (I draft the whole spine fast with `[ASSUMPTION]` tags you correct in review). Unless the user clearly wants speed, **coach; don't silently draft.** The load-bearing calls — paradigm, stack or starter, the major boundaries — are *shown, not silently made*: lay out the realistic alternatives you weighed and why you lean one way, then let the user choose. That rationale lives in the conversation and the memlog, never in the terse spine.
+
+Elicit, don't quiz: open-ended "how are you thinking about X?" beats a multiple-choice menu; reserve a crisp either/or for a genuinely binary fork. On the Fast path, inferring and tagging *is* the job.
+
+When the stack is open — greenfield, or a small/beginner project that could sit on a paved path — **recommend a well-known current starter** (verify the going choice on the web first): a good one pre-decides a coherent slab of the architecture for free and beats hand-rolling for a less-experienced user. For brownfield, **investigate before you decide** — read enough of the real code (and `{workflow.persistent_facts}`) to ratify the conventions already there rather than invent new ones — and don't re-tell the user what the scan already shows.
+
+## Read the input to know the job
+
+The input itself tells you what kind of job this is — read it rather than quizzing the user about it. A spec package (`SPEC.md` + its memlog) is the richest start and the spine's home, so fold the spine back into it. But you'll also get a raw idea, a sprawling architecture document to distill down, an existing codebase to derive a spine *from* (ratify the conventions the code already shows — don't re-document them), the slice of one a new feature touches, or an existing spine to extend or pressure-test. Prefer a `.memlog.md` over re-reading the source it came from. Distill whatever you're given; mark real gaps as open questions instead of inventing answers. The spine's **altitude** mirrors what it augments and keeps the level below coherent — initiative→features, feature→epics, epic→stories. Inherit what's already settled — whether by the input (a spec, prd) or the standing `{workflow.persistent_facts}` — silently; don't re-decide or re-ask it. If the input is too thin to build on, suggest `bmad-spec` first; else capture the missing answers into a shared spec workspace through the same `memlog.py`, so `bmad-spec` can later derive `SPEC.md` without drift.
+
+**Inheriting a parent spine** (e.g. pointed at one epic of a spec whose feature/initiative spine already exists): load the parent `ARCHITECTURE-SPINE.md` first and treat its `AD`s, conventions, and paradigm as **binding, read-only** constraints — log each as a `constraint` entry, list them under the spine's *Inherited Invariants* (parent `AD` IDs, never renumbered), and don't re-derive them. Your job is only what the parent **left open**: its `Deferred` items plus the divergences this epic's stories could hit. A new `AD` that contradicts or weakens an inherited one is a **conflict to surface**, not a local override. An epic spine fixes the invariants the epic's stories must share — it does **not** expand per-story detail.
+
+## How a run works
+
+The **memlog** (`.memlog.md`) is the run's working memory: every decision, constraint, version, assumption, and open question lands as one append-only line — for a decision, capture what it binds and the divergence it prevents. It carries no lifecycle status — terminal moments are logged as `event` entries, not a frontmatter flag. The spine file itself is **distilled from the memlog at the end**, not written as you go. Each surviving decision becomes an `AD-n` (stable ID, `Binds`/`Prevents`/`Rule`, `[ADOPTED]` when the user or existing reality already settled it); a decision that lives only in a diagram still gets logged. Resume a prior run by reloading its memlog.
+
+Writes go through the shared script (don't read the file back except on resume):
+
+- `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field scope="…" --field purpose="…" --field altitude="…"`
+- `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type <decision|constraint|version|assumption|question|direction|event> --text "…"`
+
+## Resolution rules
+
+- Bare paths and `{skill-root}` (e.g. `references/headless.md`) resolve from this skill's installed directory.
+- `{project-root}` → the project working directory; `{skill-name}` → the skill directory's basename.
+- `{workflow.<name>}` → a merged `customize.toml` field; `{doc_workspace}` → the bound run folder.
+- Forward slashes only. Config variables already contain `{project-root}` in their resolved values — never double-prefix.
+
+## On Activation
+
+**Forwarded activation:** if a caller (e.g. the `bmad-create-architecture` shim) invoked you with a stated intent and pre-resolved customization fields, honor them verbatim — skip your own intent inference, use the supplied values for those named fields, and resolve only the remaining fields from your own `customize.toml`.
+
+1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow` (on failure read `{skill-root}/customize.toml`, use defaults). Run `{workflow.activation_steps_prepend}`, then `{workflow.activation_steps_append}`. Hold `{workflow.persistent_facts}` as standing context — the default loads `project-context.md`, load-bearing for brownfield — and consult `{workflow.external_sources}` on demand.
+2. Load `{project-root}/_bmad/bmm/config.yaml` (+ `config.user.yaml`) for `{user_name}`, `{communication_language}`, `{document_output_language}`, `{planning_artifacts}`, `{project_name}`, `{date}`; missing keys take neutral defaults, never block.
+3. Headless (no interactive user) → follow `references/headless.md` for the whole run. Otherwise greet `{user_name}` in `{communication_language}`. Detect the intent from the conversation and input — **create** (the default), **update** an existing spine, or **validate** one (see those sections). If the real ask is requirements / UX / a capability contract / epic breakdown / an agent, invoke the `bmad-prd`, `bmad-ux`, `bmad-spec`, `bmad-create-epics-and-stories`, or `bmad-workflow-builder` (if the BMad Builder module is installed) skill instead.
+4. If a run folder for this target already exists under `{workflow.spine_output_path}`, offer to resume from its memlog rather than restart.
+5. Interactive create: offer the working mode in `{communication_language}` — **Coaching path** (default) or **Fast path** (see *How you work*) — before any drafting; default to Coaching unless the user asks for speed.
+6. **Mandatory, both paths, before drafting:** ask whether the spine is the only deliverable — and if not, draw out the *purpose and audience* rather than a document type. "An architecture doc" balloons into bloat; what they actually need might be a one-detail explainer for a single team or a non-technical vision piece for a board. Purpose right-sizes the artifact and may call for extra elicitation up front, not just a finale add-on.
+
+For a new spine, bind `{doc_workspace}` to `{workflow.spine_output_path}/{workflow.run_folder_pattern}/`, seed `ARCHITECTURE-SPINE.md` from `{workflow.spine_template}`, run `memlog.py init`, and tell the user the path. **At epic altitude, scope the folder to the epic** (set `run_folder_pattern` per `customize.toml`) so per-epic runs don't collide.
+
+## Reviewer Gate
+
+The spine's pre-handoff review — full mechanics in `references/reviewer-gate.md`. Load it when finalizing or validating: a deterministic `lint_spine.py` pass, then a rubric walker (good-spine checklist) + every `{workflow.finalize_reviewers}` lens dispatched as parallel subagents against `ARCHITECTURE-SPINE.md`, scaled to stakes. At Finalize you apply the clear fixes; under the Validate intent you deliver a bespoke HTML report and then get user input.
+
+## Finalize
+
+Walk the sequence; reviewer fixes land before polish.
+
+1. **Distill.** Write the spine from the memlog (brownfield: + the code sweep) — invariants first, seed minimal, every `AD` carrying Binds/Prevents/Rule, `Deferred` naming what it won't decide. No placeholders; never invent to fill a gap. The template's `<!-- -->` notes are guidance — act on them, then strip them; the finished spine carries no template comment, and only the diagrams that convey the structure (as many as the altitude needs, valid mermaid). Sweep the breadth the altitude owns — every structural dimension is decided, deferred, or an open question; a whole dimension left silent (e.g. the operational/environmental envelope: deployment & environments, infra/provider strategy, operations) is the failure, not a clean spine. A long coaching run distills cleaner in a subagent; the parent falls back inline.
+2. **Reconcile inputs.** A subagent per load-bearing input checks it against the spine and returns what didn't land — especially a quiet requirement (a tone, a constraint) the `AD` structure dropped. Before the gate.
+3. **Reviewer pass.** Run the Reviewer Gate (`references/reviewer-gate.md`). Resolve before polish.
+4. **Triage.** Open questions and `[ASSUMPTION]` tags: blockers (unsafe for what's next) resolved one at a time; the rest deferred with a revisit condition in the memlog.
+5. **Renderings & polish.** The spine is the build deliverable; with it and the memlog now in place, produce any *additional* human-facing artifact the user needs, scoped to the purpose and audience drawn out up front. The up-front question already flagged whether one's needed; if it wasn't, still offer one here, seeding concrete options: an interactive HTML+SVG deck to walk a team through the architecture and drive discussion, a fuller HTML/md solution design, a C4 set, or a view of how the work splits across teams/epics. Build only what they pick, right-sized to that purpose; apply `{workflow.doc_standards}` polish to that prose only, never to the spine.
+6. **External handoffs.** Run `{workflow.external_handoffs}`; surface returned URLs/IDs. Offer to invoke the `bmad-spec` skill to adopt the spine as a companion, keeping `AD` IDs stable so downstream can cite them.
+7. **Close.** Set the spine's own frontmatter `status: final`, `updated: {date}`; log a `memlog.py append --type event --text "spine finalized"` (the memlog has no status field). Share paths. Next, **lead with `bmad-spec`** — recommend adopting/refreshing the spine as a spec companion (always the top recommendation when a spec was an input, and a useful next step even when it wasn't), then `bmad-create-epics-and-stories` or — epic altitude — `bmad-create-story`; or invoke `bmad-help` to route.
+8. Run `{workflow.on_complete}`.
+
+## Update
+
+Amend an existing spine or provided artifact. Resume from its `.memlog.md` (the authority on what was decided), not the rendered spine. Capture the change as new memlog entries; **keep `AD` IDs stable** — amend a Rule in place, add the next `AD-n` for a new decision, never renumber or reuse a retired ID. Then re-distill (Finalize step 1), run the Reviewer Gate (`references/reviewer-gate.md`), and close as in Finalize. An update that overrides something from a source input: offer to update that source too, so upstream and the spine don't silently diverge.
+
+## Validate
+
+The standalone intent — critique an existing spine without changing it. Run the Reviewer Gate (`references/reviewer-gate.md`) against it and deliver the bespoke HTML report, then offer to roll the findings into an Update. (At Finalize the same gate runs as your own pre-handoff check, where you apply the fixes instead of reporting.)

src/bmm-skills/3-solutioning/bmad-architecture/assets/spine-template.md

@@ -0,0 +1,79 @@
+---
+name: '{name}'
+type: architecture-spine
+purpose: build-substrate    # build-substrate (default) · discussion · report · deck
+altitude: feature           # initiative (keeps features) · feature (keeps epics) · epic (keeps stories)
+paradigm: '{named design pattern, e.g. hexagonal, layered, pipes-and-filters, actor}'
+scope: '{what this spine governs}'
+status: draft               # draft · final
+created: '{date}'
+updated: '{date}'
+binds: []                   # capability / unit IDs governed (from the driving spec; at epic altitude, also the inherited parent AD ids)
+sources: []
+companions: []
+---
+
+# Architecture Spine — {name}
+
+<!-- TEMPLATE GUIDE — act on these comments, then delete them; never emit a comment in the finished spine. This is a shape, not a script: keep only the sections this spine needs and cut the rest (no empty headers). A small intent may be just paradigm + a few ADs + conventions; a platform earns more. An inherited epic spine is usually mostly Inherited Invariants + a thin Deferred. Decisions, not rationale (rationale lives in the memlog). Carry shape in diagrams; prose only where it must. -->
+
+## Design Paradigm
+
+<!-- Name the pattern (a known one loads a whole model for free) and map its layers to namespaces/directories. The smallest, most durable thing here. -->
+
+## Inherited Invariants
+
+<!-- Only when this spine inherits a higher-altitude parent. The parent's ADs/conventions/paradigm that bind here, by their ORIGINAL ids — read-only, never renumbered, not re-derived. A local decision that contradicts one is a conflict to surface, not an override. Cut this section otherwise. -->
+
+| Inherited | From parent | Binds here |
+| --- | --- | --- |
+| {AD-id / convention} | {parent spine} | {what it constrains in this scope} |
+
+## Invariants & Rules
+
+<!-- The durable heart: calls a future builder can't read off compliant code. One block per decision: stable ascending id (never reused/renumbered), Binds, Prevents (the divergence), Rule (enforceable). Tag [ADOPTED] when the user or existing reality settled it. Include a dependency-direction diagram (who may depend on whom) — it IS a rule; author it as valid mermaid, never an empty graph. -->
+
+### AD-1 — {decision}
+
+- **Binds:** {capability / unit ids / fr/nfr's, areas, or `all`}
+- **Prevents:** {the divergence this stops}
+- **Rule:** {the constraint downstream must follow}
+
+## Consistency Conventions
+
+<!-- Defaults that bind where independent builders would drift. Cut rows that don't apply; add rows the project needs. -->
+
+| Concern | Convention |
+| --- | --- |
+| Naming (entities, files, interfaces, events) | |
+| Data & formats (ids, dates, error shapes, envelopes) | |
+| State & cross-cutting (mutation, errors, logging, config, auth) | |
+
+## Stack
+
+<!-- SEED — verified current at authoring; the code owns this once it exists. Name + version only; the why lives in the memlog. One row per language, framework, key dependency, platform, or chain that's pinned. -->
+
+| Name | Version |
+| --- | --- |
+| {language / framework / key dep / platform / chain} | {pinned version} |
+
+## Structural Seed
+
+<!-- The shapes worth fixing at cold-start — not a fixed list. Include only what's non-obvious at this altitude, and use as many diagrams as convey it, each as VALID mermaid (never a placeholder or empty graph). Candidates: system/container/context view; DEPLOYMENT & ENVIRONMENTS and external provider/infra topology (cover the operational envelope here when this altitude owns it — don't let it fall through); core-entity ERD (names + relationships only; an attribute that's itself an invariant is an AD, not a diagram); a minimal source tree. The code owns the detail — this is scaffold, not a mirror to maintain. -->
+
+```text
+{root}/
+  {dir}/   # {what lives here}
+```
+
+## Capability → Architecture Map
+
+<!-- Present when a spec drove this run. Bridges the spec's capabilities to where they live + what governs them; the consistency auditor's checklist. Cut otherwise. -->
+
+| Capability / Area | Lives in | Governed by |
+| --- | --- | --- |
+| {CAP-id / area} | {component / module} | {AD-id, convention, paradigm} |
+
+## Deferred
+
+<!-- Decisions intentionally pushed down, each with the reason it can wait — including whole dimensions this altitude doesn't own yet. The half of the contract that keeps the spine lean. -->

src/bmm-skills/3-solutioning/bmad-architecture/customize.toml

@@ -0,0 +1,100 @@
+# DO NOT EDIT -- overwritten on every update.
+#
+# Workflow customization surface for bmad-architecture.
+#
+# Override files (not edited here):
+#   {project-root}/_bmad/custom/bmad-architecture.toml         (team)
+#   {project-root}/_bmad/custom/bmad-architecture.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, approved-stack policy checks, etc.
+activation_steps_prepend = []
+
+# Steps to run after greet but before the workflow begins.
+# 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
+# (approved stacks, banned dependencies, platform constraints, compliance guardrails).
+# Each entry is either 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 produced one — giving the
+# architect persistent awareness of the project's tech, domain, and conventions (load-bearing
+# for brownfield). Common opt-ins (set in team/user override TOML):
+#   "Our org is AWS-only -- do not propose GCP or Azure."
+#   "file:{project-root}/docs/engineering-standards.md"
+persistent_facts = [
+  "file:{project-root}/**/project-context.md",
+]
+
+# Executed when the workflow completes (after the spine is final and the user has been told).
+# String scalar (single instruction) or array of instructions executed in order. Empty for none.
+on_complete = ""
+
+# The architecture spine template. Treated as expert prior knowledge, not a checklist — the LLM
+# adapts it to the project, altitude, and domain, and drops sections a project genuinely doesn't
+# need. Override the path in team/user TOML to enforce a different spine shape.
+spine_template = "assets/spine-template.md"
+
+# Run folder location. ARCHITECTURE-SPINE.md, its .memlog.md, and any fuller rendering the run
+# produces all land inside `{spine_output_path}/{run_folder_pattern}/`. Resume-check scans
+# `{spine_output_path}` for prior unfinished runs.
+#
+# The default pattern fits the common case (one spine per project, at the altitude above epics).
+# At EPIC altitude, override run_folder_pattern to carry the epic identity so per-epic runs don't
+# collide on the same day — e.g. set it (team/user TOML) to "architecture-epic-{epic_id}", binding
+# {epic_id} from the driving spec / the activating payload. Headless callers may instead pass an
+# explicit doc_workspace and bypass the pattern entirely.
+spine_output_path = "{planning_artifacts}/architecture"
+run_folder_pattern = "architecture-{project_name}-{date}"
+
+# Prose-editorial standards applied at finalize ONLY to a fuller prose document the run produces
+# (a discussion report, full architecture doc, or design addendum) — never to the spine or other
+# short, structured outputs, which are terse and carry decisions in AD-n blocks and diagrams by
+# design. Each entry is a `skill:`, `file:`, or plain-text directive applied before the user sees
+# the polished draft. Suggested order: structural passes first, prose mechanics last. Append-only.
+doc_standards = [
+  "skill:bmad-editorial-review-structure",
+  "skill:bmad-editorial-review-prose",
+]
+
+# External-source registry. Natural-language directives describing knowledge bases, MCP tools, or
+# internal systems the LLM may consult ON DEMAND during the run (not preemptively) — approved-stack
+# catalogs, internal platform docs, version registries. Each entry names the tool, the trigger
+# condition, and any fields it needs. If a named tool is unavailable at runtime, the LLM falls back
+# to standard behavior (e.g. web research) and notes the gap. Empty by default.
+#
+# Examples (set in team/user override TOML):
+#   "When choosing a datastore, consult corp:platform_catalog before recommending one."
+#   "For current library versions, query corp:artifact_registry before web search."
+external_sources = []
+
+# External-handoff routing applied at Finalize to push outputs beyond local files (Confluence,
+# Notion, ticket systems). Each entry names the MCP tool, the destination, and required fields.
+# Runs after polish; returned URLs/IDs are surfaced. Unavailable tools are skipped and flagged;
+# local files always exist. Empty by default.
+external_handoffs = []
+
+# --- Finalize reviewers ---
+# Extra review lenses spawned as parallel subagents at the validation gate (Finalize and the
+# Validate intent), on top of the skill's built-in good-spine checklist and the lint_spine.py
+# mechanical floor. The GATE is stakes-gated — a throwaway spine may run it quietly or skip it —
+# but whenever the gate runs, every entry here runs with it (the configured floor, never cherry-
+# picked); only ad-hoc lenses are optional, and headless never skips the gate.
+#
+# Entries follow the standard prefix convention:
+#   "skill:NAME"   invoke the named review skill as a subagent against ARCHITECTURE-SPINE.md
+#   "file:PATH"    load the file as a review prompt; spawn an adversarial subagent applying it
+#   plain text     use the text directly as the subagent's review prompt
+#
+# Resolved on-demand (not at activation). Override TOML may append.
+finalize_reviewers = [
+  "Verify every committed decision was web-researched or reality-checked rather than asserted from training data: current library/framework versions, that each named technology still exists and fits, and — greenfield — the live defaults of any starter it leans on. Flag anything that could be out of date and wasn't confirmed against the web, the existing project, or the current starter.",
+  "Attack the spine as an adversary: construct two units one level down that each obey every AD to the letter yet still build incompatibly — clashing shared-data shapes, two owners of one entity, conflicting state-mutation paths. Every pair you find is a hole to close with a new or tightened AD.",
+]

src/bmm-skills/3-solutioning/bmad-architecture/references/headless.md

@@ -0,0 +1,26 @@
+# Headless
+
+No interactive user: infer everything, ask nothing, but never invent — record inferences as `assumptions[]` and gaps that need a human as `open_questions[]`. Detect headless from a `headless: true` flag, a non-interactive / no-TTY invocation, an activation hook that declares it, or a first message that pre-supplies all inputs and asks for an artifact path back; when ambiguous, default to interactive.
+
+Drive the run from the payload in the first message — `intent`, `altitude`, `purpose`, the driving input (spec package / PRD / raw intent / brownfield path), a parent spine path at lower altitude, and `doc_workspace` if a specific folder is required. Infer anything absent from the inputs or workspace; don't invent stack, constraints, or scope to fill a gap. You still verify named tech on the web (you can't ask, but you can check) and still drive every write through the shared `{project-root}/_bmad/scripts/memlog.py`. Run the full Reviewer Gate (`references/reviewer-gate.md`) non-interactively: `scripts/lint_spine.py` plus **every `{workflow.finalize_reviewers}` lens as a parallel subagent** (and any ad-hoc lens the spine's criticality warrants). Headless skips only the human picking from the menu — never the reviewers themselves; apply the clear fixes and record anything unresolved in `open_questions[]`. For a true authority collision, list it in `conflicts_with_prior_decisions[]`. For the Validate intent, always write the report to `{doc_workspace}` and add `"offer_to_update": true`. If intent stays ambiguous after inference, halt blocked.
+
+End with JSON only, omitting keys for artifacts not produced — the shape below is the fully-produced (`complete`) case; a `blocked` run produces no spine, so it omits `spine`, `memlog`, and `companions` entirely (see the note under the block):
+
+```json
+{
+  "status": "complete | partial | blocked",
+  "intent": "create | update | validate",
+  "altitude": "initiative | feature | epic",
+  "purpose": "build-substrate | discussion",
+  "doc_workspace": "<resolved run folder>",
+  "spine": "{doc_workspace}/ARCHITECTURE-SPINE.md",
+  "memlog": "{doc_workspace}/.memlog.md",
+  "companions": [],
+  "assumptions": [],
+  "open_questions": [],
+  "conflicts_with_prior_decisions": [],
+  "reason": "<one line, only when blocked>"
+}
+```
+
+`complete` stands alone · `partial` (spine produced, but `open_questions[]` non-empty or critical inputs inferred) means review before downstream use · `blocked` means no spine produced — return only `status`, `intent`, `reason`, and `doc_workspace` (if bound), omitting `spine`, `memlog`, `companions`, and the artifact arrays that don't exist.

src/bmm-skills/3-solutioning/bmad-architecture/references/reviewer-gate.md

@@ -0,0 +1,13 @@
+# Reviewer Gate
+
+The spine's pre-handoff review. Runs at Finalize (after distill + reconcile) and *is* the Validate intent. The difference is the ending: at Finalize you apply the clear fixes yourself; under Validate you report and don't change the spine.
+
+Cheap deterministic pass first: `uv run {skill-root}/scripts/lint_spine.py --workspace {doc_workspace}` settles the mechanical misses (placeholders, duplicate `AD` IDs, missing Binds/Prevents/Rule, unpinned Stack versions), so reviewers spend judgment on the semantic half.
+
+Assemble the menu: a **rubric walker** that judges the spine against the good-spine checklist below, **+ every entry in `{workflow.finalize_reviewers}`**, + ad-hoc lenses you invent or offer as the spine's rigor, altitude, and criticality warrant — a security/compliance lens for regulated stakes, a seam reviewer cross-team, a data-integrity lens for a heavy data model. Scale *whether and how heavily the gate runs* to the stakes: a throwaway prototype may run it quietly or skip the gate entirely; a high-criticality or platform-altitude spine earns more lenses and the explicit all / subset / skip menu. But once the gate runs, the `{workflow.finalize_reviewers}` always run — they are the configured floor, never cherry-picked out; only the ad-hoc lenses are optional. (Headless never skips the gate.)
+
+Dispatch every entry as a **parallel subagent against `ARCHITECTURE-SPINE.md`** (prefix convention: `skill:` / `file:` / plain text). Each writes its full review to `{doc_workspace}/reviews/review-{slug}.md` — a subfolder, so the gate's scratch stays out of the deliverable folder — and returns ONLY a compact summary (verdict, top 2–5 findings, file path) — the parent never holds full review text. An inline self-check does not count: the independent context is the point, because a fresh reviewer finds the divergences the author talks past. If subagents are unavailable, run sequentially — write the file first, then flush it from context.
+
+**Good-spine checklist** (what the rubric walker judges): it fixes the real divergence points for the level below and misses none; every `AD`'s Rule is enforceable and actually prevents its stated divergence; nothing under Deferred could let two units diverge; named tech is verified-current; it ratifies rather than contradicts a brownfield codebase; if a spec drove it, it covers that spec's capabilities; if a parent spine is inherited, no new `AD` weakens or contradicts an inherited one; and every dimension the altitude owns is decided, deferred, or an open question — a whole dimension left silent is a finding, especially the operational/environmental envelope (deployment & environments, infra/provider strategy, operations) a domain-focused draft skips.
+
+Surface findings tiered, never dumped: a one-sentence gate verdict, then critical + high; medium/low roll into a tail ("plus N more in {file}"). Per finding: autofix, discuss, defer to Deferred / open items, or ignore. **At Finalize this is your own gate — apply the clear fixes rather than handing over a list; surface only what genuinely needs the user.** Under the **Validate intent**, fold every reviewer's output into one bespoke HTML + markdown report and open the HTML.

src/bmm-skills/3-solutioning/bmad-architecture/scripts/lint_spine.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# ///
+"""lint-spine — the mechanical half of spine decision-integrity, done deterministically.
+
+LLMs miscount IDs and miss literal placeholders; a grep does not. This linter owns the
+checks a script does better than a prompt, and leaves the semantic half (is each Rule
+actually enforceable? does the boundary make sense?) to the rubric walker.
+
+It reads ARCHITECTURE-SPINE.md from a workspace and reports, as compact JSON on stdout:
+
+  - placeholder    literal TBD / TODO / "similar to AD-n" / unfilled {template-token}
+  - ad_id          duplicate or non-monotonic AD-n identifiers
+  - ad_fields      an AD-n block missing Binds / Prevents / Rule
+  - version_pin    a ## Stack table row with no version
+
+Fenced code blocks are blanked (replaced with equal-count blank lines) before scanning, so
+mermaid and source trees don't trip false positives AND reported line numbers still line up
+with the real file. Reported lines are absolute file lines (frontmatter offset added). Exit
+code is always 0 — findings travel in the JSON; the caller (Reviewer Gate / rubric walker)
+decides what to do with them.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+SPINE = "ARCHITECTURE-SPINE.md"
+
+AD_HEADING = re.compile(r"^#{2,4}\s*AD-(\d+)\b(.*)$", re.MULTILINE)
+HEADING = re.compile(r"^#{1,6}\s", re.MULTILINE)
+FENCE = re.compile(r"```.*?```", re.DOTALL)
+PLACEHOLDER_WORD = re.compile(r"\b(TBD|TODO|FIXME|XXX)\b")
+SIMILAR_TO = re.compile(r"similar to AD-\d+", re.IGNORECASE)
+TEMPLATE_TOKEN = re.compile(r"\{[a-z_][a-z0-9_ /.-]*\}")
+
+
+def split_frontmatter(text: str) -> tuple[str, str, int]:
+    """Return (frontmatter, body, body_line_offset).
+
+    Frontmatter is the content between the first two lines that are *exactly* `---`
+    (line-exact, like memlog.split — a `---` inside a value or a body thematic break never
+    truncates it). body_line_offset is the number of file lines before the body begins, so a
+    body-relative line number plus the offset gives the absolute file line. Absent frontmatter
+    → ('', text, 0)."""
+    lines = text.split("\n")
+    if lines and lines[0] == "---":
+        for i in range(1, len(lines)):
+            if lines[i] == "---":
+                fm = "\n".join(lines[1:i])
+                body = "\n".join(lines[i + 1:])
+                return fm, body, i + 1
+    return "", text, 0
+
+
+def blank_fences(text: str) -> str:
+    """Replace each fenced block with the same number of newlines, so scanning skips fenced
+    content while every line number outside the fence stays put."""
+    return FENCE.sub(lambda m: "\n" * m.group(0).count("\n"), text)
+
+
+def line_of(text: str, idx: int) -> int:
+    return text.count("\n", 0, idx) + 1
+
+
+def find_placeholders(body: str, offset: int) -> list[dict]:
+    findings: list[dict] = []
+    scan = blank_fences(body)
+    # (regex, label, severity) — TBD/TODO and dangling cross-refs are unambiguous; a bare
+    # {template-token} can be legitimate brace prose, so it is flagged low ("possible") to keep
+    # the mechanical pass near-zero false-positive rather than train reviewers to ignore it.
+    for rx, label, severity in (
+        (PLACEHOLDER_WORD, "placeholder marker", "high"),
+        (SIMILAR_TO, "unresolved cross-reference", "high"),
+        (TEMPLATE_TOKEN, "possible unfilled template token (verify)", "low"),
+    ):
+        for m in rx.finditer(scan):
+            findings.append({
+                "category": "placeholder",
+                "severity": severity,
+                "detail": f"{label}: {m.group(0)!r}",
+                "location": f"{SPINE} (line {offset + line_of(scan, m.start())})",
+            })
+    return findings
+
+
+def find_frontmatter_placeholders(frontmatter: str) -> list[dict]:
+    """Catch unfilled tokens left in frontmatter (e.g. paradigm/scope/date) — part of the
+    spine contract, but outside the body that find_placeholders scans."""
+    findings: list[dict] = []
+    for rx, label, severity in (
+        (PLACEHOLDER_WORD, "placeholder marker", "high"),
+        (TEMPLATE_TOKEN, "possible unfilled template token (verify)", "low"),
+    ):
+        for m in rx.finditer(frontmatter):
+            findings.append({
+                "category": "placeholder",
+                "severity": severity,
+                "detail": f"frontmatter {label}: {m.group(0)!r}",
+                "location": f"{SPINE} frontmatter (line {1 + line_of(frontmatter, m.start())})",
+            })
+    return findings
+
+
+def find_ad_issues(body: str, offset: int) -> list[dict]:
+    findings: list[dict] = []
+    scan = blank_fences(body)  # AD headings shown inside a code fence are not live ADs
+    matches = list(AD_HEADING.finditer(scan))
+    seen: dict[int, int] = {}
+    prev: int | None = None
+    for m in matches:
+        num = int(m.group(1))
+        file_line = offset + line_of(scan, m.start())
+        loc = f"{SPINE} AD-{num} (line {file_line})"
+        if num in seen:
+            findings.append({
+                "category": "ad_id",
+                "severity": "high",
+                "detail": f"AD-{num} id reused (also at line {seen[num]})",
+                "location": loc,
+            })
+        else:
+            seen[num] = file_line
+        if prev is not None and num <= prev:
+            findings.append({
+                "category": "ad_id",
+                "severity": "high",
+                "detail": f"AD-{num} is non-monotonic (follows AD-{prev}); ids must ascend and never renumber",
+                "location": loc,
+            })
+        prev = num if prev is None else max(prev, num)
+
+        # block text = from this heading to the next heading of any level
+        start = m.end()
+        nxt = HEADING.search(scan, start)
+        block = scan[start:nxt.start()] if nxt else scan[start:]
+        low = block.lower()
+        missing = [f for f in ("binds", "prevents", "rule") if f not in low]
+        if missing:
+            findings.append({
+                "category": "ad_fields",
+                "severity": "high",
+                "detail": f"AD-{num} missing required field(s): {', '.join(missing)}",
+                "location": loc,
+            })
+    return findings
+
+
+def find_unpinned_stack(body: str, offset: int) -> list[dict]:
+    """Flag a `## Stack` table row that names something but leaves its version blank or a
+    placeholder. Pinning lives in the body table now, not frontmatter. A row whose name is
+    still a `{token}` skeleton is left to the placeholder pass, not double-reported here.
+
+    Fences are blanked first (like find_placeholders / find_ad_issues), so a pipe-row or
+    heading inside a code block is never read as live Stack content. The heading match is
+    `## Stack` with a word boundary, so a renamed heading (`## Stack & Versions`) still
+    counts. Name and Version columns are located from the header row, so a reordered table
+    pairs name to version correctly; both default to the canonical positions (0, 1)."""
+    findings: list[dict] = []
+    in_stack = False
+    header_seen = False
+    name_idx, ver_idx = 0, 1
+    scan = blank_fences(body)
+    for i, raw in enumerate(scan.splitlines()):
+        if HEADING.match(raw):
+            in_stack = re.match(r"^##\s+Stack\b", raw) is not None
+            header_seen = False
+            name_idx, ver_idx = 0, 1
+            continue
+        if not in_stack or not raw.lstrip().startswith("|"):
+            continue
+        if set(raw.strip()) <= set("|-: "):
+            continue  # separator row
+        cells = _table_cells(raw)
+        if not header_seen:
+            header_seen = True
+            for j, c in enumerate(cells):
+                if c.lower() == "name":
+                    name_idx = j
+                elif c.lower() == "version":
+                    ver_idx = j
+            continue
+        name = cells[name_idx] if len(cells) > name_idx else ""
+        version = cells[ver_idx] if len(cells) > ver_idx else ""
+        if not name or TEMPLATE_TOKEN.search(name):
+            continue
+        if not version or TEMPLATE_TOKEN.search(version):
+            findings.append({
+                "category": "version_pin",
+                "severity": "medium",
+                "detail": f"Stack entry {name!r} has no version",
+                "location": f"{SPINE} (line {offset + i + 1})",
+            })
+    return findings
+
+
+def _table_cells(row: str) -> list[str]:
+    """Split a markdown table row into trimmed cells, dropping the leading/trailing pipe."""
+    s = row.strip()
+    if s.startswith("|"):
+        s = s[1:]
+    if s.endswith("|"):
+        s = s[:-1]
+    return [c.strip() for c in s.split("|")]
+
+
+def lint(text: str) -> dict:
+    frontmatter, body, offset = split_frontmatter(text)
+    findings: list[dict] = []
+    findings += find_frontmatter_placeholders(frontmatter)
+    findings += find_placeholders(body, offset)
+    findings += find_ad_issues(body, offset)
+    findings += find_unpinned_stack(body, offset)
+    counts: dict[str, int] = {}
+    for f in findings:
+        counts[f["severity"]] = counts.get(f["severity"], 0) + 1
+    return {
+        "ok": len(findings) == 0,
+        "spine": SPINE,
+        "total_findings": len(findings),
+        "by_severity": counts,
+        "findings": findings,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Lint an architecture spine for mechanical integrity.")
+    ap.add_argument("--workspace", required=True, help="run folder containing ARCHITECTURE-SPINE.md")
+    ap.add_argument("-o", "--output", help="write JSON here instead of stdout")
+    args = ap.parse_args(argv)
+
+    spine_path = Path(args.workspace) / SPINE
+    if not spine_path.exists():
+        result = {"ok": False, "error": f"{spine_path} not found", "findings": [], "total_findings": 0}
+    else:
+        try:
+            text = spine_path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as e:
+            # honor the "exit code is always 0" contract: a read/decode failure travels in JSON
+            result = {"ok": False, "error": f"could not read {spine_path}: {e}", "findings": [], "total_findings": 0}
+        else:
+            result = lint(text)
+
+    out = json.dumps(result, indent=2)
+    if args.output:
+        Path(args.output).write_text(out + "\n", encoding="utf-8")
+    else:
+        print(out)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/bmm-skills/3-solutioning/bmad-architecture/scripts/tests/test_lint_spine.py

@@ -0,0 +1,270 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pytest>=8.0"]
+# ///
+"""Tests for lint_spine.py. Run: uv run --with pytest pytest scripts/tests/test_lint_spine.py
+
+The spine under test: a clean spine lints empty; the linter catches exactly the
+mechanical defects a prompt is unreliable at — literal placeholders, AD-n id breakage,
+AD-n blocks missing required fields, and unpinned Stack versions.
+"""
+import importlib.util
+import json
+import re
+import sys
+from pathlib import Path
+
+import pytest
+
+_SPEC = importlib.util.spec_from_file_location(
+    "lint_spine", Path(__file__).resolve().parent.parent / "lint_spine.py"
+)
+lint_spine = importlib.util.module_from_spec(_SPEC)
+sys.modules["lint_spine"] = lint_spine
+_SPEC.loader.exec_module(lint_spine)
+
+
+CLEAN = """---
+name: 'Demo'
+---
+
+## Invariants & Rules
+
+### AD-1 — single write path
+
+- **Binds:** all
+- **Prevents:** divergent mutation
+- **Rule:** state changes only through the command bus
+
+### AD-2 — layered deps `[ADOPTED]`
+
+- **Binds:** all
+- **Prevents:** import cycles
+- **Rule:** ui -> app -> domain, never backward
+
+```mermaid
+flowchart LR
+  A --> B{decision}
+```
+
+## Stack
+
+| Name | Version |
+| --- | --- |
+| fastapi | 0.115 |
+| pydantic | 2.9 |
+"""
+
+
+def cats(result):
+    return sorted(f["category"] for f in result["findings"])
+
+
+def test_clean_spine_passes():
+    result = lint_spine.lint(CLEAN)
+    assert result["ok"] is True
+    assert result["total_findings"] == 0
+
+
+def test_mermaid_braces_not_flagged():
+    # the {decision} node lives in a fenced block and must not read as a template token
+    result = lint_spine.lint(CLEAN)
+    assert "placeholder" not in cats(result)
+
+
+def test_placeholder_markers_caught():
+    text = CLEAN.replace("the command bus", "TBD")
+    result = lint_spine.lint(text)
+    assert "placeholder" in cats(result)
+
+
+def test_similar_to_caught():
+    text = CLEAN.replace("import cycles", "similar to AD-1")
+    result = lint_spine.lint(text)
+    assert any("cross-reference" in f["detail"] for f in result["findings"])
+
+
+def test_unfilled_template_token_caught():
+    text = CLEAN.replace("single write path", "{decision}")
+    result = lint_spine.lint(text)
+    assert any(f["category"] == "placeholder" for f in result["findings"])
+
+
+def test_duplicate_ad_id_caught():
+    text = CLEAN.replace("### AD-2 — layered deps `[ADOPTED]`", "### AD-1 — layered deps")
+    result = lint_spine.lint(text)
+    assert "ad_id" in cats(result)
+
+
+def test_non_monotonic_ad_id_caught():
+    text = CLEAN.replace("### AD-2 — layered deps `[ADOPTED]`", "### AD-5 — layered deps").replace(
+        "### AD-1 — single write path", "### AD-9 — single write path"
+    )
+    result = lint_spine.lint(text)
+    assert any("non-monotonic" in f["detail"] for f in result["findings"])
+
+
+def test_missing_field_caught():
+    text = CLEAN.replace("- **Rule:** state changes only through the command bus\n", "")
+    result = lint_spine.lint(text)
+    assert any(f["category"] == "ad_fields" and "rule" in f["detail"] for f in result["findings"])
+
+
+def test_unpinned_dep_caught():
+    text = CLEAN.replace("| fastapi | 0.115 |", "| fastapi |  |")
+    result = lint_spine.lint(text)
+    assert "version_pin" in cats(result)
+
+
+def test_placeholder_version_caught():
+    text = CLEAN.replace("| fastapi | 0.115 |", "| fastapi | {pin} |")
+    result = lint_spine.lint(text)
+    assert any(f["category"] == "version_pin" and "fastapi" in f["detail"] for f in result["findings"])
+
+
+def test_no_stack_section_ok():
+    text = CLEAN.split("## Stack")[0]
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_stack_skeleton_row_not_version_pinned():
+    # a leftover {token} name is the placeholder pass's job, not a double-reported version_pin
+    text = CLEAN.replace("| fastapi | 0.115 |", "| {language / framework} | {pinned version} |")
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_stack_html_comment_not_parsed_as_row():
+    text = CLEAN.replace("## Stack\n", "## Stack\n\n<!-- SEED — verified current 2026-06 -->\n")
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_template_token_is_low_severity():
+    # a bare {token} can be legitimate brace prose; it is flagged, but low (not high) so the
+    # mechanical pass stays near-zero false-positive
+    text = CLEAN.replace("single write path", "{decision}")
+    result = lint_spine.lint(text)
+    toks = [f for f in result["findings"] if f["category"] == "placeholder" and "template token" in f["detail"]]
+    assert toks and all(f["severity"] == "low" for f in toks)
+
+
+def test_no_frontmatter_body_still_scanned():
+    text = "## Invariants\n\n### AD-1 — x\n\n- **Binds:** all\n- **Prevents:** drift\n- **Rule:** TBD\n"
+    result = lint_spine.lint(text)
+    assert "placeholder" in cats(result)  # TBD caught even with no frontmatter
+
+
+def test_frontmatter_value_with_dashes_not_truncated():
+    # a value containing '---' must not be read as the closing fence (line-exact close)
+    text = ("---\nname: 'x'\nscope: 'phase 1 --- phase 2'\n---\n\n"
+            "## Stack\n\n| Name | Version |\n| --- | --- |\n| fastapi |  |\n")
+    result = lint_spine.lint(text)
+    assert any(f["category"] == "version_pin" for f in result["findings"])  # read past the inline ---
+
+
+def test_ad_heading_in_fence_not_counted():
+    text = (
+        "---\nname: 'x'\n---\n\n"
+        "### AD-1 — real\n\n- **Binds:** all\n- **Prevents:** drift\n- **Rule:** do x\n\n"
+        "## Docs\n\n```text\n### AD-2 — illustrative only, no fields\n```\n"
+    )
+    result = lint_spine.lint(text)
+    assert result["ok"] is True  # the fenced AD-2 is not a live AD → no ad_fields/ad_id finding
+
+
+def test_stack_table_flags_only_the_unpinned_row():
+    text = ("---\nname: 'x'\n---\n\n## Stack\n\n| Name | Version |\n| --- | --- |\n"
+            "| fastapi | 0.115 |\n| redis |  |\n")
+    result = lint_spine.lint(text)
+    pins = [f for f in result["findings"] if f["category"] == "version_pin"]
+    assert len(pins) == 1 and "redis" in pins[0]["detail"]
+
+
+def test_stack_table_all_pinned_ok():
+    text = ("---\nname: 'x'\n---\n\n## Stack\n\n| Name | Version |\n| --- | --- |\n"
+            "| fastapi | 0.115 |\n")
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_fenced_stack_rows_not_parsed():
+    # an illustrative fenced table under ## Stack must not be read as live rows (fences are
+    # blanked first, like every other pass) — a blank-version row inside a fence is not a finding
+    text = ("---\nname: 'x'\n---\n\n## Stack\n\n| Name | Version |\n| --- | --- |\n"
+            "| fastapi | 0.115 |\n\n```text\n| example |  |\n```\n")
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_fenced_stack_heading_not_live():
+    # a `## Stack` heading shown inside a code fence is not the live Stack section
+    text = ("---\nname: 'x'\n---\n\n## Docs\n\n```md\n## Stack\n\n| foo |  |\n```\n")
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_renamed_stack_heading_still_scanned():
+    # the heading match is word-boundary, so a varied `## Stack` heading still counts
+    text = ("---\nname: 'x'\n---\n\n## Stack & Versions\n\n| Name | Version |\n| --- | --- |\n"
+            "| redis |  |\n")
+    result = lint_spine.lint(text)
+    pins = [f for f in result["findings"] if f["category"] == "version_pin"]
+    assert len(pins) == 1 and "redis" in pins[0]["detail"]
+
+
+def test_reordered_columns_pair_name_to_version():
+    # Version-then-Name header: the unpinned row must still be flagged by its real name
+    text = ("---\nname: 'x'\n---\n\n## Stack\n\n| Version | Name |\n| --- | --- |\n"
+            "| 0.115 | fastapi |\n|  | redis |\n")
+    result = lint_spine.lint(text)
+    pins = [f for f in result["findings"] if f["category"] == "version_pin"]
+    assert len(pins) == 1 and "redis" in pins[0]["detail"]
+
+
+def test_placeholder_line_number_is_absolute():
+    # a TBD after a multi-line fence reports its real file line (fence blanked, not collapsed)
+    text = (
+        "---\nname: 'x'\n---\n\n"
+        "## A\n\n"
+        "```text\nf1\nf2\nf3\n```\n\n"
+        "TBD here\n"
+    )
+    result = lint_spine.lint(text)
+    ph = next(f for f in result["findings"] if "TBD" in f["detail"])
+    n = int(re.search(r"line (\d+)", ph["location"]).group(1))
+    assert n == 13
+
+
+def test_missing_spine_file_reports_error(tmp_path, capsys):
+    rc = lint_spine.main(["--workspace", str(tmp_path)])
+    out = json.loads(capsys.readouterr().out)
+    assert rc == 0 and out["ok"] is False and "not found" in out["error"]
+
+
+def test_frontmatter_unfilled_token_caught():
+    # an unfilled {scope}/{paradigm}/{date} in frontmatter is part of the contract and must lint
+    text = "---\nname: 'x'\nscope: '{what this spine governs}'\n---\n\n## Invariants\n"
+    result = lint_spine.lint(text)
+    fm = [f for f in result["findings"] if f["category"] == "placeholder" and "frontmatter" in f["detail"]]
+    assert fm and any("template token" in f["detail"] for f in fm)
+
+
+def test_frontmatter_tbd_caught():
+    text = "---\nname: 'x'\nstatus: TBD\n---\n\n## Invariants\n"
+    result = lint_spine.lint(text)
+    assert any(f["category"] == "placeholder" and "frontmatter" in f["detail"] and "TBD" in f["detail"]
+               for f in result["findings"])
+
+
+def test_unreadable_spine_returns_error_not_crash(tmp_path, capsys):
+    # a spine that exists but can't be UTF-8 decoded must yield error JSON + exit 0, not a traceback
+    (tmp_path / lint_spine.SPINE).write_bytes(b"\xff\xfe bad bytes not utf-8")
+    rc = lint_spine.main(["--workspace", str(tmp_path)])
+    out = json.loads(capsys.readouterr().out)
+    assert rc == 0 and out["ok"] is False and "could not read" in out["error"]
+
+
+if __name__ == "__main__":
+    sys.exit(pytest.main([__file__, "-q"]))

src/bmm-skills/3-solutioning/bmad-create-architecture/SKILL.md

@@ -1,74 +1,30 @@
 ---
 name: bmad-create-architecture
-description: 'Create architecture solution design decisions for AI agent consistency. Use when the user says "lets create architecture" or "create technical architecture" or "create a solution design"'
+description: 'DEPRECATED — consolidated into bmad-architecture create intent - this skill will be removed in v7 in favor of `bmad-architecture`.'
 ---
 
-# Architecture Workflow
+# DEPRECATED — forwards to bmad-architecture (create intent)
 
-**Goal:** Create comprehensive architecture decisions through collaborative step-by-step discovery that ensures AI agents implement consistently.
+This skill was consolidated into `bmad-architecture`. It is retained as a thin compatibility shim so existing invocations by name and `_bmad/custom/bmad-create-architecture.toml` override files keep working. New work should invoke `bmad-architecture` directly — it detects create / update / validate intent from the conversation.
-
-**Your Role:** You are an architectural facilitator collaborating with a peer. This is a partnership, not a client-vendor relationship. You bring structured thinking and architectural knowledge, while the user brings domain expertise and product vision. Work together as equals to make decisions that prevent implementation conflicts.
-
-## Conventions
-
-- Bare paths (e.g. `steps/step-01-init.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.
-
-## 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
-- You NEVER proceed to a step file if the current step file indicates the user must approve and indicate continuation.
 
 ## On Activation
 
-### Step 1: Resolve the Workflow Block
+1. Resolve customization: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-create-architecture.toml` and `bmad-create-architecture.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`).
 
-Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`
+2. Load `{project-root}/_bmad/bmm/config.yaml` (and `config.user.yaml` if present) to resolve `{user_name}` and `{communication_language}`.
 
-**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:
+3. Emit a deprecation notice to the user in `{communication_language}`:
 
-1. `{skill-root}/customize.toml` — defaults
+   > Notice: `bmad-create-architecture` is deprecated and will be removed in a future release. It now forwards to `bmad-architecture` with create intent. To silence this notice and access the full new customization surface (`spine_template`, `spine_output_path`, `run_folder_pattern`, `doc_standards`, `external_sources`, `external_handoffs`, `finalize_reviewers`), migrate `_bmad/custom/bmad-create-architecture.toml` to `_bmad/custom/bmad-architecture.toml` and invoke `bmad-architecture` directly next time. Customization fields that were in this version still remain in the new version and will be respected if present in `_bmad/custom/bmad-architecture.toml`, but the new version also supports additional fields that you can take advantage of by migrating.
-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.
+4. Invoke `bmad-architecture` with the following context. Pass these as the activating context so `bmad-architecture` honors them instead of resolving its own customization from scratch:
 
-### Step 2: Execute Prepend Steps
+   - **Intent:** `create` — skip `bmad-architecture`'s usual intent detection step.
+   - **Pre-resolved legacy customization** — use these in place of resolving from `bmad-architecture`'s own `customize.toml` for the four legacy fields. For everything else (`spine_template`, `spine_output_path`, `run_folder_pattern`, `doc_standards`, `external_sources`, `external_handoffs`, `finalize_reviewers`), use `bmad-architecture`'s own defaults and overrides as normal:
+     - `activation_steps_prepend` = the resolved value from step 1
+     - `activation_steps_append` = the resolved value from step 1
+     - `persistent_facts` = the resolved value from step 1
+     - `on_complete` = the resolved value from step 1
+   - **Original user input:** forward whatever the user said when invoking this skill verbatim.
 
-Execute each entry in `{workflow.activation_steps_prepend}` in order before proceeding.
+   `bmad-architecture` takes the workflow from here. Do not execute any further steps in this shim.
-
-### 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. All other entries are facts verbatim.
-
-### Step 4: Load Config
-
-Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
-- Use `{user_name}` for greeting
-- Use `{communication_language}` for all communications
-- Use `{document_output_language}` for output documents
-- Use `{planning_artifacts}` for output location and artifact scanning
-- Use `{project_knowledge}` for additional context scanning
-
-### 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. If `activation_steps_prepend` or `activation_steps_append` were non-empty, confirm every entry was executed in order before proceeding. Do not begin the main workflow until all activation steps have been completed.
-
-## Execution
-
-Read fully and follow: `./steps/step-01-init.md` to begin the workflow.
-
-**Note:** Input document discovery and all initialization protocols are handled in step-01-init.md.

src/bmm-skills/3-solutioning/bmad-create-architecture/architecture-decision-template.md

@@ -1,12 +0,0 @@
----
-stepsCompleted: []
-inputDocuments: []
-workflowType: 'architecture'
-project_name: '{{project_name}}'
-user_name: '{{user_name}}'
-date: '{{date}}'
----
-
-# Architecture Decision Document
-
-_This document builds collaboratively through step-by-step discovery. Sections are appended as we work through each architectural decision together._

src/bmm-skills/3-solutioning/bmad-create-architecture/data/domain-complexity.csv

@@ -1,13 +0,0 @@
-domain,signals,complexity_level,suggested_workflow,web_searches
-e_commerce,"shopping,cart,checkout,payment,products,store",medium,standard,"ecommerce architecture patterns, payment processing, inventory management"
-fintech,"banking,payment,trading,finance,money,investment",high,enhanced,"financial security, PCI compliance, trading algorithms, fraud detection"
-healthcare,"medical,diagnostic,clinical,patient,hospital,health",high,enhanced,"HIPAA compliance, medical data security, FDA regulations, health tech"
-social,"social network,community,users,friends,posts,sharing",high,advanced,"social graph algorithms, feed ranking, notification systems, privacy"
-education,"learning,course,student,teacher,training,academic",medium,standard,"LMS architecture, progress tracking, assessment systems, video streaming"
-productivity,"productivity,workflow,tasks,management,business,tools",medium,standard,"collaboration patterns, real-time editing, notification systems, integration"
-media,"content,media,video,audio,streaming,broadcast",high,advanced,"CDN architecture, video encoding, streaming protocols, content delivery"
-iot,"IoT,sensors,devices,embedded,smart,connected",high,advanced,"device communication, real-time data processing, edge computing, security"
-government,"government,civic,public,admin,policy,regulation",high,enhanced,"accessibility standards, security clearance, data privacy, audit trails"
-process_control,"industrial automation,process control,PLC,SCADA,DCS,HMI,operational technology,control system,cyberphysical,MES,instrumentation,I&C,P&ID",high,advanced,"industrial process control architecture, SCADA system design, OT cybersecurity architecture, real-time control systems"
-building_automation,"building automation,BAS,BMS,HVAC,smart building,fire alarm,fire protection,fire suppression,life safety,elevator,DDC,access control,sequence of operations,commissioning",high,advanced,"building automation architecture, BACnet integration patterns, smart building design, building management system security"
-gaming,"game,gaming,multiplayer,real-time,interactive,entertainment",high,advanced,"real-time multiplayer, game engine architecture, matchmaking, leaderboards"

src/bmm-skills/3-solutioning/bmad-create-architecture/data/project-types.csv

@@ -1,7 +0,0 @@
-project_type,detection_signals,description,typical_starters
-web_app,"website,web application,browser,frontend,UI,interface",Web-based applications running in browsers,Next.js, Vite, Remix
-mobile_app,"mobile,iOS,Android,app,smartphone,tablet",Native mobile applications,React Native, Expo, Flutter
-api_backend,"API,REST,GraphQL,backend,service,microservice",Backend services and APIs,NestJS, Express, Fastify
-full_stack,"full-stack,complete,web+mobile,frontend+backend",Applications with both frontend and backend,T3 App, RedwoodJS, Blitz
-cli_tool,"CLI,command line,terminal,console,tool",Command-line interface tools,oclif, Commander, Caporal
-desktop_app,"desktop,Electron,Tauri,native app,macOS,Windows",Desktop applications,Electron, Tauri, Flutter Desktop

src/bmm-skills/3-solutioning/bmad-create-architecture/steps/step-01-init.md

@@ -1,153 +0,0 @@
-# Step 1: Architecture Workflow Initialization
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
-- ✅ ALWAYS treat this as collaborative discovery between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on initialization and setup only - don't look ahead to future steps
-- 🚪 DETECT existing workflow state and handle continuation properly
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{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
-- Input document discovery happens in this step
-
-## YOUR TASK:
-
-Initialize the Architecture workflow by detecting continuation state, discovering input documents, and setting up the document for collaborative architectural decision making.
-
-## INITIALIZATION SEQUENCE:
-
-### 1. Check for Existing Workflow
-
-First, check if the output document already exists:
-
-- Look for existing {planning_artifacts}/`*architecture*.md`
-- If exists, read the complete file(s) including frontmatter
-- If not exists, this is a fresh workflow
-
-### 2. Handle Continuation (If Document Exists)
-
-If the document exists and has frontmatter with `stepsCompleted`:
-
-- **STOP here** and load `./step-01b-continue.md` immediately
-- Do not proceed with any initialization tasks
-- Let step-01b handle the continuation logic
-
-### 3. Fresh Workflow Setup (If No Document)
-
-If no document exists or no `stepsCompleted` in frontmatter:
-
-#### A. Input Document Discovery
-
-Discover and load context documents using smart discovery. Documents can be in the following locations:
-- {planning_artifacts}/**
-- {output_folder}/**
-- {project_knowledge}/**
-- {project-root}/docs/**
-
-Also - when searching - documents can be a single markdown file, or a folder with an index and multiple files. For Example, if searching for `*foo*.md` and not found, also search for a folder called *foo*/index.md (which indicates sharded content)
-
-Try to discover the following:
-- Product Brief (`*brief*.md`)
-- Product Requirements Document (`*prd*.md`)
-- UX Design (`*ux-design*.md`) and other
-- Research Documents (`*research*.md`)
-- Project Documentation (generally multiple documents might be found for this in the `{project_knowledge}` or `{project-root}/docs` folder.)
-- Project Context (`**/project-context.md`)
-
-<critical>Confirm what you have found with the user, along with asking if the user wants to provide anything else. Only after this confirmation will you proceed to follow the loading rules</critical>
-
-**Loading Rules:**
-
-- Load ALL discovered files completely that the user confirmed or provided (no offset/limit)
-- If there is a project context, whatever is relevant should try to be biased in the remainder of this whole workflow process
-- For sharded folders, load ALL files to get complete picture, using the index first to potentially know the potential of each document
-- index.md is a guide to what's relevant whenever available
-- Track all successfully loaded files in frontmatter `inputDocuments` array
-
-#### B. Validate Required Inputs
-
-Before proceeding, verify we have the essential inputs:
-
-**PRD Validation:**
-
-- If no PRD found: "Architecture requires a PRD to work from. Please run the PRD workflow first or provide the PRD file path."
-- Do NOT proceed without PRD
-
-**Other Input that might exist:**
-
-- UX Spec: "Provides UI/UX architectural requirements"
-
-#### C. Create Initial Document
-
-Copy the template from `../architecture-decision-template.md` to `{planning_artifacts}/architecture.md`
-
-#### D. Complete Initialization and Report
-
-Complete setup and report to user:
-
-**Document Setup:**
-
-- Created: `{planning_artifacts}/architecture.md` from template
-- Initialized frontmatter with workflow state
-
-**Input Documents Discovered:**
-Report what was found:
-"Welcome {{user_name}}! I've set up your Architecture workspace for {{project_name}}.
-
-**Documents Found:**
-
-- PRD: {number of PRD files loaded or "None found - REQUIRED"}
-- UX Design: {number of UX files loaded or "None found"}
-- Research: {number of research files loaded or "None found"}
-- Project docs: {number of project files loaded or "None found"}
-- Project context: {project_context_rules count of rules for AI agents found}
-
-**Files loaded:** {list of specific file names or "No additional documents found"}
-
-Ready to begin architectural decision making. Do you have any other documents you'd like me to include?
-
-[C] Continue to project context analysis
-
-## SUCCESS METRICS:
-
-✅ Existing workflow detected and handed off to step-01b correctly
-✅ Fresh workflow initialized with template and frontmatter
-✅ Input documents discovered and loaded using sharded-first logic
-✅ All discovered files tracked in frontmatter `inputDocuments`
-✅ PRD requirement validated and communicated
-✅ User confirmed document setup and can proceed
-
-## FAILURE MODES:
-
-❌ Proceeding with fresh initialization when existing workflow exists
-❌ Not updating frontmatter with discovered input documents
-❌ Creating document without proper template
-❌ Not checking sharded folders first before whole files
-❌ Not reporting what documents were found to user
-❌ Proceeding without validating PRD requirement
-
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-
-## NEXT STEP:
-
-After user selects [C] to continue, only after ensuring all the template output has been created, then load `./step-02-context.md` to analyze the project context and begin architectural decision making.
-
-Remember: Do NOT proceed to step-02 until user explicitly selects [C] from the menu and setup is confirmed!

src/bmm-skills/3-solutioning/bmad-create-architecture/steps/step-01b-continue.md

@@ -1,173 +0,0 @@
-# Step 1b: Workflow Continuation Handler
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER generate content without user input
-
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
-- ✅ ALWAYS treat this as collaborative discovery between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on understanding current state and getting user confirmation
-- 🚪 HANDLE workflow resumption smoothly and transparently
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- 📖 Read existing document completely to understand current state
-- 💾 Update frontmatter to reflect continuation
-- 🚫 FORBIDDEN to proceed to next step without user confirmation
-
-## CONTEXT BOUNDARIES:
-
-- Existing document and frontmatter are available
-- Input documents already loaded should be in frontmatter `inputDocuments`
-- Steps already completed are in `stepsCompleted` array
-- Focus on understanding where we left off
-
-## YOUR TASK:
-
-Handle workflow continuation by analyzing existing work and guiding the user to resume at the appropriate step.
-
-## CONTINUATION SEQUENCE:
-
-### 1. Analyze Current Document State
-
-Read the existing architecture document completely and analyze:
-
-**Frontmatter Analysis:**
-
-- `stepsCompleted`: What steps have been done
-- `inputDocuments`: What documents were loaded
-- `lastStep`: Last step that was executed
-- `project_name`, `user_name`, `date`: Basic context
-
-**Content Analysis:**
-
-- What sections exist in the document
-- What architectural decisions have been made
-- What appears incomplete or in progress
-- Any TODOs or placeholders remaining
-
-### 2. Present Continuation Summary
-
-Show the user their current progress:
-
-"Welcome back {{user_name}}! I found your Architecture work for {{project_name}}.
-
-**Current Progress:**
-
-- Steps completed: {{stepsCompleted list}}
-- Last step worked on: Step {{lastStep}}
-- Input documents loaded: {{number of inputDocuments}} files
-
-**Document Sections Found:**
-{list all H2/H3 sections found in the document}
-
-{if_incomplete_sections}
-**Incomplete Areas:**
-
-- {areas that appear incomplete or have placeholders}
-  {/if_incomplete_sections}
-
-**What would you like to do?**
-[R] Resume from where we left off
-[C] Continue to next logical step
-[O] Overview of all remaining steps
-[X] Start over (will overwrite existing work)
-"
-
-### 3. Handle User Choice
-
-#### If 'R' (Resume from where we left off):
-
-- Identify the next step based on `stepsCompleted`
-- Load the appropriate step file to continue
-- Example: If `stepsCompleted: [1, 2, 3]`, load `./step-04-decisions.md`
-
-#### If 'C' (Continue to next logical step):
-
-- Analyze the document content to determine logical next step
-- May need to review content quality and completeness
-- If content seems complete for current step, advance to next
-- If content seems incomplete, suggest staying on current step
-
-#### If 'O' (Overview of all remaining steps):
-
-- Provide brief description of all remaining steps
-- Let user choose which step to work on
-- Don't assume sequential progression is always best
-
-#### If 'X' (Start over):
-
-- Confirm: "This will delete all existing architectural decisions. Are you sure? (y/n)"
-- If confirmed: Delete existing document and read fully and follow: `./step-01-init.md`
-- If not confirmed: Return to continuation menu
-
-### 4. Navigate to Selected Step
-
-After user makes choice:
-
-**Load the selected step file:**
-
-- Update frontmatter `lastStep` to reflect current navigation
-- Execute the selected step file
-- Let that step handle the detailed continuation logic
-
-**State Preservation:**
-
-- Maintain all existing content in the document
-- Keep `stepsCompleted` accurate
-- Track the resumption in workflow status
-
-### 5. Special Continuation Cases
-
-#### If `stepsCompleted` is empty but document has content:
-
-- This suggests an interrupted workflow
-- Ask user: "I see the document has content but no steps are marked as complete. Should I analyze what's here and set the appropriate step status?"
-
-#### If document appears corrupted or incomplete:
-
-- Ask user: "The document seems incomplete. Would you like me to try to recover what's here, or would you prefer to start fresh?"
-
-#### If document is complete but workflow not marked as done:
-
-- Ask user: "The architecture looks complete! Should I mark this workflow as finished, or is there more you'd like to work on?"
-
-## SUCCESS METRICS:
-
-✅ Existing document state properly analyzed and understood
-✅ User presented with clear continuation options
-✅ User choice handled appropriately and transparently
-✅ Workflow state preserved and updated correctly
-✅ Navigation to appropriate step handled smoothly
-
-## FAILURE MODES:
-
-❌ Not reading the complete existing document before making suggestions
-❌ Losing track of what steps were actually completed
-❌ Automatically proceeding without user confirmation of next steps
-❌ Not checking for incomplete or placeholder content
-❌ Losing existing document content during resumption
-
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-
-## NEXT STEP:
-
-After user selects their continuation option, load the appropriate step file based on their choice. The step file will handle the detailed work from that point forward.
-
-Valid step files to load:
-- `./step-02-context.md`
-- `./step-03-starter.md`
-- `./step-04-decisions.md`
-- `./step-05-patterns.md`
-- `./step-06-structure.md`
-- `./step-07-validation.md`
-- `./step-08-complete.md`
-
-Remember: The goal is smooth, transparent resumption that respects the work already done while giving the user control over how to proceed.

src/bmm-skills/3-solutioning/bmad-create-architecture/steps/step-02-context.md

@@ -1,224 +0,0 @@
-# Step 2: Project Context Analysis
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER generate content without user input
-
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
-- ✅ ALWAYS treat this as collaborative discovery between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on understanding project scope and requirements for architecture
-- 🎯 ANALYZE loaded documents, don't assume or generate requirements
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- ⚠️ Present A/P/C menu after generating project context analysis
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update frontmatter `stepsCompleted: [1, 2]` before loading next step
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## COLLABORATION MENUS (A/P/C):
-
-This step will generate content and present choices:
-
-- **A (Advanced Elicitation)**: Use discovery protocols to develop deeper insights about project context and architectural implications
-- **P (Party Mode)**: Bring multiple perspectives to analyze project requirements from different architectural angles
-- **C (Continue)**: Save the content to the document and proceed to next step
-
-## PROTOCOL INTEGRATION:
-
-- When 'A' selected: Invoke the `bmad-advanced-elicitation` skill
-- When 'P' selected: Invoke the `bmad-party-mode` skill
-- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
-- User accepts/rejects protocol changes before proceeding
-
-## CONTEXT BOUNDARIES:
-
-- Current document and frontmatter from step 1 are available
-- Input documents already loaded are in memory (PRD, epics, UX spec, etc.)
-- Focus on architectural implications of requirements
-- No technology decisions yet - pure analysis phase
-
-## YOUR TASK:
-
-Fully read and Analyze the loaded project documents to understand architectural scope, requirements, and constraints before beginning decision making.
-
-## CONTEXT ANALYSIS SEQUENCE:
-
-### 1. Review Project Requirements
-
-**From PRD Analysis:**
-
-- Extract and analyze Functional Requirements (FRs)
-- Identify Non-Functional Requirements (NFRs) like performance, security, compliance
-- Note any technical constraints or dependencies mentioned
-- Count and categorize requirements to understand project scale
-
-**From Epics/Stories (if available):**
-
-- Map epic structure and user stories to architectural components
-- Extract acceptance criteria for technical implications
-- Identify cross-cutting concerns that span multiple epics
-- Estimate story complexity for architectural planning
-
-**From UX Design (if available):**
-
-- Extract architectural implications from UX requirements:
-  - Component complexity (simple forms vs rich interactions)
-  - Animation/transition requirements
-  - Real-time update needs (live data, collaborative features)
-  - Platform-specific UI requirements
-  - Accessibility standards (WCAG compliance level)
-  - Responsive design breakpoints
-  - Offline capability requirements
-  - Performance expectations (load times, interaction responsiveness)
-
-### 2. Project Scale Assessment
-
-Calculate and present project complexity:
-
-**Complexity Indicators:**
-
-- Real-time features requirements
-- Multi-tenancy needs
-- Regulatory compliance requirements
-- Integration complexity
-- User interaction complexity
-- Data complexity and volume
-
-### 3. Reflect Understanding
-
-Present your analysis back to user for validation:
-
-"I'm reviewing your project documentation for {{project_name}}.
-
-{if_epics_loaded}I see {{epic_count}} epics with {{story_count}} total stories.{/if_epics_loaded}
-{if_no_epics}I found {{fr_count}} functional requirements organized into {{fr_category_list}}.{/if_no_epics}
-{if_ux_loaded}I also found your UX specification which defines the user experience requirements.{/if_ux_loaded}
-
-**Key architectural aspects I notice:**
-
-- [Summarize core functionality from FRs]
-- [Note critical NFRs that will shape architecture]
-- {if_ux_loaded}[Note UX complexity and technical requirements]{/if_ux_loaded}
-- [Identify unique technical challenges or constraints]
-- [Highlight any regulatory or compliance requirements]
-
-**Scale indicators:**
-
-- Project complexity appears to be: [low/medium/high/enterprise]
-- Primary technical domain: [web/mobile/api/backend/full-stack/etc]
-- Cross-cutting concerns identified: [list major ones]
-
-This analysis will help me guide you through the architectural decisions needed to ensure AI agents implement this consistently.
-
-Does this match your understanding of the project scope and requirements?"
-
-### 4. Generate Project Context Content
-
-Prepare the content to append to the document:
-
-#### Content Structure:
-
-```markdown
-## Project Context Analysis
-
-### Requirements Overview
-
-**Functional Requirements:**
-{{analysis of FRs and what they mean architecturally}}
-
-**Non-Functional Requirements:**
-{{NFRs that will drive architectural decisions}}
-
-**Scale & Complexity:**
-{{project_scale_assessment}}
-
-- Primary domain: {{technical_domain}}
-- Complexity level: {{complexity_level}}
-- Estimated architectural components: {{component_count}}
-
-### Technical Constraints & Dependencies
-
-{{known_constraints_dependencies}}
-
-### Cross-Cutting Concerns Identified
-
-{{concerns_that_will_affect_multiple_components}}
-```
-
-### 5. Present Content and Menu
-
-Show the generated content and present choices:
-
-"I've drafted the Project Context Analysis based on your requirements. This sets the foundation for our architectural decisions.
-
-**Here's what I'll add to the document:**
-
-[Show the complete markdown content from step 4]
-
-**What would you like to do?**
-[A] Advanced Elicitation - Let's dive deeper into architectural implications
-[P] Party Mode - Bring different perspectives to analyze requirements
-[C] Continue - Save this analysis and begin architectural decisions"
-
-### 6. Handle Menu Selection
-
-#### If 'A' (Advanced Elicitation):
-
-- Invoke the `bmad-advanced-elicitation` skill with the current context analysis
-- Process the enhanced architectural insights that come back
-- Ask user: "Accept these enhancements to the project context analysis? (y/n)"
-- If yes: Update content with improvements, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'P' (Party Mode):
-
-- Invoke the `bmad-party-mode` skill with the current project context
-- Process the collaborative improvements to architectural understanding
-- Ask user: "Accept these changes to the project context analysis? (y/n)"
-- If yes: Update content with improvements, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'C' (Continue):
-
-- Append the final content to `{planning_artifacts}/architecture.md`
-- Update frontmatter: `stepsCompleted: [1, 2]`
-- Load `./step-03-starter.md`
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 4.
-
-## SUCCESS METRICS:
-
-✅ All input documents thoroughly analyzed for architectural implications
-✅ Project scope and complexity clearly assessed and validated
-✅ Technical constraints and dependencies identified
-✅ Cross-cutting concerns mapped for architectural planning
-✅ User confirmation of project understanding
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Skimming documents without deep architectural analysis
-❌ Missing or misinterpreting critical NFRs
-❌ Not validating project understanding with user
-❌ Underestimating complexity indicators
-❌ Generating content without real analysis of loaded documents
-❌ Not presenting A/P/C menu after content generation
-
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document, load `./step-03-starter.md` to evaluate starter template options.
-
-Remember: Do NOT proceed to step-03 until user explicitly selects 'C' from the A/P/C menu and content is saved!

src/bmm-skills/3-solutioning/bmad-create-architecture/steps/step-03-starter.md

@@ -1,329 +0,0 @@
-# Step 3: Starter Template Evaluation
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER generate content without user input
-- ✅ ALWAYS treat this as collaborative discovery between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on evaluating starter template options with current versions
-- 🌐 ALWAYS search the web to verify current versions - NEVER trust hardcoded versions
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete architecture
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- 🌐 Search the web to verify current versions and options
-- ⚠️ Present A/P/C menu after generating starter template analysis
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## COLLABORATION MENUS (A/P/C):
-
-This step will generate content and present choices:
-
-- **A (Advanced Elicitation)**: Use discovery protocols to explore unconventional starter options or custom approaches
-- **P (Party Mode)**: Bring multiple perspectives to evaluate starter trade-offs for different use cases
-- **C (Continue)**: Save the content to the document and proceed to next step
-
-## PROTOCOL INTEGRATION:
-
-- When 'A' selected: Invoke the `bmad-advanced-elicitation` skill
-- When 'P' selected: Invoke the `bmad-party-mode` skill
-- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
-- User accepts/rejects protocol changes before proceeding
-
-## CONTEXT BOUNDARIES:
-
-- Project context from step 2 is available and complete
-- Project context file from step-01 may contain technical preferences
-- No architectural decisions made yet - evaluating foundations
-- Focus on technical preferences discovery and starter evaluation
-- Consider project requirements and existing preferences when evaluating options
-
-## YOUR TASK:
-
-Discover technical preferences and evaluate starter template options, leveraging existing technical preferences and establishing solid architectural foundations.
-
-## STARTER EVALUATION SEQUENCE:
-
-### 0. Check Technical Preferences & Context
-
-**Check Project Context for Existing Technical Preferences:**
-"Before we dive into starter templates, let me check if you have any technical preferences already documented.
-
-{{if_project_context_exists}}
-I found some technical rules in your project context file:
-{{extracted_technical_preferences_from_project_context}}
-
-**Project Context Technical Rules Found:**
-
-- Languages/Frameworks: {{languages_frameworks_from_context}}
-- Tools & Libraries: {{tools_from_context}}
-- Development Patterns: {{patterns_from_context}}
-- Platform Preferences: {{platforms_from_context}}
-
-{{else}}
-No existing technical preferences found in project context file. We'll establish your technical preferences now.
-{{/if_project_context}}"
-
-**Discover User Technical Preferences:**
-"Based on your project context, let's discuss your technical preferences:
-
-{{primary_technology_category}} Preferences:
-
-- **Languages**: Do you have preferences between TypeScript/JavaScript, Python, Go, Rust, etc.?
-- **Frameworks**: Any existing familiarity or preferences (React, Vue, Angular, Next.js, etc.)?
-- **Databases**: Any preferences or existing infrastructure (PostgreSQL, MongoDB, MySQL, etc.)?
-
-**Development Experience:**
-
-- What's your team's experience level with different technologies?
-- Are there any technologies you want to learn vs. what you're comfortable with?
-
-**Platform/Deployment Preferences:**
-
-- Cloud provider preferences (AWS, Vercel, Railway, etc.)?
-- Container preferences (Docker, Serverless, Traditional)?
-
-**Integrations:**
-
-- Any existing systems or APIs you need to integrate with?
-- Third-party services you plan to use (payment, authentication, analytics, etc.)?
-
-These preferences will help me recommend the most suitable starter templates and guide our architectural decisions."
-
-### 1. Identify Primary Technology Domain
-
-Based on project context analysis and technical preferences, identify the primary technology stack:
-
-- **Web application** → Look for Next.js, Vite, Remix, SvelteKit starters
-- **Mobile app** → Look for React Native, Expo, Flutter starters
-- **API/Backend** → Look for NestJS, Express, Fastify, Supabase starters
-- **CLI tool** → Look for CLI framework starters (oclif, commander, etc.)
-- **Full-stack** → Look for T3, RedwoodJS, Blitz, Next.js starters
-- **Desktop** → Look for Electron, Tauri starters
-
-### 2. UX Requirements Consideration
-
-If UX specification was loaded, consider UX requirements when selecting starter:
-
-- **Rich animations** → Framer Motion compatible starter
-- **Complex forms** → React Hook Form included starter
-- **Real-time features** → Socket.io or WebSocket ready starter
-- **Design system** → Storybook-enabled starter
-- **Offline capability** → Service worker or PWA configured starter
-
-### 3. Research Current Starter Options
-
-Search the web to find current, maintained starter templates:
-
-```
-Search the web: "{{primary_technology}} starter template CLI create command latest"
-Search the web: "{{primary_technology}} boilerplate generator latest options"
-Search the web: "{{primary_technology}} production-ready starter best practices"
-```
-
-### 4. Investigate Top Starter Options
-
-For each promising starter found, investigate details:
-
-```
-Search the web: "{{starter_name}} default setup technologies included latest"
-Search the web: "{{starter_name}} project structure file organization"
-Search the web: "{{starter_name}} production deployment capabilities"
-Search the web: "{{starter_name}} recent updates maintenance status"
-```
-
-### 5. Analyze What Each Starter Provides
-
-For each viable starter option, document:
-
-**Technology Decisions Made:**
-
-- Language/TypeScript configuration
-- Styling solution (CSS, Tailwind, Styled Components, etc.)
-- Testing framework setup
-- Linting/Formatting configuration
-- Build tooling and optimization
-- Project structure and organization
-
-**Architectural Patterns Established:**
-
-- Code organization patterns
-- Component structure conventions
-- API layering approach
-- State management setup
-- Routing patterns
-- Environment configuration
-
-**Development Experience Features:**
-
-- Hot reloading and development server
-- TypeScript configuration
-- Debugging setup
-- Testing infrastructure
-- Documentation generation
-
-### 6. Present Starter Options
-
-Based on user skill level and project needs:
-
-**For Expert Users:**
-"Found {{starter_name}} which provides:
-{{quick_decision_list_of_key_decisions}}
-
-This would establish our base architecture with these technical decisions already made. Use it?"
-
-**For Intermediate Users:**
-"I found {{starter_name}}, which is a well-maintained starter for {{project_type}} projects.
-
-It makes these architectural decisions for us:
-{{decision_list_with_explanations}}
-
-This gives us a solid foundation following current best practices. Should we use it?"
-
-**For Beginner Users:**
-"I found {{starter_name}}, which is like a pre-built foundation for your project.
-
-Think of it like buying a prefab house frame instead of cutting each board yourself.
-
-It makes these decisions for us:
-{{friendly_explanation_of_decisions}}
-
-This is a great starting point that follows best practices and saves us from making dozens of small technical choices. Should we use it?"
-
-### 7. Get Current CLI Commands
-
-If user shows interest in a starter, get the exact current commands:
-
-```
-Search the web: "{{starter_name}} CLI command options flags latest"
-Search the web: "{{starter_name}} create new project command examples"
-```
-
-### 8. Generate Starter Template Content
-
-Prepare the content to append to the document:
-
-#### Content Structure:
-
-````markdown
-## Starter Template Evaluation
-
-### Primary Technology Domain
-
-{{identified_domain}} based on project requirements analysis
-
-### Starter Options Considered
-
-{{analysis_of_evaluated_starters}}
-
-### Selected Starter: {{starter_name}}
-
-**Rationale for Selection:**
-{{why_this_starter_was_chosen}}
-
-**Initialization Command:**
-
-```bash
-{{full_starter_command_with_options}}
-```
-
-**Architectural Decisions Provided by Starter:**
-
-**Language & Runtime:**
-{{language_typescript_setup}}
-
-**Styling Solution:**
-{{styling_solution_configuration}}
-
-**Build Tooling:**
-{{build_tools_and_optimization}}
-
-**Testing Framework:**
-{{testing_setup_and_configuration}}
-
-**Code Organization:**
-{{project_structure_and_patterns}}
-
-**Development Experience:**
-{{development_tools_and_workflow}}
-
-**Note:** Project initialization using this command should be the first implementation story.
-
-````
-
-### 9. Present Content and Menu
-
-Show the generated content and present choices:
-
-"I've analyzed starter template options for {{project_type}} projects.
-
-**Here's what I'll add to the document:**
-
-[Show the complete markdown content from step 8]
-
-**What would you like to do?**
-[A] Advanced Elicitation - Explore custom approaches or unconventional starters
-[P] Party Mode - Evaluate trade-offs from different perspectives
-[C] Continue - Save this decision and move to architectural decisions"
-
-### 10. Handle Menu Selection
-
-#### If 'A' (Advanced Elicitation):
-
-- Invoke the `bmad-advanced-elicitation` skill with current starter analysis
-- Process enhanced insights about starter options or custom approaches
-- Ask user: "Accept these changes to the starter template evaluation? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'P' (Party Mode):
-
-- Invoke the `bmad-party-mode` skill with starter evaluation context
-- Process collaborative insights about starter trade-offs
-- Ask user: "Accept these changes to the starter template evaluation? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'C' (Continue):
-
-- Append the final content to `{planning_artifacts}/architecture.md`
-- Update frontmatter: `stepsCompleted: [1, 2, 3]`
-- Load `./step-04-decisions.md`
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 8.
-
-## SUCCESS METRICS:
-
-✅ Primary technology domain correctly identified from project context
-✅ Current, maintained starter templates researched and evaluated
-✅ All versions verified using web search, not hardcoded
-✅ Architectural implications of starter choice clearly documented
-✅ User provided with clear rationale for starter selection
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Not verifying current versions with web search
-❌ Ignoring UX requirements when evaluating starters
-❌ Not documenting what architectural decisions the starter makes
-❌ Failing to consider maintenance status of starter templates
-❌ Not providing clear rationale for starter selection
-❌ Not presenting A/P/C menu after content generation
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document, load `./step-04-decisions.md` to begin making specific architectural decisions.
-
-Remember: Do NOT proceed to step-04 until user explicitly selects 'C' from the A/P/C menu and content is saved!

src/bmm-skills/3-solutioning/bmad-create-architecture/steps/step-04-decisions.md

@@ -1,318 +0,0 @@
-# Step 4: Core Architectural Decisions
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER generate content without user input
-
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
-- ✅ ALWAYS treat this as collaborative discovery between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on making critical architectural decisions collaboratively
-- 🌐 ALWAYS search the web to verify current technology versions
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- 🌐 Search the web to verify technology versions and options
-- ⚠️ Present A/P/C menu after each major decision category
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update frontmatter `stepsCompleted: [1, 2, 3, 4]` before loading next step
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## COLLABORATION MENUS (A/P/C):
-
-This step will generate content and present choices for each decision category:
-
-- **A (Advanced Elicitation)**: Use discovery protocols to explore innovative approaches to specific decisions
-- **P (Party Mode)**: Bring multiple perspectives to evaluate decision trade-offs
-- **C (Continue)**: Save the current decisions and proceed to next decision category
-
-## PROTOCOL INTEGRATION:
-
-- When 'A' selected: Invoke the `bmad-advanced-elicitation` skill
-- When 'P' selected: Invoke the `bmad-party-mode` skill
-- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
-- User accepts/rejects protocol changes before proceeding
-
-## CONTEXT BOUNDARIES:
-
-- Project context from step 2 is available
-- Starter template choice from step 3 is available
-- Project context file may contain technical preferences and rules
-- Technical preferences discovered in step 3 are available
-- Focus on decisions not already made by starter template or existing preferences
-- Collaborative decision making, not recommendations
-
-## YOUR TASK:
-
-Facilitate collaborative architectural decision making, leveraging existing technical preferences and starter template decisions, focusing on remaining choices critical to the project's success.
-
-## DECISION MAKING SEQUENCE:
-
-### 1. Load Decision Framework & Check Existing Preferences
-
-**Review Technical Preferences from Step 3:**
-"Based on our technical preferences discussion in step 3, let's build on those foundations:
-
-**Your Technical Preferences:**
-{{user_technical_preferences_from_step_3}}
-
-**Starter Template Decisions:**
-{{starter_template_decisions}}
-
-**Project Context Technical Rules:**
-{{project_context_technical_rules}}"
-
-**Identify Remaining Decisions:**
-Based on technical preferences, starter template choice, and project context, identify remaining critical decisions:
-
-**Already Decided (Don't re-decide these):**
-
-- {{starter_template_decisions}}
-- {{user_technology_preferences}}
-- {{project_context_technical_rules}}
-
-**Critical Decisions:** Must be decided before implementation can proceed
-**Important Decisions:** Shape the architecture significantly
-**Nice-to-Have:** Can be deferred if needed
-
-### 2. Decision Categories by Priority
-
-#### Category 1: Data Architecture
-
-- Database choice (if not determined by starter)
-- Data modeling approach
-- Data validation strategy
-- Migration approach
-- Caching strategy
-
-#### Category 2: Authentication & Security
-
-- Authentication method
-- Authorization patterns
-- Security middleware
-- Data encryption approach
-- API security strategy
-
-#### Category 3: API & Communication
-
-- API design patterns (REST, GraphQL, etc.)
-- API documentation approach
-- Error handling standards
-- Rate limiting strategy
-- Communication between services
-
-#### Category 4: Frontend Architecture (if applicable)
-
-- State management approach
-- Component architecture
-- Routing strategy
-- Performance optimization
-- Bundle optimization
-
-#### Category 5: Infrastructure & Deployment
-
-- Hosting strategy
-- CI/CD pipeline approach
-- Environment configuration
-- Monitoring and logging
-- Scaling strategy
-
-### 3. Facilitate Each Decision Category
-
-For each category, facilitate collaborative decision making:
-
-**Present the Decision:**
-Based on user skill level and project context:
-
-**Expert Mode:**
-"{{Decision_Category}}: {{Specific_Decision}}
-
-Options: {{concise_option_list_with_tradeoffs}}
-
-What's your preference for this decision?"
-
-**Intermediate Mode:**
-"Next decision: {{Human_Friendly_Category}}
-
-We need to choose {{Specific_Decision}}.
-
-Common options:
-{{option_list_with_brief_explanations}}
-
-For your project, I'd lean toward {{recommendation}} because {{reason}}. What are your thoughts?"
-
-**Beginner Mode:**
-"Let's talk about {{Human_Friendly_Category}}.
-
-{{Educational_Context_About_Why_This_Matters}}
-
-Think of it like {{real_world_analogy}}.
-
-Your main options:
-{{friendly_options_with_pros_cons}}
-
-My suggestion: {{recommendation}}
-This is good for you because {{beginner_friendly_reason}}.
-
-What feels right to you?"
-
-**Verify Technology Versions:**
-If decision involves specific technology:
-
-```
-Search the web: "{{technology}} latest stable version"
-Search the web: "{{technology}} current LTS version"
-Search the web: "{{technology}} production readiness"
-```
-
-**Get User Input:**
-"What's your preference? (or 'explain more' for details)"
-
-**Handle User Response:**
-
-- If user wants more info: Provide deeper explanation
-- If user has preference: Discuss implications and record decision
-- If user wants alternatives: Explore other options
-
-**Record the Decision:**
-
-- Category: {{category}}
-- Decision: {{user_choice}}
-- Version: {{verified_version_if_applicable}}
-- Rationale: {{user_reasoning_or_default}}
-- Affects: {{components_or_epics}}
-- Provided by Starter: {{yes_if_from_starter}}
-
-### 4. Check for Cascading Implications
-
-After each major decision, identify related decisions:
-
-"This choice means we'll also need to decide:
-
-- {{related_decision_1}}
-- {{related_decision_2}}"
-
-### 5. Generate Decisions Content
-
-After facilitating all decision categories, prepare the content to append:
-
-#### Content Structure:
-
-```markdown
-## Core Architectural Decisions
-
-### Decision Priority Analysis
-
-**Critical Decisions (Block Implementation):**
-{{critical_decisions_made}}
-
-**Important Decisions (Shape Architecture):**
-{{important_decisions_made}}
-
-**Deferred Decisions (Post-MVP):**
-{{decisions_deferred_with_rationale}}
-
-### Data Architecture
-
-{{data_related_decisions_with_versions_and_rationale}}
-
-### Authentication & Security
-
-{{security_related_decisions_with_versions_and_rationale}}
-
-### API & Communication Patterns
-
-{{api_related_decisions_with_versions_and_rationale}}
-
-### Frontend Architecture
-
-{{frontend_related_decisions_with_versions_and_rationale}}
-
-### Infrastructure & Deployment
-
-{{infrastructure_related_decisions_with_versions_and_rationale}}
-
-### Decision Impact Analysis
-
-**Implementation Sequence:**
-{{ordered_list_of_decisions_for_implementation}}
-
-**Cross-Component Dependencies:**
-{{how_decisions_affect_each_other}}
-```
-
-### 6. Present Content and Menu
-
-Show the generated decisions content and present choices:
-
-"I've documented all the core architectural decisions we've made together.
-
-**Here's what I'll add to the document:**
-
-[Show the complete markdown content from step 5]
-
-**What would you like to do?**
-[A] Advanced Elicitation - Explore innovative approaches to any specific decisions
-[P] Party Mode - Review decisions from multiple perspectives
-[C] Continue - Save these decisions and move to implementation patterns"
-
-### 7. Handle Menu Selection
-
-#### If 'A' (Advanced Elicitation):
-
-- Invoke the `bmad-advanced-elicitation` skill with specific decision categories
-- Process enhanced insights about particular decisions
-- Ask user: "Accept these enhancements to the architectural decisions? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'P' (Party Mode):
-
-- Invoke the `bmad-party-mode` skill with architectural decisions context
-- Process collaborative insights about decision trade-offs
-- Ask user: "Accept these changes to the architectural decisions? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'C' (Continue):
-
-- Append the final content to `{planning_artifacts}/architecture.md`
-- Update frontmatter: `stepsCompleted: [1, 2, 3, 4]`
-- Load `./step-05-patterns.md`
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 5.
-
-## SUCCESS METRICS:
-
-✅ All critical architectural decisions made collaboratively
-✅ Technology versions verified using web search
-✅ Decision rationale clearly documented
-✅ Cascading implications identified and addressed
-✅ User provided appropriate level of explanation for skill level
-✅ A/P/C menu presented and handled correctly for each category
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Making recommendations instead of facilitating decisions
-❌ Not verifying technology versions with web search
-❌ Missing cascading implications between decisions
-❌ Not adapting explanations to user skill level
-❌ Forgetting to document decisions made by starter template
-❌ Not presenting A/P/C menu after content generation
-
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document, load `./step-05-patterns.md` to define implementation patterns that ensure consistency across AI agents.
-
-Remember: Do NOT proceed to step-05 until user explicitly selects 'C' from the A/P/C menu and content is saved!

src/bmm-skills/3-solutioning/bmad-create-architecture/steps/step-05-patterns.md

@@ -1,359 +0,0 @@
-# Step 5: Implementation Patterns & Consistency Rules
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER generate content without user input
-
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
-- ✅ ALWAYS treat this as collaborative discovery between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on patterns that prevent AI agent implementation conflicts
-- 🎯 EMPHASIZE what agents could decide DIFFERENTLY if not specified
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- 🎯 Focus on consistency, not implementation details
-- ⚠️ Present A/P/C menu after generating patterns content
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5]` before loading next step
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## COLLABORATION MENUS (A/P/C):
-
-This step will generate content and present choices:
-
-- **A (Advanced Elicitation)**: Use discovery protocols to develop comprehensive consistency patterns
-- **P (Party Mode)**: Bring multiple perspectives to identify potential conflict points
-- **C (Continue)**: Save the patterns and proceed to project structure
-
-## PROTOCOL INTEGRATION:
-
-- When 'A' selected: Invoke the `bmad-advanced-elicitation` skill
-- When 'P' selected: Invoke the `bmad-party-mode` skill
-- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
-- User accepts/rejects protocol changes before proceeding
-
-## CONTEXT BOUNDARIES:
-
-- Core architectural decisions from step 4 are complete
-- Technology stack is decided and versions are verified
-- Focus on HOW agents should implement, not WHAT they should implement
-- Consider what could vary between different AI agents
-
-## YOUR TASK:
-
-Define implementation patterns and consistency rules that ensure multiple AI agents write compatible, consistent code that works together seamlessly.
-
-## PATTERNS DEFINITION SEQUENCE:
-
-### 1. Identify Potential Conflict Points
-
-Based on the chosen technology stack and decisions, identify where AI agents could make different choices:
-
-**Naming Conflicts:**
-
-- Database table/column naming conventions
-- API endpoint naming patterns
-- File and directory naming
-- Component/function/variable naming
-- Route parameter formats
-
-**Structural Conflicts:**
-
-- Where tests are located
-- How components are organized
-- Where utilities and helpers go
-- Configuration file organization
-- Static asset organization
-
-**Format Conflicts:**
-
-- API response wrapper formats
-- Error response structures
-- Date/time formats in APIs and UI
-- JSON field naming conventions
-- API status code usage
-
-**Communication Conflicts:**
-
-- Event naming conventions
-- Event payload structures
-- State update patterns
-- Action naming conventions
-- Logging formats and levels
-
-**Process Conflicts:**
-
-- Loading state handling
-- Error recovery patterns
-- Retry implementation approaches
-- Authentication flow patterns
-- Validation timing and methods
-
-### 2. Facilitate Pattern Decisions
-
-For each conflict category, facilitate collaborative pattern definition:
-
-**Present the Conflict Point:**
-"Given that we're using {{tech_stack}}, different AI agents might handle {{conflict_area}} differently.
-
-For example, one agent might name database tables 'users' while another uses 'Users' - this would cause conflicts.
-
-We need to establish consistent patterns that all agents follow."
-
-**Show Options and Trade-offs:**
-"Common approaches for {{pattern_category}}:
-
-1. {{option_1}} - {{pros_and_cons}}
-2. {{option_2}} - {{pros_and_cons}}
-3. {{option_3}} - {{pros_and_cons}}
-
-Which approach makes the most sense for our project?"
-
-**Get User Decision:**
-"What's your preference for this pattern? (or discuss the trade-offs more)"
-
-### 3. Define Pattern Categories
-
-#### Naming Patterns
-
-**Database Naming:**
-
-- Table naming: users, Users, or user?
-- Column naming: user_id or userId?
-- Foreign key format: user_id or fk_user?
-- Index naming: idx_users_email or users_email_index?
-
-**API Naming:**
-
-- REST endpoint naming: /users or /user? Plural or singular?
-- Route parameter format: :id or {id}?
-- Query parameter naming: user_id or userId?
-- Header naming conventions: X-Custom-Header or Custom-Header?
-
-**Code Naming:**
-
-- Component naming: UserCard or user-card?
-- File naming: UserCard.tsx or user-card.tsx?
-- Function naming: getUserData or get_user_data?
-- Variable naming: userId or user_id?
-
-#### Structure Patterns
-
-**Project Organization:**
-
-- Where do tests live? **tests**/ or \*.test.ts co-located?
-- How are components organized? By feature or by type?
-- Where do shared utilities go?
-- How are services and repositories organized?
-
-**File Structure:**
-
-- Config file locations and naming
-- Static asset organization
-- Documentation placement
-- Environment file organization
-
-#### Format Patterns
-
-**API Formats:**
-
-- API response wrapper? {data: ..., error: ...} or direct response?
-- Error format? {message, code} or {error: {type, detail}}?
-- Date format in JSON? ISO strings or timestamps?
-- Success response structure?
-
-**Data Formats:**
-
-- JSON field naming: snake_case or camelCase?
-- Boolean representations: true/false or 1/0?
-- Null handling patterns
-- Array vs object for single items
-
-#### Communication Patterns
-
-**Event Systems:**
-
-- Event naming convention: user.created or UserCreated?
-- Event payload structure standards
-- Event versioning approach
-- Async event handling patterns
-
-**State Management:**
-
-- State update patterns: immutable updates or direct mutation?
-- Action naming conventions
-- Selector patterns
-- State organization principles
-
-#### Process Patterns
-
-**Error Handling:**
-
-- Global error handling approach
-- Error boundary patterns
-- User-facing error message format
-- Logging vs user error distinction
-
-**Loading States:**
-
-- Loading state naming conventions
-- Global vs local loading states
-- Loading state persistence
-- Loading UI patterns
-
-### 4. Generate Patterns Content
-
-Prepare the content to append to the document:
-
-#### Content Structure:
-
-```markdown
-## Implementation Patterns & Consistency Rules
-
-### Pattern Categories Defined
-
-**Critical Conflict Points Identified:**
-{{number_of_potential_conflicts}} areas where AI agents could make different choices
-
-### Naming Patterns
-
-**Database Naming Conventions:**
-{{database_naming_rules_with_examples}}
-
-**API Naming Conventions:**
-{{api_naming_rules_with_examples}}
-
-**Code Naming Conventions:**
-{{code_naming_rules_with_examples}}
-
-### Structure Patterns
-
-**Project Organization:**
-{{project_structure_rules_with_examples}}
-
-**File Structure Patterns:**
-{{file_organization_rules_with_examples}}
-
-### Format Patterns
-
-**API Response Formats:**
-{{api_response_structure_rules}}
-
-**Data Exchange Formats:**
-{{data_format_rules_with_examples}}
-
-### Communication Patterns
-
-**Event System Patterns:**
-{{event_naming_and_structure_rules}}
-
-**State Management Patterns:**
-{{state_update_and_organization_rules}}
-
-### Process Patterns
-
-**Error Handling Patterns:**
-{{consistent_error_handling_approaches}}
-
-**Loading State Patterns:**
-{{loading_state_management_rules}}
-
-### Enforcement Guidelines
-
-**All AI Agents MUST:**
-
-- {{mandatory_pattern_1}}
-- {{mandatory_pattern_2}}
-- {{mandatory_pattern_3}}
-
-**Pattern Enforcement:**
-
-- How to verify patterns are followed
-- Where to document pattern violations
-- Process for updating patterns
-
-### Pattern Examples
-
-**Good Examples:**
-{{concrete_examples_of_correct_pattern_usage}}
-
-**Anti-Patterns:**
-{{examples_of_what_to_avoid}}
-```
-
-### 5. Present Content and Menu
-
-Show the generated patterns content and present choices:
-
-"I've documented implementation patterns that will prevent conflicts between AI agents working on this project.
-
-**Here's what I'll add to the document:**
-
-[Show the complete markdown content from step 4]
-
-**What would you like to do?**
-[A] Advanced Elicitation - Explore additional consistency patterns
-[P] Party Mode - Review patterns from different implementation perspectives
-[C] Continue - Save these patterns and move to project structure"
-
-### 6. Handle Menu Selection
-
-#### If 'A' (Advanced Elicitation):
-
-- Invoke the `bmad-advanced-elicitation` skill with current patterns
-- Process enhanced consistency rules that come back
-- Ask user: "Accept these additional pattern refinements? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'P' (Party Mode):
-
-- Invoke the `bmad-party-mode` skill with implementation patterns context
-- Process collaborative insights about potential conflicts
-- Ask user: "Accept these changes to the implementation patterns? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'C' (Continue):
-
-- Append the final content to `{planning_artifacts}/architecture.md`
-- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5]`
-- Load `./step-06-structure.md`
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 4.
-
-## SUCCESS METRICS:
-
-✅ All potential AI agent conflict points identified and addressed
-✅ Comprehensive patterns defined for naming, structure, and communication
-✅ Concrete examples provided for each pattern
-✅ Enforcement guidelines clearly documented
-✅ User collaborated on pattern decisions rather than receiving recommendations
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Missing potential conflict points that could cause agent conflicts
-❌ Being too prescriptive about implementation details instead of focusing on consistency
-❌ Not providing concrete examples for each pattern
-❌ Failing to address cross-cutting concerns like error handling
-❌ Not considering the chosen technology stack when defining patterns
-❌ Not presenting A/P/C menu after content generation
-
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document, load `./step-06-structure.md` to define the complete project structure.
-
-Remember: Do NOT proceed to step-06 until user explicitly selects 'C' from the A/P/C menu and content is saved!

src/bmm-skills/3-solutioning/bmad-create-architecture/steps/step-06-structure.md

@@ -1,379 +0,0 @@
-# Step 6: Project Structure & Boundaries
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER generate content without user input
-
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
-- ✅ ALWAYS treat this as collaborative discovery between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on defining complete project structure and clear boundaries
-- 🗺️ MAP requirements/epics to architectural components
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- 🗺️ Create complete project tree, not generic placeholders
-- ⚠️ Present A/P/C menu after generating project structure
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6]` before loading next step
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## COLLABORATION MENUS (A/P/C):
-
-This step will generate content and present choices:
-
-- **A (Advanced Elicitation)**: Use discovery protocols to explore innovative project organization approaches
-- **P (Party Mode)**: Bring multiple perspectives to evaluate project structure trade-offs
-- **C (Continue)**: Save the project structure and proceed to validation
-
-## PROTOCOL INTEGRATION:
-
-- When 'A' selected: Invoke the `bmad-advanced-elicitation` skill
-- When 'P' selected: Invoke the `bmad-party-mode` skill
-- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
-- User accepts/rejects protocol changes before proceeding
-
-## CONTEXT BOUNDARIES:
-
-- All previous architectural decisions are complete
-- Implementation patterns and consistency rules are defined
-- Focus on physical project structure and component boundaries
-- Map requirements to specific files and directories
-
-## YOUR TASK:
-
-Define the complete project structure and architectural boundaries based on all decisions made, creating a concrete implementation guide for AI agents.
-
-## PROJECT STRUCTURE SEQUENCE:
-
-### 1. Analyze Requirements Mapping
-
-Map project requirements to architectural components:
-
-**From Epics (if available):**
-"Epic: {{epic_name}} → Lives in {{module/directory/service}}"
-
-- User stories within the epic
-- Cross-epic dependencies
-- Shared components needed
-
-**From FR Categories (if no epics):**
-"FR Category: {{fr_category_name}} → Lives in {{module/directory/service}}"
-
-- Related functional requirements
-- Shared functionality across categories
-- Integration points between categories
-
-### 2. Define Project Directory Structure
-
-Based on technology stack and patterns, create the complete project structure:
-
-**Root Configuration Files:**
-
-- Package management files (package.json, requirements.txt, etc.)
-- Build and development configuration
-- Environment configuration files
-- CI/CD pipeline files
-- Documentation files
-
-**Source Code Organization:**
-
-- Application entry points
-- Core application structure
-- Feature/module organization
-- Shared utilities and libraries
-- Configuration and environment files
-
-**Test Organization:**
-
-- Unit test locations and structure
-- Integration test organization
-- End-to-end test structure
-- Test utilities and fixtures
-
-**Build and Distribution:**
-
-- Build output directories
-- Distribution files
-- Static assets
-- Documentation build
-
-### 3. Define Integration Boundaries
-
-Map how components communicate and where boundaries exist:
-
-**API Boundaries:**
-
-- External API endpoints
-- Internal service boundaries
-- Authentication and authorization boundaries
-- Data access layer boundaries
-
-**Component Boundaries:**
-
-- Frontend component communication patterns
-- State management boundaries
-- Service communication patterns
-- Event-driven integration points
-
-**Data Boundaries:**
-
-- Database schema boundaries
-- Data access patterns
-- Caching boundaries
-- External data integration points
-
-### 4. Create Complete Project Tree
-
-Generate a comprehensive directory structure showing all files and directories:
-
-**Technology-Specific Structure Examples:**
-
-**Next.js Full-Stack:**
-
-```
-project-name/
-├── README.md
-├── package.json
-├── next.config.js
-├── tailwind.config.js
-├── tsconfig.json
-├── .env.local
-├── .env.example
-├── .gitignore
-├── .github/
-│   └── workflows/
-│       └── ci.yml
-├── src/
-│   ├── app/
-│   │   ├── globals.css
-│   │   ├── layout.tsx
-│   │   └── page.tsx
-│   ├── components/
-│   │   ├── ui/
-│   │   ├── forms/
-│   │   └── features/
-│   ├── lib/
-│   │   ├── db.ts
-│   │   ├── auth.ts
-│   │   └── utils.ts
-│   ├── types/
-│   └── middleware.ts
-├── prisma/
-│   ├── schema.prisma
-│   └── migrations/
-├── tests/
-│   ├── __mocks__/
-│   ├── components/
-│   └── e2e/
-└── public/
-    └── assets/
-```
-
-**API Backend (NestJS):**
-
-```
-project-name/
-├── package.json
-├── nest-cli.json
-├── tsconfig.json
-├── .env
-├── .env.example
-├── .gitignore
-├── README.md
-├── src/
-│   ├── main.ts
-│   ├── app.module.ts
-│   ├── config/
-│   ├── modules/
-│   │   ├── auth/
-│   │   ├── users/
-│   │   └── common/
-│   ├── services/
-│   ├── repositories/
-│   ├── decorators/
-│   ├── pipes/
-│   ├── guards/
-│   └── interceptors/
-├── test/
-│   ├── unit/
-│   ├── integration/
-│   └── e2e/
-├── prisma/
-│   ├── schema.prisma
-│   └── migrations/
-└── docker-compose.yml
-```
-
-### 5. Map Requirements to Structure
-
-Create explicit mapping from project requirements to specific files/directories:
-
-**Epic/Feature Mapping:**
-"Epic: User Management
-
-- Components: src/components/features/users/
-- Services: src/services/users/
-- API Routes: src/app/api/users/
-- Database: prisma/migrations/_*users*_
-- Tests: tests/features/users/"
-
-**Cross-Cutting Concerns:**
-"Authentication System
-
-- Components: src/components/auth/
-- Services: src/services/auth/
-- Middleware: src/middleware/auth.ts
-- Guards: src/guards/auth.guard.ts
-- Tests: tests/auth/"
-
-### 6. Generate Structure Content
-
-Prepare the content to append to the document:
-
-#### Content Structure:
-
-```markdown
-## Project Structure & Boundaries
-
-### Complete Project Directory Structure
-```
-
-{{complete_project_tree_with_all_files_and_directories}}
-
-```
-
-### Architectural Boundaries
-
-**API Boundaries:**
-{{api_boundary_definitions_and_endpoints}}
-
-**Component Boundaries:**
-{{component_communication_patterns_and_boundaries}}
-
-**Service Boundaries:**
-{{service_integration_patterns_and_boundaries}}
-
-**Data Boundaries:**
-{{data_access_patterns_and_boundaries}}
-
-### Requirements to Structure Mapping
-
-**Feature/Epic Mapping:**
-{{mapping_of_epics_or_features_to_specific_directories}}
-
-**Cross-Cutting Concerns:**
-{{mapping_of_shared_functionality_to_locations}}
-
-### Integration Points
-
-**Internal Communication:**
-{{how_components_within_the_project_communicate}}
-
-**External Integrations:**
-{{third_party_service_integration_points}}
-
-**Data Flow:**
-{{how_data_flows_through_the_architecture}}
-
-### File Organization Patterns
-
-**Configuration Files:**
-{{where_and_how_config_files_are_organized}}
-
-**Source Organization:**
-{{how_source_code_is_structured_and_organized}}
-
-**Test Organization:**
-{{how_tests_are_structured_and_organized}}
-
-**Asset Organization:**
-{{how_static_and_dynamic_assets_are_organized}}
-
-### Development Workflow Integration
-
-**Development Server Structure:**
-{{how_the_project_is organized_for_development}}
-
-**Build Process Structure:**
-{{how_the_build_process_uses_the_project_structure}}
-
-**Deployment Structure:**
-{{how_the_project_structure_supports_deployment}}
-```
-
-### 7. Present Content and Menu
-
-Show the generated project structure content and present choices:
-
-"I've created a complete project structure based on all our architectural decisions.
-
-**Here's what I'll add to the document:**
-
-[Show the complete markdown content from step 6]
-
-**What would you like to do?**
-[A] Advanced Elicitation - Explore innovative project organization approaches
-[P] Party Mode - Review structure from different development perspectives
-[C] Continue - Save this structure and move to architecture validation"
-
-### 8. Handle Menu Selection
-
-#### If 'A' (Advanced Elicitation):
-
-- Invoke the `bmad-advanced-elicitation` skill with current project structure
-- Process enhanced organizational insights that come back
-- Ask user: "Accept these changes to the project structure? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'P' (Party Mode):
-
-- Invoke the `bmad-party-mode` skill with project structure context
-- Process collaborative insights about organization trade-offs
-- Ask user: "Accept these changes to the project structure? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'C' (Continue):
-
-- Append the final content to `{planning_artifacts}/architecture.md`
-- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6]`
-- Load `./step-07-validation.md`
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 6.
-
-## SUCCESS METRICS:
-
-✅ Complete project tree defined with all files and directories
-✅ All architectural boundaries clearly documented
-✅ Requirements/epics mapped to specific locations
-✅ Integration points and communication patterns defined
-✅ Project structure aligned with chosen technology stack
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Creating generic placeholder structure instead of specific, complete tree
-❌ Not mapping requirements to specific files and directories
-❌ Missing important integration boundaries
-❌ Not considering the chosen technology stack in structure design
-❌ Not defining how components communicate across boundaries
-❌ Not presenting A/P/C menu after content generation
-
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document, load `./step-07-validation.md` to validate architectural coherence and completeness.
-
-Remember: Do NOT proceed to step-07 until user explicitly selects 'C' from the A/P/C menu and content is saved!

src/bmm-skills/3-solutioning/bmad-create-architecture/steps/step-07-validation.md

@@ -1,361 +0,0 @@
-# Step 7: Architecture Validation & Completion
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER generate content without user input
-
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
-- ✅ ALWAYS treat this as collaborative discovery between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on validating architectural coherence and completeness
-- ✅ VALIDATE all requirements are covered by architectural decisions
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- ✅ Run comprehensive validation checks on the complete architecture
-- ⚠️ Present A/P/C menu after generating validation results
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]` before loading next step
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## COLLABORATION MENUS (A/P/C):
-
-This step will generate content and present choices:
-
-- **A (Advanced Elicitation)**: Use discovery protocols to address complex architectural issues found during validation
-- **P (Party Mode)**: Bring multiple perspectives to resolve validation concerns
-- **C (Continue)**: Save the validation results and complete the architecture
-
-## PROTOCOL INTEGRATION:
-
-- When 'A' selected: Invoke the `bmad-advanced-elicitation` skill
-- When 'P' selected: Invoke the `bmad-party-mode` skill
-- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
-- User accepts/rejects protocol changes before proceeding
-
-## CONTEXT BOUNDARIES:
-
-- Complete architecture document with all sections is available
-- All architectural decisions, patterns, and structure are defined
-- Focus on validation, gap analysis, and coherence checking
-- Prepare for handoff to implementation phase
-
-## YOUR TASK:
-
-Validate the complete architecture for coherence, completeness, and readiness to guide AI agents through consistent implementation.
-
-## VALIDATION SEQUENCE:
-
-### 1. Coherence Validation
-
-Check that all architectural decisions work together:
-
-**Decision Compatibility:**
-
-- Do all technology choices work together without conflicts?
-- Are all versions compatible with each other?
-- Do patterns align with technology choices?
-- Are there any contradictory decisions?
-
-**Pattern Consistency:**
-
-- Do implementation patterns support the architectural decisions?
-- Are naming conventions consistent across all areas?
-- Do structure patterns align with technology stack?
-- Are communication patterns coherent?
-
-**Structure Alignment:**
-
-- Does the project structure support all architectural decisions?
-- Are boundaries properly defined and respected?
-- Does the structure enable the chosen patterns?
-- Are integration points properly structured?
-
-### 2. Requirements Coverage Validation
-
-Verify all project requirements are architecturally supported:
-
-**From Epics (if available):**
-
-- Does every epic have architectural support?
-- Are all user stories implementable with these decisions?
-- Are cross-epic dependencies handled architecturally?
-- Are there any gaps in epic coverage?
-
-**From FR Categories (if no epics):**
-
-- Does every functional requirement have architectural support?
-- Are all FR categories fully covered by architectural decisions?
-- Are cross-cutting FRs properly addressed?
-- Are there any missing architectural capabilities?
-
-**Non-Functional Requirements:**
-
-- Are performance requirements addressed architecturally?
-- Are security requirements fully covered?
-- Are scalability considerations properly handled?
-- Are compliance requirements architecturally supported?
-
-### 3. Implementation Readiness Validation
-
-Assess if AI agents can implement consistently:
-
-**Decision Completeness:**
-
-- Are all critical decisions documented with versions?
-- Are implementation patterns comprehensive enough?
-- Are consistency rules clear and enforceable?
-- Are examples provided for all major patterns?
-
-**Structure Completeness:**
-
-- Is the project structure complete and specific?
-- Are all files and directories defined?
-- Are integration points clearly specified?
-- Are component boundaries well-defined?
-
-**Pattern Completeness:**
-
-- Are all potential conflict points addressed?
-- Are naming conventions comprehensive?
-- Are communication patterns fully specified?
-- Are process patterns (error handling, etc.) complete?
-
-### 4. Gap Analysis
-
-Identify and document any missing elements:
-
-**Critical Gaps:**
-
-- Missing architectural decisions that block implementation
-- Incomplete patterns that could cause conflicts
-- Missing structural elements needed for development
-- Undefined integration points
-
-**Important Gaps:**
-
-- Areas that need more detailed specification
-- Patterns that could be more comprehensive
-- Documentation that would help implementation
-- Examples that would clarify complex decisions
-
-**Nice-to-Have Gaps:**
-
-- Additional patterns that would be helpful
-- Supplementary documentation
-- Tooling recommendations
-- Development workflow optimizations
-
-### 5. Address Validation Issues
-
-For any issues found, facilitate resolution:
-
-**Critical Issues:**
-"I found some issues that need to be addressed before implementation:
-
-{{critical_issue_description}}
-
-These could cause implementation problems. How would you like to resolve this?"
-
-**Important Issues:**
-"I noticed a few areas that could be improved:
-
-{{important_issue_description}}
-
-These aren't blocking, but addressing them would make implementation smoother. Should we work on these?"
-
-**Minor Issues:**
-"Here are some minor suggestions for improvement:
-
-{{minor_issue_description}}
-
-These are optional refinements. Would you like to address any of these?"
-
-### 6. Generate Validation Content
-
-Prepare the content to append to the document:
-
-#### Content Structure:
-
-```markdown
-## Architecture Validation Results
-
-### Coherence Validation ✅
-
-**Decision Compatibility:**
-{{assessment_of_how_all_decisions_work_together}}
-
-**Pattern Consistency:**
-{{verification_that_patterns_support_decisions}}
-
-**Structure Alignment:**
-{{confirmation_that_structure_supports_architecture}}
-
-### Requirements Coverage Validation ✅
-
-**Epic/Feature Coverage:**
-{{verification_that_all_epics_or_features_are_supported}}
-
-**Functional Requirements Coverage:**
-{{confirmation_that_all_FRs_are_architecturally_supported}}
-
-**Non-Functional Requirements Coverage:**
-{{verification_that_NFRs_are_addressed}}
-
-### Implementation Readiness Validation ✅
-
-**Decision Completeness:**
-{{assessment_of_decision_documentation_completeness}}
-
-**Structure Completeness:**
-{{evaluation_of_project_structure_completeness}}
-
-**Pattern Completeness:**
-{{verification_of_implementation_patterns_completeness}}
-
-### Gap Analysis Results
-
-{{gap_analysis_findings_with_priority_levels}}
-
-### Validation Issues Addressed
-
-{{description_of_any_issues_found_and_resolutions}}
-
-### Architecture Completeness Checklist
-
-Mark each item `[x]` only if validation confirms it; leave `[ ]` if it is missing, partial, or unverified. Any unchecked item must be reflected in the Gap Analysis above and in the Overall Status below.
-
-**Requirements Analysis**
-
-- [ ] Project context thoroughly analyzed
-- [ ] Scale and complexity assessed
-- [ ] Technical constraints identified
-- [ ] Cross-cutting concerns mapped
-
-**Architectural Decisions**
-
-- [ ] Critical decisions documented with versions
-- [ ] Technology stack fully specified
-- [ ] Integration patterns defined
-- [ ] Performance considerations addressed
-
-**Implementation Patterns**
-
-- [ ] Naming conventions established
-- [ ] Structure patterns defined
-- [ ] Communication patterns specified
-- [ ] Process patterns documented
-
-**Project Structure**
-
-- [ ] Complete directory structure defined
-- [ ] Component boundaries established
-- [ ] Integration points mapped
-- [ ] Requirements to structure mapping complete
-
-### Architecture Readiness Assessment
-
-**Overall Status:** {{READY FOR IMPLEMENTATION | READY WITH MINOR GAPS | NOT READY}} (choose READY FOR IMPLEMENTATION only when all 16 checklist items are `[x]` and no Critical Gaps remain; choose NOT READY when any Critical Gap is open or any Requirements Analysis or Architectural Decisions item is unchecked; otherwise READY WITH MINOR GAPS)
-
-**Confidence Level:** {{high/medium/low}} based on validation results
-
-**Key Strengths:**
-{{list_of_architecture_strengths}}
-
-**Areas for Future Enhancement:**
-{{areas_that_could_be_improved_later}}
-
-### Implementation Handoff
-
-**AI Agent Guidelines:**
-
-- Follow all architectural decisions exactly as documented
-- Use implementation patterns consistently across all components
-- Respect project structure and boundaries
-- Refer to this document for all architectural questions
-
-**First Implementation Priority:**
-{{starter_template_command_or_first_architectural_step}}
-```
-
-### 7. Present Content and Menu
-
-Show the validation results and present choices:
-
-"I've completed a comprehensive validation of your architecture.
-
-**Validation Summary:**
-
-- ✅ Coherence: All decisions work together
-- ✅ Coverage: All requirements are supported
-- ✅ Readiness: AI agents can implement consistently
-
-**Here's what I'll add to complete the architecture document:**
-
-[Show the complete markdown content from step 6]
-
-**What would you like to do?**
-[A] Advanced Elicitation - Address any complex architectural concerns
-[P] Party Mode - Review validation from different implementation perspectives
-[C] Continue - Complete the architecture and finish workflow
-
-### 8. Handle Menu Selection
-
-#### If 'A' (Advanced Elicitation):
-
-- Invoke the `bmad-advanced-elicitation` skill with validation issues
-- Process enhanced solutions for complex concerns
-- Ask user: "Accept these architectural improvements? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'P' (Party Mode):
-
-- Invoke the `bmad-party-mode` skill with validation context
-- Process collaborative insights on implementation readiness
-- Ask user: "Accept these changes to the validation results? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'C' (Continue):
-
-- Append the final content to `{planning_artifacts}/architecture.md`
-- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]`
-- Load `./step-08-complete.md`
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 6.
-
-## SUCCESS METRICS:
-
-✅ All architectural decisions validated for coherence
-✅ Complete requirements coverage verified
-✅ Implementation readiness confirmed
-✅ All gaps identified and addressed
-✅ Comprehensive validation checklist completed
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Skipping validation of decision compatibility
-❌ Not verifying all requirements are architecturally supported
-❌ Missing potential implementation conflicts
-❌ Not addressing gaps found during validation
-❌ Providing incomplete validation checklist
-❌ Not presenting A/P/C menu after content generation
-
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document, load `./step-08-complete.md` to complete the workflow and provide implementation guidance.
-
-Remember: Do NOT proceed to step-08 until user explicitly selects 'C' from the A/P/C menu and content is saved!

src/bmm-skills/3-solutioning/bmad-create-architecture/steps/step-08-complete.md

@@ -1,82 +0,0 @@
-# Step 8: Architecture Completion & Handoff
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER generate content without user input
-
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
-- ✅ ALWAYS treat this as collaborative completion between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on successful workflow completion and implementation handoff
-- 🎯 PROVIDE clear next steps for implementation phase
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- 🎯 Present completion summary and implementation guidance
-- 📖 Update frontmatter with final workflow state
-- 🚫 THIS IS THE FINAL STEP IN THIS WORKFLOW
-
-## YOUR TASK:
-
-Complete the architecture workflow, provide a comprehensive completion summary, and guide the user to the next phase of their project development.
-
-## COMPLETION SEQUENCE:
-
-### 1. Congratulate the User on Completion
-
-Both you and the User completed something amazing here - give a summary of what you achieved together and really congratulate the user on a job well done.
-
-### 2. Update the created document's frontmatter
-
-```yaml
-stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]
-workflowType: 'architecture'
-lastStep: 8
-status: 'complete'
-completedAt: '{{current_date}}'
-```
-
-### 3. Next Steps Guidance
-
-Architecture complete. Invoke the `bmad-help` skill.
-
-Upon Completion of task output: offer to answer any questions about the Architecture Document.
-
-
-## SUCCESS METRICS:
-
-✅ Complete architecture document delivered with all sections
-✅ All architectural decisions documented and validated
-✅ Implementation patterns and consistency rules finalized
-✅ Project structure complete with all files and directories
-✅ User provided with clear next steps and implementation guidance
-✅ Workflow status properly updated
-✅ User collaboration maintained throughout completion process
-
-## FAILURE MODES:
-
-❌ Not providing clear implementation guidance
-❌ Missing final validation of document completeness
-❌ Not updating workflow status appropriately
-❌ Failing to celebrate the successful completion
-❌ Not providing specific next steps for the user
-❌ Rushing completion without proper summary
-
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-
-## WORKFLOW COMPLETE:
-
-This is the final step of the Architecture workflow. The user now has a complete, validated architecture document ready for AI agent implementation.
-
-The architecture will serve as the single source of truth for all technical decisions, ensuring consistent implementation across the entire project development lifecycle.
-
-## On Complete
-
-Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow.on_complete`
-
-If the resolved `workflow.on_complete` is non-empty, follow it as the final terminal instruction before exiting.

src/bmm-skills/3-solutioning/bmad-create-epics-and-stories/steps/step-01-validate-prerequisites.md

@@ -48,7 +48,7 @@ Verify required documents exist and are complete:
 
 1. **PRD.md** - Contains requirements (FRs and NFRs) and product scope
 2. **Architecture.md** - Contains technical decisions, API contracts, data models
-3. **UX Design.md** (if UI exists) - Contains interaction patterns, mockups, user flows
+3. **UX design contract** (if UI exists) - Contains visual identity, interaction patterns, mockups, and user flows
 
 ### 2. Document Discovery and Validation
 
@@ -66,8 +66,16 @@ Search for required documents using these patterns (sharded means a large docume
 
 **UX Design Document Search (Optional):**
 
-1. `{planning_artifacts}/*ux*.md` (whole document)
+1. `{planning_artifacts}/ux-designs/ux-*/DESIGN.md` and `{planning_artifacts}/ux-designs/ux-*/EXPERIENCE.md` (bmad-ux spine pair)
-2. `{planning_artifacts}/*ux*/index.md` (sharded version)
+2. `{planning_artifacts}/*ux*.md` (legacy whole document)
+3. `{planning_artifacts}/*ux*/index.md` (legacy sharded version)
+
+For each matching bmad-ux run folder, treat `DESIGN.md` and `EXPERIENCE.md` as one UX design contract:
+
+- Confirm and load both files together. `DESIGN.md` owns visual identity and design tokens; `EXPERIENCE.md` owns information architecture, behavior, states, interactions, accessibility, and journeys.
+- Add both files to the `inputDocuments: []` frontmatter array.
+- If only one spine exists, report the incomplete pair and ask whether the user wants to include the partial UX handoff.
+- If multiple run folders match, show each run folder with the spine frontmatter `status` and `updated` values when available, then ask the user which UX design contract to include.
 
 Before proceeding, Ask the user if there are any other documents to include for analysis, and if anything found should be excluded. Wait for user confirmation. Once confirmed, create the {planning_artifacts}/epics.md from the ../templates/epics-template.md and in the front matter list the files in the array of `inputDocuments: []`.
 
@@ -136,7 +144,7 @@ Review the Architecture document for technical requirements that impact epic and
 
 **IMPORTANT**: The UX Design Specification is a first-class input document, not supplementary material. Requirements from the UX spec must be extracted with the same rigor as PRD functional requirements.
 
-Read the FULL UX Design document and extract ALL actionable work items:
+Read the FULL UX design contract and extract ALL actionable work items. For a bmad-ux spine pair, read both `DESIGN.md` and `EXPERIENCE.md`:
 
 **Look for:**
 

src/bmm-skills/4-implementation/bmad-code-review/SKILL.md

@@ -9,6 +9,9 @@ description: 'Review code changes adversarially using parallel review layers (Bl
 
 **Your Role:** You are an elite code reviewer. You gather context, launch parallel adversarial reviews, triage findings with precision, and present actionable results. No noise, no filler.
 
+Subagents, when the capability is available, are an important part of this workflow. Use them as directed by the workflow steps.
+If you need an explicit user instruction to run them, ask once now for the whole workflow run.
+
 ## Conventions
 
 - Bare paths (e.g. `checklist.md`) resolve from the skill root.