chore(deps): lockfile audit fixes for transitive vulnerabilities (#2382)

Resolves 12 of 14 open Dependabot alerts via `npm audit fix`
(no package.json changes, no semver-range bumps):

- vite 6.4.1 -> 6.4.2
- defu 6.1.4 -> 6.1.5
- flatted 3.4.1 -> 3.4.2
- postcss 8.5.6 -> 8.5.13
- h3 1.15.8 -> 1.15.11
- yaml 2.8.2 -> 2.8.4
- brace-expansion 4.0.3 -> 4.0.4
- picomatch 2.3.1 -> 2.3.2 and 4.0.3 -> 4.0.4
- astro 5.17.1 -> 5.18.1

Two astro alerts requiring 5->6 and the markdown-it
(markdownlint-cli2) alert are left for separate, scoped upgrades.

Verified: npm run docs:build, npm run test (83 tests),
lint, lint:md, format:check all pass.

docs/explanation/forensic-investigation.md

@@ -0,0 +1,137 @@
+---
+title: "Forensic Investigation"
+description: How bmad-investigate treats every issue like a crime scene, grades evidence, and produces a structured case file engineers can act on
+sidebar:
+  order: 6
+---
+
+You hand `bmad-investigate` a crash log, a stack trace, or just a "this used to work, now it doesn't". The skill takes
+over the investigator's discipline for the duration of the run. It does not start fixing. It opens a case file.
+
+Every finding gets graded. Every hypothesis gets a status. Wrong turns are kept, not erased. The deliverable is a
+document another engineer can pick up cold.
+
+This page explains why investigation is its own discipline, and what the skill buys you that a regular dev workflow
+doesn't.
+
+## The Problem With "Just Debug It"
+
+Normal debugging blends three things: looking at evidence, reasoning about cause, and changing code to test the theory.
+When they're blended, two failure modes show up.
+
+The first is **narrative lock-in**. The first plausible story becomes the working theory, and every observation gets
+bent to fit it. The bug stays unfixed until someone gives up and starts over. Hours later.
+
+The second is **evidence amnesia**. You traced something, ruled it out, but didn't write down why. Two days later, with
+fresh eyes, you trace it again. Or worse, a colleague picks up the bug and re-runs the same dead end you already
+eliminated.
+
+The skill's design is a direct response to both.
+
+## Evidence Grading
+
+Every finding in an investigation is one of three things.
+
+- **Confirmed.** Directly observed in logs, code, or dumps; cited with a specific reference (a `path:line`, a log
+  timestamp, a commit hash). If someone asks "how do you know?", you point at the citation.
+- **Deduced.** Logically follows from confirmed evidence; the reasoning chain is shown. If a step in the chain is wrong,
+  the deduction is wrong, and you can see exactly which step.
+- **Hypothesized.** Plausible but unconfirmed. States what evidence would confirm or refute, and declares upfront what
+  would close it. Hypotheses are explicitly *not facts*.
+
+The grading is not about being humble. It's about making the case file readable. A reader can scan the Confirmed section
+to know what is true, the Deduced section to know what follows, and the Hypothesized section to know what is still open.
+Confusion between the three is the most common reason investigations spiral.
+
+## Stronghold First
+
+Investigation never starts from a theory. It starts from one piece of confirmed evidence and expands outward. That
+evidence might be a specific error message, a stack frame, or a timestamped log entry.
+
+This is the opposite of how investigations often go. Someone has a hunch, builds a theory, and then hunts for evidence
+that supports it. The hunch can be right; the *method* is fragile because it makes confirmation bias the default.
+
+A stronghold is a fact you can return to when reasoning gets murky. If a deduction takes you somewhere strange, you can
+walk it back to the stronghold and try a different branch. Without one, you don't know which step to undo.
+
+When evidence is sparse, the skill says so and switches to hypothesis-driven exploration: form hypotheses from what's
+available, identify what would test each, present a prioritized data-collection list. Missing evidence is itself a
+finding.
+
+## Hypothesis Discipline
+
+Hypotheses are never deleted from the case file. When evidence confirms or refutes one, its **Status** field updates
+from Open to Confirmed or Refuted, and a **Resolution** explains what evidence settled it.
+
+This rule has a real cost. Case files grow. The benefit is real too. The full reasoning history becomes part of the
+deliverable. Six months later, when a similar bug surfaces, the next investigator can read the original case file and
+see which paths were already eliminated and why. Without that history, every new investigator re-runs the same dead
+ends.
+
+It also disciplines the present-tense investigator. If you can't delete a wrong hypothesis, you have to disprove it
+with cited evidence. Quietly dropping it when it becomes inconvenient is no longer an option.
+
+## Challenge the Premise
+
+The user's description of the problem is a hypothesis, not a fact. "The cache is broken" is something a user *believes*.
+Before the skill builds an investigation around it, the technical claims are verified independently. If the evidence
+contradicts the premise, the report says so directly.
+
+This is the forensic instinct: the witness's account is data, not truth. Sometimes the reported bug is real but
+mislabeled. Sometimes the described symptom is downstream of a different cause. Investigations that take the premise as
+gospel diagnose the wrong defect, and the bug returns in a slightly different form.
+
+## A Calibrated Walk
+
+The skill is one procedure, not two modes. It calibrates how much defect-chasing versus how much area-exploration the
+input demands, on a continuous scale.
+
+A symptom-driven case (a ticket, a crash, an error message, a "this used to work") leans into hypothesis tracking,
+timeline reconstruction, and a fix direction. A no-symptom case (understanding a module before you touch it, evaluating
+reusability, building a mental model) leans into I/O mapping, control-flow filtering, and a verification plan. Most
+real cases sit somewhere between, and the case file reflects whichever balance the evidence required.
+
+The discipline is the same regardless of where on the scale a case lands: stronghold first, evidence grading, hypothesis
+tracking, never erase. The output is always at `{implementation_artifacts}/investigations/{slug}-investigation.md`, with
+sections that don't apply to a given case left empty or omitted.
+
+When a deep bug requires understanding a broader subsystem, the procedure folds in the I/O mapping, control-flow
+filtering, working-backward-from-outputs, and cross-component boundary tracing techniques inline. The area model lands
+in the same case file. There is no mode switch.
+
+## Methodology Lives in the Skill
+
+The investigator's discipline is a property of the skill itself. Whoever invokes `bmad-investigate` takes on the
+methodology and communication style for the run: clinical precision, evidence-first language, no hedging, case-file
+framing. When the skill ends, the caller returns to its prior voice. No persona swap, just a tone shift from the skill's
+principles.
+
+This matters because investigation and implementation reward different instincts. Investigators are slow and precise.
+Implementers are fast and confident. The same brain doing both in one session tends to do neither well. The skill
+carves out the investigative posture inline, without a context switch to a separate identity.
+
+## What You Get
+
+A completed investigation file:
+
+- Separates Confirmed findings (with citations) from Deductions and Hypotheses
+- Preserves all hypotheses ever formed, with their final Status and Resolution
+- Reconstructs a timeline of events from multiple evidence sources
+- Identifies data gaps and what they would resolve
+- Provides actionable conclusions grounded in evidence
+- Includes a reproduction plan when a root cause is identified
+- Maintains an investigation backlog of paths still to explore
+
+Hand it to an engineer who was not present and they understand what happened, what is known, and what remains uncertain.
+That's the bar.
+
+## The Bigger Idea
+
+Most "AI debugging" today blends evidence, reasoning, and code changes into one stream of plausible-looking text. The
+signal is hard to find, the dead ends repeat, and the case file, if there is one, is a chat log nobody wants to read.
+
+`bmad-investigate` treats investigation as a discipline with its own deliverable. Evidence has a grade. Hypotheses have
+a status. Wrong turns are documented, not erased. The case file outlives the session.
+
+When the next bug shows up that looks like one you've seen before, you have somewhere to start that isn't a blank
+prompt.

docs/fr/explanation/forensic-investigation.md

@@ -0,0 +1,157 @@
+---
+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
+sidebar:
+  order: 6
+---
+
+Vous confiez à `bmad-investigate` un journal de plantage, une trace de pile, 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 à
+corriger. 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
+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
+développement classique n'apporte pas.
+
+## Le problème du « débogue, c'est tout »
+
+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
+observation est tordue pour la confirmer. Le bug reste non corrigé jusqu'à ce que quelqu'un abandonne et reparte de
+zéro. Des heures plus tard.
+
+Le second est l'**amnésie probatoire**. Vous avez tracé quelque chose, l'avez écarté, mais n'avez pas écrit pourquoi.
+Deux jours plus tard, avec un regard frais, vous le retracez. Pire encore, un collègue reprend le bug et refait la même
+impasse que vous aviez déjà éliminé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.
+
+- **Confirmé.** Directement observé dans les logs, le code ou les dumps ; cité 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
+  la citation.
+- **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.
+- **Hypothétique.** Plausible mais non confirmé. Énonce quelle preuve confirmerait ou réfuterait, et déclare d'avance ce
+  qui le clôturerait. Les hypothèses sont explicitement *non factuelles*.
+
+Le classement n'est pas une posture d'humilité. 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
+savoir ce qui reste ouvert. Confondre les trois est la première raison pour laquelle les enquêtes dérapent.
+
+## Tête de pont 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
+preuve peut être un message d'erreur précis, une trame de pile, 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,
+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.
+
+Une tête de pont 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,
+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
+à 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.
+
+## 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é.
+
+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
+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
+les mêmes impasses.
+
+Cela discipline aussi l'enquêteur du présent. 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.
+
+## 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
+que l'utilisateur *croit*. Avant que le skill ne construise une enquête autour, les affirmations techniques sont
+vérifiées de manière indépendante. Si la preuve contredit la prémisse, le rapport le dit directement.
+
+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
+pour argent comptant diagnostiquent le mauvais défaut, et le bug revient sous une forme légèrement différente.
+
+## Une marche calibrée
+
+Le skill est une seule procédure, pas deux modes. Il calibre la part d'investigation de défaut versus la part
+d'exploration de zone que l'entrée demande, sur une échelle continue.
+
+Un cas piloté par 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
+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é.
+
+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
+des preuves, suivi des hypothèses, jamais effacer. La sortie est toujours
+`{implementation_artifacts}/investigations/{slug}-investigation.md`, avec les sections qui ne s'appliquent pas à un cas
+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
+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
+mode.
+
+## La méthodologie vit 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
+et le style de communication pour 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
+changement de persona, juste un déplacement de ton issu des 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
+précis. Les implémenteurs sont rapides et confiants. Le même cerveau faisant les deux dans une seule session finit par
+mal faire les deux. Le skill délimite la posture d'enquête en ligne, sans changement de contexte vers une identité
+séparée.
+
+## Ce que vous obtenez
+
+Un fichier d'enquête achevé :
+
+- 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
+- Reconstruit une chronologie des événements à partir de plusieurs sources de preuves
+- Identifie les lacunes de données et ce qu'elles résoudraient
+- Fournit des conclusions actionnables 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
+
+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
+incertain. C'est la barre.
+
+## L'idée plus large
+
+La plupart du « débogage par IA » d'aujourd'hui mélange preuves, raisonnement et changements de code en un seul flux de
+texte plausible. Le signal est difficile à trouver, les impasses se répètent, et le dossier, s'il en existe un, est un
+journal de chat 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
+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
+une invite vide.
+
+## Glossaire
+
+[^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.
+[^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,
+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/reference/workflow-map.md

@@ -5,13 +5,23 @@ 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 contexte et de la planification. Les agents IA fonctionnent de manière optimale avec un contexte clair et structuré. Le système BMM construit ce contexte progressivement à travers 4 phases distinctes — chaque phase, et plusieurs workflows optionnels au sein de chaque phase, produisent des documents qui alimentent la phase suivante, afin que les agents sachent toujours quoi construire et pourquoi.
+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
+contexte et de la planification. Les agents IA fonctionnent de manière optimale avec un contexte clair et structuré. Le
+système BMM construit ce contexte progressivement à travers 4 phases distinctes — chaque phase, et plusieurs workflows
+optionnels au sein de chaque phase, produisent des documents qui alimentent la phase suivante, afin que les agents
+sachent toujours quoi 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 cadre mental de référence.
+La logique et les concepts proviennent des méthodologies agiles qui ont été utilisées avec succès dans l'industrie comme
+cadre mental 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 quoi faire ensuite. Vous pouvez toujours vous référer à cette page également — mais `bmad-help` est entièrement interactif et beaucoup plus rapide si vous avez déjà installé la méthode BMad. De plus, si vous utilisez différents modules qui ont étendu la méthode BMad ou ajouté d'autres modules complémentaires non extensifs — `bmad-help` évolue pour connaître tout ce qui est disponible et vous donner les meilleurs conseils du moment.
+Si à tout moment vous ne savez pas quoi faire, le skill `bmad-help` vous aidera à rester sur la bonne voie ou à savoir
+quoi faire ensuite. Vous pouvez toujours vous référer à cette page également — mais `bmad-help` est entièrement
+interactif et beaucoup plus rapide si vous avez déjà installé la méthode BMad. De plus, si vous utilisez différents
+modules qui ont étendu la méthode BMad ou ajouté d'autres modules complémentaires non extensifs — `bmad-help` évolue
+pour connaître tout ce qui est disponible et vous donner les meilleurs conseils du moment.
 
-Note finale importante : Chaque workflow ci-dessous peut être exécuté directement avec l'outil de votre choix via un skill ou en chargeant d'abord un agent et en utilisant l'entrée du menu des agents.
+Note finale importante : Chaque workflow ci-dessous peut être exécuté directement avec l'outil de votre choix via un
+skill ou en chargeant d'abord un agent et en utilisant l'entrée du 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>
 
@@ -21,14 +31,15 @@ Note finale importante : Chaque workflow ci-dessous peut être exécuté directe
 
 ## 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 chaque outil et quand l’utiliser**](../explanation/analysis-phase.md).
+Explorez l’espace problème et validez les idées avant de vous engager dans la planification. [**Découvrez ce que fait
+chaque outil et quand l’utiliser**](../explanation/analysis-phase.md).
 
 | Workflow                                                                  | Objectif                                                                                 | Produit                   |
 |---------------------------------------------------------------------------|------------------------------------------------------------------------------------------|---------------------------|
 | `bmad-brainstorming`                                                      | Brainstormez des idées de projet avec l’accompagnement guidé d’un coach de brainstorming | `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-product-brief`                                                      | Capturez la vision stratégique — idéal lorsque votre concept est clair                   | `product-brief.md`        |
-| `bmad-prfaq`                                                              | Working Backwards — éprouvez et forgez votre concept produit                             | `prfaq-{project}.md`       |
+| `bmad-prfaq`                                                              | Working Backwards — éprouvez et forgez votre concept produit                             | `prfaq-{project}.md`      |
 
 ## Phase 2 : Planification
 
@@ -36,60 +47,75 @@ Définissez ce qu'il faut construire et pour qui.
 
 | Workflow                | Objectif                                                | Produit      |
 |-------------------------|---------------------------------------------------------|--------------|
-| `bmad-create-prd`       | Définissez les exigences (FRs/NFRs)[^1]                     | `PRD.md`[^2]     |
+| `bmad-create-prd`       | Définissez les exigences (FRs/NFRs)[^1]                 | `PRD.md`[^2] |
 | `bmad-create-ux-design` | Concevez l'expérience utilisateur (lorsque l'UX compte) | `ux-spec.md` |
 
 ## Phase 3 : Solutioning
 
 Décidez comment le construire et décomposez le travail en stories.
 
-| Workflow                              | Objectif                                          | Produit                      |
+| Workflow                              | Objectif                                          | Produit                         |
-|---------------------------------------|---------------------------------------------------|------------------------------|
+|---------------------------------------|---------------------------------------------------|---------------------------------|
-| `bmad-create-architecture`            | Rendez les décisions techniques explicites        | `architecture.md` avec ADRs[^3]  |
+| `bmad-create-architecture`            | Rendez les décisions techniques explicites        | `architecture.md` avec ADRs[^3] |
-| `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 travail implémentable | Fichiers d'epic avec stories    |
-| `bmad-check-implementation-readiness` | Vérification avant implémentation                 | Décision Passe/Réserves/Échec  |
+| `bmad-check-implementation-readiness` | Vérification avant implémentation                 | Décision Passe/Réserves/Échec   |
 
 ## Phase 4 : Implémentation
 
 Construisez, une story à la fois. Bientôt disponible : automatisation complète de la phase 4 !
 
-| Workflow               | Objectif                                                                            | Produit                          |
+| Workflow               | Objectif                                                                            | Produit                                              |
-|------------------------|-------------------------------------------------------------------------------------|----------------------------------|
+|------------------------|-------------------------------------------------------------------------------------|------------------------------------------------------|
-| `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`   | Revue après complétion 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`        |
 
 ## Quick Dev (Parcours Parallèle)
 
 Sautez les phases 1-3 pour les travaux de faible envergure et bien compris.
 
-| Workflow         | Objectif                                                                            | Produit               |
+| Workflow         | Objectif                                                                            | Produit            |
-|------------------|-------------------------------------------------------------------------------------|-----------------------|
+|------------------|-------------------------------------------------------------------------------------|--------------------|
 | `bmad-quick-dev` | Flux rapide unifié — clarifie l'intention, planifie, implémente, révise et présente | `spec-*.md` + code |
 
 ## Gestion du Contexte
 
-Chaque document devient le contexte de la phase suivante. Le PRD[^2] indique à l'architecte quelles contraintes sont importantes. L'architecture indique à l'agent de développement quels modèles suivre. Les fichiers de story fournissent un contexte focalisé et complet pour l'implémentation. Sans cette structure, les agents prennent des décisions incohérentes.
+Chaque document devient le contexte de la phase suivante. Le PRD[^2] indique à l'architecte quelles contraintes sont
+importantes. L'architecture indique à l'agent de développement quels modèles suivre. Les fichiers de story fournissent
+un contexte focalisé et complet pour l'implémentation. Sans cette structure, les agents prennent des décisions
+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 fichier fonctionne comme une constitution pour votre projet — il guide les décisions d'implémentation à travers tous les workflows. Ce fichier optionnel peut être généré à la fin de la création de l'architecture, ou dans un projet existant il peut également être généré pour capturer ce qui est important de conserver aligné avec les conventions actuelles.
+Créez `project-context.md` pour vous assurer que les agents IA suivent les règles et préférences de votre projet. Ce
+fichier fonctionne comme une constitution pour votre projet — il guide les décisions d'implémentation à travers tous les
+workflows. Ce fichier optionnel peut être généré à la fin de la création de l'architecture, ou dans un projet existant
+il peut également être généré pour capturer ce qui est important de conserver aligné avec les conventions actuelles.
 :::
 
 **Comment le créer :**
 
-- **Manuellement** — Créez `_bmad-output/project-context.md` avec votre pile technologique et vos règles d'implémentation
+- **Manuellement** — Créez `_bmad-output/project-context.md` avec votre pile technologique et vos règles
-- **Générez-le** — Exécutez `bmad-generate-project-context` pour l'auto-générer à partir de votre architecture ou de votre codebase
+  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
 
 [**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 faire** (fonctionnalités, comportements attendus) et **comment il doit le faire** (contraintes de performance, sécurité, fiabilité, ergonomie, etc.).
+[^1]: FR / NFR (Functional / Non-Functional Requirement) : exigences décrivant respectivement **ce que le système doit
-[^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.
+faire** (fonctionnalités, comportements attendus) et **comment il doit le faire** (contraintes de performance, sécurité,
-[^3]: 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.
+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
+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/how-to/expand-bmad-for-your-org.md

@@ -1,11 +1,11 @@
 ---
 title: 'How to Expand BMad for Your Organization'
-description: Five customization patterns that reshape BMad without forking — agent-wide rules, workflow conventions, external publishing, template swaps, and agent roster changes
+description: Six customization patterns that reshape BMad without forking — agent-wide rules, workflow conventions, external publishing, template swaps, agent roster changes, and advanced integration patterns
 sidebar:
   order: 9
 ---
 
-BMad's customization surface lets an organization reshape behavior without editing installed files or forking skills. This guide walks through five recipes that cover most enterprise needs.
+BMad's customization surface lets an organization reshape behavior without editing installed files or forking skills. This guide walks through six recipes that cover most enterprise needs.
 
 :::note[Prerequisites]
 
@@ -227,9 +227,79 @@ One sentence, loaded every session. It pairs with the `bmad-agent-dev.toml` cust
 
 Keep the IDE file **succinct**. A dozen well-chosen lines are more effective than a sprawling list. Models read it every turn, and noise crowds out signal.
 
+## Recipe 6: Advanced Integration Patterns
+
+Several BMad workflows expose a richer configuration surface beyond the basics covered in Recipes 1–5. These patterns — on-demand knowledge sources, automatic output publishing, finalize-time doc standards, and swappable templates — appear across multiple workflows. Check a workflow's `customize.toml` to see which fields it exposes; the examples below use `bmad-prd` because it exposes all of them, but the same patterns apply wherever the field appears.
+
+### On-demand knowledge sources (`external_sources`)
+
+Connect the workflow to internal knowledge bases, competitive databases, or compliance references. The agent consults these on demand when the conversation surfaces a matching need — never preemptively.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (same pattern works in any workflow that exposes external_sources)
+
+[workflow]
+external_sources = [
+  "When the user mentions a competitor or market segment, query corp:competitive_db (category={project_name}) before drafting the differentiation section.",
+  "For regulatory domains (healthcare, fintech, education), consult corp:compliance_reference before drafting domain-specific sections.",
+]
+```
+
+Each entry is a natural-language directive naming the MCP tool, the trigger condition, and any fields the tool needs. If the tool is unavailable at runtime, the workflow falls back to standard behavior and notes the gap.
+
+### Automatic output publishing (`external_handoffs`)
+
+Route completed artifacts to external systems of record after the workflow finalizes. Unlike `on_complete` (Recipe 3), `external_handoffs` is a dedicated append array — team entries stack, and each handoff fires independently with graceful degradation if a tool is unavailable.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (same pattern works in any workflow that exposes external_handoffs)
+
+[workflow]
+external_handoffs = [
+  "After finalize, upload prd.md and addendum.md to Confluence via corp:confluence_upload (space_key='PROD', parent_page='PRDs', label='prd', author={user_name}). Capture and surface the returned page URL.",
+  "Mirror to Notion via notion:create_page (database_id='abc123', title='PRD: ' + {project_name}).",
+]
+```
+
+If a named tool is unavailable, the handoff is skipped and flagged — local files always exist regardless.
+
+### Finalize-time doc standards (`doc_standards`)
+
+Apply org writing standards to human-consumed documents at finalize, after content is complete but before the user sees the output. Each entry is a `skill:`, `file:`, or plain-text directive; passes run as parallel subagents.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (same pattern works in any workflow that exposes doc_standards)
+
+[workflow]
+doc_standards = [
+  "file:{project-root}/docs/enterprise/voice-and-tone.md",
+  "All dates must use ISO 8601 format (YYYY-MM-DD).",
+  "Replace any use of 'leverage' with 'use'.",
+]
+```
+
+`doc_standards` is an append array — team entries stack on top of whatever defaults the workflow ships with. Broader structural passes should come before narrower prose passes.
+
+### Swappable templates and checklists
+
+Workflows that produce structured documents typically expose template and checklist paths as overridable scalars. Point them at org-owned files under `{project-root}` to enforce a different structure without editing any source.
+
+```toml
+# _bmad/custom/bmad-prd.toml
+
+[workflow]
+# Regulated-industry PRD structure
+prd_template = "{project-root}/docs/enterprise/prd-template-hipaa.md"
+
+# Org-specific validation criteria
+validation_checklist = "{project-root}/docs/enterprise/prd-checklist-regulated.md"
+```
+
+The agent adapts to whatever structure the template defines. Keep templates under `{project-root}/docs/` or `{project-root}/_bmad/custom/templates/` so they version alongside the override file. For multi-org repos, use `.user.toml` to let teams point at their own templates without touching the committed team file.
+
 ## Combining Recipes
 
-All five recipes compose. A realistic enterprise override for `bmad-product-brief` might set `persistent_facts` (Recipe 2), `on_complete` (Recipe 3), and `brief_template` (Recipe 4) in one file. The agent-level rule (Recipe 1) lives in a separate file under the agent's name, central config (Recipe 5) pins the shared roster and team settings, and all four apply in parallel.
+All six recipes compose. A realistic enterprise override for `bmad-product-brief` might set `persistent_facts` (Recipe 2), `on_complete` (Recipe 3), and `brief_template` (Recipe 4) in one file. The agent-level rule (Recipe 1) lives in a separate file under the agent's name, central config (Recipe 5) pins the shared roster and team settings, advanced integration patterns (Recipe 6) configure external sources and handoffs, and all layers apply in parallel.
 
 ```toml
 # _bmad/custom/bmad-product-brief.toml (workflow-level)

docs/reference/commands.md

@@ -52,7 +52,7 @@ Each skill is a directory containing a `SKILL.md` file. For example, a Claude Co
 .claude/skills/
 ├── bmad-help/
 │   └── SKILL.md
-├── bmad-create-prd/
+├── bmad-prd/
 │   └── SKILL.md
 ├── bmad-agent-dev/
 │   └── SKILL.md
@@ -91,9 +91,9 @@ Workflow skills run a structured, multi-step process without loading an agent pe
 
 | Example skill | Purpose |
 | --- | --- |
-| `bmad-product-brief` | Create a product brief — guided discovery when your concept is clear |
+| `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-create-prd` | Create a Product Requirements Document |
+| `bmad-prd` | Create, update, or validate a Product Requirements Document |
 | `bmad-create-architecture` | Design system architecture |
 | `bmad-create-epics-and-stories` | Create epics and stories |
 | `bmad-dev-story` | Implement a story |
@@ -124,7 +124,7 @@ The core module includes 11 built-in tools — reviews, compression, brainstormi
 
 ## Naming Convention
 
-All skills use the `bmad-` prefix followed by a descriptive name (e.g., `bmad-agent-dev`, `bmad-create-prd`, `bmad-help`). See [Modules](./modules.md) for available modules.
+All skills use the `bmad-` prefix followed by a descriptive name (e.g., `bmad-agent-dev`, `bmad-prd`, `bmad-help`). See [Modules](./modules.md) for available modules.
 
 ## Troubleshooting
 

docs/reference/workflow-map.md

@@ -5,13 +5,22 @@ sidebar:
   order: 1
 ---
 
-The BMad Method (BMM) is a module in the BMad Ecosystem, targeted at following the best practices of context engineering and planning. AI agents work best with clear, structured context. The BMM system builds that context progressively across 4 distinct phases - each phase, and multiple workflows optionally within each phase, produce documents that inform the next, so agents always know what to build and why.
+The BMad Method (BMM) is a module in the BMad Ecosystem, targeted at following the best practices of context engineering
+and planning. AI agents work best with clear, structured context. The BMM system builds that context progressively
+across 4 distinct phases - each phase, and multiple workflows optionally within each phase, produce documents that
+inform the next, so agents always know what to build and why.
 
-The rationale and concepts come from agile methodologies that have been used across the industry with great success as a mental framework.
+The rationale and concepts come from agile methodologies that have been used across the industry with great success as a
+mental framework.
 
-If at any time you are unsure what to do, the `bmad-help` skill will help you stay on track or know what to do next. You can always refer to this for reference also - but `bmad-help` is fully interactive and much quicker if you have already installed the BMad Method. Additionally, if you are using different modules that have extended the BMad Method or added other complementary non-extension modules - `bmad-help` evolves to know all that is available to give you the best in-the-moment advice.
+If at any time you are unsure what to do, the `bmad-help` skill will help you stay on track or know what to do next. You
+can always refer to this for reference also - but `bmad-help` is fully interactive and much quicker if you have already
+installed the BMad Method. Additionally, if you are using different modules that have extended the BMad Method or added
+other complementary non-extension modules - `bmad-help` evolves to know all that is available to give you the best
+in-the-moment advice.
 
-Final important note: Every workflow below can be run directly with your tool of choice via skill or by loading an agent first and using the entry from the agents menu.
+Final important note: Every workflow below can be run directly with your tool of choice via skill or by loading an agent
+first and using the entry from the agents menu.
 
 <iframe src="/workflow-map-diagram.html" title="BMad Method Workflow Map Diagram" width="100%" height="100%" style="border-radius: 8px; border: 1px solid #334155; min-height: 900px;"></iframe>
 
@@ -21,30 +30,43 @@ Final important note: Every workflow below can be run directly with your tool of
 
 ## Phase 1: Analysis (Optional)
 
-Explore the problem space and validate ideas before committing to planning. [**Learn what each tool does and when to use it**](../explanation/analysis-phase.md).
+Explore the problem space and validate ideas before committing to planning. [**Learn what each tool does and when to use
+it**](../explanation/analysis-phase.md).
 
-| Workflow                        | Purpose                                                                    | Produces                  |
+| Workflow                                                                  | Purpose                                                                    | Produces                  |
-| ------------------------------- | -------------------------------------------------------------------------- | ------------------------- |
+|---------------------------------------------------------------------------|----------------------------------------------------------------------------|---------------------------|
-| `bmad-brainstorming`            | Brainstorm Project Ideas with guided facilitation of a brainstorming coach | `brainstorming-report.md` |
+| `bmad-brainstorming`                                                      | Brainstorm Project Ideas with guided facilitation of a brainstorming coach | `brainstorming-report.md` |
-| `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validate market, technical, or domain assumptions | Research findings |
+| `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validate market, technical, or domain assumptions                          | Research findings         |
-| `bmad-product-brief`            | Capture strategic vision — best when your concept is clear                 | `product-brief.md`        |
+| `bmad-product-brief`                                                      | Capture strategic vision — best when your concept is clear                 | `product-brief.md`        |
-| `bmad-prfaq`                    | Working Backwards — stress-test and forge your product concept             | `prfaq-{project}.md`      |
+| `bmad-prfaq`                                                              | Working Backwards — stress-test and forge your product concept             | `prfaq-{project}.md`      |
 
 ## Phase 2: Planning
 
 Define what to build and for whom.
 
-| Workflow                    | Purpose                                  | Produces     |
+| Workflow                | Purpose                                                                             | Produces                                          |
-| --------------------------- | ---------------------------------------- | ------------ |
+|-------------------------|-------------------------------------------------------------------------------------|---------------------------------------------------|
-| `bmad-create-prd`    | Define requirements (FRs/NFRs)           | `PRD.md`     |
+| `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-create-ux-design`  | Design user experience (when UX matters) | `ux-spec.md` |
+| `bmad-create-ux-design` | Design user experience (when UX matters)                                            | `ux-spec.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`
+- **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
+:::
+
+:::tip[Upstream: `bmad-product-brief`]
+`bmad-product-brief` (Phase 1) produces a `product-brief.md` that `bmad-prd` can source-extract during Discovery, reducing re-explanation and keeping the two documents aligned. Neither skill requires the other — start with `bmad-prd` directly if you already know what you're building.
+:::
 
 ## Phase 3: Solutioning
 
 Decide how to build it and break work into stories.
 
-| Workflow                                  | Purpose                                    | Produces                    |
+| Workflow                              | Purpose                                    | Produces                    |
-| ----------------------------------------- | ------------------------------------------ | --------------------------- |
+|---------------------------------------|--------------------------------------------|-----------------------------|
 | `bmad-create-architecture`            | Make technical decisions explicit          | `architecture.md` with ADRs |
 | `bmad-create-epics-and-stories`       | Break requirements into implementable work | Epic files with stories     |
 | `bmad-check-implementation-readiness` | Gate check before implementation           | PASS/CONCERNS/FAIL decision |
@@ -53,32 +75,38 @@ Decide how to build it and break work into stories.
 
 Build it, one story at a time. Coming soon, full phase 4 automation!
 
-| Workflow                   | Purpose                                                                  | Produces                         |
+| Workflow               | Purpose                                                                       | Produces                                             |
-| -------------------------- | ------------------------------------------------------------------------ | -------------------------------- |
+|------------------------|-------------------------------------------------------------------------------|------------------------------------------------------|
-| `bmad-sprint-planning` | Initialize tracking (once per project to sequence the dev cycle)         | `sprint-status.yaml`          |
+| `bmad-sprint-planning` | Initialize tracking (once per project to sequence the dev cycle)              | `sprint-status.yaml`                                 |
-| `bmad-create-story`    | Prepare next story for implementation                                    | `story-[slug].md`             |
+| `bmad-create-story`    | Prepare next story for implementation                                         | `story-[slug].md`                                    |
-| `bmad-dev-story`       | Implement the story                                                      | Working code + tests          |
+| `bmad-dev-story`       | Implement the story                                                           | Working code + tests                                 |
-| `bmad-code-review`     | Validate implementation quality                                          | Approved or changes requested |
+| `bmad-code-review`     | Validate implementation quality                                               | Approved or changes requested                        |
-| `bmad-correct-course`  | Handle significant mid-sprint changes                                    | Updated plan or re-routing    |
+| `bmad-correct-course`  | Handle significant mid-sprint changes                                         | Updated plan or re-routing                           |
-| `bmad-sprint-status`   | Track sprint progress and story status                                   | Sprint status update          |
+| `bmad-sprint-status`   | Track sprint progress and story status                                        | Sprint status update                                 |
-| `bmad-retrospective`   | Review after epic completion                                             | Lessons learned               |
+| `bmad-retrospective`   | Review after epic completion                                                  | Lessons learned                                      |
+| `bmad-investigate`     | Forensic case investigation with evidence-graded findings, calibrated to the input | `{slug}-investigation.md` |
 
 ## Quick Flow (Parallel Track)
 
 Skip phases 1-3 for small, well-understood work.
 
-| Workflow           | Purpose                                                                     | Produces               |
+| Workflow         | Purpose                                                                   | Produces           |
-| ------------------ | --------------------------------------------------------------------------- | ---------------------- |
+|------------------|---------------------------------------------------------------------------|--------------------|
-| `bmad-quick-dev`   | Unified quick flow — clarify intent, plan, implement, review, and present   | `spec-*.md` + code  |
+| `bmad-quick-dev` | Unified quick flow — clarify intent, plan, implement, review, and present | `spec-*.md` + code |
 
 ## Context Management
 
-Each document becomes context for the next phase. The PRD tells the architect what constraints matter. The architecture tells the dev agent which patterns to follow. Story files give focused, complete context for implementation. Without this structure, agents make inconsistent decisions.
+Each document becomes context for the next phase. The PRD tells the architect what constraints matter. The architecture
+tells the dev agent which patterns to follow. Story files give focused, complete context for implementation. Without
+this structure, agents make inconsistent decisions.
 
 ### Project Context
 
 :::tip[Recommended]
-Create `project-context.md` to ensure AI agents follow your project's rules and preferences. This file works like a constitution for your project — it guides implementation decisions across all workflows. This optional file can be generated at the end of Architecture Creation, or in an existing project it can be generated also to capture whats important to keep aligned with current conventions.
+Create `project-context.md` to ensure AI agents follow your project's rules and preferences. This file works like a
+constitution for your project — it guides implementation decisions across all workflows. This optional file can be
+generated at the end of Architecture Creation, or in an existing project it can be generated also to capture whats
+important to keep aligned with current conventions.
 :::
 
 **How to create it:**

docs/tutorials/getting-started.md

@@ -114,7 +114,7 @@ BMad-Help will detect what you've completed and recommend exactly what to do nex
 :::
 
 :::note[How to Load Agents and Run Workflows]
-Each workflow has a **skill** you invoke by name in your IDE (e.g., `bmad-create-prd`). Your AI tool will recognize the `bmad-*` name and run it — you don't need to load agents separately. You can also invoke an agent skill directly for general conversation (e.g., `bmad-agent-pm` for the PM agent).
+Each workflow has a **skill** you invoke by name in your IDE (e.g., `bmad-prd`). Your AI tool will recognize the `bmad-*` name and run it — you don't need to load agents separately. You can also invoke an agent skill directly for general conversation (e.g., `bmad-agent-pm` for the PM agent).
 :::
 
 :::caution[Fresh Chats]
@@ -142,9 +142,14 @@ All workflows in this phase are optional. [**Not sure which to use?**](../explan
 ### Phase 2: Planning (Required)
 
 **For BMad Method and Enterprise tracks:**
-1. Invoke the **PM agent** (`bmad-agent-pm`) in a new chat
+1. Run `bmad-prd` in a new chat — state your intent (Create / Update / Validate) or let the skill ask
-2. Run the `bmad-create-prd` workflow (`bmad-create-prd`)
+2. Output: `prd.md`, `addendum.md`, `decision-log.md`
-3. Output: `PRD.md`
+
+:::note[`bmad-prd` intents]
+- **Create** — coached discovery from scratch; the skill names the workspace folder and guides you to a PRD you're proud of
+- **Update** — point it at an existing PRD and a change signal; it surfaces conflicts before applying changes
+- **Validate** — critique a finished PRD against a checklist and produce an HTML findings report
+:::
 
 **For Quick Flow track:**
 - Run `bmad-quick-dev` — it handles planning and implementation in a single workflow, skip to implementation
@@ -225,7 +230,7 @@ your-project/
 | Workflow                              | Command                                    | Agent     | Purpose                                         |
 | ------------------------------------- | ------------------------------------------ | --------- | ----------------------------------------------- |
 | **`bmad-help`** ⭐                    | `bmad-help`                               | Any       | **Your intelligent guide — ask anything!**      |
-| `bmad-create-prd`                | `bmad-create-prd`                     | PM        | Create Product Requirements Document            |
+| `bmad-prd`                       | `bmad-prd`                            | Any       | Create, update, or validate a PRD               |
 | `bmad-create-architecture`            | `bmad-create-architecture`            | Architect | Create architecture document                     |
 | `bmad-generate-project-context`       | `bmad-generate-project-context`           | Analyst   | Create project context file                     |
 | `bmad-create-epics-and-stories`       | `bmad-create-epics-and-stories`       | PM        | Break down PRD into epics            |

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

@@ -0,0 +1,237 @@
+{
+  "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

@@ -0,0 +1,46 @@
+# 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

@@ -0,0 +1,40 @@
+# 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

@@ -0,0 +1,56 @@
+---
+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

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,116 @@
+# 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

@@ -0,0 +1,41 @@
+# 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

@@ -0,0 +1,57 @@
+---
+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

@@ -0,0 +1,29 @@
+# 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

@@ -0,0 +1,90 @@
+# 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

@@ -0,0 +1,101 @@
+# 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

@@ -0,0 +1,18 @@
+[
+  { "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

@@ -2428,9 +2428,9 @@
       "license": "MIT"
     },
     "node_modules/@jest/reporters/node_modules/brace-expansion": {
-      "version": "2.0.2",
+      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.0.tgz",
-      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -4034,9 +4034,9 @@
       }
     },
     "node_modules/anymatch/node_modules/picomatch": {
-      "version": "2.3.1",
+      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -4101,15 +4101,15 @@
       }
     },
     "node_modules/astro": {
-      "version": "5.17.1",
+      "version": "5.18.1",
-      "resolved": "https://registry.npmjs.org/astro/-/astro-5.17.1.tgz",
+      "resolved": "https://registry.npmjs.org/astro/-/astro-5.18.1.tgz",
-      "integrity": "sha512-oD3tlxTaVWGq/Wfbqk6gxzVRz98xa/rYlpe+gU2jXJMSD01k6sEDL01ZlT8mVSYB/rMgnvIOfiQQ3BbLdN237A==",
+      "integrity": "sha512-m4VWilWZ+Xt6NPoYzC4CgGZim/zQUO7WFL0RHCH0AiEavF1153iC3+me2atDvXpf/yX4PyGUeD8wZLq1cirT3g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@astrojs/compiler": "^2.13.0",
-        "@astrojs/internal-helpers": "0.7.5",
+        "@astrojs/internal-helpers": "0.7.6",
-        "@astrojs/markdown-remark": "6.3.10",
+        "@astrojs/markdown-remark": "6.3.11",
         "@astrojs/telemetry": "3.3.0",
         "@capsizecss/unpack": "^4.0.0",
         "@oslojs/encoding": "^1.1.0",
@@ -4130,7 +4130,7 @@
         "dlv": "^1.1.3",
         "dset": "^3.1.4",
         "es-module-lexer": "^1.7.0",
-        "esbuild": "^0.25.0",
+        "esbuild": "^0.27.3",
         "estree-walker": "^3.0.3",
         "flattie": "^1.1.1",
         "fontace": "~0.4.0",
@@ -4200,6 +4200,485 @@
         "astro": "^4.0.0-beta || ^5.0.0-beta || ^3.3.0 || ^6.0.0-beta"
       }
     },
+    "node_modules/astro/node_modules/@astrojs/internal-helpers": {
+      "version": "0.7.6",
+      "resolved": "https://registry.npmjs.org/@astrojs/internal-helpers/-/internal-helpers-0.7.6.tgz",
+      "integrity": "sha512-GOle7smBWKfMSP8osUIGOlB5kaHdQLV3foCsf+5Q9Wsuu+C6Fs3Ez/ttXmhjZ1HkSgsogcM1RXSjjOVieHq16Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/astro/node_modules/@astrojs/markdown-remark": {
+      "version": "6.3.11",
+      "resolved": "https://registry.npmjs.org/@astrojs/markdown-remark/-/markdown-remark-6.3.11.tgz",
+      "integrity": "sha512-hcaxX/5aC6lQgHeGh1i+aauvSwIT6cfyFjKWvExYSxUhZZBBdvCliOtu06gbQyhbe0pGJNoNmqNlQZ5zYUuIyQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@astrojs/internal-helpers": "0.7.6",
+        "@astrojs/prism": "3.3.0",
+        "github-slugger": "^2.0.0",
+        "hast-util-from-html": "^2.0.3",
+        "hast-util-to-text": "^4.0.2",
+        "import-meta-resolve": "^4.2.0",
+        "js-yaml": "^4.1.1",
+        "mdast-util-definitions": "^6.0.0",
+        "rehype-raw": "^7.0.0",
+        "rehype-stringify": "^10.0.1",
+        "remark-gfm": "^4.0.1",
+        "remark-parse": "^11.0.0",
+        "remark-rehype": "^11.1.2",
+        "remark-smartypants": "^3.0.2",
+        "shiki": "^3.21.0",
+        "smol-toml": "^1.6.0",
+        "unified": "^11.0.5",
+        "unist-util-remove-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "unist-util-visit-parents": "^6.0.2",
+        "vfile": "^6.0.3"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/aix-ppc64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.7.tgz",
+      "integrity": "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/android-arm": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.7.tgz",
+      "integrity": "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/android-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.7.tgz",
+      "integrity": "sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/android-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.7.tgz",
+      "integrity": "sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/darwin-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.7.tgz",
+      "integrity": "sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/darwin-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.7.tgz",
+      "integrity": "sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/freebsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.7.tgz",
+      "integrity": "sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/linux-arm": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.7.tgz",
+      "integrity": "sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/linux-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.7.tgz",
+      "integrity": "sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/linux-ia32": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.7.tgz",
+      "integrity": "sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/linux-loong64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.7.tgz",
+      "integrity": "sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/linux-mips64el": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.7.tgz",
+      "integrity": "sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/linux-ppc64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.7.tgz",
+      "integrity": "sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/linux-riscv64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.7.tgz",
+      "integrity": "sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/linux-s390x": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.7.tgz",
+      "integrity": "sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/linux-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.7.tgz",
+      "integrity": "sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/netbsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.7.tgz",
+      "integrity": "sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/openbsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.7.tgz",
+      "integrity": "sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.7.tgz",
+      "integrity": "sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/sunos-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.7.tgz",
+      "integrity": "sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/win32-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.7.tgz",
+      "integrity": "sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/win32-ia32": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.7.tgz",
+      "integrity": "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/astro/node_modules/@esbuild/win32-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.7.tgz",
+      "integrity": "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/astro/node_modules/@img/sharp-darwin-arm64": {
       "version": "0.34.5",
       "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.34.5.tgz",
@@ -4662,6 +5141,48 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/astro/node_modules/esbuild": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.7.tgz",
+      "integrity": "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.27.7",
+        "@esbuild/android-arm": "0.27.7",
+        "@esbuild/android-arm64": "0.27.7",
+        "@esbuild/android-x64": "0.27.7",
+        "@esbuild/darwin-arm64": "0.27.7",
+        "@esbuild/darwin-x64": "0.27.7",
+        "@esbuild/freebsd-arm64": "0.27.7",
+        "@esbuild/freebsd-x64": "0.27.7",
+        "@esbuild/linux-arm": "0.27.7",
+        "@esbuild/linux-arm64": "0.27.7",
+        "@esbuild/linux-ia32": "0.27.7",
+        "@esbuild/linux-loong64": "0.27.7",
+        "@esbuild/linux-mips64el": "0.27.7",
+        "@esbuild/linux-ppc64": "0.27.7",
+        "@esbuild/linux-riscv64": "0.27.7",
+        "@esbuild/linux-s390x": "0.27.7",
+        "@esbuild/linux-x64": "0.27.7",
+        "@esbuild/netbsd-arm64": "0.27.7",
+        "@esbuild/netbsd-x64": "0.27.7",
+        "@esbuild/openbsd-arm64": "0.27.7",
+        "@esbuild/openbsd-x64": "0.27.7",
+        "@esbuild/openharmony-arm64": "0.27.7",
+        "@esbuild/sunos-x64": "0.27.7",
+        "@esbuild/win32-arm64": "0.27.7",
+        "@esbuild/win32-ia32": "0.27.7",
+        "@esbuild/win32-x64": "0.27.7"
+      }
+    },
     "node_modules/astro/node_modules/sharp": {
       "version": "0.34.5",
       "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.34.5.tgz",
@@ -4994,9 +5515,9 @@
       "license": "ISC"
     },
     "node_modules/brace-expansion": {
-      "version": "1.1.12",
+      "version": "1.1.14",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.14.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "integrity": "sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -5548,9 +6069,9 @@
       }
     },
     "node_modules/cookie-es": {
-      "version": "1.2.2",
+      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/cookie-es/-/cookie-es-1.2.2.tgz",
+      "resolved": "https://registry.npmjs.org/cookie-es/-/cookie-es-1.2.3.tgz",
-      "integrity": "sha512-+W7VmiVINB+ywl1HGXJXmrqkOhpKrIiVZV6tQuV54ZyQC7MMuBt81Vc336GMLoHBq5hV/F9eXgt5Mnx0Rha5Fg==",
+      "integrity": "sha512-lXVyvUvrNXblMqzIRrxHb57UUVmqsSWlxqt3XIjCkUP0wDAf6uicO6KMbEgYrMNtEvWgWHwe42CKxPu9MYAnWw==",
       "dev": true,
       "license": "MIT"
     },
@@ -5770,9 +6291,9 @@
       }
     },
     "node_modules/defu": {
-      "version": "6.1.4",
+      "version": "6.1.7",
-      "resolved": "https://registry.npmjs.org/defu/-/defu-6.1.4.tgz",
+      "resolved": "https://registry.npmjs.org/defu/-/defu-6.1.7.tgz",
-      "integrity": "sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg==",
+      "integrity": "sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==",
       "dev": true,
       "license": "MIT"
     },
@@ -6920,9 +7441,9 @@
       }
     },
     "node_modules/flatted": {
-      "version": "3.4.1",
+      "version": "3.4.2",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.1.tgz",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",
-      "integrity": "sha512-IxfVbRFVlV8V/yRaGzk0UVIcsKKHMSfYw66T/u4nTwlWteQePsxe//LjudR1AMX4tZW3WFCh3Zqa/sjlqpbURQ==",
+      "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==",
       "dev": true,
       "license": "ISC"
     },
@@ -7129,9 +7650,9 @@
       }
     },
     "node_modules/glob/node_modules/brace-expansion": {
-      "version": "5.0.4",
+      "version": "5.0.5",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
-      "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==",
+      "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
       "license": "MIT",
       "dependencies": {
         "balanced-match": "^4.0.2"
@@ -7217,15 +7738,15 @@
       "license": "ISC"
     },
     "node_modules/h3": {
-      "version": "1.15.8",
+      "version": "1.15.11",
-      "resolved": "https://registry.npmjs.org/h3/-/h3-1.15.8.tgz",
+      "resolved": "https://registry.npmjs.org/h3/-/h3-1.15.11.tgz",
-      "integrity": "sha512-iOH6Vl8mGd9nNfu9C0IZ+GuOAfJHcyf3VriQxWaSWIB76Fg4BnFuk4cxBxjmQSSxJS664+pgjP6e7VBnUzFfcg==",
+      "integrity": "sha512-L3THSe2MPeBwgIZVSH5zLdBBU90TOxarvhK9d04IDY2AmVS8j2Jz2LIWtwsGOU3lu2I5jCN7FNvVfY2+XyF+mg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "cookie-es": "^1.2.2",
+        "cookie-es": "^1.2.3",
         "crossws": "^0.3.5",
-        "defu": "^6.1.4",
+        "defu": "^6.1.6",
         "destr": "^2.0.5",
         "iron-webcrypto": "^1.2.1",
         "node-mock-http": "^1.0.4",
@@ -8363,9 +8884,9 @@
       }
     },
     "node_modules/jest-config/node_modules/brace-expansion": {
-      "version": "2.0.2",
+      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.0.tgz",
-      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -8765,9 +9286,9 @@
       }
     },
     "node_modules/jest-runtime/node_modules/brace-expansion": {
-      "version": "2.0.2",
+      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.0.tgz",
-      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -10709,9 +11230,9 @@
       }
     },
     "node_modules/micromatch/node_modules/picomatch": {
-      "version": "2.3.1",
+      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -11403,9 +11924,9 @@
       "license": "ISC"
     },
     "node_modules/picomatch": {
-      "version": "4.0.3",
+      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
-      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -11518,9 +12039,9 @@
       }
     },
     "node_modules/postcss": {
-      "version": "8.5.6",
+      "version": "8.5.13",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.13.tgz",
-      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "integrity": "sha512-qif0+jGGZoLWdHey3UFHHWP0H7Gbmsk8T5VEqyYFbWqPr1XqvLGBbk/sl8V5exGmcYJklJOhOQq1pV9IcsiFag==",
       "dev": true,
       "funding": [
         {
@@ -12602,9 +13123,9 @@
       }
     },
     "node_modules/smol-toml": {
-      "version": "1.6.0",
+      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.6.0.tgz",
+      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.6.1.tgz",
-      "integrity": "sha512-4zemZi0HvTnYwLfrpk/CF9LOd9Lt87kAt50GnqhMpyF9U3poDAP2+iukq2bZsO/ufegbYehBkqINbsWxj4l4cw==",
+      "integrity": "sha512-dWUG8F5sIIARXih1DTaQAX4SsiTXhInKf1buxdY9DIg4ZYPZK5nGM1VRIYmEbDbsHt7USo99xSLFu5Q1IqTmsg==",
       "dev": true,
       "license": "BSD-3-Clause",
       "engines": {
@@ -13093,9 +13614,9 @@
       }
     },
     "node_modules/test-exclude/node_modules/brace-expansion": {
-      "version": "2.0.2",
+      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.0.tgz",
-      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -13831,9 +14352,9 @@
       }
     },
     "node_modules/vite": {
-      "version": "6.4.1",
+      "version": "6.4.2",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.2.tgz",
-      "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
+      "integrity": "sha512-2N/55r4JDJ4gdrCvGgINMy+HH3iRpNIz8K6SFwVsA+JbQScLiC+clmAxBgwiSPgcG9U15QmvqCGWzMbqda5zGQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -14129,9 +14650,9 @@
       "license": "ISC"
     },
     "node_modules/yaml": {
-      "version": "2.8.2",
+      "version": "2.8.4",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.2.tgz",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.4.tgz",
-      "integrity": "sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==",
+      "integrity": "sha512-ml/JPOj9fOQK8RNnWojA67GbZ0ApXAUlN2UQclwv2eVgTgn7O9gg9o7paZWKMp4g0H3nTLtS9LVzhkpOFIKzog==",
       "license": "ISC",
       "bin": {
         "yaml": "bin.mjs"

src/bmm-skills/1-analysis/bmad-prfaq/bmad-manifest.json

@@ -7,8 +7,8 @@
       "description": "Produces battle-tested PRFAQ document and optional LLM distillate for PRD input.",
       "supports-headless": true,
       "phase-name": "1-analysis",
-      "after": ["brainstorming", "perform-research"],
+      "preceded-by": ["brainstorming", "perform-research"],
-      "before": ["create-prd"],
+      "followed-by": ["create-prd"],
       "is-required": false,
       "output-location": "{planning_artifacts}"
     }

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

@@ -1,117 +1,81 @@
 ---
 name: bmad-product-brief
-description: Create or update product briefs through guided or autonomous discovery. Use when the user requests to create or update a Product Brief.
+description: Create, update, or validate a product brief. Use when the user wants help producing, editing, or validating a brief.
 ---
 
-# Create Product Brief
+# Overview
 
-## Overview
+You are an expert product analyst coach and facilitator. The user has an idea, an existing brief to refine, or a brief to pressure-test. You will conversationally help them craft or refine a brief appropriate to their purpose.
 
-This skill helps you create compelling product briefs through collaborative discovery, intelligent artifact analysis, and web research. Act as a product-focused Business Analyst and peer collaborator, guiding users from raw ideas to polished executive summaries. Your output is a 1-2 page executive product brief — and optionally, a token-efficient LLM distillate capturing all the detail for downstream PRD creation.
+You are not in a hurry. You will not do the thinking for them. Coach, do not quiz. Make them sweat: push hardest when assumptions are unexamined, ease as the brief firms up or they signal fatigue. Get out what is stuck in their head and what they may have forgotten. Push back when an answer is thin.
 
-The user is the domain expert. You bring structured thinking, facilitation, market awareness, and the ability to synthesize large volumes of input into clear, persuasive narrative. Work together as equals.
+Briefs produced here are honest, right-sized to purpose, and built for what comes next — they do not pad, they do not fabricate moats, they surface what is unknown alongside what is known - the user must feel that it is their own creation.
 
-**Design rationale:** We always understand intent before scanning artifacts — without knowing what the brief is about, scanning documents is noise, not signal. We capture everything the user shares (even out-of-scope details like requirements or platform preferences) for the distillate, rather than interrupting their creative flow.
+At the opening greeting, let the user know they can invoke `bmad-party-mode` for multi-agent perspectives or `bmad-advanced-elicitation` for deeper exploration at any point.
-
-## Conventions
-
-- Bare paths (e.g. `prompts/finalize.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.
-
-## Activation Mode Detection
-
-Check activation context immediately:
-
-1. **Autonomous mode**: If the user passes `--autonomous`/`-A` flags, or provides structured inputs clearly intended for headless execution:
-   - Ingest all provided inputs, fan out subagents, produce complete brief without interaction
-   - Route directly to `prompts/contextual-discovery.md` with `{mode}=autonomous`
-
-2. **Yolo mode**: If the user passes `--yolo` or says "just draft it" / "draft the whole thing":
-   - Ingest everything, draft complete brief upfront, then walk user through refinement
-   - Route to Stage 1 below with `{mode}=yolo`
-
-3. **Guided mode** (default): Conversational discovery with soft gates
-   - Route to Stage 1 below with `{mode}=guided`
 
 ## On Activation
 
-### Step 1: Resolve the Workflow Block
+1. Resolve customization: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`. On failure, surface the diagnostic and halt.
+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. Note `{workflow.external_sources}` as a registry of external systems available for consultation when the conversation surfaces a relevant need — knowledge bases, internal MCP tools, reference systems. Do not query preemptively; consult each only when its directive matches the moment. If a named tool is unavailable at runtime, fall back to standard behavior and note the gap when relevant.
+5. Load `{project-root}/_bmad/bmm/config.yaml` (and `config.user.yaml` if present). Resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{planning_artifacts}`, `{project_name}`, `{date}`.
+6. Greet `{user_name}` in `{communication_language}`. Detect intent (create / update / validate). If interactive and intent is unclear, ask; for headless behavior see `## Headless Mode`.
+7. Execute each entry in `{workflow.activation_steps_append}` in order.
 
-Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`
+## Intent Operating Modes
 
-**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:
+**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.output_dir}/{workflow.output_folder_name}/` 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.
 
-1. `{skill-root}/customize.toml` — defaults
+**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.
-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.
+**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.
 
-### Step 2: Execute Prepend Steps
+## Headless Mode
 
-Execute each entry in `{workflow.activation_steps_prepend}` in order before proceeding.
+When invoked headless, do not ask. Complete the intent using what is provided, what exists in `{doc_workspace}`, or what you can discover yourself. If intent remains ambiguous after inference, halt with a `blocked` JSON status and a `reason` field — do not prompt. End with a JSON response listing status, intent, and artifact paths. The `intent` field must match the detected intent: `"create"`, `"update"`, or `"validate"`. Examples:
 
-### Step 3: Load Persistent Facts
+```json
+{
+  "status": "complete",
+  "intent": "create",
+  "brief": "{doc_workspace}/brief.md",
+  "addendum": "{doc_workspace}/addendum.md",
+  "decision_log": "{doc_workspace}/decision-log.md",
+  "open_questions": [],
+  "external_handoffs": [
+    {"directive": "Confluence upload", "tool": "corp:confluence_upload", "url": "https://confluence.corp/PROD/123", "status": "ok"}
+  ]
+}
+```
 
-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.
+```json
+{
+  "status": "complete",
+  "intent": "validate",
+  "offer_to_update": true
+}
+```
 
-### Step 4: Load Config
+Omit keys for artifacts that were not produced.
 
-Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+## Discovery
-- 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
+Conversationally surface what the user brings, why this brief exists, and the domain — echo back how each shapes your approach. Open with space for the full picture: invite a brain dump and ask up front for any source material they already have (memo, deck, transcript, prior brief, slack thread). Read what exists first; ask only what is missing. After the dump, a simple "anything else?" often surfaces what they almost forgot. Drill into specifics only after the broad shape is on the table; premature granular questions interrupt the dump and miss the room. Get a read on stakes early (passion project, internal pitch, investor input, public launch), and let that calibrate how hard you push. Suggest research (web, competitive, market) only when the stakes warrant it.
 
-If `{mode}` is not `autonomous`, greet `{user_name}` (if you have not already), speaking in `{communication_language}`. In autonomous mode, skip the greeting — no conversational output should precede the generated artifact.
+## Constraints
 
-### Step 6: Execute Append Steps
+- **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.
+- **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.
+- **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.
 
-Execute each entry in `{workflow.activation_steps_append}` in order.
+## Finalize
 
-Activation is complete. Begin the workflow at Stage 1 below.
+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.
-
+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.
-## Stage 1: Understand Intent
+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.
-**Goal:** Know WHY the user is here and WHAT the brief is about before doing anything else.
+5. Run `{workflow.on_complete}` if non-empty. Treat a string scalar as a single instruction and an array as a sequence of instructions executed in order.
-
-**Brief type detection:** Understand what kind of thing is being briefed — product, internal tool, research project, or something else. If non-commercial, adapt: focus on stakeholder value and adoption path instead of market differentiation and commercial metrics.
-
-**Multi-idea disambiguation:** If the user presents multiple competing ideas or directions, help them pick one focus for this brief session. Note that others can be briefed separately.
-
-**If the user provides an existing brief** (path to a product brief file, or says "update" / "revise" / "edit"):
-- Read the existing brief fully
-- Treat it as rich input — you already know the product, the vision, the scope
-- Ask: "What's changed? What do you want to update or improve?"
-- The rest of the workflow proceeds normally — contextual discovery may pull in new research, elicitation focuses on gaps or changes, and draft-and-review produces an updated version
-
-**If the user already provided context** when launching the skill (description, docs, brain dump):
-- Acknowledge what you received — but **DO NOT read document files yet**. Note their paths for Stage 2's subagents to scan contextually. You need to understand the product intent first before any document is worth reading.
-- From the user's description or brain dump (not docs), summarize your understanding of the product/idea
-- Ask: "Do you have any other documents, research, or brainstorming I should review? Anything else to add before I dig in?"
-
-**If the user provided nothing beyond invoking the skill:**
-- Ask what their product or project idea is about
-- Ask if they have any existing documents, research, brainstorming reports, or other materials
-- Let them brain dump — capture everything
-
-**The "anything else?" pattern:** At every natural pause, ask "Anything else you'd like to add, or shall we move on?" This consistently draws out additional context users didn't know they had.
-
-**Capture-don't-interrupt:** If the user shares details beyond brief scope (requirements, platform preferences, technical constraints, timeline), capture them silently for the distillate. Don't redirect or stop their flow.
-
-**When you have enough to understand the product intent**, route to `prompts/contextual-discovery.md` with the current mode.
-
-## Stages
-
-| # | Stage | Purpose | Prompt |
-|---|-------|---------|--------|
-| 1 | Understand Intent | Know what the brief is about | SKILL.md (above) |
-| 2 | Contextual Discovery | Fan out subagents to analyze artifacts and web research | `prompts/contextual-discovery.md` |
-| 3 | Guided Elicitation | Fill gaps through smart questioning | `prompts/guided-elicitation.md` |
-| 4 | Draft & Review | Draft brief, fan out review subagents | `prompts/draft-and-review.md` |
-| 5 | Finalize | Polish, output, offer distillate | `prompts/finalize.md` |

src/bmm-skills/1-analysis/bmad-product-brief/agents/artifact-analyzer.md

@@ -1,60 +0,0 @@
-# Artifact Analyzer
-
-You are a research analyst. Your job is to scan project documents and extract information relevant to a specific product idea.
-
-## Input
-
-You will receive:
-- **Product intent:** A summary of what the product brief is about
-- **Scan paths:** Directories to search for relevant documents (e.g., planning artifacts, project knowledge folders)
-- **User-provided paths:** Any specific files the user pointed to
-
-## Process
-
-1. **Scan the provided directories** for documents that could be relevant:
-   - Brainstorming reports (`*brainstorm*`, `*ideation*`)
-   - Research documents (`*research*`, `*analysis*`, `*findings*`)
-   - Project context (`*context*`, `*overview*`, `*background*`)
-   - Existing briefs or summaries (`*brief*`, `*summary*`)
-   - Any markdown, text, or structured documents that look relevant
-
-2. **For sharded documents** (a folder with `index.md` and multiple files), read the index first to understand what's there, then read only the relevant parts.
-
-3. **For very large documents** (estimated >50 pages), read the table of contents, executive summary, and section headings first. Read only sections directly relevant to the stated product intent. Note which sections were skimmed vs read fully.
-
-4. **Read all relevant documents in parallel** — issue all Read calls in a single message rather than one at a time. Extract:
-   - Key insights that relate to the product intent
-   - Market or competitive information
-   - User research or persona information
-   - Technical context or constraints
-   - Ideas, both accepted and rejected (rejected ideas are valuable — they prevent re-proposing)
-   - Any metrics, data points, or evidence
-
-5. **Ignore documents that aren't relevant** to the stated product intent. Don't waste tokens on unrelated content.
-
-## Output
-
-Return ONLY the following JSON object. No preamble, no commentary. Maximum 8 bullets per section.
-
-```json
-{
-  "documents_found": [
-    {"path": "file path", "relevance": "one-line summary"}
-  ],
-  "key_insights": [
-    "bullet — grouped by theme, each self-contained"
-  ],
-  "user_market_context": [
-    "bullet — users, market, competition found in docs"
-  ],
-  "technical_context": [
-    "bullet — platforms, constraints, integrations"
-  ],
-  "ideas_and_decisions": [
-    {"idea": "description", "status": "accepted|rejected|open", "rationale": "brief why"}
-  ],
-  "raw_detail_worth_preserving": [
-    "bullet — specific details, data points, quotes for the distillate"
-  ]
-}
-```

src/bmm-skills/1-analysis/bmad-product-brief/agents/opportunity-reviewer.md

@@ -1,44 +0,0 @@
-# Opportunity Reviewer
-
-You are a strategic advisor reviewing a product brief draft. Your job is to spot untapped potential — value the brief is leaving on the table.
-
-## Input
-
-You will receive the complete draft product brief.
-
-## Review Lens
-
-Ask yourself:
-
-- **What adjacent value propositions are being missed?** Are there related problems this solution naturally addresses?
-- **What market angles are underemphasized?** Is the positioning leaving opportunities unexplored?
-- **What partnerships or integrations could multiply impact?** Who would benefit from aligning with this product?
-- **What's the network effect or viral potential?** Is there a growth flywheel the brief doesn't describe?
-- **What's underemphasized?** Which strengths deserve more spotlight?
-- **What user segments are overlooked?** Could this serve audiences not yet mentioned?
-- **What's the bigger story?** If you zoom out, is there a more compelling narrative?
-- **What would an investor want to hear more about?** What would make someone lean forward?
-
-## Output
-
-Return ONLY the following JSON object. No preamble, no commentary. Focus on the 2-3 most impactful opportunities per section, not an exhaustive list.
-
-```json
-{
-  "untapped_value": [
-    {"opportunity": "adjacent problem or value prop", "rationale": "why it matters"}
-  ],
-  "positioning_opportunities": [
-    {"angle": "market angle or narrative", "impact": "how it strengthens the brief"}
-  ],
-  "growth_and_scale": [
-    "bullet — network effects, viral loops, expansion paths"
-  ],
-  "strategic_partnerships": [
-    {"partner_type": "who", "value": "why this alliance matters"}
-  ],
-  "underemphasized_strengths": [
-    {"strength": "what's underplayed", "suggestion": "how to elevate it"}
-  ]
-}
-```

src/bmm-skills/1-analysis/bmad-product-brief/agents/skeptic-reviewer.md

@@ -1,44 +0,0 @@
-# Skeptic Reviewer
-
-You are a critical analyst reviewing a product brief draft. Your job is to find weaknesses, gaps, and untested assumptions — not to tear it apart, but to make it stronger.
-
-## Input
-
-You will receive the complete draft product brief.
-
-## Review Lens
-
-Ask yourself:
-
-- **What's missing?** Are there sections that feel thin or glossed over?
-- **What assumptions are untested?** Where does the brief assert things without evidence?
-- **What could go wrong?** What risks aren't acknowledged?
-- **Where is it vague?** Which claims need more specificity?
-- **Does the problem statement hold up?** Is this a real, significant problem or a nice-to-have?
-- **Are the differentiators actually defensible?** Could a competitor replicate them easily?
-- **Do the success metrics make sense?** Are they measurable and meaningful?
-- **Is the MVP scope realistic?** Too ambitious? Too timid?
-
-## Output
-
-Return ONLY the following JSON object. No preamble, no commentary. Maximum 5 items per section. Prioritize — lead with the most impactful issues.
-
-```json
-{
-  "critical_gaps": [
-    {"issue": "what's missing", "impact": "why it matters", "suggestion": "how to fix"}
-  ],
-  "untested_assumptions": [
-    {"assumption": "what's asserted", "risk": "what could go wrong"}
-  ],
-  "unacknowledged_risks": [
-    {"risk": "potential failure mode", "severity": "high|medium|low"}
-  ],
-  "vague_areas": [
-    {"section": "where", "issue": "what's vague", "suggestion": "how to sharpen"}
-  ],
-  "suggested_improvements": [
-    "actionable suggestion"
-  ]
-}
-```

src/bmm-skills/1-analysis/bmad-product-brief/agents/web-researcher.md

@@ -1,49 +0,0 @@
-# Web Researcher
-
-You are a market research analyst. Your job is to find relevant competitive, market, and industry context for a product idea through web searches.
-
-## Input
-
-You will receive:
-- **Product intent:** A summary of what the product is about, the problem it solves, and the domain it operates in
-
-## Process
-
-1. **Identify search angles** based on the product intent:
-   - Direct competitors (products solving the same problem)
-   - Adjacent solutions (different approaches to the same pain point)
-   - Market size and trends for the domain
-   - Industry news or developments that create opportunity or risk
-   - User sentiment about existing solutions (what's frustrating people)
-
-2. **Execute 3-5 targeted web searches** — quality over quantity. Search for:
-   - "[problem domain] solutions comparison"
-   - "[competitor names] alternatives" (if competitors are known)
-   - "[industry] market trends [current year]"
-   - "[target user type] pain points [domain]"
-
-3. **Synthesize findings** — don't just list links. Extract the signal.
-
-## Output
-
-Return ONLY the following JSON object. No preamble, no commentary. Maximum 5 bullets per section.
-
-```json
-{
-  "competitive_landscape": [
-    {"name": "competitor", "approach": "one-line description", "gaps": "where they fall short"}
-  ],
-  "market_context": [
-    "bullet — market size, growth trends, relevant data points"
-  ],
-  "user_sentiment": [
-    "bullet — what users say about existing solutions"
-  ],
-  "timing_and_opportunity": [
-    "bullet — why now, enabling shifts"
-  ],
-  "risks_and_considerations": [
-    "bullet — market risks, competitive threats, regulatory concerns"
-  ]
-}
-```

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

@@ -0,0 +1,41 @@
+# Product Brief Template
+
+A flexible starting structure for the executive product brief. Adapt aggressively to the product, the purpose, and the domain. Drop sections that do not earn their place, add sections the product needs, reorder freely. The brief serves the product's story, not the template's shape.
+
+## Default Structure
+
+```markdown
+# Product Brief: {Product Name}
+
+## Executive Summary
+
+[2-3 paragraph narrative: what this is, what problem it solves, why it matters, why now. Compelling enough to stand alone — if someone reads only this section, they should understand the vision.]
+
+## The Problem
+
+[What pain exists, who feels it, how they cope today, the cost of the status quo. Be specific: real scenarios, real frustrations, real consequences.]
+
+## The Solution
+
+[What is being built, how it solves the problem. Focus on the experience and the outcome, not the implementation.]
+
+## What Makes This Different
+
+[Key differentiators. Why this approach over alternatives, what is the unfair advantage. Be honest. If the moat is execution speed, say so. Do not fabricate technical moats.]
+
+## Who This Serves
+
+[Primary users — vivid but brief. Who they are, what they need, what success looks like for them. Secondary users if relevant.]
+
+## Success Criteria
+
+[How we know this is working. Mix of user success signals and business objectives. Measurable.]
+
+## Scope
+
+[What is in for the first version. What is explicitly out. Keep this tight — boundary document, not a feature list.]
+
+## Vision
+
+[Where this goes if it succeeds. What it becomes in 2-3 years. Inspiring but grounded.]
+```

src/bmm-skills/1-analysis/bmad-product-brief/bmad-manifest.json

@@ -1,17 +0,0 @@
-{
-  "module-code": "bmm",
-  "replaces-skill": "bmad-create-product-brief",
-  "capabilities": [
-    {
-      "name": "create-brief",
-      "menu-code": "CB",
-      "description": "Produces executive product brief and optional LLM distillate for PRD input.",
-      "supports-headless": true,
-      "phase-name": "1-analysis",
-      "after": ["brainstorming", "perform-research"],
-      "before": ["create-prd"],
-      "is-required": true,
-      "output-location": "{planning_artifacts}"
-    }
-  ]
-}

src/bmm-skills/1-analysis/bmad-product-brief/customize.toml

@@ -1,47 +1,94 @@
 # DO NOT EDIT -- overwritten on every update.
 #
-# Workflow customization surface for bmad-product-brief. Mirrors the
+# Workflow customization surface for bmad-product-brief.
-# agent customization shape under the [workflow] namespace.
+#
+# Override files (not edited here):
+#   {project-root}/_bmad/custom/bmad-product-brief.toml         (team)
+#   {project-root}/_bmad/custom/bmad-product-brief.user.toml    (personal)
 
 [workflow]
 
 # --- Configurable below. Overrides merge per BMad structural rules: ---
-#   scalars: override wins • arrays (persistent_facts, activation_steps_*): append
+#   scalars: override wins • arrays: append
-#   arrays-of-tables with `code`/`id`: replace matching items, append new ones.
 
 # Steps to run before the standard activation (config load, greet).
-# Overrides append. Use for pre-flight loads, compliance checks, etc.
+# Use for pre-flight loads, compliance checks, etc.
-
 activation_steps_prepend = []
 
-# Steps to run after greet but before Stage 1 of the workflow.
+# Steps to run after greet but before the workflow begins.
-# Overrides append. Use for context-heavy setup that should happen
+# Use for context-heavy setup that should happen once the user has been acknowledged.
-# once the user has been acknowledged.
-
 activation_steps_append = []
 
 # Persistent facts the workflow keeps in mind for the whole run
 # (standards, compliance constraints, stylistic guardrails).
-# Distinct from the runtime memory sidecar — these are static context
+# Each entry is either a literal sentence, a skill prefixed with `skill:`, or a `file:`-prefixed path/glob
-# loaded on activation. Overrides append.
+# whose contents are loaded as facts.
-#
+# Default is empty. Common opt-ins (set in your team/user override TOML):
-# Each entry is either:
+#   "file:{project-root}/_bmad-output/planning-artifacts/project-context.md"  # bmad-generate-project-context output
-#   - a literal sentence, e.g. "All briefs must include a regulatory-risk section."
+#   "skill:acme-co:terms-and-conditions"                                      # a skill that contains some relevant info to the documents that may be generated
-#   - a file reference prefixed with `file:`, e.g. "file:{project-root}/docs/standards.md"
+#   "Elvis has left the building"                                             # generic agent instructions
-#     (glob patterns are supported; the file's contents are loaded and treated as facts).
+persistent_facts = []
 
-persistent_facts = [
+# Executed when the workflow completes (after the user has been told the
-  "file:{project-root}/**/project-context.md",
+# brief is ready). Accepts either a string scalar (single instruction)
+# or an array of instructions executed in order. Empty for none.
+on_complete = ""
+
+# Default brief structure. Treated as a starting point — the LLM adapts it
+# to the product, purpose, and domain. Override the path in team/user TOML
+# to enforce a different structure (e.g. regulated-industry, investor-deck).
+brief_template = "assets/brief-template.md"
+
+# Run folder location. The brief and optional addendum land inside `{output_dir}/{output_folder_name}/`.
+output_dir = "{planning_artifacts}/briefs"
+output_folder_name = "brief-{project_name}-{date}"
+
+# Document standards applied to human-consumed docs at finalize. Each entry is
+# a `skill:`, `file:`, or plain-text directive; the parent LLM applies the
+# findings before the user sees the draft. Encodes standards, not options.
+#
+# Examples:
+#   "skill:bmad-editorial-review-prose"
+#   "file:{project-root}/_bmad/style-guides/company-voice.md"
+#   "Convert all dates to ISO 8601 format."
+#
+# Suggested order (broader passes first, narrower last):
+#   1. Structural (cuts, reorganization, section sizing)
+#   2. Content/voice/conventions (org standards, tone, terminology, compliance)
+#   3. Prose mechanics (grammar, clarity, typos)
+#
+# Override the array in team/user TOML to add additional standards. Append-only:
+# base entries cannot be removed or replaced (resolver has no removal mechanism).
+doc_standards = [
+  "skill:bmad-editorial-review-structure",
+  "skill:bmad-editorial-review-prose",
 ]
 
-# Path to the brief structure template used in Stage 4 drafting.
+# External-source registry. Natural-language directives describing knowledge
-# Bare paths resolve from the skill root; use `{project-root}/...` to
+# bases, MCP tools, or internal systems the LLM may consult during the workflow
-# point at an org-owned template elsewhere in the repo. Override wins.
+# when a relevant need surfaces. The LLM does NOT query these preemptively —
+# it consults them on demand (during Discovery, validation, drafting, etc.).
+# Each entry names the tool, the conditions for using it, and any fields the
+# tool needs. If a named MCP tool is unavailable at runtime, the LLM falls
+# back to standard behavior and notes the gap. Empty by default.
+#
+# Examples (set in team/user override TOML):
+#   "When researching internal product context, consult corp:kb_search (database='product-docs') before web search."
+#   "For voice-of-customer signal during Discovery, query corp:feedback_search with project={project_name}."
+#   "When validating domain-compliance claims for a healthcare brief, cross-check against corp:hipaa_reference."
+external_sources = []
 
-brief_template = "resources/brief-template.md"
+# External-handoff routing. Natural-language directives the LLM applies at
-
+# Finalize to route outputs beyond local files (Confluence, Notion, Google
-# Scalar: executed when the workflow reaches its terminal stage, after
+# Drive, ticket systems, etc.). Each entry names the MCP tool, the destination,
-# the main output has been delivered. Override wins. Leave empty for
+# and the fields the tool needs. Handoffs run after the artifact is polished
-# no custom post-completion behavior.
+# and before the final user-facing message. URLs or IDs returned by the
-
+# destination are captured and surfaced to the user. If a named tool is
-on_complete = ""
+# unavailable at runtime, the handoff is skipped and flagged in the JSON
+# status; local files always exist regardless. Fires automatically — users
+# can opt out in their prompt for a specific run. Empty by default.
+#
+# Examples (set in team/user override TOML):
+#   "After finalize, upload brief.md and addendum.md to Confluence via corp:confluence_upload (space_key='PROD', parent_page='Product Briefs', label='brief', author={user_name})."
+#   "Post a ready-for-review ping to Slack via corp:slack_post (channel='#product', text='New brief: '+{confluence_url})."
+external_handoffs = []

src/bmm-skills/1-analysis/bmad-product-brief/prompts/contextual-discovery.md

@@ -1,58 +0,0 @@
-**Language:** Use `{communication_language}` for all output.
-**Output Language:** Use `{document_output_language}` for documents.
-**Output Location:** `{planning_artifacts}`
-**Paths:** Bare paths (e.g. `agents/foo.md`) resolve from the skill root.
-
-# Stage 2: Contextual Discovery
-
-**Goal:** Armed with the user's stated intent, intelligently gather and synthesize all available context — documents, project knowledge, and web research — so later stages work from a rich, relevant foundation.
-
-## Subagent Fan-Out
-
-Now that you know what the brief is about, fan out subagents in parallel to gather context. Each subagent receives the product intent summary so it knows what's relevant.
-
-**Launch in parallel:**
-
-1. **Artifact Analyzer** (`agents/artifact-analyzer.md`) — Scans `{planning_artifacts}` and `{project_knowledge}` for relevant documents. Also scans any specific paths the user provided. Returns structured synthesis of what it found.
-
-2. **Web Researcher** (`agents/web-researcher.md`) — Searches for competitive landscape, market context, trends, and relevant industry data. Returns structured findings scoped to the product domain.
-
-### Graceful Degradation
-
-If subagents are unavailable or fail:
-- Read only the most relevant 1-2 documents in the main context and summarize (don't full-read everything — limit context impact in degraded mode)
-- Do a few targeted web searches inline
-- Never block the workflow because a subagent feature is unavailable
-
-## Synthesis
-
-Once subagent results return (or inline scanning completes):
-
-1. **Merge findings** with what the user already told you
-2. **Identify gaps** — what do you still need to know to write a solid brief?
-3. **Note surprises** — anything from research that contradicts or enriches the user's assumptions?
-
-## Mode-Specific Behavior
-
-**Guided mode:**
-- Present a concise summary of what you found: "Here's what I learned from your documents and web research..."
-- Highlight anything surprising or worth discussing
-- Share the gaps you've identified
-- Ask: "Anything else you'd like to add, or shall we move on to filling in the details?"
-- Route to `prompts/guided-elicitation.md`
-
-**Yolo mode:**
-- Absorb all findings silently
-- Skip directly to `prompts/draft-and-review.md` — you have enough to draft
-- The user will refine later
-
-**Headless mode:**
-- Absorb all findings
-- Skip directly to `prompts/draft-and-review.md`
-- No interaction
-
-## Stage Complete
-
-This stage is complete when subagent results (or inline scanning fallback) have returned and findings are merged with user context. Route per mode:
-- **Guided** → `prompts/guided-elicitation.md`
-- **Yolo / Headless** → `prompts/draft-and-review.md`

src/bmm-skills/1-analysis/bmad-product-brief/prompts/draft-and-review.md

@@ -1,87 +0,0 @@
-**Language:** Use `{communication_language}` for all output.
-**Output Language:** Use `{document_output_language}` for documents.
-**Output Location:** `{planning_artifacts}`
-**Paths:** Bare paths (e.g. `agents/foo.md`) resolve from the skill root.
-
-# Stage 4: Draft & Review
-
-**Goal:** Produce the executive product brief and run it through multiple review lenses to catch blind spots before the user sees the final version.
-
-## Step 1: Draft the Executive Brief
-
-Use the template at `{workflow.brief_template}` as a guide — adapt structure to fit the product's story.
-
-**Writing principles:**
-- **Executive audience** — persuasive, clear, concise. 1-2 pages.
-- **Lead with the problem** — make the reader feel the pain before presenting the solution
-- **Concrete over abstract** — specific examples, real scenarios, measurable outcomes
-- **Confident voice** — this is a pitch, not a hedge
-- Write in `{document_output_language}`
-
-**Create the output document at:** `{planning_artifacts}/product-brief-{project_name}.md`
-
-Include YAML frontmatter:
-```yaml
----
-title: "Product Brief: {project_name}"
-status: "draft"
-created: "{timestamp}"
-updated: "{timestamp}"
-inputs: [list of input files used]
----
-```
-
-## Step 2: Fan Out Review Subagents
-
-Before showing the draft to the user, run it through multiple review lenses in parallel.
-
-**Launch in parallel:**
-
-1. **Skeptic Reviewer** (`agents/skeptic-reviewer.md`) — "What's missing? What assumptions are untested? What could go wrong? Where is the brief vague or hand-wavy?"
-
-2. **Opportunity Reviewer** (`agents/opportunity-reviewer.md`) — "What adjacent value propositions are being missed? What market angles or partnerships could strengthen this? What's underemphasized?"
-
-3. **Contextual Reviewer** — You (the main agent) pick the most useful third lens based on THIS specific product. Choose the lens that addresses the SINGLE BIGGEST RISK that the skeptic and opportunity reviewers won't naturally catch. Examples:
-   - For healthtech: "Regulatory and compliance risk reviewer"
-   - For devtools: "Developer experience and adoption friction critic"
-   - For marketplace: "Network effects and chicken-and-egg problem analyst"
-   - For enterprise: "Procurement and organizational change management reviewer"
-   - **When domain is unclear, default to:** "Go-to-market and launch risk reviewer" — examines distribution, pricing, and first-customer acquisition. Almost always valuable, frequently missed.
-   Describe the lens, run the review yourself inline.
-
-### Graceful Degradation
-
-If subagents are unavailable:
-- Perform all three review passes yourself, sequentially
-- Apply each lens deliberately — don't blend them into one generic review
-- The quality of review matters more than the parallelism
-
-## Step 3: Integrate Review Insights
-
-After all reviews complete:
-
-1. **Triage findings** — group by theme, remove duplicates
-2. **Apply non-controversial improvements** directly to the draft (obvious gaps, unclear language, missing specifics)
-3. **Flag substantive suggestions** that need user input (strategic choices, scope questions, market positioning decisions)
-
-## Step 4: Present to User
-
-**Headless mode:** Skip to `prompts/finalize.md` — no user interaction. Save the improved draft directly.
-
-**Yolo and Guided modes:**
-
-Present the draft brief to the user. Then share the reviewer insights:
-
-"Here's your product brief draft. Before we finalize, my review panel surfaced some things worth considering:
-
-**[Grouped reviewer findings — only the substantive ones that need user input]**
-
-What do you think? Any changes you'd like to make?"
-
-Present reviewer findings with brief rationale, then offer: "Want me to dig into any of these, or are you ready to make your revisions?"
-
-**Iterate** as long as the user wants to refine. Use the "anything else, or are we happy with this?" soft gate.
-
-## Stage Complete
-
-This stage is complete when: (a) the draft has been reviewed by all three lenses and improvements integrated, AND either (autonomous) save and route directly, or (guided/yolo) the user is satisfied. Route to `prompts/finalize.md`.

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

@@ -1,78 +0,0 @@
-**Language:** Use `{communication_language}` for all output.
-**Output Language:** Use `{document_output_language}` for documents.
-**Output Location:** `{planning_artifacts}`
-**Paths:** Bare paths (e.g. `prompts/foo.md`) resolve from the skill root.
-
-# Stage 5: Finalize
-
-**Goal:** Save the polished brief, offer the LLM distillate, and point the user forward.
-
-## Step 1: Polish and Save
-
-Update the product brief document at `{planning_artifacts}/product-brief-{project_name}.md`:
-- Update frontmatter `status` to `"complete"`
-- Update `updated` timestamp
-- Ensure formatting is clean and consistent
-- Confirm the document reads well as a standalone 1-2 page executive summary
-
-## Step 2: Offer the Distillate
-
-Throughout the discovery process, you likely captured detail that doesn't belong in a 1-2 page executive summary but is valuable for downstream work — requirements hints, platform preferences, rejected ideas, technical constraints, detailed user scenarios, competitive deep-dives, etc.
-
-**Ask the user:**
-"Your product brief is complete. During our conversation, I captured additional detail that goes beyond the executive summary — things like [mention 2-3 specific examples of overflow you captured]. Would you like me to create a detail pack for PRD creation? It distills all that extra context into a concise, structured format optimized for the next phase."
-
-**If yes, create the distillate** at `{planning_artifacts}/product-brief-{project_name}-distillate.md`:
-
-```yaml
----
-title: "Product Brief Distillate: {project_name}"
-type: llm-distillate
-source: "product-brief-{project_name}.md"
-created: "{timestamp}"
-purpose: "Token-efficient context for downstream PRD creation"
----
-```
-
-**Distillate content principles:**
-- Dense bullet points, not prose
-- Each bullet carries enough context to be understood standalone (don't assume the reader has the full brief loaded)
-- Group by theme, not by when it was mentioned
-- Include:
-  - **Rejected ideas** — so downstream workflows don't re-propose them, with brief rationale
-  - **Requirements hints** — anything the user mentioned that sounds like a requirement
-  - **Technical context** — platforms, integrations, constraints, preferences
-  - **Detailed user scenarios** — richer than what fits in the exec summary
-  - **Competitive intelligence** — specifics from web research worth preserving
-  - **Open questions** — things surfaced but not resolved during discovery
-  - **Scope signals** — what the user indicated is in/out/maybe for MVP
-- Token-conscious: be concise, but give enough context per bullet so an LLM reading this later understands WHY each point matters
-
-**Headless mode:** Always create the distillate automatically — unless the session was too brief to capture meaningful overflow (in that case, note this in the completion output instead of creating an empty file).
-
-## Step 3: Present Completion
-
-"Your product brief for {project_name} is complete!
-
-**Executive Brief:** `{planning_artifacts}/product-brief-{project_name}.md`
-[If distillate created:] **Detail Pack:** `{planning_artifacts}/product-brief-{project_name}-distillate.md`
-
-**Recommended next step:** Use the product brief (and detail pack) as input for PRD creation — tell your assistant 'create a PRD' and point it to these files."
-[If distillate created:] "The detail pack contains all the overflow context (requirements hints, rejected ideas, technical constraints) specifically structured for the PRD workflow to consume."
-
-**Headless mode:** Output the file paths as structured JSON and exit:
-```json
-{
-  "status": "complete",
-  "brief": "{planning_artifacts}/product-brief-{project_name}.md",
-  "distillate": "{path or null}",
-  "confidence": "high|medium|low",
-  "open_questions": ["any unresolved items"]
-}
-```
-
-## Stage 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. After delivering the completion message and file paths, the workflow is done. If the user requests further revisions, loop back to `prompts/draft-and-review.md`. Otherwise, exit.

src/bmm-skills/1-analysis/bmad-product-brief/prompts/guided-elicitation.md

@@ -1,71 +0,0 @@
-**Language:** Use `{communication_language}` for all output.
-**Output Language:** Use `{document_output_language}` for documents.
-**Paths:** Bare paths (e.g. `prompts/foo.md`) resolve from the skill root.
-
-# Stage 3: Guided Elicitation
-
-**Goal:** Fill the gaps in what you know. By now you have the user's brain dump, artifact analysis, and web research. This stage is about smart, targeted questioning — not rote section-by-section interrogation.
-
-**Skip this stage entirely in Yolo and Autonomous modes** — go directly to `prompts/draft-and-review.md`.
-
-## Approach
-
-You are NOT walking through a rigid questionnaire. You're having a conversation that covers the substance of a great product brief. The topics below are your mental checklist, not a script. Adapt to:
-- What you already know (don't re-ask what's been covered)
-- What the user is excited about (follow their energy)
-- What's genuinely unclear (focus questions where they matter)
-
-## Topics to Cover (flexibly, conversationally)
-
-### Vision & Problem
-- What core problem does this solve? For whom?
-- How do people solve this today? What's frustrating about current approaches?
-- What would success look like for the people this helps?
-- What's the insight or angle that makes this approach different?
-
-### Users & Value
-- Who experiences this problem most acutely?
-- Are there different user types with different needs?
-- What's the "aha moment" — when does a user realize this is what they needed?
-- How does this fit into their existing workflow or life?
-
-### Market & Differentiation
-- What competitive or alternative solutions exist? (Leverage web research findings)
-- What's the unfair advantage or defensible moat?
-- Why is now the right time for this?
-
-### Success & Scope
-- How will you know this is working? What metrics matter?
-- What's the minimum viable version that creates real value?
-- What's explicitly NOT in scope for the first version?
-- If this is wildly successful, what does it become in 2-3 years?
-
-## The Flow
-
-For each topic area where you have gaps:
-
-1. **Lead with what you know** — "Based on your input and my research, it sounds like [X]. Is that right?"
-2. **Ask the gap question** — targeted, specific, not generic
-3. **Reflect and confirm** — paraphrase what you heard
-4. **"Anything else on this, or shall we move on?"** — the soft gate
-
-If the user is giving you detail beyond brief scope (requirements, architecture, platform details, timelines), **capture it silently** for the distillate. Acknowledge it briefly ("Good detail, I'll capture that") but don't derail the conversation.
-
-## When to Move On
-
-When you have enough substance to draft a compelling 1-2 page executive brief covering:
-- Clear problem and who it affects
-- Proposed solution and what makes it different
-- Target users (at least primary)
-- Some sense of success criteria or business objectives
-- MVP-level scope thinking
-
-You don't need perfection — you need enough to draft well. Missing details can be surfaced during the review stage.
-
-If the user is providing complete, confident answers and you have solid coverage across all four topic areas after fewer than 3-4 exchanges, proactively offer to draft early.
-
-**Transition:** "I think I have a solid picture. Ready for me to draft the brief, or is there anything else you'd like to add?"
-
-## Stage Complete
-
-This stage is complete when sufficient substance exists to draft a compelling brief and the user confirms readiness. Route to `prompts/draft-and-review.md`.

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

@@ -1,60 +0,0 @@
-# Product Brief Template
-
-This is a flexible guide for the executive product brief — adapt it to serve the product's story. Merge sections, add new ones, reorder as needed. The product determines the structure, not the template.
-
-## Sensible Default Structure
-
-```markdown
-# Product Brief: {Product Name}
-
-## Executive Summary
-
-[2-3 paragraph narrative: What is this? What problem does it solve? Why does it matter? Why now?
-This should be compelling enough to stand alone — if someone reads only this section, they should understand the vision.]
-
-## The Problem
-
-[What pain exists? Who feels it? How are they coping today? What's the cost of the status quo?
-Be specific — real scenarios, real frustrations, real consequences.]
-
-## The Solution
-
-[What are we building? How does it solve the problem?
-Focus on the experience and outcome, not the implementation.]
-
-## What Makes This Different
-
-[Key differentiators. Why this approach vs alternatives? What's the unfair advantage?
-Be honest — if the moat is execution speed, say so. Don't fabricate technical moats.]
-
-## Who This Serves
-
-[Primary users — vivid but brief. Who are they, what do they need, what does success look like for them?
-Secondary users if relevant.]
-
-## Success Criteria
-
-[How do we know this is working? What metrics matter?
-Mix of user success signals and business objectives. Be measurable.]
-
-## Scope
-
-[What's in for the first version? What's explicitly out?
-Keep this tight — it's a boundary document, not a feature list.]
-
-## Vision
-
-[Where does this go if it succeeds? What does it become in 2-3 years?
-Inspiring but grounded.]
-```
-
-## Adaptation Guidelines
-
-- **For B2B products:** Consider adding a "Buyer vs User" section if they're different people
-- **For platforms/marketplaces:** Consider a "Network Effects" or "Ecosystem" section
-- **For technical products:** May need a brief "Technical Approach" section (keep it high-level)
-- **For regulated industries:** Consider a "Compliance & Regulatory" section
-- **If scope is well-defined:** Merge "Scope" and "Vision" into "Roadmap Thinking"
-- **If the problem is well-known:** Shorten "The Problem" and expand "What Makes This Different"
-
-The brief should be 1-2 pages. If it's longer, you're putting in too much detail — that's what the distillate is for.

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

@@ -55,19 +55,9 @@ principles = [
 # registered skill by name) or `prompt` (executes the prompt text directly).
 
 [[agent.menu]]
-code = "CP"
+code = "PRD"
-description = "Expert led facilitation to produce your Product Requirements Document"
+description = "Create, update, or validate a PRD — state your intent or the skill will ask"
-skill = "bmad-create-prd"
+skill = "bmad-prd"
-
-[[agent.menu]]
-code = "VP"
-description = "Validate a PRD is comprehensive, lean, well organized and cohesive"
-skill = "bmad-validate-prd"
-
-[[agent.menu]]
-code = "EP"
-description = "Update an existing Product Requirements Document"
-skill = "bmad-edit-prd"
 
 [[agent.menu]]
 code = "CE"

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

@@ -1,104 +1,30 @@
 ---
 name: bmad-create-prd
-description: 'Create a PRD from scratch. Use when the user says "lets create a product requirements document" or "I want to create a new PRD"'
+description: 'DEPRECATED — consolidated into bmad-prd create intent - this skill will be removed in v7 in favor of `bmad-prd`.'
 ---
 
-# PRD Create Workflow
+# DEPRECATED — forwards to bmad-prd (create intent)
 
-**Goal:** Create comprehensive PRDs through structured workflow facilitation.
+This skill was consolidated into `bmad-prd`. It is retained as a thin compatibility shim so existing invocations by name and `_bmad/custom/bmad-create-prd.toml` override files keep working. New work should invoke `bmad-prd` directly — it detects create / update / validate intent from the conversation.
-
-**Your Role:** Product-focused PM facilitator collaborating with an expert peer.
-
-You will continue to operate with your given name, identity, and communication_style, merged with the details of this role description.
-
-## Conventions
-
-- Bare paths (e.g. `steps-c/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 **step-file architecture** for disciplined execution:
-
-### Core Principles
-
-- **Micro-file Design**: Each step is a self-contained instruction file that is a part of an overall workflow that must be followed exactly
-- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until told to do so
-- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
-- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array when a workflow produces a document
-- **Append-Only Building**: Build documents by appending content as directed to the output file
-
-### Step Processing Rules
-
-1. **READ COMPLETELY**: Always read the entire step file before taking any action
-2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
-3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
-4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
-5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
-6. **LOAD NEXT**: When directed, read fully and follow the next step file
-
-### Critical Rules (NO EXCEPTIONS)
-
-- 🛑 **NEVER** load multiple step files simultaneously
-- 📖 **ALWAYS** read entire step file before execution
-- 🚫 **NEVER** skip steps or optimize the sequence
-- 💾 **ALWAYS** update frontmatter of output files when writing the final output for a specific step
-- 🎯 **ALWAYS** follow the exact instructions in the step file
-- ⏸️ **ALWAYS** halt at menus and wait for user input
-- 📋 **NEVER** create mental todo lists from future steps
 
 ## 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-prd.toml` and `bmad-create-prd.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-prd` is deprecated and will be removed in a future release. It now forwards to `bmad-prd` with create intent. To silence this notice and access the full new customization surface (`prd_template`, `validation_checklist`, `doc_standards`, `external_sources`, `external_handoffs`, `output_dir`, `output_folder_name`), migrate `_bmad/custom/bmad-create-prd.toml` to `_bmad/custom/bmad-prd.toml` and invoke `bmad-prd` 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-prd.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-prd` with the following context. Pass these as the activating context so `bmad-prd` honors them instead of resolving its own customization from scratch:
 
-### Step 2: Execute Prepend Steps
+   - **Intent:** `create` — skip `bmad-prd`'s usual intent detection step.
+   - **Pre-resolved legacy customization** — use these in place of resolving from `bmad-prd`'s own `customize.toml` for the four legacy fields. For everything else (`prd_template`, `validation_checklist`, `validation_report_template`, `doc_standards`, `output_dir`, `output_folder_name`, `external_sources`, `external_handoffs`), use `bmad-prd`'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-prd` 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. Begin the workflow below.
-
-## Paths
-
-- `outputFile` = `{planning_artifacts}/prd.md`
-
-## Execution
-
-✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the configured `{communication_language}`.
-✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`.
-
-**Create Mode: Creating a new PRD from scratch.**
-
-Read fully and follow: `./steps-c/step-01-init.md`

src/bmm-skills/2-plan-workflows/bmad-create-prd/data/domain-complexity.csv

@@ -1,15 +0,0 @@
-domain,signals,complexity,key_concerns,required_knowledge,suggested_workflow,web_searches,special_sections
-healthcare,"medical,diagnostic,clinical,FDA,patient,treatment,HIPAA,therapy,pharma,drug",high,"FDA approval;Clinical validation;HIPAA compliance;Patient safety;Medical device classification;Liability","Regulatory pathways;Clinical trial design;Medical standards;Data privacy;Integration requirements","domain-research","FDA software medical device guidance {date};HIPAA compliance software requirements;Medical software standards {date};Clinical validation software","clinical_requirements;regulatory_pathway;validation_methodology;safety_measures"
-fintech,"payment,banking,trading,investment,crypto,wallet,transaction,KYC,AML,funds,fintech",high,"Regional compliance;Security standards;Audit requirements;Fraud prevention;Data protection","KYC/AML requirements;PCI DSS;Open banking;Regional laws (US/EU/APAC);Crypto regulations","domain-research","fintech regulations {date};payment processing compliance {date};open banking API standards;cryptocurrency regulations {date}","compliance_matrix;security_architecture;audit_requirements;fraud_prevention"
-govtech,"government,federal,civic,public sector,citizen,municipal,voting",high,"Procurement rules;Security clearance;Accessibility (508);FedRAMP;Privacy;Transparency","Government procurement;Security frameworks;Accessibility standards;Privacy laws;Open data requirements","domain-research","government software procurement {date};FedRAMP compliance requirements;section 508 accessibility;government security standards","procurement_compliance;security_clearance;accessibility_standards;transparency_requirements"
-edtech,"education,learning,student,teacher,curriculum,assessment,K-12,university,LMS",medium,"Student privacy (COPPA/FERPA);Accessibility;Content moderation;Age verification;Curriculum standards","Educational privacy laws;Learning standards;Accessibility requirements;Content guidelines;Assessment validity","domain-research","educational software privacy {date};COPPA FERPA compliance;WCAG education requirements;learning management standards","privacy_compliance;content_guidelines;accessibility_features;curriculum_alignment"
-aerospace,"aircraft,spacecraft,aviation,drone,satellite,propulsion,flight,radar,navigation",high,"Safety certification;DO-178C compliance;Performance validation;Simulation accuracy;Export controls","Aviation standards;Safety analysis;Simulation validation;ITAR/export controls;Performance requirements","domain-research + technical-model","DO-178C software certification;aerospace simulation standards {date};ITAR export controls software;aviation safety requirements","safety_certification;simulation_validation;performance_requirements;export_compliance"
-automotive,"vehicle,car,autonomous,ADAS,automotive,driving,EV,charging",high,"Safety standards;ISO 26262;V2X communication;Real-time requirements;Certification","Automotive standards;Functional safety;V2X protocols;Real-time systems;Testing requirements","domain-research","ISO 26262 automotive software;automotive safety standards {date};V2X communication protocols;EV charging standards","safety_standards;functional_safety;communication_protocols;certification_requirements"
-scientific,"research,algorithm,simulation,modeling,computational,analysis,data science,ML,AI",medium,"Reproducibility;Validation methodology;Peer review;Performance;Accuracy;Computational resources","Scientific method;Statistical validity;Computational requirements;Domain expertise;Publication standards","technical-model","scientific computing best practices {date};research reproducibility standards;computational modeling validation;peer review software","validation_methodology;accuracy_metrics;reproducibility_plan;computational_requirements"
-legaltech,"legal,law,contract,compliance,litigation,patent,attorney,court",high,"Legal ethics;Bar regulations;Data retention;Attorney-client privilege;Court system integration","Legal practice rules;Ethics requirements;Court filing systems;Document standards;Confidentiality","domain-research","legal technology ethics {date};law practice management software requirements;court filing system standards;attorney client privilege technology","ethics_compliance;data_retention;confidentiality_measures;court_integration"
-insuretech,"insurance,claims,underwriting,actuarial,policy,risk,premium",high,"Insurance regulations;Actuarial standards;Data privacy;Fraud detection;State compliance","Insurance regulations by state;Actuarial methods;Risk modeling;Claims processing;Regulatory reporting","domain-research","insurance software regulations {date};actuarial standards software;insurance fraud detection;state insurance compliance","regulatory_requirements;risk_modeling;fraud_detection;reporting_compliance"
-energy,"energy,utility,grid,solar,wind,power,electricity,oil,gas",high,"Grid compliance;NERC standards;Environmental regulations;Safety requirements;Real-time operations","Energy regulations;Grid standards;Environmental compliance;Safety protocols;SCADA systems","domain-research","energy sector software compliance {date};NERC CIP standards;smart grid requirements;renewable energy software standards","grid_compliance;safety_protocols;environmental_compliance;operational_requirements"
-process_control,"industrial automation,process control,PLC,SCADA,DCS,HMI,operational technology,OT,control system,cyberphysical,MES,historian,instrumentation,I&C,P&ID",high,"Functional safety;OT cybersecurity;Real-time control requirements;Legacy system integration;Process safety and hazard analysis;Environmental compliance and permitting;Engineering authority and PE requirements","Functional safety standards;OT security frameworks;Industrial protocols;Process control architecture;Plant reliability and maintainability","domain-research + technical-model","IEC 62443 OT cybersecurity requirements {date};functional safety software requirements {date};industrial process control architecture;ISA-95 manufacturing integration","functional_safety;ot_security;process_requirements;engineering_authority"
-building_automation,"building automation,BAS,BMS,HVAC,smart building,lighting control,fire alarm,fire protection,fire suppression,life safety,elevator,access control,DDC,energy management,sequence of operations,commissioning",high,"Life safety codes;Building energy standards;Multi-trade coordination and interoperability;Commissioning and ongoing operational performance;Indoor environmental quality and occupant comfort;Engineering authority and PE requirements","Building automation protocols;HVAC and mechanical controls;Fire alarm, fire protection, and life safety design;Commissioning process and sequence of operations;Building codes and energy standards","domain-research","smart building software architecture {date};BACnet integration best practices;building automation cybersecurity {date};ASHRAE building standards","life_safety;energy_compliance;commissioning_requirements;engineering_authority"
-gaming,"game,player,gameplay,level,character,multiplayer,quest",redirect,"REDIRECT TO GAME WORKFLOWS","Game design","game-brief","NA","NA"
-general,"",low,"Standard requirements;Basic security;User experience;Performance","General software practices","continue","software development best practices {date}","standard_requirements"

src/bmm-skills/2-plan-workflows/bmad-create-prd/data/prd-purpose.md

@@ -1,197 +0,0 @@
-# BMAD PRD Purpose
-
-**The PRD is the top of the required funnel that feeds all subsequent product development work in rhw BMad Method.**
-
----
-
-## What is a BMAD PRD?
-
-A dual-audience document serving:
-1. **Human Product Managers and builders** - Vision, strategy, stakeholder communication
-2. **LLM Downstream Consumption** - UX Design → Architecture → Epics → Development AI Agents
-
-Each successive document becomes more AI-tailored and granular.
-
----
-
-## Core Philosophy: Information Density
-
-**High Signal-to-Noise Ratio**
-
-Every sentence must carry information weight. LLMs consume precise, dense content efficiently.
-
-**Anti-Patterns (Eliminate These):**
-- ❌ "The system will allow users to..." → ✅ "Users can..."
-- ❌ "It is important to note that..." → ✅ State the fact directly
-- ❌ "In order to..." → ✅ "To..."
-- ❌ Conversational filler and padding → ✅ Direct, concise statements
-
-**Goal:** Maximum information per word. Zero fluff.
-
----
-
-## The Traceability Chain
-
-**PRD starts the chain:**
-```
-Vision → Success Criteria → User Journeys → Functional Requirements → (future: User Stories)
-```
-
-**In the PRD, establish:**
-- Vision → Success Criteria alignment
-- Success Criteria → User Journey coverage
-- User Journey → Functional Requirement mapping
-- All requirements traceable to user needs
-
-**Why:** Each downstream artifact (UX, Architecture, Epics, Stories) must trace back to documented user needs and business objectives. This chain ensures we build the right thing.
-
----
-
-## What Makes Great Functional Requirements?
-
-### FRs are Capabilities, Not Implementation
-
-**Good FR:** "Users can reset their password via email link"
-**Bad FR:** "System sends JWT via email and validates with database" (implementation leakage)
-
-**Good FR:** "Dashboard loads in under 2 seconds for 95th percentile"
-**Bad FR:** "Fast loading time" (subjective, unmeasurable)
-
-### SMART Quality Criteria
-
-**Specific:** Clear, precisely defined capability
-**Measurable:** Quantifiable with test criteria
-**Attainable:** Realistic within constraints
-**Relevant:** Aligns with business objectives
-**Traceable:** Links to source (executive summary or user journey)
-
-### FR Anti-Patterns
-
-**Subjective Adjectives:**
-- ❌ "easy to use", "intuitive", "user-friendly", "fast", "responsive"
-- ✅ Use metrics: "completes task in under 3 clicks", "loads in under 2 seconds"
-
-**Implementation Leakage:**
-- ❌ Technology names, specific libraries, implementation details
-- ✅ Focus on capability and measurable outcomes
-
-**Vague Quantifiers:**
-- ❌ "multiple users", "several options", "various formats"
-- ✅ "up to 100 concurrent users", "3-5 options", "PDF, DOCX, TXT formats"
-
-**Missing Test Criteria:**
-- ❌ "The system shall provide notifications"
-- ✅ "The system shall send email notifications within 30 seconds of trigger event"
-
----
-
-## What Makes Great Non-Functional Requirements?
-
-### NFRs Must Be Measurable
-
-**Template:**
-```
-"The system shall [metric] [condition] [measurement method]"
-```
-
-**Examples:**
-- ✅ "The system shall respond to API requests in under 200ms for 95th percentile as measured by APM monitoring"
-- ✅ "The system shall maintain 99.9% uptime during business hours as measured by cloud provider SLA"
-- ✅ "The system shall support 10,000 concurrent users as measured by load testing"
-
-### NFR Anti-Patterns
-
-**Unmeasurable Claims:**
-- ❌ "The system shall be scalable" → ✅ "The system shall handle 10x load growth through horizontal scaling"
-- ❌ "High availability required" → ✅ "99.9% uptime as measured by cloud provider SLA"
-
-**Missing Context:**
-- ❌ "Response time under 1 second" → ✅ "API response time under 1 second for 95th percentile under normal load"
-
----
-
-## Domain-Specific Requirements
-
-**Auto-Detect and Enforce Based on Project Context**
-
-Certain industries have mandatory requirements that must be present:
-
-- **Healthcare:** HIPAA Privacy & Security Rules, PHI encryption, audit logging, MFA
-- **Fintech:** PCI-DSS Level 1, AML/KYC compliance, SOX controls, financial audit trails
-- **GovTech:** NIST framework, Section 508 accessibility (WCAG 2.1 AA), FedRAMP, data residency
-- **E-Commerce:** PCI-DSS for payments, inventory accuracy, tax calculation by jurisdiction
-
-**Why:** Missing these requirements in the PRD means they'll be missed in architecture and implementation, creating expensive rework. During PRD creation there is a step to cover this - during validation we want to make sure it was covered. For this purpose steps will utilize a domain-complexity.csv and project-types.csv.
-
----
-
-## Document Structure (Markdown, Human-Readable)
-
-### Required Sections
-1. **Executive Summary** - Vision, differentiator, target users
-2. **Success Criteria** - Measurable outcomes (SMART)
-3. **Product Scope** - MVP, Growth, Vision phases
-4. **User Journeys** - Comprehensive coverage
-5. **Domain Requirements** - Industry-specific compliance (if applicable)
-6. **Innovation Analysis** - Competitive differentiation (if applicable)
-7. **Project-Type Requirements** - Platform-specific needs
-8. **Functional Requirements** - Capability contract (FRs)
-9. **Non-Functional Requirements** - Quality attributes (NFRs)
-
-### Formatting for Dual Consumption
-
-**For Humans:**
-- Clear, professional language
-- Logical flow from vision to requirements
-- Easy for stakeholders to review and approve
-
-**For LLMs:**
-- ## Level 2 headers for all main sections (enables extraction)
-- Consistent structure and patterns
-- Precise, testable language
-- High information density
-
----
-
-## Downstream Impact
-
-**How the PRD Feeds Next Artifacts:**
-
-**UX Design:**
-- User journeys → interaction flows
-- FRs → design requirements
-- Success criteria → UX metrics
-
-**Architecture:**
-- FRs → system capabilities
-- NFRs → architecture decisions
-- Domain requirements → compliance architecture
-- Project-type requirements → platform choices
-
-**Epics & Stories (created after architecture):**
-- FRs → user stories (1 FR could map to 1-3 stories potentially)
-- Acceptance criteria → story acceptance tests
-- Priority → sprint sequencing
-- Traceability → stories map back to vision
-
-**Development AI Agents:**
-- Precise requirements → implementation clarity
-- Test criteria → automated test generation
-- Domain requirements → compliance enforcement
-- Measurable NFRs → performance targets
-
----
-
-## Summary: What Makes a Great BMAD PRD?
-
-✅ **High Information Density** - Every sentence carries weight, zero fluff
-✅ **Measurable Requirements** - All FRs and NFRs are testable with specific criteria
-✅ **Clear Traceability** - Each requirement links to user need and business objective
-✅ **Domain Awareness** - Industry-specific requirements auto-detected and included
-✅ **Zero Anti-Patterns** - No subjective adjectives, implementation leakage, or vague quantifiers
-✅ **Dual Audience Optimized** - Human-readable AND LLM-consumable
-✅ **Markdown Format** - Professional, clean, accessible to all stakeholders
-
----
-
-**Remember:** The PRD is the foundation. Quality here ripples through every subsequent phase. A dense, precise, well-traced PRD makes UX design, architecture, epic breakdown, and AI development dramatically more effective.

src/bmm-skills/2-plan-workflows/bmad-create-prd/data/project-types.csv

@@ -1,11 +0,0 @@
-project_type,detection_signals,key_questions,required_sections,skip_sections,web_search_triggers,innovation_signals
-api_backend,"API,REST,GraphQL,backend,service,endpoints","Endpoints needed?;Authentication method?;Data formats?;Rate limits?;Versioning?;SDK needed?","endpoint_specs;auth_model;data_schemas;error_codes;rate_limits;api_docs","ux_ui;visual_design;user_journeys","framework best practices;OpenAPI standards","API composition;New protocol"
-mobile_app,"iOS,Android,app,mobile,iPhone,iPad","Native or cross-platform?;Offline needed?;Push notifications?;Device features?;Store compliance?","platform_reqs;device_permissions;offline_mode;push_strategy;store_compliance","desktop_features;cli_commands","app store guidelines;platform requirements","Gesture innovation;AR/VR features"
-saas_b2b,"SaaS,B2B,platform,dashboard,teams,enterprise","Multi-tenant?;Permission model?;Subscription tiers?;Integrations?;Compliance?","tenant_model;rbac_matrix;subscription_tiers;integration_list;compliance_reqs","cli_interface;mobile_first","compliance requirements;integration guides","Workflow automation;AI agents"
-developer_tool,"SDK,library,package,npm,pip,framework","Language support?;Package managers?;IDE integration?;Documentation?;Examples?","language_matrix;installation_methods;api_surface;code_examples;migration_guide","visual_design;store_compliance","package manager best practices;API design patterns","New paradigm;DSL creation"
-cli_tool,"CLI,command,terminal,bash,script","Interactive or scriptable?;Output formats?;Config method?;Shell completion?","command_structure;output_formats;config_schema;scripting_support","visual_design;ux_principles;touch_interactions","CLI design patterns;shell integration","Natural language CLI;AI commands"
-web_app,"website,webapp,browser,SPA,PWA","SPA or MPA?;Browser support?;SEO needed?;Real-time?;Accessibility?","browser_matrix;responsive_design;performance_targets;seo_strategy;accessibility_level","native_features;cli_commands","web standards;WCAG guidelines","New interaction;WebAssembly use"
-game,"game,player,gameplay,level,character","REDIRECT TO USE THE BMad Method Game Module Agent and Workflows - HALT","game-brief;GDD","most_sections","game design patterns","Novel mechanics;Genre mixing"
-desktop_app,"desktop,Windows,Mac,Linux,native","Cross-platform?;Auto-update?;System integration?;Offline?","platform_support;system_integration;update_strategy;offline_capabilities","web_seo;mobile_features","desktop guidelines;platform requirements","Desktop AI;System automation"
-iot_embedded,"IoT,embedded,device,sensor,hardware","Hardware specs?;Connectivity?;Power constraints?;Security?;OTA updates?","hardware_reqs;connectivity_protocol;power_profile;security_model;update_mechanism","visual_ui;browser_support","IoT standards;protocol specs","Edge AI;New sensors"
-blockchain_web3,"blockchain,crypto,DeFi,NFT,smart contract","Chain selection?;Wallet integration?;Gas optimization?;Security audit?","chain_specs;wallet_support;smart_contracts;security_audit;gas_optimization","traditional_auth;centralized_db","blockchain standards;security patterns","Novel tokenomics;DAO structure"

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-01-init.md

@@ -1,178 +0,0 @@
-# Step 1: Workflow Initialization
-
-**Progress: Step 1 of 11** - Next: Project Discovery
-
-## STEP GOAL:
-
-Initialize the PRD workflow by detecting continuation state, discovering input documents, and setting up the document structure for collaborative product requirement discovery.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a product-focused PM facilitator collaborating with an expert peer
-- ✅ If you already have been given a name, communication_style and persona, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring structured thinking and facilitation skills, while the user brings domain expertise and product vision
-
-### Step-Specific Rules:
-
-- 🎯 Focus only on initialization and setup - no content generation yet
-- 🚫 FORBIDDEN to look ahead to future steps or assume knowledge from them
-- 💬 Approach: Systematic setup with clear reporting to user
-- 🚪 Detect existing workflow state and handle continuation properly
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis of current state before taking any action
-- 💾 Initialize document structure and update frontmatter appropriately
-- Update frontmatter: add this step name to the end of the steps completed array (it should be the first entry in the steps array since this is step 1)
-- 🚫 FORBIDDEN to load next step until user selects 'C' (Continue)
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Variables from workflow.md are available in memory
-- Focus: Workflow initialization and document setup only
-- Limits: Don't assume knowledge from other steps or create content yet
-- Dependencies: Configuration loaded from workflow.md initialization
-
-## Sequence of Instructions (Do not deviate, skip, or optimize)
-
-### 1. Check for Existing Workflow State
-
-First, check if the output document already exists:
-
-**Workflow State Detection:**
-
-- Look for file at `{outputFile}`
-- If exists, read the complete file 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` BUT `step-12-complete` is NOT in the list, follow the Continuation Protocol since the document is incomplete:
-
-**Continuation Protocol:**
-
-- **STOP immediately** and load `./step-01b-continue.md`
-- Do not proceed with any initialization tasks
-- Let step-01b handle all continuation logic
-- This is an auto-proceed situation - no user choice needed
-
-### 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}/**
-- 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`)
-- Research Documents (`/*research*.md`)
-- Project Documentation (generally multiple documents might be found for this in the `{project_knowledge}` or `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. Create Initial Document
-
-**Document Setup:**
-
-- Copy the template from `../templates/prd-template.md` to `{outputFile}`
-- Initialize frontmatter with proper structure including inputDocuments array.
-
-#### C. Present Initialization Results
-
-**Setup Report to User:**
-
-"Welcome {{user_name}}! I've set up your PRD workspace for {{project_name}}.
-
-**Document Setup:**
-
-- Created: `{outputFile}` from template
-- Initialized frontmatter with workflow state
-
-**Input Documents Discovered:**
-
-- Product briefs: {{briefCount}} files {if briefCount > 0}✓ loaded{else}(none found){/if}
-- Research: {{researchCount}} files {if researchCount > 0}✓ loaded{else}(none found){/if}
-- Brainstorming: {{brainstormingCount}} files {if brainstormingCount > 0}✓ loaded{else}(none found){/if}
-- Project docs: {{projectDocsCount}} files {if projectDocsCount > 0}✓ loaded (brownfield project){else}(none found - greenfield project){/if}
-
-**Files loaded:** {list of specific file names or "No additional documents found"}
-
-{if projectDocsCount > 0}
-📋 **Note:** This is a **brownfield project**. Your existing project documentation has been loaded. In the next step, I'll ask specifically about what new features or changes you want to add to your existing system.
-{/if}
-
-Do you have any other documents you'd like me to include, or shall we continue to the next step?"
-
-### 4. Present MENU OPTIONS
-
-Display menu after setup report:
-
-"[C] Continue - Save this and move to Project Discovery (Step 2 of 11)"
-
-#### Menu Handling Logic:
-
-- IF C: Update output file frontmatter, adding this step name to the end of the list of stepsCompleted, then read fully and follow: ./step-02-discovery.md
-- IF user provides additional files: Load them, update inputDocuments and documentCounts, redisplay report
-- IF user asks questions: Answer and redisplay menu
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-
-## CRITICAL STEP COMPLETION NOTE
-
-ONLY WHEN [C continue option] is selected and [frontmatter properly updated with this step added to stepsCompleted and documentCounts], will you then read fully and follow: `./step-02-discovery.md` to begin project discovery.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Existing workflow detected and properly handed off to step-01b
-- Fresh workflow initialized with template and proper frontmatter
-- Input documents discovered and loaded using sharded-first logic
-- All discovered files tracked in frontmatter `inputDocuments`
-- User clearly informed of brownfield vs greenfield status
-- Menu presented and user input handled correctly
-- Frontmatter updated with this step name added to stepsCompleted before proceeding
-
-### ❌ SYSTEM FAILURE:
-
-- Proceeding with fresh initialization when existing workflow exists
-- Not updating frontmatter with discovered input documents
-- **Not storing document counts in frontmatter**
-- Creating document without proper template structure
-- Not checking sharded folders first before whole files
-- Not reporting discovered documents to user clearly
-- Proceeding without user selecting 'C' (Continue)
-
-**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-01b-continue.md

@@ -1,161 +0,0 @@
-# Step 1B: Workflow Continuation
-
-## STEP GOAL:
-
-Resume the PRD workflow from where it was left off, ensuring smooth continuation with full context restoration.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a product-focused PM facilitator collaborating with an expert peer
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ Resume workflow from exact point where it was interrupted
-
-### Step-Specific Rules:
-
-- 💬 FOCUS on understanding where we left off and continuing appropriately
-- 🚫 FORBIDDEN to modify content completed in previous steps
-- 📖 Only reload documents that were already tracked in `inputDocuments`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis of current state before taking action
-- Update frontmatter: add this step name to the end of the steps completed array
-- 📖 Only load documents that were already tracked in `inputDocuments`
-- 🚫 FORBIDDEN to discover new input documents during continuation
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Current document and frontmatter are already loaded
-- Focus: Workflow state analysis and continuation logic only
-- Limits: Don't assume knowledge beyond what's in the document
-- Dependencies: Existing workflow state from previous session
-
-## Sequence of Instructions (Do not deviate, skip, or optimize)
-
-### 1. Analyze Current State
-
-**State Assessment:**
-Review the frontmatter to understand:
-
-- `stepsCompleted`: Array of completed step filenames
-- Last element of `stepsCompleted` array: The most recently completed step
-- `inputDocuments`: What context was already loaded
-- All other frontmatter variables
-
-### 2. Restore Context Documents
-
-**Context Reloading:**
-
-- For each document in `inputDocuments`, load the complete file
-- This ensures you have full context for continuation
-- Don't discover new documents - only reload what was previously processed
-
-### 3. Determine Next Step
-
-**Step Sequence Lookup:**
-
-Use the following ordered sequence to determine the next step from the last completed step:
-
-| Last Completed | Next Step |
-|---|---|
-| step-01-init.md | step-02-discovery.md |
-| step-02-discovery.md | step-02b-vision.md |
-| step-02b-vision.md | step-02c-executive-summary.md |
-| step-02c-executive-summary.md | step-03-success.md |
-| step-03-success.md | step-04-journeys.md |
-| step-04-journeys.md | step-05-domain.md |
-| step-05-domain.md | step-06-innovation.md |
-| step-06-innovation.md | step-07-project-type.md |
-| step-07-project-type.md | step-08-scoping.md |
-| step-08-scoping.md | step-09-functional.md |
-| step-09-functional.md | step-10-nonfunctional.md |
-| step-10-nonfunctional.md | step-11-polish.md |
-| step-11-polish.md | step-12-complete.md |
-
-1. Get the last element from the `stepsCompleted` array
-2. Look it up in the table above to find the next step
-3. That's the next step to load!
-
-**Example:**
-- If `stepsCompleted = ["step-01-init.md", "step-02-discovery.md", "step-03-success.md"]`
-- Last element is `"step-03-success.md"`
-- Table lookup → next step is `./step-04-journeys.md`
-
-### 4. Handle Workflow Completion
-
-**If `stepsCompleted` array contains `"step-12-complete.md"`:**
-"Great news! It looks like we've already completed the PRD workflow for {{project_name}}.
-
-The final document is ready at `{outputFile}` with all sections completed.
-
-Would you like me to:
-
-- Review the completed PRD with you
-- Suggest next workflow steps (like architecture or epic creation)
-- Start a new PRD revision
-
-What would be most helpful?"
-
-### 5. Present Current Progress
-
-**If workflow not complete:**
-"Welcome back {{user_name}}! I'm resuming our PRD collaboration for {{project_name}}.
-
-**Current Progress:**
-- Last completed: {last step filename from stepsCompleted array}
-- Next up: {next step from lookup table}
-- Context documents available: {len(inputDocuments)} files
-
-**Document Status:**
-- Current PRD document is ready with all completed sections
-- Ready to continue from where we left off
-
-Does this look right, or do you want to make any adjustments before we proceed?"
-
-### 6. Present MENU OPTIONS
-
-Display: "**Select an Option:** [C] Continue to {next step name}"
-
-#### Menu Handling Logic:
-
-- IF C: Read fully and follow the next step determined from the lookup table in step 3
-- IF Any other comments or queries: respond and redisplay menu
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-
-## CRITICAL STEP COMPLETION NOTE
-
-ONLY WHEN [C continue option] is selected and [current state confirmed], will you then read fully and follow the next step (from the lookup table) to resume the workflow.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All previous input documents successfully reloaded
-- Current workflow state accurately analyzed and presented
-- User confirms understanding of progress before continuation
-- Correct next step identified and prepared for loading
-
-### ❌ SYSTEM FAILURE:
-
-- Discovering new input documents instead of reloading existing ones
-- Modifying content from already completed steps
-- Failing to determine the next step from the lookup table
-- Proceeding without user confirmation of current state
-
-**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-02-discovery.md

@@ -1,208 +0,0 @@
-# Step 2: Project Discovery
-
-**Progress: Step 2 of 13** - Next: Product Vision
-
-## STEP GOAL:
-
-Discover and classify the project - understand what type of product this is, what domain it operates in, and the project context (greenfield vs brownfield).
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read
-- ✅ ALWAYS treat this as collaborative discovery between PM peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a product-focused PM facilitator collaborating with an expert peer
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring structured thinking and facilitation skills, while the user brings domain expertise and product vision
-
-### Step-Specific Rules:
-
-- 🎯 Focus on classification and understanding - no content generation yet
-- 🚫 FORBIDDEN to generate executive summary or vision statements (that's next steps)
-- 💬 APPROACH: Natural conversation to understand the project
-- 🎯 LOAD classification data BEFORE starting discovery conversation
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- ⚠️ Present A/P/C menu after classification complete
-- 💾 ONLY save classification to frontmatter when user chooses C (Continue)
-- 📖 Update frontmatter, adding this step to the end of the list of stepsCompleted
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## CONTEXT BOUNDARIES:
-
-- Current document and frontmatter from step 1 are available
-- Input documents already loaded are in memory (product briefs, research, brainstorming, project docs)
-- **Document counts available in frontmatter `documentCounts`**
-- Classification CSV data will be loaded in this step only
-- No executive summary or vision content yet (that's steps 2b and 2c)
-
-## YOUR TASK:
-
-Discover and classify the project through natural conversation:
-- What type of product is this? (web app, API, mobile, etc.)
-- What domain does it operate in? (healthcare, fintech, e-commerce, etc.)
-- What's the project context? (greenfield new product vs brownfield existing system)
-- How complex is this domain? (low, medium, high)
-
-## DISCOVERY SEQUENCE:
-
-### 1. Check Document State
-
-Read the frontmatter from `{outputFile}` to get document counts:
-- `briefCount` - Product briefs available
-- `researchCount` - Research documents available
-- `brainstormingCount` - Brainstorming docs available
-- `projectDocsCount` - Existing project documentation
-
-**Announce your understanding:**
-
-"From step 1, I have loaded:
-- Product briefs: {{briefCount}}
-- Research: {{researchCount}}
-- Brainstorming: {{brainstormingCount}}
-- Project docs: {{projectDocsCount}}
-
-{{if projectDocsCount > 0}}This is a brownfield project - I'll focus on understanding what you want to add or change.{{else}}This is a greenfield project - I'll help you define the full product vision.{{/if}}"
-
-### 2. Load Classification Data
-
-**Attempt subprocess data lookup:**
-
-**Project Type Lookup:**
-"Your task: Lookup data in ../data/project-types.csv
-
-**Search criteria:**
-- Find row where project_type matches {{detectedProjectType}}
-
-**Return format:**
-Return ONLY the matching row as a YAML-formatted object with these fields:
-project_type, detection_signals
-
-**Do NOT return the entire CSV - only the matching row.**"
-
-**Domain Complexity Lookup:**
-"Your task: Lookup data in ../data/domain-complexity.csv
-
-**Search criteria:**
-- Find row where domain matches {{detectedDomain}}
-
-**Return format:**
-Return ONLY the matching row as a YAML-formatted object with these fields:
-domain, complexity, typical_concerns, compliance_requirements
-
-**Do NOT return the entire CSV - only the matching row.**"
-
-**Graceful degradation (if Task tool unavailable):**
-- Load the CSV files directly
-- Find the matching rows manually
-- Extract required fields
-- Keep in memory for intelligent classification
-
-### 3. Begin Discovery Conversation
-
-**Start with what you know:**
-
-If the user has a product brief or project docs, acknowledge them and share your understanding. Then ask clarifying questions to deepen your understanding.
-
-If this is a greenfield project with no docs, start with open-ended discovery:
-- What problem does this solve?
-- Who's it for?
-- What excites you about building this?
-
-**Listen for classification signals:**
-
-As the user describes their product, match against:
-- **Project type signals** (API, mobile, SaaS, etc.)
-- **Domain signals** (healthcare, fintech, education, etc.)
-- **Complexity indicators** (regulated industries, novel technology, etc.)
-
-### 4. Confirm Classification
-
-Once you have enough understanding, share your classification:
-
-"I'm hearing this as:
-- **Project Type:** {{detectedType}}
-- **Domain:** {{detectedDomain}}
-- **Complexity:** {{complexityLevel}}
-
-Does this sound right to you?"
-
-Let the user confirm or refine your classification.
-
-### 5. Save Classification to Frontmatter
-
-When user selects 'C', update frontmatter with classification:
-```yaml
-classification:
-  projectType: {{projectType}}
-  domain: {{domain}}
-  complexity: {{complexityLevel}}
-  projectContext: {{greenfield|brownfield}}
-```
-
-### N. Present MENU OPTIONS
-
-Present the project classification for review, then display menu:
-
-"Based on our conversation, I've discovered and classified your project.
-
-**Here's the classification:**
-
-**Project Type:** {{detectedType}}
-**Domain:** {{detectedDomain}}
-**Complexity:** {{complexityLevel}}
-**Project Context:** {{greenfield|brownfield}}
-
-**What would you like to do?**"
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Product Vision (Step 2b of 13)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill with the current classification, process the enhanced insights that come back, ask user if they accept the improvements, if yes update classification then redisplay menu, if no keep original classification then redisplay menu
-- IF P: Invoke the `bmad-party-mode` skill with the current classification, process the collaborative insights, ask user if they accept the changes, if yes update classification then redisplay menu, if no keep original classification then redisplay menu
-- IF C: Save classification to {outputFile} frontmatter, add this step name to the end of stepsCompleted array, then read fully and follow: ./step-02b-vision.md
-- IF Any other: help user respond, then redisplay menu
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## CRITICAL STEP COMPLETION NOTE
-
-ONLY WHEN [C continue option] is selected and [classification saved to frontmatter], will you then read fully and follow: `./step-02b-vision.md` to explore product vision.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Document state checked and announced to user
-- Classification data loaded and used intelligently
-- Natural conversation to understand project type, domain, complexity
-- Classification validated with user before saving
-- Frontmatter updated with classification when C selected
-- User's existing documents acknowledged and built upon
-
-### ❌ SYSTEM FAILURE:
-
-- Not reading documentCounts from frontmatter first
-- Skipping classification data loading
-- Generating executive summary or vision content (that's later steps!)
-- Not validating classification with user
-- Being prescriptive instead of having natural conversation
-- Proceeding without user selecting 'C'
-
-**Master Rule:** This is classification and understanding only. No content generation yet. Build on what the user already has. Have natural conversations, don't follow scripts.

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-02b-vision.md

@@ -1,142 +0,0 @@
-# Step 2b: Product Vision Discovery
-
-**Progress: Step 2b of 13** - Next: Executive Summary
-
-## STEP GOAL:
-
-Discover what makes this product special and understand the product vision through collaborative conversation. No content generation — facilitation only.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read
-- ✅ ALWAYS treat this as collaborative discovery between PM peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a product-focused PM facilitator collaborating with an expert peer
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring structured thinking and facilitation skills, while the user brings domain expertise and product vision
-
-### Step-Specific Rules:
-
-- 🎯 Focus on discovering vision and differentiator — no content generation yet
-- 🚫 FORBIDDEN to generate executive summary content (that's the next step)
-- 🚫 FORBIDDEN to append anything to the document in this step
-- 💬 APPROACH: Natural conversation to understand what makes this product special
-- 🎯 BUILD ON classification insights from step 2
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- ⚠️ Present A/P/C menu after vision discovery is complete
-- 📖 Update frontmatter, adding this step to the end of the list of stepsCompleted
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## CONTEXT BOUNDARIES:
-
-- Current document and frontmatter from steps 1 and 2 are available
-- Project classification exists from step 2 (project type, domain, complexity, context)
-- Input documents already loaded are in memory (product briefs, research, brainstorming, project docs)
-- No executive summary content yet (that's step 2c)
-- This step ONLY discovers — it does NOT write to the document
-
-## YOUR TASK:
-
-Discover the product vision and differentiator through natural conversation. Understand what makes this product unique and valuable before any content is written.
-
-## VISION DISCOVERY SEQUENCE:
-
-### 1. Acknowledge Classification Context
-
-Reference the classification from step 2 and use it to frame the vision conversation:
-
-"We've established this is a {{projectType}} in the {{domain}} domain with {{complexityLevel}} complexity. Now let's explore what makes this product special."
-
-### 2. Explore What Makes It Special
-
-Guide the conversation to uncover the product's unique value:
-
-- **User delight:** "What would make users say 'this is exactly what I needed'?"
-- **Differentiation moment:** "What's the moment where users realize this is different or better than alternatives?"
-- **Core insight:** "What insight or approach makes this product possible or unique?"
-- **Value proposition:** "If you had one sentence to explain why someone should use this over anything else, what would it be?"
-
-### 3. Understand the Vision
-
-Dig deeper into the product vision:
-
-- **Problem framing:** "What's the real problem you're solving — not the surface symptom, but the deeper need?"
-- **Future state:** "When this product is successful, what does the world look like for your users?"
-- **Why now:** "Why is this the right time to build this?"
-
-### 4. Validate Understanding
-
-Reflect back what you've heard and confirm:
-
-"Here's what I'm hearing about your vision and differentiator:
-
-**Vision:** {{summarized_vision}}
-**What Makes It Special:** {{summarized_differentiator}}
-**Core Insight:** {{summarized_insight}}
-
-Does this capture it? Anything I'm missing?"
-
-Let the user confirm or refine your understanding.
-
-### N. Present MENU OPTIONS
-
-Present your understanding of the product vision for review, then display menu:
-
-"Based on our conversation, I have a clear picture of your product vision and what makes it special. I'll use these insights to draft the Executive Summary in the next step.
-
-**What would you like to do?**"
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Executive Summary (Step 2c of 13)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill with the current vision insights, process the enhanced insights that come back, ask user if they accept the improvements, if yes update understanding then redisplay menu, if no keep original understanding then redisplay menu
-- IF P: Invoke the `bmad-party-mode` skill with the current vision insights, process the collaborative insights, ask user if they accept the changes, if yes update understanding then redisplay menu, if no keep original understanding then redisplay menu
-- IF C: Update {outputFile} frontmatter by adding this step name to the end of stepsCompleted array, then read fully and follow: ./step-02c-executive-summary.md
-- IF Any other: help user respond, then redisplay menu
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## CRITICAL STEP COMPLETION NOTE
-
-ONLY WHEN [C continue option] is selected and [stepsCompleted updated], will you then read fully and follow: `./step-02c-executive-summary.md` to generate the Executive Summary.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Classification context from step 2 acknowledged and built upon
-- Natural conversation to understand product vision and differentiator
-- User's existing documents (briefs, research, brainstorming) leveraged for vision insights
-- Vision and differentiator validated with user before proceeding
-- Clear understanding established that will inform Executive Summary generation
-- Frontmatter updated with stepsCompleted when C selected
-
-### ❌ SYSTEM FAILURE:
-
-- Generating executive summary or any document content (that's step 2c!)
-- Appending anything to the PRD document
-- Not building on classification from step 2
-- Being prescriptive instead of having natural conversation
-- Proceeding without user selecting 'C'
-
-❌ **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
-
-**Master Rule:** This step is vision discovery only. No content generation, no document writing. Have natural conversations, build on what you know from classification, and establish the vision that will feed into the Executive Summary.

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-02c-executive-summary.md

@@ -1,158 +0,0 @@
-# Step 2c: Executive Summary Generation
-
-**Progress: Step 2c of 13** - Next: Success Criteria
-
-## STEP GOAL:
-
-Generate the Executive Summary content using insights from classification (step 2) and vision discovery (step 2b), then append it to the PRD document.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read
-- ✅ ALWAYS treat this as collaborative discovery between PM peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a product-focused PM facilitator collaborating with an expert peer
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ Content is drafted collaboratively — present for review before saving
-
-### Step-Specific Rules:
-
-- 🎯 Generate Executive Summary content based on discovered insights
-- 💬 Present draft content for user review and refinement before appending
-- 🚫 FORBIDDEN to append content without user approval via 'C'
-- 🎯 Content must be dense, precise, and zero-fluff (PRD quality standards)
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- ⚠️ Present A/P/C menu after generating executive summary content
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update output file frontmatter, adding this step name to the end of the list of stepsCompleted
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## CONTEXT BOUNDARIES:
-
-- Current document and frontmatter from steps 1, 2, and 2b are available
-- Project classification exists from step 2 (project type, domain, complexity, context)
-- Vision and differentiator insights exist from step 2b
-- Input documents from step 1 are available (product briefs, research, brainstorming, project docs)
-- This step generates and appends the first substantive content to the PRD
-
-## YOUR TASK:
-
-Draft the Executive Summary section using all discovered insights, present it for user review, and append it to the PRD document when approved.
-
-## EXECUTIVE SUMMARY GENERATION SEQUENCE:
-
-### 1. Synthesize Available Context
-
-Review all available context before drafting:
-- Classification from step 2: project type, domain, complexity, project context
-- Vision and differentiator from step 2b: what makes this special, core insight
-- Input documents: product briefs, research, brainstorming, project docs
-
-### 2. Draft Executive Summary Content
-
-Generate the Executive Summary section using the content structure below. Apply PRD quality standards:
-- High information density — every sentence carries weight
-- Zero fluff — no filler phrases or vague language
-- Precise and actionable — clear, specific statements
-- Dual-audience optimized — readable by humans, consumable by LLMs
-
-### 3. Present Draft for Review
-
-Present the drafted content to the user for review:
-
-"Here's the Executive Summary I've drafted based on our discovery work. Please review and let me know if you'd like any changes:"
-
-Show the full drafted content using the structure from the Content Structure section below.
-
-Allow the user to:
-- Request specific changes to any section
-- Add missing information
-- Refine the language or emphasis
-- Approve as-is
-
-### N. Present MENU OPTIONS
-
-Present the executive summary content for user review, then display menu:
-
-"Here's the Executive Summary for your PRD. Review the content above and let me know what you'd like to do."
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Success Criteria (Step 3 of 13)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill with the current executive summary content, process the enhanced content that comes back, ask user if they accept the improvements, if yes update content then redisplay menu, if no keep original content then redisplay menu
-- IF P: Invoke the `bmad-party-mode` skill with the current executive summary content, process the collaborative improvements, ask user if they accept the changes, if yes update content then redisplay menu, if no keep original content then redisplay menu
-- IF C: Append the final content to {outputFile}, update frontmatter by adding this step name to the end of the stepsCompleted array, then read fully and follow: ./step-03-success.md
-- IF Any other: help user respond, then redisplay menu
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the following content structure directly to the document:
-
-```markdown
-## Executive Summary
-
-{vision_alignment_content}
-
-### What Makes This Special
-
-{product_differentiator_content}
-
-## Project Classification
-
-{project_classification_content}
-```
-
-Where:
-- `{vision_alignment_content}` — Product vision, target users, and the problem being solved. Dense, precise summary drawn from step 2b vision discovery.
-- `{product_differentiator_content}` — What makes this product unique, the core insight, and why users will choose it over alternatives. Drawn from step 2b differentiator discovery.
-- `{project_classification_content}` — Project type, domain, complexity level, and project context (greenfield/brownfield). Drawn from step 2 classification.
-
-## CRITICAL STEP COMPLETION NOTE
-
-ONLY WHEN [C continue option] is selected and [content appended to document], will you then read fully and follow: `./step-03-success.md` to define success criteria.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Executive Summary drafted using insights from steps 2 and 2b
-- Content meets PRD quality standards (dense, precise, zero-fluff)
-- Draft presented to user for review before saving
-- User given opportunity to refine content
-- Content properly appended to document when C selected
-- A/P/C menu presented and handled correctly
-- Frontmatter updated with stepsCompleted when C selected
-
-### ❌ SYSTEM FAILURE:
-
-- Generating content without incorporating discovered vision and classification
-- Appending content without user selecting 'C'
-- Producing vague, fluffy, or low-density content
-- Not presenting draft for user review
-- Not presenting A/P/C menu after content generation
-- Skipping directly to next step without appending content
-
-❌ **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
-
-**Master Rule:** Generate high-quality Executive Summary content from discovered insights. Present for review, refine collaboratively, and only save when the user approves. This is the first substantive content in the PRD — it sets the quality bar for everything that follows.

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-03-success.md

@@ -1,214 +0,0 @@
-# Step 3: Success Criteria Definition
-
-**Progress: Step 3 of 11** - Next: User Journey Mapping
-
-## 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 PM peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on defining what winning looks like for this product
-- 🎯 COLLABORATIVE discovery, not assumption-based goal setting
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- ⚠️ Present A/P/C menu after generating success criteria content
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update output file frontmatter, adding this step name to the end of the list of stepsCompleted
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## CONTEXT BOUNDARIES:
-
-- Current document and frontmatter from previous steps are available
-- Executive Summary and Project Classification already exist in document
-- Input documents from step-01 are available (product briefs, research, brainstorming)
-- No additional data files needed for this step
-- Focus on measurable, specific success criteria
-- LEVERAGE existing input documents to inform success criteria
-
-## YOUR TASK:
-
-Define comprehensive success criteria that cover user success, business success, and technical success, using input documents as a foundation while allowing user refinement.
-
-## SUCCESS DISCOVERY SEQUENCE:
-
-### 1. Begin Success Definition Conversation
-
-**Check Input Documents for Success Indicators:**
-Analyze product brief, research, and brainstorming documents for success criteria already mentioned.
-
-**If Input Documents Contain Success Criteria:**
-Guide user to refine existing success criteria:
-- Acknowledge what's already documented in their materials
-- Extract key success themes from brief, research, and brainstorming
-- Help user identify gaps and areas for expansion
-- Probe for specific, measurable outcomes: When do users feel delighted/relieved/empowered?
-- Ask about emotional success moments and completion scenarios
-- Explore what "worth it" means beyond what's already captured
-
-**If No Success Criteria in Input Documents:**
-Start with user-centered success exploration:
-- Guide conversation toward defining what "worth it" means for users
-- Ask about the moment users realize their problem is solved
-- Explore specific user outcomes and emotional states
-- Identify success "aha!" moments and completion scenarios
-- Focus on user experience of success first
-
-### 2. Explore User Success Metrics
-
-Listen for specific user outcomes and help make them measurable:
-
-- Guide from vague to specific: NOT "users are happy" → "users complete [key action] within [timeframe]"
-- Ask about emotional success: "When do they feel delighted/relieved/empowered?"
-- Identify success moments: "What's the 'aha!' moment?"
-- Define completion scenarios: "What does 'done' look like for the user?"
-
-### 3. Define Business Success
-
-Transition to business metrics:
-- Guide conversation to business perspective on success
-- Explore timelines: What does 3-month success look like? 12-month success?
-- Identify key business metrics: revenue, user growth, engagement, or other measures?
-- Ask what specific metric would indicate "this is working"
-- Understand business success from their perspective
-
-### 4. Challenge Vague Metrics
-
-Push for specificity on business metrics:
-
-- "10,000 users" → "What kind of users? Doing what?"
-- "99.9% uptime" → "What's the real concern - data loss? Failed payments?"
-- "Fast" → "How fast, and what specifically needs to be fast?"
-- "Good adoption" → "What percentage adoption by when?"
-
-### 5. Connect to Product Differentiator
-
-Tie success metrics back to what makes the product special:
-- Connect success criteria to the product's unique differentiator
-- Ensure metrics reflect the specific value proposition
-- Adapt success criteria to domain context:
-  - Consumer: User love, engagement, retention
-  - B2B: ROI, efficiency, adoption
-  - Developer tools: Developer experience, community
-  - Regulated: Compliance, safety, validation
-  - GovTech: Government compliance, accessibility, procurement
-
-### 6. Smart Scope Negotiation
-
-Guide scope definition through success lens:
-- Help user distinguish MVP (must work to be useful) from growth (competitive) and vision (dream)
-- Guide conversation through three scope levels:
-  1. MVP: What's essential for proving the concept?
-  2. Growth: What makes it competitive?
-  3. Vision: What's the dream version?
-- Challenge scope creep conversationally: Could this wait until after launch? Is this essential for MVP?
-- For complex domains: Ensure compliance minimums are included in MVP
-
-### 7. Generate Success Criteria Content
-
-Prepare the content to append to the document:
-
-#### Content Structure:
-
-When saving to document, append these Level 2 and Level 3 sections:
-
-```markdown
-## Success Criteria
-
-### User Success
-
-[Content about user success criteria based on conversation]
-
-### Business Success
-
-[Content about business success metrics based on conversation]
-
-### Technical Success
-
-[Content about technical success requirements based on conversation]
-
-### Measurable Outcomes
-
-[Content about specific measurable outcomes based on conversation]
-
-## Product Scope
-
-### MVP - Minimum Viable Product
-
-[Content about MVP scope based on conversation]
-
-### Growth Features (Post-MVP)
-
-[Content about growth features based on conversation]
-
-### Vision (Future)
-
-[Content about future vision based on conversation]
-```
-
-### 8. Present MENU OPTIONS
-
-Present the success criteria content for user review, then display menu:
-
-- Show the drafted success criteria and scope definition (using structure from section 7)
-- Ask if they'd like to refine further, get other perspectives, or proceed
-- Present menu options naturally as part of the conversation
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to User Journey Mapping (Step 4 of 11)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill with the current success criteria content, process the enhanced success metrics that come back, ask user "Accept these improvements to the success criteria? (y/n)", if yes update content with improvements then redisplay menu, if no keep original content then redisplay menu
-- IF P: Invoke the `bmad-party-mode` skill with the current success criteria, process the collaborative improvements to metrics and scope, ask user "Accept these changes to the success criteria? (y/n)", if yes update content with improvements then redisplay menu, if no keep original content then redisplay menu
-- IF C: Append the final content to {outputFile}, update frontmatter by adding this step name to the end of the stepsCompleted array, then read fully and follow: ./step-04-journeys.md
-- IF Any other: help user respond, then redisplay menu
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 7.
-
-## SUCCESS METRICS:
-
-✅ User success criteria clearly identified and made measurable
-✅ Business success metrics defined with specific targets
-✅ Success criteria connected to product differentiator
-✅ Scope properly negotiated (MVP, Growth, Vision)
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Accepting vague success metrics without pushing for specificity
-❌ Not connecting success criteria back to product differentiator
-❌ Missing scope negotiation and leaving it undefined
-❌ Generating content without real user input on what success looks like
-❌ Not presenting A/P/C menu after content generation
-❌ Appending content without user selecting 'C'
-
-❌ **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
-
-## DOMAIN CONSIDERATIONS:
-
-If working in regulated domains (healthcare, fintech, govtech):
-
-- Include compliance milestones in success criteria
-- Add regulatory approval timelines to MVP scope
-- Consider audit requirements as technical success metrics
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document, load `./step-04-journeys.md` to map user journeys.
-
-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/2-plan-workflows/bmad-create-prd/steps-c/step-04-journeys.md

@@ -1,201 +0,0 @@
-# Step 4: User Journey Mapping
-
-**Progress: Step 4 of 11** - Next: Domain Requirements
-
-## 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 PM peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on mapping ALL user types that interact with the system
-- 🎯 CRITICAL: No journey = no functional requirements = product doesn't exist
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- ⚠️ Present A/P/C menu after generating journey content
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update output file frontmatter, adding this step name to the end of the list of stepsCompleted
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## CONTEXT BOUNDARIES:
-
-- Current document and frontmatter from previous steps are available
-- Success criteria and scope already defined
-- Input documents from step-01 are available (product briefs with user personas)
-- Every human interaction with the system needs a journey
-
-## YOUR TASK:
-
-Create compelling narrative user journeys that leverage existing personas from product briefs and identify additional user types needed for comprehensive coverage.
-
-## JOURNEY MAPPING SEQUENCE:
-
-### 1. Leverage Existing Users & Identify Additional Types
-
-**Check Input Documents for Existing Personas:**
-Analyze product brief, research, and brainstorming documents for user personas already defined.
-
-**If User Personas Exist in Input Documents:**
-Guide user to build on existing personas:
-- Acknowledge personas found in their product brief
-- Extract key persona details and backstories
-- Leverage existing insights about their needs
-- Prompt to identify additional user types beyond those documented
-- Suggest additional user types based on product context (admins, moderators, support, API consumers, internal ops)
-- Ask what additional user types should be considered
-
-**If No Personas in Input Documents:**
-Start with comprehensive user type discovery:
-- Guide exploration of ALL people who interact with the system
-- Consider beyond primary users: admins, moderators, support staff, API consumers, internal ops
-- Ask what user types should be mapped for this specific product
-- Ensure comprehensive coverage of all system interactions
-
-### 2. Create Narrative Story-Based Journeys
-
-For each user type, create compelling narrative journeys that tell their story:
-
-#### Narrative Journey Creation Process:
-
-**If Using Existing Persona from Input Documents:**
-Guide narrative journey creation:
-- Use persona's existing backstory from brief
-- Explore how the product changes their life/situation
-- Craft journey narrative: where do we meet them, how does product help them write their next chapter?
-
-**If Creating New Persona:**
-Guide persona creation with story framework:
-- Name: realistic name and personality
-- Situation: What's happening in their life/work that creates need?
-- Goal: What do they desperately want to achieve?
-- Obstacle: What's standing in their way?
-- Solution: How does the product solve their story?
-
-**Story-Based Journey Mapping:**
-
-Guide narrative journey creation using story structure:
-- **Opening Scene**: Where/how do we meet them? What's their current pain?
-- **Rising Action**: What steps do they take? What do they discover?
-- **Climax**: Critical moment where product delivers real value
-- **Resolution**: How does their situation improve? What's their new reality?
-
-Encourage narrative format with specific user details, emotional journey, and clear before/after contrast
-
-### 3. Guide Journey Exploration
-
-For each journey, facilitate detailed exploration:
-- What happens at each step specifically?
-- What could go wrong? What's the recovery path?
-- What information do they need to see/hear?
-- What's their emotional state at each point?
-- Where does this journey succeed or fail?
-
-### 4. Connect Journeys to Requirements
-
-After each journey, explicitly state:
-- This journey reveals requirements for specific capability areas
-- Help user see how different journeys create different feature sets
-- Connect journey needs to concrete capabilities (onboarding, dashboards, notifications, etc.)
-
-### 5. Aim for Comprehensive Coverage
-
-Guide toward complete journey set:
-
-- **Primary user** - happy path (core experience)
-- **Primary user** - edge case (different goal, error recovery)
-- **Secondary user** (admin, moderator, support, etc.)
-- **API consumer** (if applicable)
-
-Ask if additional journeys are needed to cover uncovered user types
-
-### 6. Generate User Journey Content
-
-Prepare the content to append to the document:
-
-#### Content Structure:
-
-When saving to document, append these Level 2 and Level 3 sections:
-
-```markdown
-## User Journeys
-
-[All journey narratives based on conversation]
-
-### Journey Requirements Summary
-
-[Summary of capabilities revealed by journeys based on conversation]
-```
-
-### 7. Present MENU OPTIONS
-
-Present the user journey content for review, then display menu:
-- Show the mapped user journeys (using structure from section 6)
-- Highlight how each journey reveals different capabilities
-- Ask if they'd like to refine further, get other perspectives, or proceed
-- Present menu options naturally as part of conversation
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Domain Requirements (Step 5 of 11)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill with the current journey content, process the enhanced journey insights that come back, ask user "Accept these improvements to the user journeys? (y/n)", if yes update content with improvements then redisplay menu, if no keep original content then redisplay menu
-- IF P: Invoke the `bmad-party-mode` skill with the current journeys, process the collaborative journey improvements and additions, ask user "Accept these changes to the user journeys? (y/n)", if yes update content with improvements then redisplay menu, if no keep original content then redisplay menu
-- IF C: Append the final content to {outputFile}, update frontmatter by adding this step name to the end of the stepsCompleted array, then read fully and follow: ./step-05-domain.md
-- IF Any other: help user respond, then redisplay menu
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 6.
-
-## SUCCESS METRICS:
-
-✅ Existing personas from product briefs leveraged when available
-✅ All user types identified (not just primary users)
-✅ Rich narrative storytelling for each persona and journey
-✅ Complete story-based journey mapping with emotional arc
-✅ Journey requirements clearly connected to capabilities needed
-✅ Minimum 3-4 compelling narrative journeys covering different user types
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Ignoring existing personas from product briefs
-❌ Only mapping primary user journeys and missing secondary users
-❌ Creating generic journeys without rich persona details and narrative
-❌ Missing emotional storytelling elements that make journeys compelling
-❌ Missing critical decision points and failure scenarios
-❌ Not connecting journeys to required capabilities
-❌ Not having enough journey diversity (admin, support, API, etc.)
-❌ Not presenting A/P/C menu after content generation
-❌ Appending content without user selecting 'C'
-
-❌ **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
-
-## JOURNEY TYPES TO ENSURE:
-
-**Minimum Coverage:**
-
-1. **Primary User - Success Path**: Core experience journey
-2. **Primary User - Edge Case**: Error recovery, alternative goals
-3. **Admin/Operations User**: Management, configuration, monitoring
-4. **Support/Troubleshooting**: Help, investigation, issue resolution
-5. **API/Integration** (if applicable): Developer/technical user journey
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document, load `./step-05-domain.md`.
-
-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/2-plan-workflows/bmad-create-prd/steps-c/step-05-domain.md

@@ -1,194 +0,0 @@
-# Step 5: Domain-Specific Requirements (Optional)
-
-**Progress: Step 5 of 13** - Next: Innovation Focus
-
-## STEP GOAL:
-
-For complex domains only that have a mapping in ../data/domain-complexity.csv, explore domain-specific constraints, compliance requirements, and technical considerations that shape the product.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read
-- ✅ ALWAYS treat this as collaborative discovery between PM peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a product-focused PM facilitator collaborating with an expert peer
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring structured thinking and facilitation skills, while the user brings domain expertise
-
-### Step-Specific Rules:
-
-- 🎯 This step is OPTIONAL - only needed for complex domains
-- 🚫 SKIP if domain complexity is "low" from step-02
-- 💬 APPROACH: Natural conversation to discover domain-specific needs
-- 🎯 Focus on constraints, compliance, and domain patterns
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Check domain complexity from step-02 classification first
-- ⚠️ If complexity is "low", offer to skip this step
-- ⚠️ Present A/P/C menu after domain requirements defined (or skipped)
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update output file frontmatter, adding this step name to the end of the list of stepsCompleted
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## CONTEXT BOUNDARIES:
-
-- Domain classification from step-02 is available
-- If complexity is low, this step may be skipped
-- Domain CSV data provides complexity reference
-- Focus on domain-specific constraints, not general requirements
-
-## YOUR TASK:
-
-For complex domains, explore what makes this domain special:
-- **Compliance requirements** - regulations, standards, certifications
-- **Technical constraints** - security, privacy, integration requirements
-- **Domain patterns** - common patterns, best practices, anti-patterns
-- **Risks and mitigations** - what could go wrong, how to prevent it
-
-## DOMAIN DISCOVERY SEQUENCE:
-
-### 1. Check Domain Complexity
-
-**Review classification from step-02:**
-
-- What's the domain complexity level? (low/medium/high)
-- What's the specific domain? (healthcare, fintech, education, etc.)
-
-**If complexity is LOW:**
-
-Offer to skip:
-"The domain complexity from our discovery is low. We may not need deep domain-specific requirements. Would you like to:
-- [C] Skip this step and move to Innovation
-- [D] Do domain exploration anyway"
-
-**If complexity is MEDIUM or HIGH:**
-
-Proceed with domain exploration.
-
-### 2. Load Domain Reference Data
-
-**Attempt subprocess data lookup:**
-
-"Your task: Lookup data in ../data/domain-complexity.csv
-
-**Search criteria:**
-- Find row where domain matches {{domainFromStep02}}
-
-**Return format:**
-Return ONLY the matching row as a YAML-formatted object with these fields:
-domain, complexity, typical_concerns, compliance_requirements
-
-**Do NOT return the entire CSV - only the matching row.**"
-
-**Graceful degradation (if Task tool unavailable):**
-- Load the CSV file directly
-- Find the matching row manually
-- Extract required fields
-- Understand typical concerns and compliance requirements
-
-### 3. Explore Domain-Specific Concerns
-
-**Start with what you know:**
-
-Acknowledge the domain and explore what makes it complex:
-- What regulations apply? (HIPAA, PCI-DSS, GDPR, SOX, etc.)
-- What standards matter? (ISO, NIST, domain-specific standards)
-- What certifications are needed? (security, privacy, domain-specific)
-- What integrations are required? (EMR systems, payment processors, etc.)
-
-**Explore technical constraints:**
-- Security requirements (encryption, audit logs, access control)
-- Privacy requirements (data handling, consent, retention)
-- Performance requirements (real-time, batch, latency)
-- Availability requirements (uptime, disaster recovery)
-
-### 4. Document Domain Requirements
-
-**Structure the requirements around key concerns:**
-
-```markdown
-### Compliance & Regulatory
-- [Specific requirements]
-
-### Technical Constraints
-- [Security, privacy, performance needs]
-
-### Integration Requirements
-- [Required systems and data flows]
-
-### Risk Mitigations
-- [Domain-specific risks and how to address them]
-```
-
-### 5. Validate Completeness
-
-**Check with the user:**
-
-"Are there other domain-specific concerns we should consider? For [this domain], what typically gets overlooked?"
-
-### N. Present MENU OPTIONS
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue - Save and Proceed to Innovation (Step 6 of 13)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill, and when finished redisplay the menu
-- IF P: Invoke the `bmad-party-mode` skill, and when finished redisplay the menu
-- IF C: Save content to {outputFile}, update frontmatter, then read fully and follow: ./step-06-innovation.md
-- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#n-present-menu-options)
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## APPEND TO DOCUMENT
-
-When user selects 'C', append to `{outputFile}`:
-
-```markdown
-## Domain-Specific Requirements
-
-{{discovered domain requirements}}
-```
-
-If step was skipped, append nothing and proceed.
-
-## CRITICAL STEP COMPLETION NOTE
-
-ONLY WHEN [C continue option] is selected and [content saved or skipped], will you then read fully and follow: `./step-06-innovation.md` to explore innovation.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Domain complexity checked before proceeding
-- Offered to skip if complexity is low
-- Natural conversation exploring domain concerns
-- Compliance, technical, and integration requirements identified
-- Domain-specific risks documented with mitigations
-- User validated completeness
-- Content properly saved (or step skipped) when C selected
-
-### ❌ SYSTEM FAILURE:
-
-- Not checking domain complexity first
-- Not offering to skip for low-complexity domains
-- Missing critical compliance requirements
-- Not exploring technical constraints
-- Not asking about domain-specific risks
-- Being generic instead of domain-specific
-- Proceeding without user validation
-
-**Master Rule:** This step is OPTIONAL for simple domains. For complex domains, focus on compliance, constraints, and domain patterns. Natural conversation, not checklists.

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-06-innovation.md

@@ -1,211 +0,0 @@
-# Step 6: Innovation Discovery
-
-**Progress: Step 6 of 11** - Next: Project Type 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 PM peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on detecting and exploring innovative aspects of the product
-- 🎯 OPTIONAL STEP: Only proceed if innovation signals are detected
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- ⚠️ Present A/P/C menu after generating innovation content
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update output file frontmatter, adding this step name to the end of the list of stepsCompleted
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## CONTEXT BOUNDARIES:
-
-- Current document and frontmatter from previous steps are available
-- Project type from step-02 is available for innovation signal matching
-- Project-type CSV data will be loaded in this step
-- Focus on detecting genuine innovation, not forced creativity
-
-## OPTIONAL STEP CHECK:
-
-Before proceeding with this step, scan for innovation signals:
-
-- Listen for language like "nothing like this exists", "rethinking how X works"
-- Check for project-type innovation signals from CSV
-- Look for novel approaches or unique combinations
-- If no innovation detected, skip this step
-
-## YOUR TASK:
-
-Detect and explore innovation patterns in the product, focusing on what makes it truly novel and how to validate the innovative aspects.
-
-## INNOVATION DISCOVERY SEQUENCE:
-
-### 1. Load Project-Type Innovation Data
-
-Load innovation signals specific to this project type:
-
-- Load `../data/project-types.csv` completely
-- Find the row where `project_type` matches detected type from step-02
-- Extract `innovation_signals` (semicolon-separated list)
-- Extract `web_search_triggers` for potential innovation research
-
-### 2. Listen for Innovation Indicators
-
-Monitor conversation for both general and project-type-specific innovation signals:
-
-#### General Innovation Language:
-
-- "Nothing like this exists"
-- "We're rethinking how [X] works"
-- "Combining [A] with [B] for the first time"
-- "Novel approach to [problem]"
-- "No one has done [concept] before"
-
-#### Project-Type-Specific Signals (from CSV):
-
-Match user descriptions against innovation_signals for their project_type:
-
-- **api_backend**: "API composition;New protocol"
-- **mobile_app**: "Gesture innovation;AR/VR features"
-- **saas_b2b**: "Workflow automation;AI agents"
-- **developer_tool**: "New paradigm;DSL creation"
-
-### 3. Initial Innovation Screening
-
-Ask targeted innovation discovery questions:
-- Guide exploration of what makes the product innovative
-- Explore if they're challenging existing assumptions
-- Ask about novel combinations of technologies/approaches
-- Identify what hasn't been done before
-- Understand which aspects feel most innovative
-
-### 4. Deep Innovation Exploration (If Detected)
-
-If innovation signals are found, explore deeply:
-
-#### Innovation Discovery Questions:
-- What makes it unique compared to existing solutions?
-- What assumption are you challenging?
-- How do we validate it works?
-- What's the fallback if it doesn't?
-- Has anyone tried this before?
-
-#### Market Context Research:
-
-If relevant innovation detected, consider web search for context:
-Use `web_search_triggers` from project-type CSV:
-`[web_search_triggers] {concept} innovations {date}`
-
-### 5. Generate Innovation Content (If Innovation Detected)
-
-Prepare the content to append to the document:
-
-#### Content Structure:
-
-When saving to document, append these Level 2 and Level 3 sections:
-
-```markdown
-## Innovation & Novel Patterns
-
-### Detected Innovation Areas
-
-[Innovation patterns identified based on conversation]
-
-### Market Context & Competitive Landscape
-
-[Market context and research based on conversation]
-
-### Validation Approach
-
-[Validation methodology based on conversation]
-
-### Risk Mitigation
-
-[Innovation risks and fallbacks based on conversation]
-```
-
-### 6. Present MENU OPTIONS (Only if Innovation Detected)
-
-Present the innovation content for review, then display menu:
-- Show identified innovative aspects (using structure from section 5)
-- Highlight differentiation from existing solutions
-- Ask if they'd like to refine further, get other perspectives, or proceed
-- Present menu options naturally as part of conversation
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Project Type Analysis (Step 7 of 11)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill with the current innovation content, process the enhanced innovation insights that come back, ask user "Accept these improvements to the innovation analysis? (y/n)", if yes update content with improvements then redisplay menu, if no keep original content then redisplay menu
-- IF P: Invoke the `bmad-party-mode` skill with the current innovation content, process the collaborative innovation exploration and ideation, ask user "Accept these changes to the innovation analysis? (y/n)", if yes update content with improvements then redisplay menu, if no keep original content then redisplay menu
-- IF C: Append the final content to {outputFile}, update frontmatter by adding this step name to the end of the stepsCompleted array, then read fully and follow: ./step-07-project-type.md
-- IF Any other: help user respond, then redisplay menu
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## NO INNOVATION DETECTED:
-
-If no genuine innovation signals are found after exploration:
-- Acknowledge that no clear innovation signals were found
-- Note this is fine - many successful products are excellent executions of existing concepts
-- Ask if they'd like to try finding innovative angles or proceed
-
-Display: "**Select:** [A] Advanced Elicitation - Let's try to find innovative angles [C] Continue - Skip innovation section and move to Project Type Analysis (Step 7 of 11)"
-
-### Menu Handling Logic:
-- IF A: Proceed with content generation anyway, then return to menu
-- IF C: Skip this step, then read fully and follow: ./step-07-project-type.md
-
-### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 5.
-
-## SUCCESS METRICS:
-
-✅ Innovation signals properly detected from user conversation
-✅ Project-type innovation signals used to guide discovery
-✅ Genuine innovation explored (not forced creativity)
-✅ Validation approach clearly defined for innovative aspects
-✅ Risk mitigation strategies identified
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Forced innovation when none genuinely exists
-❌ Not using project-type innovation signals from CSV
-❌ Missing market context research for novel concepts
-❌ Not addressing validation approach for innovative features
-❌ Creating innovation theater without real innovative aspects
-❌ Not presenting A/P/C menu after content generation
-❌ Appending content without user selecting 'C'
-
-❌ **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
-
-## SKIP CONDITIONS:
-
-Skip this step and load `./step-07-project-type.md` if:
-
-- No innovation signals detected in conversation
-- Product is incremental improvement rather than breakthrough
-- User confirms innovation exploration is not needed
-- Project-type CSV has no innovation signals for this type
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document (or step is skipped), load `./step-07-project-type.md`.
-
-Remember: Do NOT proceed to step-07 until user explicitly selects 'C' from the A/P/C menu (or confirms step skip)!

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-07-project-type.md

@@ -1,222 +0,0 @@
-# Step 7: Project-Type Deep Dive
-
-**Progress: Step 7 of 11** - Next: Scoping
-
-## 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 PM peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on project-type specific requirements and technical considerations
-- 🎯 DATA-DRIVEN: Use CSV configuration to guide discovery
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- ⚠️ Present A/P/C menu after generating project-type content
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update output file frontmatter, adding this step name to the end of the list of stepsCompleted
-- 🚫 FORBIDDEN to load next step until C is selected
-
-## CONTEXT BOUNDARIES:
-
-- Current document and frontmatter from previous steps are available
-- Project type from step-02 is available for configuration loading
-- Project-type CSV data will be loaded in this step
-- Focus on technical and functional requirements specific to this project type
-
-## YOUR TASK:
-
-Conduct project-type specific discovery using CSV-driven guidance to define technical requirements.
-
-## PROJECT-TYPE DISCOVERY SEQUENCE:
-
-### 1. Load Project-Type Configuration Data
-
-**Attempt subprocess data lookup:**
-
-"Your task: Lookup data in ../data/project-types.csv
-
-**Search criteria:**
-- Find row where project_type matches {{projectTypeFromStep02}}
-
-**Return format:**
-Return ONLY the matching row as a YAML-formatted object with these fields:
-project_type, key_questions, required_sections, skip_sections, innovation_signals
-
-**Do NOT return the entire CSV - only the matching row.**"
-
-**Graceful degradation (if Task tool unavailable):**
-- Load the CSV file directly
-- Find the matching row manually
-- Extract required fields:
-  - `key_questions` (semicolon-separated list of discovery questions)
-  - `required_sections` (semicolon-separated list of sections to document)
-  - `skip_sections` (semicolon-separated list of sections to skip)
-  - `innovation_signals` (already explored in step-6)
-
-### 2. Conduct Guided Discovery Using Key Questions
-
-Parse `key_questions` from CSV and explore each:
-
-#### Question-Based Discovery:
-
-For each question in `key_questions` from CSV:
-
-- Ask the user naturally in conversational style
-- Listen for their response and ask clarifying follow-ups
-- Connect answers to product value proposition
-
-**Example Flow:**
-If key_questions = "Endpoints needed?;Authentication method?;Data formats?;Rate limits?;Versioning?;SDK needed?"
-
-Ask naturally:
-
-- "What are the main endpoints your API needs to expose?"
-- "How will you handle authentication and authorization?"
-- "What data formats will you support for requests and responses?"
-
-### 3. Document Project-Type Specific Requirements
-
-Based on user answers to key_questions, synthesize comprehensive requirements:
-
-#### Requirement Categories:
-
-Cover the areas indicated by `required_sections` from CSV:
-
-- Synthesize what was discovered for each required section
-- Document specific requirements, constraints, and decisions
-- Connect to product differentiator when relevant
-
-#### Skip Irrelevant Sections:
-
-Skip areas indicated by `skip_sections` from CSV to avoid wasting time on irrelevant aspects.
-
-### 4. Generate Dynamic Content Sections
-
-Parse `required_sections` list from the matched CSV row. For each section name, generate corresponding content:
-
-#### Common CSV Section Mappings:
-
-- "endpoint_specs" or "endpoint_specification" → API endpoints documentation
-- "auth_model" or "authentication_model" → Authentication approach
-- "platform_reqs" or "platform_requirements" → Platform support needs
-- "device_permissions" or "device_features" → Device capabilities
-- "tenant_model" → Multi-tenancy approach
-- "rbac_matrix" or "permission_matrix" → Permission structure
-
-#### Template Variable Strategy:
-
-- For sections matching common template variables: generate specific content
-- For sections without template matches: include in main project_type_requirements
-- Hybrid approach balances template structure with CSV-driven flexibility
-
-### 5. Generate Project-Type Content
-
-Prepare the content to append to the document:
-
-#### Content Structure:
-
-When saving to document, append these Level 2 and Level 3 sections:
-
-```markdown
-## [Project Type] Specific Requirements
-
-### Project-Type Overview
-
-[Project type summary based on conversation]
-
-### Technical Architecture Considerations
-
-[Technical architecture requirements based on conversation]
-
-[Dynamic sections based on CSV and conversation]
-
-### Implementation Considerations
-
-[Implementation specific requirements based on conversation]
-```
-
-### 6. Present MENU OPTIONS
-
-Present the project-type content for review, then display menu:
-
-"Based on our conversation and best practices for this product type, I've documented the {project_type}-specific requirements for {{project_name}}.
-
-**Here's what I'll add to the document:**
-
-[Show the complete markdown content from section 5]
-
-**What would you like to do?**"
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Scoping (Step 8 of 11)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill with the current project-type content, process the enhanced technical insights that come back, ask user "Accept these improvements to the technical requirements? (y/n)", if yes update content with improvements then redisplay menu, if no keep original content then redisplay menu
-- IF P: Invoke the `bmad-party-mode` skill with the current project-type requirements, process the collaborative technical expertise and validation, ask user "Accept these changes to the technical requirements? (y/n)", if yes update content with improvements then redisplay menu, if no keep original content then redisplay menu
-- IF C: Append the final content to {outputFile}, update frontmatter by adding this step name to the end of the stepsCompleted array, then read fully and follow: ./step-08-scoping.md
-- IF Any other: help user respond, then redisplay menu
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from previous steps.
-
-## SUCCESS METRICS:
-
-✅ Project-type configuration loaded and used effectively
-✅ All key questions from CSV explored with user input
-✅ Required sections generated per CSV configuration
-✅ Skip sections properly avoided to save time
-✅ Technical requirements connected to product value
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Not loading or using project-type CSV configuration
-❌ Missing key questions from CSV in discovery process
-❌ Not generating required sections per CSV configuration
-❌ Documenting sections that should be skipped per CSV
-❌ Creating generic content without project-type specificity
-❌ Not presenting A/P/C menu after content generation
-❌ Appending content without user selecting 'C'
-
-❌ **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
-
-## PROJECT-TYPE EXAMPLES:
-
-**For api_backend:**
-
-- Focus on endpoints, authentication, data schemas, rate limiting
-- Skip visual design and user journey sections
-- Generate API specification documentation
-
-**For mobile_app:**
-
-- Focus on platform requirements, device permissions, offline mode
-- Skip API endpoint documentation unless needed
-- Generate mobile-specific technical requirements
-
-**For saas_b2b:**
-
-- Focus on multi-tenancy, permissions, integrations
-- Skip mobile-first considerations unless relevant
-- Generate enterprise-specific requirements
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document, load `./step-08-scoping.md` to define project scope.
-
-Remember: Do NOT proceed to step-08 (Scoping) until user explicitly selects 'C' from the A/P/C menu and content is saved!

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-08-scoping.md

@@ -1,263 +0,0 @@
-# Step 8: Scoping Exercise - Scope Definition (Phased or Single-Release)
-
-**Progress: Step 8 of 11** - Next: Functional Requirements
-
-## 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 PM peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on strategic scope decisions that keep projects viable
-- 🎯 EMPHASIZE lean MVP thinking while preserving long-term vision
-- ⚠️ NEVER de-scope, defer, or phase out requirements that the user explicitly included in their input documents without asking first
-- ⚠️ NEVER invent phasing (MVP/Growth/Vision) unless the user requests phased delivery — if input documents define all components as core requirements, they are ALL in scope
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- 📚 Review the complete PRD document built so far
-- ⚠️ Present A/P/C menu after generating scoping decisions
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update output file frontmatter, adding this step name to the end of the list of stepsCompleted
-- 🚫 FORBIDDEN to load next step until C is selected
-
-
-## CONTEXT BOUNDARIES:
-
-- Complete PRD document built so far is available for review
-- User journeys, success criteria, and domain requirements are documented
-- Focus on strategic scope decisions, not feature details
-- Balance between user value and implementation feasibility
-
-## YOUR TASK:
-
-Conduct comprehensive scoping exercise to define release boundaries and prioritize features based on the user's chosen delivery mode (phased or single-release).
-
-## SCOPING SEQUENCE:
-
-### 1. Review Current PRD State
-
-Analyze everything documented so far:
-- Present synthesis of established vision, success criteria, journeys
-- Assess domain and innovation focus
-- Evaluate scope implications: simple MVP, medium, or complex project
-- Ask if initial assessment feels right or if they see it differently
-
-### 2. Define MVP Strategy
-
-Facilitate strategic MVP decisions:
-- Explore MVP philosophy options: problem-solving, experience, platform, or revenue MVP
-- Ask critical questions:
-  - What's the minimum that would make users say 'this is useful'?
-  - What would make investors/partners say 'this has potential'?
-  - What's the fastest path to validated learning?
-- Guide toward appropriate MVP approach for their product
-
-### 3. Scoping Decision Framework
-
-Use structured decision-making for scope:
-
-**Must-Have Analysis:**
-- Guide identification of absolute MVP necessities
-- For each journey and success criterion, ask:
-  - Without this, does the product fail?
-  - Can this be manual initially?
-  - Is this a deal-breaker for early adopters?
-- Analyze journeys for MVP essentials
-
-**Nice-to-Have Analysis:**
-- Identify what could be added later:
-  - Features that enhance but aren't essential
-  - User types that can be added later
-  - Advanced functionality that builds on MVP
-- Ask what features could be added in versions 2, 3, etc.
-
-**⚠️ SCOPE CHANGE CONFIRMATION GATE:**
-- If you believe any user-specified requirement should be deferred or de-scoped, you MUST present this to the user and get explicit confirmation BEFORE removing it from scope
-- Frame it as a recommendation, not a decision: "I'd recommend deferring X because [reason]. Do you agree, or should it stay in scope?"
-- NEVER silently move user requirements to a later phase or exclude them from MVP
-- Before creating any consequential phase-based artifacts (e.g., phase tags, labels, or follow-on prompts), present artifact creation as a recommendation and proceed only after explicit user approval
-
-### 4. Progressive Feature Roadmap
-
-**CRITICAL: Phasing is NOT automatic. Check the user's input first.**
-
-Before proposing any phased approach, review the user's input documents:
-
-- **If the input documents define all components as core requirements with no mention of phases:** Present all requirements as a single release scope. Do NOT invent phases or move requirements to fabricated future phases.
-- **If the input documents explicitly request phased delivery:** Guide mapping of features across the phases the user defined.
-- **If scope is unclear:** ASK the user whether they want phased delivery or a single release before proceeding.
-
-**When the user requests phased delivery**, guide mapping of features across the phases the user defines:
-
-- Use user-provided phase labels and count; if none are provided, propose a default (e.g., MVP/Growth/Vision) and ask for confirmation
-- Ensure clear progression and dependencies between phases
-
-**Each phase should address:**
-
-- Core user value delivery and essential journeys for that phase
-- Clear boundaries on what ships in each phase
-- Dependencies on prior phases
-
-**When the user chooses a single release**, define the complete scope:
-
-- All user-specified requirements are in scope
-- Focus must-have vs nice-to-have analysis on what ships in this release
-- Do NOT create phases — use must-have/nice-to-have priority within the single release
-
-**If phased delivery:** "Where does your current vision fit in this development sequence?"
-**If single release:** "How does your current vision map to this upcoming release?"
-
-### 5. Risk-Based Scoping
-
-Identify and mitigate scoping risks:
-
-**Technical Risks:**
-"Looking at your innovation and domain requirements:
-
-- What's the most technically challenging aspect?
-- Could we simplify the initial implementation?
-- What's the riskiest assumption about technology feasibility?"
-
-**Market Risks:**
-
-- What's the biggest market risk?
-- How does the MVP address this?
-- What learning do we need to de-risk this?"
-
-**Resource Risks:**
-
-- What if we have fewer resources than planned?
-- What's the absolute minimum team size needed?
-- Can we launch with a smaller feature set?"
-
-### 6. Generate Scoping Content
-
-Prepare comprehensive scoping section:
-
-#### Content Structure:
-
-**If user chose phased delivery:**
-
-```markdown
-## Project Scoping & Phased Development
-
-### MVP Strategy & Philosophy
-
-**MVP Approach:** {{chosen_mvp_approach}}
-**Resource Requirements:** {{mvp_team_size_and_skills}}
-
-### MVP Feature Set (Phase 1)
-
-**Core User Journeys Supported:**
-{{essential_journeys_for_mvp}}
-
-**Must-Have Capabilities:**
-{{list_of_essential_mvp_features}}
-
-### Post-MVP Features
-
-**Phase 2 (Post-MVP):**
-{{planned_growth_features}}
-
-**Phase 3 (Expansion):**
-{{planned_expansion_features}}
-
-### Risk Mitigation Strategy
-
-**Technical Risks:** {{mitigation_approach}}
-**Market Risks:** {{validation_approach}}
-**Resource Risks:** {{contingency_approach}}
-```
-
-**If user chose single release (no phasing):**
-
-```markdown
-## Project Scoping
-
-### Strategy & Philosophy
-
-**Approach:** {{chosen_approach}}
-**Resource Requirements:** {{team_size_and_skills}}
-
-### Complete Feature Set
-
-**Core User Journeys Supported:**
-{{all_journeys}}
-
-**Must-Have Capabilities:**
-{{list_of_must_have_features}}
-
-**Nice-to-Have Capabilities:**
-{{list_of_nice_to_have_features}}
-
-### Risk Mitigation Strategy
-
-**Technical Risks:** {{mitigation_approach}}
-**Market Risks:** {{validation_approach}}
-**Resource Risks:** {{contingency_approach}}
-```
-
-### 7. Present MENU OPTIONS
-
-Present the scoping decisions for review, then display menu:
-- Show strategic scoping plan (using structure from step 6)
-- Highlight release boundaries and prioritization (phased roadmap only if phased delivery was selected)
-- Ask if they'd like to refine further, get other perspectives, or proceed
-- Present menu options naturally as part of conversation
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Functional Requirements (Step 9 of 11)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill with the current scoping analysis, process the enhanced insights that come back, ask user if they accept the improvements, if yes update content then redisplay menu, if no keep original content then redisplay menu
-- IF P: Invoke the `bmad-party-mode` skill with the scoping context, process the collaborative insights on MVP and roadmap decisions, ask user if they accept the changes, if yes update content then redisplay menu, if no keep original content then redisplay menu
-- IF C: Append the final content to {outputFile}, update frontmatter by adding this step name to the end of the stepsCompleted array (also add `releaseMode: phased` or `releaseMode: single-release` to frontmatter based on user's choice), then read fully and follow: ./step-09-functional.md
-- IF Any other: help user respond, then redisplay menu
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 6.
-
-## SUCCESS METRICS:
-
-✅ Complete PRD document analyzed for scope implications
-✅ Strategic MVP approach defined and justified
-✅ Clear feature boundaries established (phased or single-release, per user preference)
-✅ All user-specified requirements accounted for — none silently removed or deferred
-✅ Any scope reduction recommendations presented to user with rationale and explicit confirmation obtained
-✅ Key risks identified and mitigation strategies defined
-✅ User explicitly agrees to scope decisions
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Not analyzing the complete PRD before making scoping decisions
-❌ Making scope decisions without strategic rationale
-❌ Not getting explicit user agreement on MVP boundaries
-❌ Missing critical risk analysis
-❌ Not presenting A/P/C menu after content generation
-❌ **CRITICAL**: Silently de-scoping or deferring requirements that the user explicitly included in their input documents
-❌ **CRITICAL**: Inventing phasing (MVP/Growth/Vision) when the user did not request phased delivery
-❌ **CRITICAL**: Making consequential scoping decisions (what is in/out of scope) without explicit user confirmation
-❌ **CRITICAL**: Creating phase-based artifacts (tags, labels, follow-on prompts) without explicit user approval
-
-❌ **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-09-functional.md.
-
-Remember: Do NOT proceed to step-09 until user explicitly selects 'C' from the A/P/C menu and content is saved!

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-09-functional.md

@@ -1,219 +0,0 @@
-# Step 9: Functional Requirements Synthesis
-
-**Progress: Step 9 of 11** - Next: Non-Functional Requirements
-
-## 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 PM peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on creating comprehensive capability inventory for the product
-- 🎯 CRITICAL: This is THE CAPABILITY CONTRACT for all downstream work
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- ⚠️ Present A/P/C menu after generating functional requirements
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update output file frontmatter, adding this step name to the end of the list of stepsCompleted
-- 🚫 FORBIDDEN to load next step until C is selected
-
-
-## CONTEXT BOUNDARIES:
-
-- Current document and frontmatter from previous steps are available
-- ALL previous content (executive summary, success criteria, journeys, domain, innovation, project-type) must be referenced
-- No additional data files needed for this step
-- Focus on capabilities, not implementation details
-
-## CRITICAL IMPORTANCE:
-
-**This section defines THE CAPABILITY CONTRACT for the entire product:**
-
-- UX designers will ONLY design what's listed here
-- Architects will ONLY support what's listed here
-- Epic breakdown will ONLY implement what's listed here
-- If a capability is missing from FRs, it will NOT exist in the final product
-
-## FUNCTIONAL REQUIREMENTS SYNTHESIS SEQUENCE:
-
-### 1. Understand FR Purpose and Usage
-
-Start by explaining the critical role of functional requirements:
-
-**Purpose:**
-FRs define WHAT capabilities the product must have. They are the complete inventory of user-facing and system capabilities that deliver the product vision.
-
-**Critical Properties:**
-✅ Each FR is a testable capability
-✅ Each FR is implementation-agnostic (could be built many ways)
-✅ Each FR specifies WHO and WHAT, not HOW
-✅ No UI details, no performance numbers, no technology choices
-✅ Comprehensive coverage of capability areas
-
-**How They Will Be Used:**
-
-1. UX Designer reads FRs → designs interactions for each capability
-2. Architect reads FRs → designs systems to support each capability
-3. PM reads FRs → creates epics and stories to implement each capability
-
-### 2. Review Existing Content for Capability Extraction
-
-Systematically review all previous sections to extract capabilities:
-
-**Extract From:**
-
-- Executive Summary → Core product differentiator capabilities
-- Success Criteria → Success-enabling capabilities
-- User Journeys → Journey-revealed capabilities
-- Domain Requirements → Compliance and regulatory capabilities
-- Innovation Patterns → Innovative feature capabilities
-- Project-Type Requirements → Technical capability needs
-
-### 3. Organize Requirements by Capability Area
-
-Group FRs by logical capability areas (NOT by technology or layer):
-
-**Good Grouping Examples:**
-
-- ✅ "User Management" (not "Authentication System")
-- ✅ "Content Discovery" (not "Search Algorithm")
-- ✅ "Team Collaboration" (not "WebSocket Infrastructure")
-
-**Target 5-8 Capability Areas** for typical projects.
-
-### 4. Generate Comprehensive FR List
-
-Create complete functional requirements using this format:
-
-**Format:**
-
-- FR#: [Actor] can [capability] [context/constraint if needed]
-- Number sequentially (FR1, FR2, FR3...)
-- Aim for 20-50 FRs for typical projects
-
-**Altitude Check:**
-Each FR should answer "WHAT capability exists?" NOT "HOW it's implemented?"
-
-**Examples:**
-
-- ✅ "Users can customize appearance settings"
-- ❌ "Users can toggle light/dark theme with 3 font size options stored in LocalStorage"
-
-### 5. Self-Validation Process
-
-Before presenting to user, validate the FR list:
-
-**Completeness Check:**
-
-1. "Did I cover EVERY capability mentioned in the MVP scope section?"
-2. "Did I include domain-specific requirements as FRs?"
-3. "Did I cover the project-type specific needs?"
-4. "Could a UX designer read ONLY the FRs and know what to design?"
-5. "Could an Architect read ONLY the FRs and know what to support?"
-6. "Are there any user actions or system behaviors we discussed that have no FR?"
-
-**Altitude Check:**
-
-1. "Am I stating capabilities (WHAT) or implementation (HOW)?"
-2. "Am I listing acceptance criteria or UI specifics?" (Remove if yes)
-3. "Could this FR be implemented 5 different ways?" (Good - means it's not prescriptive)
-
-**Quality Check:**
-
-1. "Is each FR clear enough that someone could test whether it exists?"
-2. "Is each FR independent (not dependent on reading other FRs to understand)?"
-3. "Did I avoid vague terms like 'good', 'fast', 'easy'?" (Use NFRs for quality attributes)
-
-### 6. Generate Functional Requirements Content
-
-Prepare the content to append to the document:
-
-#### Content Structure:
-
-When saving to document, append these Level 2 and Level 3 sections:
-
-```markdown
-## Functional Requirements
-
-### [Capability Area Name]
-
-- FR1: [Specific Actor] can [specific capability]
-- FR2: [Specific Actor] can [specific capability]
-- FR3: [Specific Actor] can [specific capability]
-
-### [Another Capability Area]
-
-- FR4: [Specific Actor] can [specific capability]
-- FR5: [Specific Actor] can [specific capability]
-
-[Continue for all capability areas discovered in conversation]
-```
-
-### 7. Present MENU OPTIONS
-
-Present the functional requirements for review, then display menu:
-- Show synthesized functional requirements (using structure from step 6)
-- Emphasize this is the capability contract for all downstream work
-- Highlight that every feature must trace back to these requirements
-- Ask if they'd like to refine further, get other perspectives, or proceed
-- Present menu options naturally as part of conversation
-
-**What would you like to do?**"
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Non-Functional Requirements (Step 10 of 11)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill with the current FR list, process the enhanced capability coverage that comes back, ask user if they accept the additions, if yes update content then redisplay menu, if no keep original content then redisplay menu
-- IF P: Invoke the `bmad-party-mode` skill with the current FR list, process the collaborative capability validation and additions, ask user if they accept the changes, if yes update content then redisplay menu, if no keep original content then redisplay menu
-- IF C: Append the final content to {outputFile}, update frontmatter by adding this step name to the end of the stepsCompleted array, then read fully and follow: ./step-10-nonfunctional.md
-- IF Any other: help user respond, then redisplay menu
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 6.
-
-## SUCCESS METRICS:
-
-✅ All previous discovery content synthesized into FRs
-✅ FRs organized by capability areas (not technology)
-✅ Each FR states WHAT capability exists, not HOW to implement
-✅ Comprehensive coverage with 20-50 FRs typical
-✅ Altitude validation ensures implementation-agnostic requirements
-✅ Completeness check validates coverage of all discussed capabilities
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Missing capabilities from previous discovery sections
-❌ Organizing FRs by technology instead of capability areas
-❌ Including implementation details or UI specifics in FRs
-❌ Not achieving comprehensive coverage of discussed capabilities
-❌ Using vague terms instead of testable capabilities
-❌ Not presenting A/P/C menu after content generation
-❌ Appending content without user selecting 'C'
-
-❌ **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
-
-## CAPABILITY CONTRACT REMINDER:
-
-Emphasize to user: "This FR list is now binding. Any feature not listed here will not exist in the final product unless we explicitly add it. This is why it's critical to ensure completeness now."
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document, load ./step-10-nonfunctional.md to define non-functional requirements.
-
-Remember: Do NOT proceed to step-10 until user explicitly selects 'C' from the A/P/C menu and content is saved!

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-10-nonfunctional.md

@@ -1,230 +0,0 @@
-# Step 10: Non-Functional Requirements
-
-**Progress: Step 10 of 12** - Next: Polish Document
-
-## 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 PM peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on quality attributes that matter for THIS specific product
-- 🎯 SELECTIVE: Only document NFRs that actually apply to the product
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- ⚠️ Present A/P/C menu after generating NFR content
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update output file frontmatter, adding this step name to the end of the list of stepsCompleted
-- 🚫 FORBIDDEN to load next step until C is selected
-
-
-## CONTEXT BOUNDARIES:
-
-- Current document and frontmatter from previous steps are available
-- Functional requirements already defined and will inform NFRs
-- Domain and project-type context will guide which NFRs matter
-- Focus on specific, measurable quality criteria
-
-## YOUR TASK:
-
-Define non-functional requirements that specify quality attributes for the product, focusing only on what matters for THIS specific product.
-
-## NON-FUNCTIONAL REQUIREMENTS SEQUENCE:
-
-### 1. Explain NFR Purpose and Scope
-
-Start by clarifying what NFRs are and why we're selective:
-
-**NFR Purpose:**
-NFRs define HOW WELL the system must perform, not WHAT it must do. They specify quality attributes like performance, security, scalability, etc.
-
-**Selective Approach:**
-We only document NFRs that matter for THIS product. If a category doesn't apply, we skip it entirely. This prevents requirement bloat and focuses on what's actually important.
-
-### 2. Assess Product Context for NFR Relevance
-
-Evaluate which NFR categories matter based on product context:
-
-**Quick Assessment Questions:**
-
-- **Performance**: Is there user-facing impact of speed?
-- **Security**: Are we handling sensitive data or payments?
-- **Scalability**: Do we expect rapid user growth?
-- **Accessibility**: Are we serving broad public audiences?
-- **Integration**: Do we need to connect with other systems?
-- **Reliability**: Would downtime cause significant problems?
-
-### 3. Explore Relevant NFR Categories
-
-For each relevant category, conduct targeted discovery:
-
-#### Performance NFRs (If relevant):
-
-Explore performance requirements:
-- What parts of the system need to be fast for users to be successful?
-- Are there specific response time expectations?
-- What happens if performance is slower than expected?
-- Are there concurrent user scenarios we need to support?
-
-#### Security NFRs (If relevant):
-
-Explore security requirements:
-- What data needs to be protected?
-- Who should have access to what?
-- What are the security risks we need to mitigate?
-- Are there compliance requirements (GDPR, HIPAA, PCI-DSS)?
-
-#### Scalability NFRs (If relevant):
-
-Explore scalability requirements:
-- How many users do we expect initially? Long-term?
-- Are there seasonal or event-based traffic spikes?
-- What happens if we exceed our capacity?
-- What growth scenarios should we plan for?
-
-#### Accessibility NFRs (If relevant):
-
-Explore accessibility requirements:
-- Are we serving users with visual, hearing, or motor impairments?
-- Are there legal accessibility requirements (WCAG, Section 508)?
-- What accessibility features are most important for our users?
-
-#### Integration NFRs (If relevant):
-
-Explore integration requirements:
-- What external systems do we need to connect with?
-- Are there APIs or data formats we must support?
-- How reliable do these integrations need to be?
-
-### 4. Make NFRs Specific and Measurable
-
-For each relevant NFR category, ensure criteria are testable:
-
-**From Vague to Specific:**
-
-- NOT: "The system should be fast" → "User actions complete within 2 seconds"
-- NOT: "The system should be secure" → "All data is encrypted at rest and in transit"
-- NOT: "The system should scale" → "System supports 10x user growth with <10% performance degradation"
-
-### 5. Generate NFR Content (Only Relevant Categories)
-
-Prepare the content to append to the document:
-
-#### Content Structure (Dynamic based on relevance):
-
-When saving to document, append these Level 2 and Level 3 sections (only include sections that are relevant):
-
-```markdown
-## Non-Functional Requirements
-
-### Performance
-
-[Performance requirements based on conversation - only include if relevant]
-
-### Security
-
-[Security requirements based on conversation - only include if relevant]
-
-### Scalability
-
-[Scalability requirements based on conversation - only include if relevant]
-
-### Accessibility
-
-[Accessibility requirements based on conversation - only include if relevant]
-
-### Integration
-
-[Integration requirements based on conversation - only include if relevant]
-```
-
-### 6. Present MENU OPTIONS
-
-Present the non-functional requirements for review, then display menu:
-- Show defined NFRs (using structure from step 5)
-- Note that only relevant categories were included
-- Emphasize NFRs specify how well the system needs to perform
-- Ask if they'd like to refine further, get other perspectives, or proceed
-- Present menu options naturally as part of conversation
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Polish Document (Step 11 of 12)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill with the current NFR content, process the enhanced quality attribute insights that come back, ask user if they accept the improvements, if yes update content then redisplay menu, if no keep original content then redisplay menu
-- IF P: Invoke the `bmad-party-mode` skill with the current NFR list, process the collaborative technical validation and additions, ask user if they accept the changes, if yes update content then redisplay menu, if no keep original content then redisplay menu
-- IF C: Append the final content to {outputFile}, update frontmatter by adding this step name to the end of the stepsCompleted array, then read fully and follow: ./step-11-polish.md
-- IF Any other: help user respond, then redisplay menu
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', append the content directly to the document using the structure from step 5.
-
-## SUCCESS METRICS:
-
-✅ Only relevant NFR categories documented (no requirement bloat)
-✅ Each NFR is specific and measurable
-✅ NFRs connected to actual user needs and business context
-✅ Vague requirements converted to testable criteria
-✅ Domain-specific compliance requirements included if relevant
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-
-## FAILURE MODES:
-
-❌ Documenting NFR categories that don't apply to the product
-❌ Leaving requirements vague and unmeasurable
-❌ Not connecting NFRs to actual user or business needs
-❌ Missing domain-specific compliance requirements
-❌ Creating overly prescriptive technical requirements
-❌ Not presenting A/P/C menu after content generation
-❌ Appending content without user selecting 'C'
-
-❌ **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
-
-## NFR CATEGORY GUIDANCE:
-
-**Include Performance When:**
-
-- User-facing response times impact success
-- Real-time interactions are critical
-- Performance is a competitive differentiator
-
-**Include Security When:**
-
-- Handling sensitive user data
-- Processing payments or financial information
-- Subject to compliance regulations
-- Protecting intellectual property
-
-**Include Scalability When:**
-
-- Expecting rapid user growth
-- Handling variable traffic patterns
-- Supporting enterprise-scale usage
-- Planning for market expansion
-
-**Include Accessibility When:**
-
-- Serving broad public audiences
-- Subject to accessibility regulations
-- Targeting users with disabilities
-- B2B customers with accessibility requirements
-
-## NEXT STEP:
-
-After user selects 'C' and content is saved to document, load ./step-11-polish.md to finalize the PRD and complete the workflow.
-
-Remember: Do NOT proceed to step-11 until user explicitly selects 'C' from the A/P/C menu and content is saved!

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-11-polish.md

@@ -1,221 +0,0 @@
-# Step 11: Document Polish
-
-**Progress: Step 11 of 12** - Next: Complete PRD
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 CRITICAL: Load the ENTIRE document before making changes
-- 📖 CRITICAL: Read complete step file before taking action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- ✅ This is a POLISH step - optimize existing content
-- 📋 IMPROVE flow, coherence, and readability
-- 💬 PRESERVE user's voice and intent
-- 🎯 MAINTAIN all essential information while improving presentation
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Load complete document first
-- 📝 Review for flow and coherence issues
-- ✂️ Reduce duplication while preserving essential info
-- 📖 Ensure proper ## Level 2 headers throughout
-- 💾 Save optimized document
-- ⚠️ Present A/P/C menu after polish
-- 🚫 DO NOT skip review steps
-
-## CONTEXT BOUNDARIES:
-
-- Complete PRD document exists from all previous steps
-- Document may have duplication from progressive append
-- Sections may not flow smoothly together
-- Level 2 headers ensure document can be split if needed
-- Focus on readability and coherence
-
-## YOUR TASK:
-
-Optimize the complete PRD document for flow, coherence, and professional presentation while preserving all essential information.
-
-## DOCUMENT POLISH SEQUENCE:
-
-### 1. Load Context and Document
-
-**CRITICAL:** Load the PRD purpose document first:
-
-- Read `../data/prd-purpose.md` to understand what makes a great BMAD PRD
-- Internalize the philosophy: information density, traceability, measurable requirements
-- Keep the dual-audience nature (humans + LLMs) in mind
-
-**Then Load the PRD Document:**
-
-- Read `{outputFile}` completely from start to finish
-- Understand the full document structure and content
-- Identify all sections and their relationships
-- Note areas that need attention
-
-### 2. Document Quality Review
-
-Review the entire document with PRD purpose principles in mind:
-
-**Information Density:**
-- Are there wordy phrases that can be condensed?
-- Is conversational padding present?
-- Can sentences be more direct and concise?
-
-**Flow and Coherence:**
-- Do sections transition smoothly?
-- Are there jarring topic shifts?
-- Does the document tell a cohesive story?
-- Is the progression logical for readers?
-
-**Duplication Detection:**
-- Are ideas repeated across sections?
-- Is the same information stated multiple times?
-- Can redundant content be consolidated?
-- Are there contradictory statements?
-
-**Header Structure:**
-- Are all main sections using ## Level 2 headers?
-- Is the hierarchy consistent (##, ###, ####)?
-- Can sections be easily extracted or referenced?
-- Are headers descriptive and clear?
-
-**Readability:**
-- Are sentences clear and concise?
-- Is the language consistent throughout?
-- Are technical terms used appropriately?
-- Would stakeholders find this easy to understand?
-
-### 2b. Brainstorming Reconciliation (if brainstorming input exists)
-
-**Check the PRD frontmatter `inputDocuments` for any brainstorming document** (e.g., `brainstorming-session*.md`, `brainstorming-report.md`). If a brainstorming document was used as input:
-
-1. **Load the brainstorming document** and extract all distinct ideas, themes, and recommendations
-2. **Cross-reference against the PRD** — for each brainstorming idea, check if it landed in any PRD section (requirements, success criteria, user journeys, scope, etc.)
-3. **Identify dropped ideas** — ideas from brainstorming that do not appear anywhere in the PRD. Pay special attention to:
-   - Tone, personality, and interaction design ideas (these are most commonly lost)
-   - Design philosophy and coaching approach ideas
-   - "What should this feel like" ideas (UX feel, not just UX function)
-   - Qualitative/soft ideas that don't map cleanly to functional requirements
-4. **Present findings to user**: "These brainstorming ideas did not make it into the PRD: [list]. Should any be incorporated?"
-5. **If user wants to incorporate dropped ideas**: Add them to the most appropriate PRD section (success criteria, non-functional requirements, or a new section if needed)
-
-**Why this matters**: Brainstorming documents are often long, and the PRD's structured template has an implicit bias toward concrete/structural ideas. Soft ideas (tone, philosophy, interaction feel) frequently get silently dropped because they don't map cleanly to FR/NFR format.
-
-### 3. Optimization Actions
-
-Make targeted improvements:
-
-**Improve Flow:**
-- Add transition sentences between sections
-- Smooth out jarring topic shifts
-- Ensure logical progression
-- Connect related concepts across sections
-
-**Reduce Duplication:**
-- Consolidate repeated information
-- Keep content in the most appropriate section
-- Use cross-references instead of repetition
-- Remove redundant explanations
-
-**Enhance Coherence:**
-- Ensure consistent terminology throughout
-- Align all sections with product differentiator
-- Maintain consistent voice and tone
-- Verify scope consistency across sections
-
-**Optimize Headers:**
-- Ensure all main sections use ## Level 2
-- Make headers descriptive and action-oriented
-- Check that headers follow consistent patterns
-- Verify headers support document navigation
-
-### 4. Preserve Critical Information
-
-**While optimizing, ensure NOTHING essential is lost:**
-
-**Must Preserve:**
-- All user success criteria
-- All functional requirements (capability contract)
-- All user journey narratives
-- All scope decisions (whether phased or single-release), including consent-critical evidence (explicit user confirmations and rationales for any scope changes from step 8)
-- All non-functional requirements
-- Product differentiator and vision
-- Domain-specific requirements
-- Innovation analysis (if present)
-
-**Can Consolidate:**
-- Repeated explanations of the same concept
-- Redundant background information
-- Multiple versions of similar content
-- Overlapping examples
-
-### 5. Generate Optimized Document
-
-Create the polished version:
-
-**Polishing Process:**
-1. Start with original document
-2. Apply all optimization actions
-3. Review to ensure nothing essential was lost
-4. Verify improvements enhance readability
-5. Prepare optimized version for review
-
-### 6. Present MENU OPTIONS
-
-Present the polished document for review, then display menu:
-- Show what changed in the polish
-- Highlight improvements made (flow, duplication, headers)
-- Ask if they'd like to refine further, get other perspectives, or proceed
-- Present menu options naturally as part of conversation
-
-Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Complete PRD (Step 12 of 12)"
-
-#### Menu Handling Logic:
-- IF A: Invoke the `bmad-advanced-elicitation` skill with the polished document, process the enhanced refinements that come back, ask user "Accept these polish improvements? (y/n)", if yes update content with improvements then redisplay menu, if no keep original polish then redisplay menu
-- IF P: Invoke the `bmad-party-mode` skill with the polished document, process the collaborative refinements to flow and coherence, ask user "Accept these polish changes? (y/n)", if yes update content with improvements then redisplay menu, if no keep original polish then redisplay menu
-- IF C: Save the polished document to {outputFile}, update frontmatter by adding this step name to the end of the stepsCompleted array, then read fully and follow: ./step-12-complete.md
-- IF Any other: help user respond, then redisplay menu
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- After other menu items execution, return to this menu
-
-## APPEND TO DOCUMENT:
-
-When user selects 'C', replace the entire document content with the polished version.
-
-## SUCCESS METRICS:
-
-✅ Complete document loaded and reviewed
-✅ Flow and coherence improved
-✅ Duplication reduced while preserving essential information
-✅ All main sections use ## Level 2 headers
-✅ Transitions between sections are smooth
-✅ User's voice and intent preserved
-✅ Document is more readable and professional
-✅ A/P/C menu presented and handled correctly
-✅ Brainstorming reconciliation completed (if brainstorming input exists)
-✅ Polished document saved when C selected
-
-## FAILURE MODES:
-
-❌ Loading only partial document (leads to incomplete polish)
-❌ Removing essential information while reducing duplication
-❌ Not preserving user's voice and intent
-❌ Changing content instead of improving presentation
-❌ Not ensuring ## Level 2 headers for main sections
-❌ Making arbitrary style changes instead of coherence improvements
-❌ Not presenting A/P/C menu for user approval
-❌ Saving polished document without user selecting 'C'
-
-❌ **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 changes without complete understanding of document requirements
-
-## NEXT STEP:
-
-After user selects 'C' and polished document is saved, load `./step-12-complete.md` to complete the workflow.
-
-Remember: Do NOT proceed to step-12 until user explicitly selects 'C' from the A/P/C menu and polished document is saved!

src/bmm-skills/2-plan-workflows/bmad-create-prd/steps-c/step-12-complete.md

@@ -1,121 +0,0 @@
-# Step 12: Workflow Completion
-
-**Final Step - Complete the PRD**
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- ✅ THIS IS A FINAL STEP - Workflow completion required
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action
-- 🛑 NO content generation - this is a wrap-up step
-- 📋 FINALIZE document and update workflow status
-- 💬 FOCUS on completion, validation options, and next steps
-- 🎯 UPDATE workflow status files with completion information
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Show your analysis before taking any action
-- 💾 Update the main workflow status file with completion information (if exists)
-- 📖 Offer validation workflow options to user
-- 🚫 DO NOT load additional steps after this one
-
-## TERMINATION STEP PROTOCOLS:
-
-- This is a FINAL step - workflow completion required
-- Update workflow status file with finalized document
-- Suggest validation and next workflow steps
-- Mark workflow as complete in status tracking
-
-## CONTEXT BOUNDARIES:
-
-- Complete and polished PRD document is available from all previous steps
-- Workflow frontmatter shows all completed steps including polish
-- All collaborative content has been generated, saved, and optimized
-- Focus on completion, validation options, and next steps
-
-## YOUR TASK:
-
-Complete the PRD workflow, update status files, offer validation options, and suggest next steps for the project.
-
-## WORKFLOW COMPLETION SEQUENCE:
-
-### 1. Announce Workflow Completion
-
-Inform user that the PRD is complete and polished:
-- Celebrate successful completion of comprehensive PRD
-- Summarize all sections that were created
-- Highlight that document has been polished for flow and coherence
-- Emphasize document is ready for downstream work
-
-### 2. Workflow Status Update
-
-Update the main workflow status file if there is one:
-
-- Check workflow configuration for a status file (if one exists)
-- Update workflow_status["prd"] = "{outputFile}"
-- Save file, preserving all comments and structure
-- Mark current timestamp as completion time
-
-### 3. Validation Workflow Options
-
-Offer validation workflows to ensure PRD is ready for implementation:
-
-**Available Validation Workflows:**
-
-**Option 1: Check Implementation Readiness** (`skill:bmad-check-implementation-readiness`)
-- Validates PRD has all information needed for development
-- Checks epic coverage completeness
-- Reviews UX alignment with requirements
-- Assesses epic quality and readiness
-- Identifies gaps before architecture/design work begins
-
-**When to use:** Before starting technical architecture or epic breakdown
-
-**Option 2: Skip for Now**
-- Proceed directly to next workflows (architecture, UX, epics)
-- Validation can be done later if needed
-- Some teams prefer to validate during architecture reviews
-
-### 4. Suggest Next Workflows
-
-PRD complete. Invoke the `bmad-help` skill.
-
-### 5. Final Completion Confirmation
-
-- Confirm completion with user and summarize what has been accomplished
-- Document now contains: Executive Summary, Success Criteria, User Journeys, Domain Requirements (if applicable), Innovation Analysis (if applicable), Project-Type Requirements, Functional Requirements (capability contract), Non-Functional Requirements, and has been polished for flow and coherence
-- Ask if they'd like to run validation workflow or proceed to next workflows
-
-## SUCCESS METRICS:
-
-✅ PRD document contains all required sections and has been polished
-✅ All collaborative content properly saved and optimized
-✅ Workflow status file updated with completion information (if exists)
-✅ Validation workflow options clearly presented
-✅ Clear next step guidance provided to user
-✅ Document quality validation completed
-✅ User acknowledges completion and understands next options
-
-## FAILURE MODES:
-
-❌ Not updating workflow status file with completion information (if exists)
-❌ Not offering validation workflow options
-❌ Missing clear next step guidance for user
-❌ Not confirming document completeness with user
-❌ Workflow not properly marked as complete in status tracking (if applicable)
-❌ User unclear about what happens next or what validation options exist
-
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-
-## FINAL REMINDER to give the user:
-
-The polished PRD serves as the foundation for all subsequent product development activities. All design, architecture, and development work should trace back to the requirements and vision documented in this PRD - update it also as needed as you continue planning.
-
-**Congratulations on completing the Product Requirements Document for {{project_name}}!** 🎉
-
-## 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/2-plan-workflows/bmad-create-prd/templates/prd-template.md

@@ -1,10 +0,0 @@
----
-stepsCompleted: []
-inputDocuments: []
-workflowType: 'prd'
----
-
-# Product Requirements Document - {{project_name}}
-
-**Author:** {{user_name}}
-**Date:** {{date}}

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

@@ -1,102 +1,30 @@
 ---
 name: bmad-edit-prd
-description: 'Edit an existing PRD. Use when the user says "edit this PRD".'
+description: 'DEPRECATED — consolidated into bmad-prd update intent - this skill will be removed in v7 in favor of `bmad-prd`.'
 ---
 
-# PRD Edit Workflow
+# DEPRECATED — forwards to bmad-prd (update intent)
 
-**Goal:** Edit and improve existing PRDs through structured enhancement workflow.
+This skill was consolidated into `bmad-prd`. It is retained as a thin compatibility shim so existing invocations by name and `_bmad/custom/bmad-edit-prd.toml` override files keep working. New work should invoke `bmad-prd` directly — it detects create / update / validate intent from the conversation.
-
-**Your Role:** PRD improvement specialist.
-
-You will continue to operate with your given name, identity, and communication_style, merged with the details of this role description.
-
-## Conventions
-
-- Bare paths (e.g. `steps-e/step-e-01-discovery.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 **step-file architecture** for disciplined execution:
-
-### Core Principles
-
-- **Micro-file Design**: Each step is a self-contained instruction file that is a part of an overall workflow that must be followed exactly
-- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until told to do so
-- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
-- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array when a workflow produces a document
-- **Append-Only Building**: Build documents by appending content as directed to the output file
-
-### Step Processing Rules
-
-1. **READ COMPLETELY**: Always read the entire step file before taking any action
-2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
-3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
-4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
-5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
-6. **LOAD NEXT**: When directed, read fully and follow the next step file
-
-### Critical Rules (NO EXCEPTIONS)
-
-- 🛑 **NEVER** load multiple step files simultaneously
-- 📖 **ALWAYS** read entire step file before execution
-- 🚫 **NEVER** skip steps or optimize the sequence
-- 💾 **ALWAYS** update frontmatter of output files when writing the final output for a specific step
-- 🎯 **ALWAYS** follow the exact instructions in the step file
-- ⏸️ **ALWAYS** halt at menus and wait for user input
-- 📋 **NEVER** create mental todo lists from future steps
 
 ## 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-edit-prd.toml` and `bmad-edit-prd.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-edit-prd` is deprecated and will be removed in a future release. It now forwards to `bmad-prd` with update intent. To silence this notice and access the full new customization surface (`prd_template`, `validation_checklist`, `doc_standards`, `external_sources`, `external_handoffs`, `output_dir`, `output_folder_name`), migrate `_bmad/custom/bmad-edit-prd.toml` to `_bmad/custom/bmad-prd.toml` and invoke `bmad-prd` 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-prd.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-prd` with the following context. Pass these as the activating context so `bmad-prd` honors them instead of resolving its own customization from scratch:
 
-### Step 2: Execute Prepend Steps
+   - **Intent:** `update` — skip `bmad-prd`'s usual intent detection step.
+   - **Pre-resolved legacy customization** — use these in place of resolving from `bmad-prd`'s own `customize.toml` for the four legacy fields. For everything else (`prd_template`, `validation_checklist`, `validation_report_template`, `doc_standards`, `output_dir`, `output_folder_name`, `external_sources`, `external_handoffs`), use `bmad-prd`'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 (the target PRD path, the change signal, etc.).
 
-Execute each entry in `{workflow.activation_steps_prepend}` in order before proceeding.
+   `bmad-prd` 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. Begin the workflow below.
-
-## Execution
-
-✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the configured `{communication_language}`.
-✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`.
-
-**Edit Mode: Improving an existing PRD.**
-
-Prompt for PRD path: "Which PRD would you like to edit? Please provide the path to the PRD.md file."
-
-Then read fully and follow: `./steps-e/step-e-01-discovery.md`

src/bmm-skills/2-plan-workflows/bmad-edit-prd/data/prd-purpose.md

@@ -1,197 +0,0 @@
-# BMAD PRD Purpose
-
-**The PRD is the top of the required funnel that feeds all subsequent product development work in rhw BMad Method.**
-
----
-
-## What is a BMAD PRD?
-
-A dual-audience document serving:
-1. **Human Product Managers and builders** - Vision, strategy, stakeholder communication
-2. **LLM Downstream Consumption** - UX Design → Architecture → Epics → Development AI Agents
-
-Each successive document becomes more AI-tailored and granular.
-
----
-
-## Core Philosophy: Information Density
-
-**High Signal-to-Noise Ratio**
-
-Every sentence must carry information weight. LLMs consume precise, dense content efficiently.
-
-**Anti-Patterns (Eliminate These):**
-- ❌ "The system will allow users to..." → ✅ "Users can..."
-- ❌ "It is important to note that..." → ✅ State the fact directly
-- ❌ "In order to..." → ✅ "To..."
-- ❌ Conversational filler and padding → ✅ Direct, concise statements
-
-**Goal:** Maximum information per word. Zero fluff.
-
----
-
-## The Traceability Chain
-
-**PRD starts the chain:**
-```
-Vision → Success Criteria → User Journeys → Functional Requirements → (future: User Stories)
-```
-
-**In the PRD, establish:**
-- Vision → Success Criteria alignment
-- Success Criteria → User Journey coverage
-- User Journey → Functional Requirement mapping
-- All requirements traceable to user needs
-
-**Why:** Each downstream artifact (UX, Architecture, Epics, Stories) must trace back to documented user needs and business objectives. This chain ensures we build the right thing.
-
----
-
-## What Makes Great Functional Requirements?
-
-### FRs are Capabilities, Not Implementation
-
-**Good FR:** "Users can reset their password via email link"
-**Bad FR:** "System sends JWT via email and validates with database" (implementation leakage)
-
-**Good FR:** "Dashboard loads in under 2 seconds for 95th percentile"
-**Bad FR:** "Fast loading time" (subjective, unmeasurable)
-
-### SMART Quality Criteria
-
-**Specific:** Clear, precisely defined capability
-**Measurable:** Quantifiable with test criteria
-**Attainable:** Realistic within constraints
-**Relevant:** Aligns with business objectives
-**Traceable:** Links to source (executive summary or user journey)
-
-### FR Anti-Patterns
-
-**Subjective Adjectives:**
-- ❌ "easy to use", "intuitive", "user-friendly", "fast", "responsive"
-- ✅ Use metrics: "completes task in under 3 clicks", "loads in under 2 seconds"
-
-**Implementation Leakage:**
-- ❌ Technology names, specific libraries, implementation details
-- ✅ Focus on capability and measurable outcomes
-
-**Vague Quantifiers:**
-- ❌ "multiple users", "several options", "various formats"
-- ✅ "up to 100 concurrent users", "3-5 options", "PDF, DOCX, TXT formats"
-
-**Missing Test Criteria:**
-- ❌ "The system shall provide notifications"
-- ✅ "The system shall send email notifications within 30 seconds of trigger event"
-
----
-
-## What Makes Great Non-Functional Requirements?
-
-### NFRs Must Be Measurable
-
-**Template:**
-```
-"The system shall [metric] [condition] [measurement method]"
-```
-
-**Examples:**
-- ✅ "The system shall respond to API requests in under 200ms for 95th percentile as measured by APM monitoring"
-- ✅ "The system shall maintain 99.9% uptime during business hours as measured by cloud provider SLA"
-- ✅ "The system shall support 10,000 concurrent users as measured by load testing"
-
-### NFR Anti-Patterns
-
-**Unmeasurable Claims:**
-- ❌ "The system shall be scalable" → ✅ "The system shall handle 10x load growth through horizontal scaling"
-- ❌ "High availability required" → ✅ "99.9% uptime as measured by cloud provider SLA"
-
-**Missing Context:**
-- ❌ "Response time under 1 second" → ✅ "API response time under 1 second for 95th percentile under normal load"
-
----
-
-## Domain-Specific Requirements
-
-**Auto-Detect and Enforce Based on Project Context**
-
-Certain industries have mandatory requirements that must be present:
-
-- **Healthcare:** HIPAA Privacy & Security Rules, PHI encryption, audit logging, MFA
-- **Fintech:** PCI-DSS Level 1, AML/KYC compliance, SOX controls, financial audit trails
-- **GovTech:** NIST framework, Section 508 accessibility (WCAG 2.1 AA), FedRAMP, data residency
-- **E-Commerce:** PCI-DSS for payments, inventory accuracy, tax calculation by jurisdiction
-
-**Why:** Missing these requirements in the PRD means they'll be missed in architecture and implementation, creating expensive rework. During PRD creation there is a step to cover this - during validation we want to make sure it was covered. For this purpose steps will utilize a domain-complexity.csv and project-types.csv.
-
----
-
-## Document Structure (Markdown, Human-Readable)
-
-### Required Sections
-1. **Executive Summary** - Vision, differentiator, target users
-2. **Success Criteria** - Measurable outcomes (SMART)
-3. **Product Scope** - MVP, Growth, Vision phases
-4. **User Journeys** - Comprehensive coverage
-5. **Domain Requirements** - Industry-specific compliance (if applicable)
-6. **Innovation Analysis** - Competitive differentiation (if applicable)
-7. **Project-Type Requirements** - Platform-specific needs
-8. **Functional Requirements** - Capability contract (FRs)
-9. **Non-Functional Requirements** - Quality attributes (NFRs)
-
-### Formatting for Dual Consumption
-
-**For Humans:**
-- Clear, professional language
-- Logical flow from vision to requirements
-- Easy for stakeholders to review and approve
-
-**For LLMs:**
-- ## Level 2 headers for all main sections (enables extraction)
-- Consistent structure and patterns
-- Precise, testable language
-- High information density
-
----
-
-## Downstream Impact
-
-**How the PRD Feeds Next Artifacts:**
-
-**UX Design:**
-- User journeys → interaction flows
-- FRs → design requirements
-- Success criteria → UX metrics
-
-**Architecture:**
-- FRs → system capabilities
-- NFRs → architecture decisions
-- Domain requirements → compliance architecture
-- Project-type requirements → platform choices
-
-**Epics & Stories (created after architecture):**
-- FRs → user stories (1 FR could map to 1-3 stories potentially)
-- Acceptance criteria → story acceptance tests
-- Priority → sprint sequencing
-- Traceability → stories map back to vision
-
-**Development AI Agents:**
-- Precise requirements → implementation clarity
-- Test criteria → automated test generation
-- Domain requirements → compliance enforcement
-- Measurable NFRs → performance targets
-
----
-
-## Summary: What Makes a Great BMAD PRD?
-
-✅ **High Information Density** - Every sentence carries weight, zero fluff
-✅ **Measurable Requirements** - All FRs and NFRs are testable with specific criteria
-✅ **Clear Traceability** - Each requirement links to user need and business objective
-✅ **Domain Awareness** - Industry-specific requirements auto-detected and included
-✅ **Zero Anti-Patterns** - No subjective adjectives, implementation leakage, or vague quantifiers
-✅ **Dual Audience Optimized** - Human-readable AND LLM-consumable
-✅ **Markdown Format** - Professional, clean, accessible to all stakeholders
-
----
-
-**Remember:** The PRD is the foundation. Quality here ripples through every subsequent phase. A dense, precise, well-traced PRD makes UX design, architecture, epic breakdown, and AI development dramatically more effective.

src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-01-discovery.md

@@ -1,242 +0,0 @@
----
-# File references (ONLY variables used in this step)
-prdPurpose: '../data/prd-purpose.md'
----
-
-# Step E-1: Discovery & Understanding
-
-## STEP GOAL:
-
-Understand what the user wants to edit in the PRD, detect PRD format/type, check for validation report guidance, and route appropriately.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and PRD Improvement Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring analytical expertise and improvement guidance
-- ✅ User brings domain knowledge and edit requirements
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on discovering user intent and PRD format
-- 🚫 FORBIDDEN to make any edits yet
-- 💬 Approach: Inquisitive and analytical, understanding before acting
-- 🚪 This is a branch step - may route to legacy conversion
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Discover user's edit requirements
-- 🎯 Auto-detect validation reports in PRD folder (use as guide)
-- 🎯 Load validation report if provided (use as guide)
-- 🎯 Detect PRD format (BMAD/legacy)
-- 🎯 Route appropriately based on format
-- 💾 Document discoveries for next step
-- 🚫 FORBIDDEN to proceed without understanding requirements
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file to edit, optional validation report, auto-detected validation reports
-- Focus: User intent discovery and format detection only
-- Limits: Don't edit yet, don't validate yet
-- Dependencies: None - this is first edit step
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Load PRD Purpose Standards
-
-Load and read the complete file at:
-`{prdPurpose}` (data/prd-purpose.md)
-
-This file defines what makes a great BMAD PRD. Internalize this understanding - it will guide improvement recommendations.
-
-### 2. Discover PRD to Edit
-
-"**PRD Edit Workflow**
-
-Which PRD would you like to edit?
-
-Please provide the path to the PRD file you want to edit."
-
-**Wait for user to provide PRD path.**
-
-### 3. Validate PRD Exists and Load
-
-Once PRD path is provided:
-- Check if PRD file exists at specified path
-- If not found: "I cannot find a PRD at that path. Please check the path and try again."
-- If found: Load the complete PRD file including frontmatter
-
-### 4. Check for Existing Validation Report
-
-**Check if validation report exists in the PRD folder:**
-
-```bash
-# Look for most recent validation report in the PRD folder
-ls -t {prd_folder_path}/validation-report-*.md 2>/dev/null | head -1
-```
-
-**If validation report found:**
-
-Display:
-"**📋 Found Validation Report**
-
-I found a validation report from {validation_date} in the PRD folder.
-
-This report contains findings from previous validation checks and can help guide our edits to fix known issues.
-
-**Would you like to:**
-- **[U] Use validation report** - Load it to guide and prioritize edits
-- **[S] Skip** - Proceed with manual edit discovery"
-
-**Wait for user input.**
-
-**IF U (Use validation report):**
-- Load the validation report file
-- Extract findings, issues, and improvement suggestions
-- Note: "Validation report loaded - will use it to guide prioritized improvements"
-- Continue to step 5
-
-**IF S (Skip) or no validation report found:**
-- Note: "Proceeding with manual edit discovery"
-- Continue to step 5
-
-**If no validation report found:**
-- Note: "No validation report found in PRD folder"
-- Continue to step 5 without asking user
-
-### 5. Ask About Validation Report
-
-"**Do you have a validation report to guide edits?**
-
-If you've run the validation workflow on this PRD, I can use that report to guide improvements and prioritize changes.
-
-Validation report path (or type 'none'):"
-
-**Wait for user input.**
-
-**If validation report path provided:**
-- Load the validation report
-- Extract findings, severity, improvement suggestions
-- Note: "Validation report loaded - will use it to guide prioritized improvements"
-
-**If no validation report:**
-- Note: "Proceeding with manual edit discovery"
-- Continue to step 6
-
-### 6. Discover Edit Requirements
-
-"**What would you like to edit in this PRD?**
-
-Please describe the changes you want to make. For example:
-- Fix specific issues (information density, implementation leakage, etc.)
-- Add missing sections or content
-- Improve structure and flow
-- Convert to BMAD format (if legacy PRD)
-- General improvements
-- Other changes
-
-**Describe your edit goals:**"
-
-**Wait for user to describe their requirements.**
-
-### 7. Detect PRD Format
-
-Analyze the loaded PRD:
-
-**Extract all ## Level 2 headers** from PRD
-
-**Check for BMAD PRD core sections:**
-1. Executive Summary
-2. Success Criteria
-3. Product Scope
-4. User Journeys
-5. Functional Requirements
-6. Non-Functional Requirements
-
-**Classify format:**
-- **BMAD Standard:** 5-6 core sections present
-- **BMAD Variant:** 3-4 core sections present, generally follows BMAD patterns
-- **Legacy (Non-Standard):** Fewer than 3 core sections, does not follow BMAD structure
-
-### 8. Route Based on Format and Context
-
-**IF validation report provided OR PRD is BMAD Standard/Variant:**
-
-Display: "**Edit Requirements Understood**
-
-**PRD Format:** {classification}
-{If validation report: "**Validation Guide:** Yes - will use validation report findings"}
-**Edit Goals:** {summary of user's requirements}
-
-**Proceeding to deep review and analysis...**"
-
-Read fully and follow: `./step-e-02-review.md`
-
-**IF PRD is Legacy (Non-Standard) AND no validation report:**
-
-Display: "**Format Detected:** Legacy PRD
-
-This PRD does not follow BMAD standard structure (only {count}/6 core sections present).
-
-**Your edit goals:** {user's requirements}
-
-**How would you like to proceed?**"
-
-Present MENU OPTIONS below for user selection
-
-### 9. Present MENU OPTIONS (Legacy PRDs Only)
-
-**[C] Convert to BMAD Format** - Convert PRD to BMAD standard structure, then apply your edits
-**[E] Edit As-Is** - Apply your edits without converting the format
-**[X] Exit** - Exit and review conversion options
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input
-- Only proceed based on user selection
-
-#### Menu Handling Logic:
-
-- IF C (Convert): Read fully and follow: `./step-e-01b-legacy-conversion.md`
-- IF E (Edit As-Is): Display "Proceeding with edits..." then load next step
-- IF X (Exit): Display summary and exit
-- IF Any other: help user, then redisplay menu
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- User's edit requirements clearly understood
-- Auto-detected validation reports loaded and analyzed (when found)
-- Manual validation report loaded and analyzed (if provided)
-- PRD format detected correctly
-- BMAD PRDs proceed directly to review step
-- Legacy PRDs pause and present conversion options
-- User can choose conversion path or edit as-is
-
-### ❌ SYSTEM FAILURE:
-
-- Not discovering user's edit requirements
-- Not auto-detecting validation reports in PRD folder
-- Not loading validation report when provided (auto or manual)
-- Missing format detection
-- Not pausing for legacy PRDs without guidance
-- Auto-proceeding without understanding intent
-
-**Master Rule:** Understand before editing. Detect format early so we can guide users appropriately. Auto-detect and use validation reports for prioritized improvements.

src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-01b-legacy-conversion.md

@@ -1,204 +0,0 @@
----
-# File references (ONLY variables used in this step)
-prdFile: '{prd_file_path}'
-prdPurpose: '../data/prd-purpose.md'
----
-
-# Step E-1B: Legacy PRD Conversion Assessment
-
-## STEP GOAL:
-
-Analyze legacy PRD against BMAD standards, identify gaps, propose conversion strategy, and let user choose how to proceed.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and PRD Improvement Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring BMAD standards expertise and conversion guidance
-- ✅ User brings domain knowledge and edit requirements
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on conversion assessment and proposal
-- 🚫 FORBIDDEN to perform conversion yet (that comes in edit step)
-- 💬 Approach: Analytical gap analysis with clear recommendations
-- 🚪 This is a branch step - user chooses conversion path
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Analyze legacy PRD against BMAD standard
-- 💾 Identify gaps and estimate conversion effort
-- 📖 Present conversion options with effort estimates
-- 🚫 FORBIDDEN to proceed without user selection
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Legacy PRD, user's edit requirements, prd-purpose standards
-- Focus: Conversion assessment only (not actual conversion)
-- Limits: Don't convert yet, don't validate yet
-- Dependencies: Step e-01 detected legacy format and routed here
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Attempt Sub-Process Assessment
-
-**Try to use Task tool with sub-agent:**
-
-"Perform legacy PRD conversion assessment:
-
-**Load the PRD and prd-purpose.md**
-
-**For each BMAD PRD section, analyze:**
-1. Does PRD have this section? (Executive Summary, Success Criteria, Product Scope, User Journeys, Functional Requirements, Non-Functional Requirements)
-2. If present: Is it complete and well-structured?
-3. If missing: What content exists that could migrate to this section?
-4. Effort to create/complete: Minimal / Moderate / Significant
-
-**Identify:**
-- Core sections present: {count}/6
-- Content gaps in each section
-- Overall conversion effort: Quick / Moderate / Substantial
-- Recommended approach: Full restructuring vs targeted improvements
-
-Return conversion assessment with gap analysis and effort estimate."
-
-**Graceful degradation (if no Task tool):**
-- Manually check PRD for each BMAD section
-- Note what's present and what's missing
-- Estimate conversion effort
-- Identify best conversion approach
-
-### 2. Build Gap Analysis
-
-**For each BMAD core section:**
-
-**Executive Summary:**
-- Present: [Yes/No/Partial]
-- Gap: [what's missing or incomplete]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-**Success Criteria:**
-- Present: [Yes/No/Partial]
-- Gap: [what's missing or incomplete]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-**Product Scope:**
-- Present: [Yes/No/Partial]
-- Gap: [what's missing or incomplete]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-**User Journeys:**
-- Present: [Yes/No/Partial]
-- Gap: [what's missing or incomplete]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-**Functional Requirements:**
-- Present: [Yes/No/Partial]
-- Gap: [what's missing or incomplete]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-**Non-Functional Requirements:**
-- Present: [Yes/No/Partial]
-- Gap: [what's missing or incomplete]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-**Overall Assessment:**
-- Sections Present: {count}/6
-- Total Conversion Effort: [Quick/Moderate/Substantial]
-- Recommended: [Full restructuring / Targeted improvements]
-
-### 3. Present Conversion Assessment
-
-Display:
-
-"**Legacy PRD Conversion Assessment**
-
-**Current PRD Structure:**
-- Core sections present: {count}/6
-{List which sections are present/missing}
-
-**Gap Analysis:**
-
-{Present gap analysis table showing each section's status and effort}
-
-**Overall Conversion Effort:** {effort level}
-
-**Your Edit Goals:**
-{Reiterate user's stated edit requirements}
-
-**Recommendation:**
-{Based on effort and user goals, recommend best approach}
-
-**How would you like to proceed?**"
-
-### 4. Present MENU OPTIONS
-
-**[R] Restructure to BMAD** - Full conversion to BMAD format, then apply your edits
-**[I] Targeted Improvements** - Apply your edits to existing structure without restructuring
-**[E] Edit & Restructure** - Do both: convert format AND apply your edits
-**[X] Exit** - Review assessment and decide
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input
-- Only proceed based on user selection
-
-#### Menu Handling Logic:
-
-- IF R (Restructure): Note conversion mode, then load next step
-- IF I (Targeted): Note targeted mode, then load next step
-- IF E (Edit & Restructure): Note both mode, then load next step
-- IF X (Exit): Display summary, exit
-
-### 5. Document Conversion Strategy
-
-Store conversion decision for next step:
-
-- **Conversion mode:** [Full restructuring / Targeted improvements / Both]
-- **Edit requirements:** [user's requirements from step e-01]
-- **Gap analysis:** [summary of gaps identified]
-
-Display: "**Conversion Strategy Documented**
-
-Mode: {conversion mode}
-Edit goals: {summary}
-
-**Proceeding to deep review...**"
-
-Read fully and follow: `./step-e-02-review.md`
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All 6 BMAD core sections analyzed for gaps
-- Effort estimates provided for each section
-- Overall conversion effort assessed correctly
-- Clear recommendation provided based on effort and user goals
-- User chooses conversion strategy (restructure/targeted/both)
-- Conversion strategy documented for next step
-
-### ❌ SYSTEM FAILURE:
-
-- Not analyzing all 6 core sections
-- Missing effort estimates
-- Not providing clear recommendation
-- Auto-proceeding without user selection
-- Not documenting conversion strategy
-
-**Master Rule:** Legacy PRDs need conversion assessment so users understand the work involved and can choose the best approach.

src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-02-review.md

@@ -1,245 +0,0 @@
----
-# File references (ONLY variables used in this step)
-prdFile: '{prd_file_path}'
-validationReport: '{validation_report_path}'  # If provided
-prdPurpose: '../data/prd-purpose.md'
----
-
-# Step E-2: Deep Review & Analysis
-
-## STEP GOAL:
-
-Thoroughly review the existing PRD, analyze validation report findings (if provided), and prepare a detailed change plan before editing.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and PRD Improvement Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring analytical expertise and improvement planning
-- ✅ User brings domain knowledge and approval authority
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on review and analysis, not editing yet
-- 🚫 FORBIDDEN to make changes to PRD in this step
-- 💬 Approach: Thorough analysis with user confirmation on plan
-- 🚪 This is a middle step - user confirms plan before proceeding
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Load and analyze validation report (if provided)
-- 🎯 Deep review of entire PRD
-- 🎯 Map validation findings to specific sections
-- 🎯 Prepare detailed change plan
-- 💬 Get user confirmation on plan
-- 🚫 FORBIDDEN to proceed to edit without user approval
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file, validation report (if provided), user requirements from step e-01
-- Focus: Analysis and planning only (no editing)
-- Limits: Don't change PRD yet, don't validate yet
-- Dependencies: Step e-01 completed - requirements and format known
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Attempt Sub-Process Deep Review
-
-**Try to use Task tool with sub-agent:**
-
-"Perform deep PRD review and change planning:
-
-**Context from step e-01:**
-- User's edit requirements: {user_requirements}
-- PRD format: {BMAD/legacy}
-- Validation report provided: {yes/no}
-- Conversion mode: {restructure/targeted/both} (if legacy)
-
-**IF validation report provided:**
-1. Extract all findings from validation report
-2. Map findings to specific PRD sections
-3. Prioritize by severity: Critical > Warning > Informational
-4. For each critical issue: identify specific fix needed
-5. For user's manual edit goals: identify where in PRD to apply
-
-**IF no validation report:**
-1. Read entire PRD thoroughly
-2. Analyze against BMAD standards (from prd-purpose.md)
-3. Identify issues in:
-   - Information density (anti-patterns)
-   - Structure and flow
-   - Completeness (missing sections/content)
-   - Measurability (unmeasurable requirements)
-   - Traceability (broken chains)
-   - Implementation leakage
-4. Map user's edit goals to specific sections
-
-**Output:**
-- Section-by-section analysis
-- Specific changes needed for each section
-- Prioritized action list
-- Recommended order for applying changes
-
-Return detailed change plan with section breakdown."
-
-**Graceful degradation (if no Task tool):**
-- Manually read PRD sections
-- Manually analyze validation report findings (if provided)
-- Build section-by-section change plan
-- Prioritize changes by severity/user goals
-
-### 2. Build Change Plan
-
-**Organize by PRD section:**
-
-**For each section (in order):**
-- **Current State:** Brief description of what exists
-- **Issues Identified:** [List from validation report or manual analysis]
-- **Changes Needed:** [Specific changes required]
-- **Priority:** [Critical/High/Medium/Low]
-- **User Requirements Met:** [Which user edit goals address this section]
-
-**Include:**
-- Sections to add (if missing)
-- Sections to update (if present but needs work)
-- Content to remove (if incorrect/leakage)
-- Structure changes (if reformatting needed)
-
-### 3. Prepare Change Plan Summary
-
-**Summary sections:**
-
-**Changes by Type:**
-- **Additions:** {count} sections to add
-- **Updates:** {count} sections to update
-- **Removals:** {count} items to remove
-- **Restructuring:** {yes/no} if format conversion needed
-
-**Priority Distribution:**
-- **Critical:** {count} changes (must fix)
-- **High:** {count} changes (important)
-- **Medium:** {count} changes (nice to have)
-- **Low:** {count} changes (optional)
-
-**Estimated Effort:**
-[Quick/Moderate/Substantial] based on scope and complexity
-
-### 4. Present Change Plan to User
-
-Display:
-
-"**Deep Review Complete - Change Plan**
-
-**PRD Analysis:**
-{Brief summary of PRD current state}
-
-{If validation report provided:}
-**Validation Findings:**
-{count} issues identified: {critical} critical, {warning} warnings
-
-**Your Edit Requirements:**
-{summary of what user wants to edit}
-
-**Proposed Change Plan:**
-
-**By Section:**
-{Present section-by-section breakdown}
-
-**By Priority:**
-- Critical: {count} items
-- High: {count} items
-- Medium: {count} items
-
-**Estimated Effort:** {effort level}
-
-**Questions:**
-1. Does this change plan align with what you had in mind?
-2. Any sections I should add/remove/reprioritize?
-3. Any concerns before I proceed with edits?
-
-**Review the plan and let me know if you'd like any adjustments.**"
-
-### 5. Get User Confirmation
-
-Wait for user to review and provide feedback.
-
-**If user wants adjustments:**
-- Discuss requested changes
-- Revise change plan accordingly
-- Represent for confirmation
-
-**If user approves:**
-- Note: "Change plan approved. Proceeding to edit step."
-- Continue to step 6
-
-### 6. Document Approved Plan
-
-Store approved change plan for next step:
-
-- **Approved changes:** Section-by-section list
-- **Priority order:** Sequence to apply changes
-- **User confirmed:** Yes
-
-Display: "**Change Plan Approved**
-
-{Brief summary of approved plan}
-
-**Proceeding to edit step...**"
-
-Read fully and follow: `./step-e-03-edit.md`
-
-### 7. Present MENU OPTIONS (If User Wants Discussion)
-
-**[A] Advanced Elicitation** - Get additional perspectives on change plan
-**[P] Party Mode** - Discuss with team for more ideas
-**[C] Continue to Edit** - Proceed with approved plan
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input
-- Only proceed to edit when user selects 'C'
-
-#### Menu Handling Logic:
-
-- IF A: Invoke the `bmad-advanced-elicitation` skill, then return to discussion
-- IF P: Invoke the `bmad-party-mode` skill, then return to discussion
-- IF C: Document approval, then load step-e-03-edit.md
-- IF Any other: discuss, then redisplay menu
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Validation report findings fully analyzed (if provided)
-- Deep PRD review completed systematically
-- Change plan built section-by-section
-- Changes prioritized by severity/user goals
-- User presented with clear plan
-- User confirms or adjusts plan
-- Approved plan documented for next step
-
-### ❌ SYSTEM FAILURE:
-
-- Not analyzing validation report findings (if provided)
-- Superficial review instead of deep analysis
-- Missing section-by-section breakdown
-- Not prioritizing changes
-- Proceeding without user approval
-
-**Master Rule:** Plan before editing. Thorough analysis ensures we make the right changes in the right order. User approval prevents misalignment.

src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-03-edit.md

@@ -1,250 +0,0 @@
----
-# File references (ONLY variables used in this step)
-prdFile: '{prd_file_path}'
-prdPurpose: '../data/prd-purpose.md'
----
-
-# Step E-3: Edit & Update
-
-## STEP GOAL:
-
-Apply changes to the PRD following the approved change plan from step e-02, including content updates, structure improvements, and format conversion if needed.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 ALWAYS generate content WITH user input/approval
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and PRD Improvement Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring analytical expertise and precise editing skills
-- ✅ User brings domain knowledge and approval authority
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on implementing approved changes from step e-02
-- 🚫 FORBIDDEN to make changes beyond the approved plan
-- 💬 Approach: Methodical, section-by-section execution
-- 🚪 This is a middle step - user can request adjustments
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Follow approved change plan systematically
-- 💾 Edit PRD content according to plan
-- 📖 Update frontmatter as needed
-- 🚫 FORBIDDEN to proceed without completion
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file, approved change plan from step e-02, prd-purpose standards
-- Focus: Implementing changes from approved plan only
-- Limits: Don't add changes beyond plan, don't validate yet
-- Dependencies: Step e-02 completed - plan approved by user
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Retrieve Approved Change Plan
-
-From step e-02, retrieve:
-- **Approved changes:** Section-by-section list
-- **Priority order:** Sequence to apply changes
-- **User requirements:** Edit goals from step e-01
-
-Display: "**Starting PRD Edits**
-
-**Change Plan:** {summary}
-**Total Changes:** {count}
-**Estimated Effort:** {effort level}
-
-**Proceeding with edits section by section...**"
-
-### 2. Attempt Sub-Process Edits (For Complex Changes)
-
-**Try to use Task tool with sub-agent for major sections:**
-
-"Execute PRD edits for {section_name}:
-
-**Context:**
-- Section to edit: {section_name}
-- Current content: {existing content}
-- Changes needed: {specific changes from plan}
-- BMAD PRD standards: Load from prd-purpose.md
-
-**Tasks:**
-1. Read current PRD section
-2. Apply specified changes
-3. Ensure BMAD PRD principles compliance:
-   - High information density (no filler)
-   - Measurable requirements
-   - Clear structure
-   - Proper markdown formatting
-4. Return updated section content
-
-Apply changes and return updated section."
-
-**Graceful degradation (if no Task tool):**
-- Perform edits directly in current context
-- Load PRD section, apply changes, save
-
-### 3. Execute Changes Section-by-Section
-
-**For each section in approved plan (in priority order):**
-
-**a) Load current section**
-- Read the current PRD section content
-- Note what exists
-
-**b) Apply changes per plan**
-- Additions: Create new sections with proper content
-- Updates: Modify existing content per plan
-- Removals: Remove specified content
-- Restructuring: Reformat content to BMAD standard
-
-**c) Update PRD file**
-- Apply changes to PRD
-- Save updated PRD
-- Verify changes applied correctly
-
-**Display progress after each section:**
-"**Section Updated:** {section_name}
-Changes: {brief summary}
-{More sections remaining...}"
-
-### 4. Handle Restructuring (If Needed)
-
-**If conversion mode is "Full restructuring" or "Both":**
-
-**For restructuring:**
-- Reorganize PRD to BMAD standard structure
-- Ensure proper ## Level 2 headers
-- Reorder sections logically
-- Update PRD frontmatter to match BMAD format
-
-**Follow BMAD PRD structure:**
-1. Executive Summary
-2. Success Criteria
-3. Product Scope
-4. User Journeys
-5. Domain Requirements (if applicable)
-6. Innovation Analysis (if applicable)
-7. Project-Type Requirements
-8. Functional Requirements
-9. Non-Functional Requirements
-
-Display: "**PRD Restructured**
-BMAD standard structure applied.
-{Sections added/reordered}"
-
-### 5. Update PRD Frontmatter
-
-**Ensure frontmatter is complete and accurate:**
-
-```yaml
----
-workflowType: 'prd'
-workflow: 'create'  # or 'validate' or 'edit'
-classification:
-  domain: '{domain}'
-  projectType: '{project_type}'
-  complexity: '{complexity}'
-inputDocuments: [list of input documents]
-stepsCompleted: ['step-e-01-discovery', 'step-e-02-review', 'step-e-03-edit']
-lastEdited: '{current_date}'
-editHistory:
-  - date: '{current_date}'
-    changes: '{summary of changes}'
----
-```
-
-**Update frontmatter accordingly.**
-
-### 6. Final Review of Changes
-
-**Load complete updated PRD**
-
-**Verify:**
-- All approved changes applied correctly
-- PRD structure is sound
-- No unintended modifications
-- Frontmatter is accurate
-
-**If issues found:**
-- Fix them now
-- Note corrections made
-
-**If user wants adjustments:**
-- Accept feedback and make adjustments
-- Re-verify after adjustments
-
-### 7. Confirm Completion
-
-Display:
-
-"**PRD Edits Complete**
-
-**Changes Applied:** {count} sections modified
-**PRD Updated:** {prd_file_path}
-
-**Summary of Changes:**
-{Brief bullet list of major changes}
-
-**PRD is ready for:**
-- Use in downstream workflows (UX, Architecture)
-- Validation (if not yet validated)
-
-**What would you like to do next?**"
-
-### 8. Present MENU OPTIONS
-
-**[V] Run Validation** - Execute full validation workflow (./steps-v/step-v-01-discovery.md)
-**[S] Summary Only** - End with summary of changes (no validation)
-**[A] Adjust** - Make additional edits
-**[X] Exit** - Exit edit workflow
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input
-- Only proceed based on user selection
-
-#### Menu Handling Logic:
-
-- IF V (Validate): Display "Starting validation workflow..." then read fully and follow: `./steps-v/step-v-01-discovery.md`
-- IF S (Summary): Present edit summary and exit
-- IF A (Adjust): Accept additional requirements, loop back to editing
-- IF X (Exit): Display summary and exit
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All approved changes from step e-02 applied correctly
-- Changes executed in planned priority order
-- Restructuring completed (if needed)
-- Frontmatter updated accurately
-- Final verification confirms changes
-- User can proceed to validation or exit with summary
-- Option to run validation seamlessly integrates edit and validate modes
-
-### ❌ SYSTEM FAILURE:
-
-- Making changes beyond approved plan
-- Not following priority order
-- Missing restructuring (if conversion mode)
-- Not updating frontmatter
-- No final verification
-- Not saving updated PRD
-
-**Master Rule:** Execute the plan exactly as approved. PRD is now ready for validation or downstream use. Validation integration ensures quality.

src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-04-complete.md

@@ -1,165 +0,0 @@
----
-# File references (ONLY variables used in this step)
-prdFile: '{prd_file_path}'
----
-
-# Step E-4: Complete & Validate
-
-## STEP GOAL:
-
-Present summary of completed edits and offer next steps including seamless integration with validation workflow.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 ALWAYS generate content WITH user input/approval
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and PRD Improvement Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring synthesis and summary expertise
-- ✅ User chooses next actions
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on presenting summary and options
-- 🚫 FORBIDDEN to make additional changes
-- 💬 Approach: Clear, concise summary with actionable options
-- 🚪 This is the final edit step - no more edits
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Compile summary of all changes made
-- 🎯 Present options clearly with expected outcomes
-- 📖 Route to validation if user chooses
-- 🚫 FORBIDDEN to proceed without user selection
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Updated PRD file, edit history from step e-03
-- Focus: Summary and options only (no more editing)
-- Limits: Don't make changes, just present options
-- Dependencies: Step e-03 completed - all edits applied
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Compile Edit Summary
-
-From step e-03 change execution, compile:
-
-**Changes Made:**
-- Sections added: {list with names}
-- Sections updated: {list with names}
-- Content removed: {list}
-- Structure changes: {description}
-
-**Edit Details:**
-- Total sections affected: {count}
-- Mode: {restructure/targeted/both}
-- Priority addressed: {Critical/High/Medium/Low}
-
-**PRD Status:**
-- Format: {BMAD Standard / BMAD Variant / Legacy (converted)}
-- Completeness: {assessment}
-- Ready for: {downstream use cases}
-
-### 2. Present Completion Summary
-
-Display:
-
-"**✓ PRD Edit Complete**
-
-**Updated PRD:** {prd_file_path}
-
-**Changes Summary:**
-{Present bulleted list of major changes}
-
-**Edit Mode:** {mode}
-**Sections Modified:** {count}
-
-**PRD Format:** {format}
-
-**PRD is now ready for:**
-- Downstream workflows (UX Design, Architecture)
-- Validation to ensure quality
-- Production use
-
-**What would you like to do next?**"
-
-### 3. Present MENU OPTIONS
-
-Display:
-
-**[V] Run Full Validation** - Execute complete validation workflow (steps-v) to verify PRD quality
-**[E] Edit More** - Make additional edits to the PRD
-**[S] Summary** - End with detailed summary of changes
-**[X] Exit** - Exit edit workflow
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input
-- Only proceed based on user selection
-
-#### Menu Handling Logic:
-
-- **IF V (Run Full Validation):**
-  - Display: "**Starting Validation Workflow**"
-  - Display: "This will run all 13 validation checks on the updated PRD."
-  - Display: "Preparing to validate: {prd_file_path}"
-  - Display: "**Proceeding to validation...**"
-  - Invoke the `bmad-validate-prd` skill to run the complete validation workflow
-
-- **IF E (Edit More):**
-  - Display: "**Additional Edits**"
-  - Ask: "What additional edits would you like to make?"
-  - Accept input, then display: "**Returning to edit step...**"
-  - Read fully and follow: `./step-e-03-edit.md` again
-
-- **IF S (Summary):**
-  - Display detailed summary including:
-    - Complete list of all changes made
-    - Before/after comparison (key improvements)
-    - Recommendations for next steps
-  - Display: "**Edit Workflow Complete**"
-  - Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow.on_complete` — if the resolved value is non-empty, follow it as the final terminal instruction before exiting.
-  - Exit
-
-- **IF X (Exit):**
-  - Display summary
-  - Display: "**Edit Workflow Complete**"
-  - Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow.on_complete` — if the resolved value is non-empty, follow it as the final terminal instruction before exiting.
-  - Exit
-
-- **IF Any other:** Help user, then redisplay menu
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Complete edit summary compiled accurately
-- All changes clearly documented
-- Options presented with clear expectations
-- Validation option seamlessly integrates with steps-v workflow
-- User can validate, edit more, or exit
-- Clean handoff to validation workflow (if chosen)
-- Edit workflow completes properly
-
-### ❌ SYSTEM FAILURE:
-
-- Missing changes in summary
-- Not offering validation option
-- Not documenting completion properly
-- No clear handoff to validation workflow
-
-**Master Rule:** Edit workflow seamlessly integrates with validation. User can edit → validate → edit again → validate again in iterative improvement cycle.

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

@@ -0,0 +1,90 @@
+---
+name: bmad-prd
+description: Create, update, validate, or analyze a PRD. Use when the user wants help producing, editing, validating, or analyzing a PRD.
+---
+# BMad PRD
+
+## Overview
+
+You are an expert PM facilitator. The user has an idea that needs to be captured in a PRD; your job is to coach them to a PRD they are proud of — guide, do not do the thinking for them. Discovery posture, the patterns that hold a PRD together, and the rules that keep parent context lean live in `## Discovery`, `## PRD Discipline`, and `## Constraints`.
+
+At the opening greeting, let the user know they can invoke the skills `bmad-party-mode` for multi-agent perspectives or `bmad-advanced-elicitation` for deeper exploration at any point.
+
+## On Activation
+
+1. Resolve customization: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`. On failure, surface the diagnostic and halt.
+2. Execute each entry in `{workflow.activation_steps_prepend}` in order.
+3. Treat every entry in `{workflow.persistent_facts}` as foundational context. Entries prefixed `file:` are paths or globs under `{project-root}` — load their contents as facts. All others are facts verbatim.
+4. Note `{workflow.external_sources}` as a registry to consult on demand when the conversation surfaces a relevant need. Do not query preemptively. If a named tool is unavailable at runtime, fall back to standard behavior and note the gap.
+5. Load `{project-root}/_bmad/bmm/config.yaml` (and `config.user.yaml` if present). Resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{planning_artifacts}`, `{project_name}`, `{date}`.
+6. Detect mode and intent. If headless (no interactive user), read `references/headless.md` and follow it for the whole run with matched intent. If interactive, greet `{user_name}` in `{communication_language}` and detect intent (create / update / validate); ask if intent is unclear.
+7. Execute each entry in `{workflow.activation_steps_append}` in order.
+
+## Intent Operating Modes
+
+**Create.** A PRD the user is proud of, drawn out through real conversation. Discovery first, drafting second. Bind `{doc_workspace}` to a fresh folder at `{workflow.output_dir}/{workflow.output_folder_name}/` and write `prd.md` there with YAML frontmatter (title, created, updated). Version and state transitions live in `decision-log.md`. For Update and Validate, `{doc_workspace}` is the existing folder of the PRD being targeted. When drafting is complete, proceed to `## Finalize`.
+
+**Update.** Reconcile an existing PRD with a change signal. Orient via source extractors (see `## Constraints` → Extract, don't ingest) against the PRD, addendum, `decision-log.md`, and original inputs — then run the `## Discovery` posture against the change signal. Surface conflicts with prior decisions before changing. If the change is fundamental, offer Create instead of patching. When changes are applied, proceed to `## Finalize`.
+
+**Validate** (or *analyze*). Critique an existing PRD against `{workflow.validation_checklist}`. Standalone — does NOT enter `## Finalize`. Orient via source extractors against `decision-log.md` and any original inputs to give the validator context. Spawn the validator subagent against `prd.md` (and `addendum.md` if present); produce findings and a validation report per `references/validation-render.md`. Always offer to roll findings into an Update.
+
+## Discovery
+
+Open with space for the full picture: invite a brain dump, inputs, ideas, WHY they are doing this. Read what exists first; ask only what is missing. After the dump, a simple "anything else?" often surfaces what they almost forgot.
+
+Before drafting, read the situation across four dimensions — they determine the PRD's shape:
+
+- **Stakes.** Calibrates rigor, section depth, and which adapt-in clusters apply.
+- **Audience.** Drives tone, evidence requirements, and approval sections.
+- **Existing inputs.** Existing artifacts mean those parts of the PRD reference, not relitigate. When project-context, prior PRDs, or existing UX/architecture are present, this is brownfield — frame Discovery around what is new or changing.
+- **Downstream depth.** Whole spec for a small build, or top of a chain through UX → architecture → epics → stories? Affects how much the PRD encodes vs. defers.
+
+**Right-skill check.** Once the situation is read, sanity-check that PRD is the best tool. Three cases where it isn't:
+
+- **Games** → suggest `bmad-gds` for the Game Design Document.
+- **Small scope + wants a captured artifact** (small tweak to an existing codebase, single doc to point at) → stay here and produce an *all-inclusive document*: lean spine plus inline Stories via the adapt-in Stories cluster.
+- **Express implementation** (wants to build now, no planning chain or captured artifact needed) → suggest `bmad-quick-dev`.
+
+Surface these honestly and let the user choose; if they prefer this skill anyway, proceed with the right-sized version.
+
+Coach, do not quiz. Push hardest on PRD Discipline risks — unexamined assumptions, capability-vs-implementation confusion, term drift, scope creep, ambiguity for downstream readers. Suggest research if needed and have subagents use web search tools as needed.
+
+**Working mode.** Once the situational read is complete, offer the user a choice before proceeding — one sentence per option:
+
+- **Express:** resolve any remaining critical gaps in a short batch, then draft the full PRD at once.
+- **Facilitative:** work through the sections that require PM thinking before drafting, using the techniques in `references/facilitation-guide.md`. Capture all decisions in the log, section to section. Draft after the key sections are walked. The goal is that the user has authored the thinking — not just answered intake questions.
+
+In both modes, resolve decisions conversationally rather than silently deferring them into `[ASSUMPTION]` tags. Only use `[ASSUMPTION]` when the answer requires research or external input the PM cannot provide in the moment.
+
+## PRD Discipline
+
+- **Features grouped, FRs nested.** Features open with behavioral description; FRs nested and numbered globally for stable IDs. Cross-cutting NFRs in their own section; skip traceability matrices.
+- **Capabilities, not implementation.** FRs describe what users or systems can do, not how. Tech choices go in addendum.
+- **No innovation theater.** Don't fabricate novelty; add a differentiation section only when Discovery surfaced something genuinely novel.
+- **Personas, when used, are research-grounded or marked `[ILLUSTRATIVE]`.** Invented detail is *persona theater* — false specificity the team builds for. Personas must drive decisions; two to four max.
+- **Domain awareness.** Regulatory or compliance constraints surface in the PRD, not deferred to architecture.
+- **Right-size to purpose.** Section depth and adapt-in clusters follow project type and stakes — the template's adapt-in menu names the standard clusters.
+- **Non-Goals explicit.** Pair with inline `[NON-GOAL for MVP]` and `[v2 — out of MVP]` callouts so omissions aren't silently assumed.
+- **Never silently de-scope.** Nothing the user explicitly included drops without asking. Propose phasing; never impose it.
+- **Counter-metrics named.** When Success Metrics is present, name what NOT to optimize.
+- **Assumptions visible.** Inferences without direct user confirmation are tagged `[ASSUMPTION: ...]` inline and indexed at the end.
+- **`[NOTE FOR PM]` callouts** at decision points the user deferred or left tension on.
+
+## Constraints
+
+- **Persistence is near real-time.** Create the workspace (`prd.md` skeleton, `decision-log.md`) on disk the moment Create intent is confirmed; tell the user the path.
+- **File roles.** `decision-log.md` — every decision, change, and version transition, in real time. `addendum.md` — depth that doesn't fit PRD shape: rejected alternatives, technical detail, ops/cost, competitive analysis. Capture technical-how detail to addendum immediately when the user volunteers it.
+- **Continuity across sessions.** If a prior draft exists in `{workflow.output_dir}`, offer to resume; surface open items first.
+- **Extract, don't ingest.** Never load source documents into the parent context wholesale. Delegate to subagents to extract what's relevant; the parent assembles from extracts.
+- **Downstream workflows run in fresh context.** This skill's output is `prd.md` (and optional `addendum.md`). Never invoke downstream workflows or produce separate handoff artifacts.
+
+## Finalize
+
+1. Decision log audit: walk `decision-log.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`; surface gaps, especially qualitative ideas (tone, voice, feel) the FR structure silently drops. Must happen before polish.
+3. Discipline pass: validator subagent against `prd.md` with `{workflow.validation_checklist}`. Findings stay in-conversation — autofix obvious issues, ask on ambiguous ones. No report file is written. Resolve before polish.
+4. Open-items review: triage all Open Questions, `[ASSUMPTION]` tags, and `[NOTE FOR PM]` callouts. Surface only phase-blockers one at a time; resolve before calling the PRD ready. Log deferred items to `decision-log.md`. If phase-blocking count is high, flag it.
+5. Polish: apply `{workflow.doc_standards}` to `prd.md` and `addendum.md` via parallel subagents.
+6. External handoffs: execute `{workflow.external_handoffs}` entries; surface returned URLs/IDs. Skip and flag unavailable tools.
+7. Record finalization to `decision-log.md`. Share all artifact paths. Invoke `bmad-help` to share possible steps.
+8. Run `{workflow.on_complete}` if non-empty.

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

@@ -0,0 +1,76 @@
+# Headless Mode JSON Schemas
+
+Every headless run ends with one of these payloads. Omit keys for artifacts not produced.
+
+## Common fields
+
+- `status` — `"complete"`, `"blocked"`, or `"partial"`
+- `intent` — `"create"`, `"update"`, or `"validate"` (matches the detected intent)
+- `reason` — required when `status` is `"blocked"`; one-sentence explanation
+- `assumptions` — array of inferred values that were not directly confirmed by inputs
+- `open_questions` — array of items that need a human decision before the artifact can be considered final
+
+## Create
+
+```json
+{
+  "status": "complete",
+  "intent": "create",
+  "prd": "{doc_workspace}/prd.md",
+  "addendum": "{doc_workspace}/addendum.md",
+  "decision_log": "{doc_workspace}/decision-log.md",
+  "open_questions": [],
+  "assumptions": [],
+  "external_handoffs": [
+    {"directive": "Confluence upload", "tool": "corp:confluence_upload", "url": "https://confluence.corp/PROD/123", "status": "ok"}
+  ]
+}
+```
+
+## Update
+
+```json
+{
+  "status": "complete",
+  "intent": "update",
+  "prd": "{doc_workspace}/prd.md",
+  "decision_log": "{doc_workspace}/decision-log.md",
+  "changes_summary": "1-3 sentences describing what changed and why",
+  "conflicts_with_prior_decisions": [],
+  "open_questions": [],
+  "external_handoffs": [
+    {"directive": "Confluence upload", "tool": "corp:confluence_upload", "url": "https://confluence.corp/PROD/123", "status": "ok"}
+  ]
+}
+```
+
+## Validate
+
+```json
+{
+  "status": "complete",
+  "intent": "validate",
+  "validation_report": "{doc_workspace}/validation-report.md",
+  "findings_summary": {
+    "critical": 0,
+    "high": 0,
+    "medium": 0,
+    "low": 0
+  },
+  "offer_to_update": true
+}
+```
+
+`validation_report` is always written for Validate intent — the path here is required, not optional.
+
+## Blocked
+
+```json
+{
+  "status": "blocked",
+  "intent": "update",
+  "reason": "Change signal ambiguous — could be a scope expansion or a clarification; no inferred direction"
+}
+```
+
+Always include the intent (best-guess if not certain) and a one-sentence `reason`.

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

@@ -0,0 +1,158 @@
+# PRD Template — A Menu, Not a Skeleton
+
+This is a menu of sections the facilitator picks from based on what the product, the stakes, the audience, and the existing inputs actually need. Hobby projects use the essential spine and stop. Enterprise initiatives, regulated submissions, and consumer launches add clusters from the adapt-in menu below. **Never include a section just because it appears here.** Drop, reorder, rename, combine — whatever the PRD needs.
+
+---
+
+## Essential Spine *(almost always present)*
+
+```markdown
+---
+title: {Product Name}
+created: {YYYY-MM-DD}
+updated: {YYYY-MM-DD}
+---
+
+# PRD: {Product Name}
+*Working title — confirm.*
+
+## 0. Document Purpose
+[1 paragraph: who this PRD is for (PM, stakeholders, downstream workflow owners), how it's structured (Glossary-anchored vocabulary, features grouped with FRs nested, assumptions tagged inline and indexed). If UX work or other inputs already exist, name them here and reference where they live — this PRD builds on them, it does not duplicate.]
+
+## 1. Vision
+[2-3 paragraphs: what this is, what it does for the user, why it matters. Compelling enough to stand alone.]
+
+## 2. Target User
+
+### 2.1 Primary Persona
+[Vivid but tight. Who they are, how this product fits their context.]
+
+### 2.2 Jobs To Be Done
+[Bulleted. Emotional, social, functional, contextual — whichever apply. Even "this is for me as the builder" is a valid persona for a hobby project.]
+
+### 2.3 Non-Users (v1) *(add when the audience boundary is non-obvious)*
+[Who this is explicitly not for in v1.]
+
+### 2.4 Key User Journeys
+*Named flows the product enables — one line each, numbered globally as UJ-1 through UJ-N for downstream traceability. Detailed flow design (steps, screens, edge flows) is the job of the UX workflow, not this PRD. Features in §4 may reference journeys by ID inline ("realizes UJ-3").*
+
+- **UJ-1** — [Named flow, one line: who does what, to what end.]
+- **UJ-2** — ...
+
+[For hobby/utility projects, 1-3 journeys may be enough. For complex multi-feature products (onboarding, checkout, multi-step approvals), expand. For libraries/CLIs with minimal flow, reduce to a single line or collapse into §2.2 JTBD.]
+
+## 3. Glossary
+*Downstream workflows and readers must use these terms exactly.*
+
+- **Term** — Definition. Relationships to other Glossary terms. Cardinality where relevant.
+- **Term** — ...
+
+[Every domain noun the rest of the document uses. Defined once. No synonyms anywhere else in the PRD.]
+
+## 4. Features
+*Each subsection is a coherent feature: behavioral description first, FRs nested under it, optional feature-specific NFRs and notes. FRs are numbered globally (FR-1 through FR-N) so downstream artifacts have stable references even if features get reorganized. Reference user journeys by ID inline ("realizes UJ-2") where the chain matters.*
+
+### 4.1 {Feature Name}
+**Description:** [Behavioral narrative — how this feature works, who uses it, the user experience, edge cases. Use Glossary terms exactly. Embed inline `[ASSUMPTION: ...]` tags where you inferred without confirmation.]
+
+**Functional Requirements:**
+- **FR-1** — [Actor] can [capability] [under conditions / with measurement].
+- **FR-2** — ...
+
+**Feature-specific NFRs:** *(only if any apply uniquely to this feature)*
+- Performance / security / accessibility / etc. specific to this feature.
+
+**Notes:** *(optional — open questions specific to this feature, `[NOTE FOR PM]` callouts)*
+
+### 4.2 {Feature Name}
+...
+
+## 5. Non-Goals (Explicit)
+[Bulleted. What this product is *not* and what it will *not* do in v1. Does outsized work for downstream readers and workflows — prevents the "let me also add this nearby thing" failure mode at every level (epic, ticket, code). Inline `[NON-GOAL for MVP]` callouts within §4 Features cover deferred items within features; this section captures the broader "we are not building X / we are not becoming Y" statements.]
+
+## 6. MVP Scope
+
+### 6.1 In Scope
+[Bulleted, crisp.]
+
+### 6.2 Out of Scope for MVP
+[Bulleted. Each item with a one-line reason if the reason matters. Mark items deferred to v2/v3 explicitly. Add `[NOTE FOR PM]` callouts where a deferred item is emotionally load-bearing — flags it for revisit if timeline permits.]
+
+## 7. Success Metrics
+
+**Primary**
+- Metric — definition, target.
+
+**Secondary**
+- Metric — definition, target.
+
+**Counter-metrics (do not optimize)**
+- Metric — why this should *not* be optimized.
+
+[Length scales with stakes. Hobby/utility PRD: a single sentence may be enough ("Success: I use this weekly and don't abandon it after a month"). Public launch / enterprise: full quantitative breakdown with measurement methods. Counter-metrics are as load-bearing as primary metrics — they prevent the architect from optimizing the wrong thing and the dev from gaming the wrong target.]
+
+## 8. Open Questions
+[Numbered. Things still unknown — they become future tickets or follow-up research, not silent gaps.]
+
+## 9. Assumptions Index
+*Every `[ASSUMPTION]` from the document, surfaced for explicit confirmation:*
+- Inline assumption from §X.Y — short description.
+- ...
+```
+
+---
+
+## Adapt-In Menu *(add the clusters the product calls for)*
+
+### Cross-cutting quality and shape *(most non-trivial PRDs)*
+- **Cross-Cutting NFRs** — system-wide non-functional requirements not tied to a single feature (performance, security, reliability, observability). Add when system-wide quality attributes are meaningful.
+- **Constraints and Guardrails** — Safety, Privacy, Cost. Subsection per cluster. Add when any of these are real concerns.
+- **Why Now** — add when timing is load-bearing (a market shift, a technology enabler, a regulatory deadline). Drop when timing is incidental.
+
+### Consumer / branded products
+- **Aesthetic and Tone** — visual references, anti-references, voice/tone for any product-generated text.
+- **Information Architecture** — top-level surfaces, navigation, screens.
+- **Monetization** — free vs. paid, pricing assumptions, ads policy.
+- **Platform** — web, mobile, PWA, native, v1 vs. v2+.
+
+### Enterprise initiatives
+- **Stakeholders and Approvals** — who must sign off, at what stage.
+- **Risk and Mitigations** — operational, security, business, reputational risk register.
+- **ROI / Business Case** — quantified benefit, cost, payback period.
+- **Operational Requirements** — SLAs, RTO/RPO, support tier, on-call expectations.
+- **Integration and Dependencies** — SSO, existing enterprise systems, data sources, downstream consumers.
+- **Rollout and Change Management** — phased rollout plan, training, internal communication.
+- **Data Governance** — residency, sovereignty, classification, retention.
+- **Audit Trail / Decision Provenance** — formal documentation requirements for regulated environments.
+
+### Regulated domains
+- **Compliance and Regulatory** — HIPAA, PCI-DSS, GDPR, SOX, SOC 2, Section 508 / WCAG 2.1 AA, FedRAMP, etc. — whichever apply. If any item needs depth, add a `[NOTE FOR PM]` callout to revisit or move to an addendum.
+
+### Developer products (libraries, APIs, CLIs, SDKs)
+- **API Contracts / Public Surface** — endpoint shapes, breaking change policy.
+- **Versioning and Deprecation Policy**.
+- **Performance Budgets** — latency, throughput, resource use.
+- **Language / Runtime Targets and Dependency Policy**.
+
+### Embedded / hardware
+- **Hardware Constraints** — memory, power, form factor.
+- **Deployment and Update Mechanism** — OTA, manual, image-based.
+- **Environmental and Reliability Requirements**.
+
+### Small-scope all-inclusive *(use when scope is 1-2 stories' worth and the user wants a single captured artifact — chosen during the Right-skill check in Discovery)*
+- **Stories** — story-level specs listed inline at the end of the doc. Each story: *"As a [persona], I can [action] [under conditions]. Acceptance: [testable criteria]."* Numbered Story-1, Story-2, ... for reference. Pair with very lean §1 Vision, §2 Target User (often just JTBD + one UJ), §3 Glossary (handful of terms), §4 Features (often a single feature), §6 MVP Scope (in/out very tight). The whole doc fits on a page or two and captures intent + implementable stories in one place. If the user doesn't want the captured artifact at all, `bmad-quick-dev` is the better path — this cluster is only for "I want a doc *and* the stories."
+
+---
+
+## Notes for the facilitator
+
+- **The essential spine is the floor, not the ceiling.** A hobby PRD might keep all ten sections short. An enterprise PRD layers many clusters from the adapt-in menu.
+- **§3 Glossary before §4 Features.** Mechanics never introduce a new domain noun without adding it to the Glossary in the same pass. Persona, JTBD, and Journeys may use Glossary terms before §3 formally defines them — context is inferable; the Glossary is for downstream anchoring.
+- **§2.4 Key User Journeys are brief.** One line each. Numbered globally (UJ-1 through UJ-N) so architecture, epics, stories, and tickets can reference them by stable ID. Detailed flow design happens in the UX workflow — not here.
+- **§4 Features pattern at every scale.** Description → FRs nested → optional NFRs → optional notes. Hobby PRD: one short paragraph and three FRs per feature. Enterprise feature: multi-paragraph description, fifteen FRs, several feature-specific NFRs, open questions. Same shape, different depth.
+- **`[ASSUMPTION]`, `[NON-GOAL]`, `[v2 — out of MVP]`, `[NOTE FOR PM]` callouts are first-class.** They signal to downstream readers and the next session of work. Every `[ASSUMPTION]` lands in §9 Assumptions Index.
+- **When UX is *input* to the PRD** (journeys already designed elsewhere): §2.4 names the journeys by ID and points to the existing UX doc. Reference, do not duplicate.
+- **When UX is *output* of the PRD** (no UX work yet — downstream `bmad-create-ux-design` will produce it): §2.4 captures the PM's intent on which journeys exist; UX elaborates them into detailed flows downstream.
+- **§7 Success Metrics scales with stakes** but is always present. Counter-metrics matter as much as primary metrics — they shape what NOT to optimize.
+- **Small-scope all-inclusive option.** When scope is genuinely 1-2 stories and the user wants a single artifact instead of running a separate `bmad-create-story` workflow, add the adapt-in *Stories* cluster: lean §1-§6 plus inline §Stories at the end. The whole doc fits on a page or two. This is a valid PRD shape for tiny work — don't apologize for it.
+- **Adapt the section numbering.** The spine uses 0-9; adapt-in additions slot in wherever they read best (e.g., Aesthetic & Tone before §3 if branding is foundational, Compliance after §5 Non-Goals, Constraints & Guardrails between Features and Non-Goals, Stories at the very end after Assumptions Index).

src/bmm-skills/2-plan-workflows/bmad-prd/assets/prd-validation-checklist.md

@@ -0,0 +1,30 @@
+# PRD Validation Checklist
+
+Loaded by the PRD validator subagent. For each item, return `{id, status: pass|fail|warn|n/a, severity: low|medium|high|critical, location, note}`. Skip items not applicable to the agreed stakes. Cite specific PRD locations — never abstract criticism.
+
+## Quality
+
+- **Q-1. Information density.** Sentences carry weight. Flag filler, hedging, and conversational padding.
+- **Q-2. Measurability.** Where measurement matters, FRs and Success Metrics are measurable; subjective adjectives flagged. Counter-metrics named when Success Metrics exist.
+- **Q-3. Traceability.** Where the chain matters, FRs name their link to a user journey or success criterion inline.
+- **Q-4. Vision and JTBDs concrete.** Vision is specific and stands alone — not a generic feature list. JTBDs are audience-grounded, not abstract.
+- **Q-5. Non-Goals explicit.** A Non-Goals section is present where it would do real work; inline `[NON-GOAL]` and `[v2]` callouts where omissions would otherwise be silently assumed.
+- **Q-6. Dual-audience and self-contained.** Each section makes sense pulled out alone (cross-references via Glossary terms, not "see above"); the PRD is readable by humans and structured cleanly for downstream source-extraction by UX, architecture, and story-creation workflows.
+
+## Discipline
+
+- **D-1. Capabilities, not implementation.** FRs describe what users/systems can do, not how. Flag technology names, library choices, architecture decisions.
+- **D-2. Input fidelity.** Requirements from input documents (brief, research, prior PRD) are still in scope or explicitly handled via Non-Goals or `[ASSUMPTION]`.
+- **D-3. Personas grounded.** If personas exist, they are research-grounded or marked `[ILLUSTRATIVE]`. Each persona drives at least one decision.
+- **D-4. No innovation theater.** Novelty claims are real, not invented.
+
+## Structural integrity
+
+- **S-1. Glossary integrity.** Every domain noun is defined in the Glossary and used identically throughout. Flag drift (case, plural, synonyms) and candidate missing-term entries.
+- **S-2. ID continuity.** FR / UJ / Story IDs are contiguous, unique, and cross-references resolve.
+- **S-3. Assumptions Index.** Every inline `[ASSUMPTION: ...]` appears in the Assumptions Index and vice versa.
+- **S-4. Open-items density.** Count Open Questions + `[ASSUMPTION]` + `[NOTE FOR PM]`. Red flag if density is high relative to the agreed stakes.
+
+## Stakes-gated
+
+- **STK-1. Required sections.** The PRD includes the sections the agreed stakes and product type warrant.

src/bmm-skills/2-plan-workflows/bmad-prd/assets/validation-report-template.html

@@ -0,0 +1,190 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>PRD Validation: $prd_name</title>
+<style>
+  :root {
+    --bg: #fafaf9;
+    --surface: #ffffff;
+    --border: #e7e5e4;
+    --text: #1c1917;
+    --muted: #78716c;
+    --pass: #22c55e;
+    --warn: #eab308;
+    --fail: #ef4444;
+    --na: #94a3b8;
+    --sev-low: #64748b;
+    --sev-medium: #ca8a04;
+    --sev-high: #ea580c;
+    --sev-critical: #dc2626;
+    --grade-exc: #16a34a;
+    --grade-good: #65a30d;
+    --grade-fair: #d97706;
+    --grade-poor: #dc2626;
+  }
+  * { box-sizing: border-box; }
+  html, body { margin: 0; padding: 0; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Inter, system-ui, sans-serif;
+    background: var(--bg);
+    color: var(--text);
+    line-height: 1.55;
+    font-size: 15px;
+  }
+  .container { max-width: 960px; margin: 0 auto; padding: 32px 24px 64px; }
+
+  header.report-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 24px;
+    padding-bottom: 16px;
+    border-bottom: 1px solid var(--border);
+    margin-bottom: 24px;
+  }
+  .title h1 { margin: 0; font-size: 22px; font-weight: 600; letter-spacing: -0.01em; }
+  .title .subtitle { color: var(--muted); font-size: 13px; margin-top: 4px; font-family: ui-monospace, "SF Mono", Menlo, monospace; }
+  .grade {
+    padding: 10px 18px;
+    border-radius: 8px;
+    font-weight: 600;
+    color: white;
+    font-size: 15px;
+    white-space: nowrap;
+  }
+  .grade-excellent { background: var(--grade-exc); }
+  .grade-good { background: var(--grade-good); }
+  .grade-fair { background: var(--grade-fair); }
+  .grade-poor { background: var(--grade-poor); }
+
+  .synthesis {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-left: 3px solid var(--muted);
+    border-radius: 8px;
+    padding: 16px 20px;
+    margin-bottom: 24px;
+    color: var(--text);
+    font-size: 15px;
+  }
+  .synthesis:empty { display: none; }
+
+  .scoreboard {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 18px 20px;
+    margin-bottom: 24px;
+  }
+  .score-bar { margin: 0 0 14px; line-height: 0; }
+  .score-stats { display: flex; gap: 22px; font-size: 14px; flex-wrap: wrap; }
+  .score-stats span { display: inline-flex; align-items: center; gap: 6px; }
+  .score-stats .dot { width: 10px; height: 10px; border-radius: 50%; display: inline-block; }
+  .dot-pass { background: var(--pass); }
+  .dot-warn { background: var(--warn); }
+  .dot-fail { background: var(--fail); }
+  .dot-na { background: var(--na); }
+  .total-count { margin-left: auto; color: var(--muted); }
+
+  section.category { margin-bottom: 16px; }
+  section.category details {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    overflow: hidden;
+  }
+  section.category summary {
+    padding: 14px 20px;
+    cursor: pointer;
+    user-select: none;
+    list-style: none;
+  }
+  section.category summary::-webkit-details-marker { display: none; }
+  section.category summary::before {
+    content: "▸";
+    display: inline-block;
+    margin-right: 10px;
+    color: var(--muted);
+    transition: transform 0.15s ease;
+  }
+  section.category details[open] summary::before { transform: rotate(90deg); }
+  section.category summary h2 { display: inline; margin: 0; font-size: 16px; font-weight: 600; letter-spacing: -0.005em; }
+  section.category .count { color: var(--muted); font-weight: 400; margin-left: 6px; font-size: 14px; }
+
+  article.finding { padding: 16px 20px; border-top: 1px solid var(--border); }
+  article.finding-fail { background: rgba(239, 68, 68, 0.025); }
+  article.finding header {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    flex-wrap: wrap;
+    margin-bottom: 8px;
+  }
+  .badge {
+    font-size: 10.5px;
+    padding: 3px 8px;
+    border-radius: 4px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+    line-height: 1.4;
+  }
+  .badge-pass { background: rgba(34, 197, 94, 0.12); color: #15803d; }
+  .badge-warn { background: rgba(234, 179, 8, 0.14); color: #854d0e; }
+  .badge-fail { background: rgba(239, 68, 68, 0.12); color: #b91c1c; }
+  .badge-na { background: rgba(148, 163, 184, 0.16); color: #475569; }
+  .badge-sev-low { background: rgba(100, 116, 139, 0.12); color: var(--sev-low); }
+  .badge-sev-medium { background: rgba(202, 138, 4, 0.14); color: var(--sev-medium); }
+  .badge-sev-high { background: rgba(234, 88, 12, 0.14); color: var(--sev-high); }
+  .badge-sev-critical { background: rgba(220, 38, 38, 0.14); color: var(--sev-critical); }
+  .finding-id { font-family: ui-monospace, "SF Mono", Menlo, monospace; font-size: 12px; color: var(--muted); }
+  .finding-title { margin: 0; font-size: 15px; font-weight: 500; flex: 1; min-width: 200px; }
+  .finding-location, .finding-note, .finding-fix { margin-top: 6px; font-size: 14px; color: var(--text); }
+  .finding-location strong, .finding-fix strong { color: var(--muted); font-weight: 500; }
+
+  footer.report-footer {
+    margin-top: 40px;
+    padding-top: 16px;
+    border-top: 1px solid var(--border);
+    font-size: 12px;
+    color: var(--muted);
+    font-family: ui-monospace, "SF Mono", Menlo, monospace;
+  }
+  footer .meta { display: flex; gap: 24px; flex-wrap: wrap; }
+</style>
+</head>
+<body>
+  <div class="container">
+    <header class="report-header">
+      <div class="title">
+        <h1>$prd_name — Validation Report</h1>
+        <div class="subtitle">$prd_path</div>
+      </div>
+      <div class="grade $grade_class">$grade</div>
+    </header>
+
+    <div class="synthesis">$overall_synthesis</div>
+
+    <div class="scoreboard">
+      <div class="score-bar">$score_svg</div>
+      <div class="score-stats">
+        <span><span class="dot dot-pass"></span>$passed pass</span>
+        <span><span class="dot dot-warn"></span>$warned warn</span>
+        <span><span class="dot dot-fail"></span>$failed fail</span>
+        <span><span class="dot dot-na"></span>$na n/a</span>
+        <span class="total-count">$total items checked</span>
+      </div>
+    </div>
+
+    $categories_html
+
+    <footer class="report-footer">
+      <div class="meta">
+        <span>Checklist: $checklist_path</span>
+        <span>Generated: $timestamp</span>
+      </div>
+    </footer>
+  </div>
+</body>
+</html>

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

@@ -0,0 +1,113 @@
+# DO NOT EDIT -- overwritten on every update.
+#
+# Workflow customization surface for bmad-prd.
+#
+# Override files (not edited here):
+#   {project-root}/_bmad/custom/bmad-prd.toml         (team)
+#   {project-root}/_bmad/custom/bmad-prd.user.toml    (personal)
+
+[workflow]
+
+# --- Configurable below. Overrides merge per BMad structural rules: ---
+#   scalars: override wins • arrays: append
+
+# Steps to run before the standard activation (config load, greet).
+# Use for pre-flight loads, compliance checks, etc.
+activation_steps_prepend = []
+
+# Steps to run after greet but before 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
+# (standards, compliance constraints, stylistic 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 has produced one — this gives
+# the facilitator persistent awareness of the project's tech, domain, and constraints without
+# re-asking. Common opt-ins (set in team/user override TOML):
+#   "skill:acme-co:terms-and-conditions"                                      # a skill that contains some relevant info
+#   "Investor PRDs must include a market sizing section."                    # generic agent instruction
+persistent_facts = [
+  "file:{project-root}/**/project-context.md",
+]
+
+# Executed when the workflow completes (after the user has been told the
+# PRD is ready). Accepts either a string scalar (single instruction)
+# or an array of instructions executed in order. Empty for none.
+on_complete = ""
+
+# Default PRD structure. Treated as a starting point — the LLM adapts it
+# to the product, project type, and domain. Override the path in team/user TOML
+# to enforce a different structure (e.g. regulated-industry, internal-tool, investor-input).
+prd_template = "assets/prd-template.md"
+
+# Validation checklist used at the Validate intent and at Finalize step 3.
+# A subagent walks the checklist against prd.md and returns structured findings.
+# Override the path in team/user TOML to enforce an org-specific checklist
+# (regulated-industry compliance, investor-pitch standards, etc.).
+validation_checklist = "assets/prd-validation-checklist.md"
+
+# HTML template used to render validation findings into a styled, scannable
+# report. The renderer (scripts/render-validation-html.py) substitutes
+# structured findings + summary stats into this template; the template is
+# fully overridable to match org branding. The default uses inline CSS, no
+# external dependencies, and native HTML <details> for collapse — no JS.
+validation_report_template = "assets/validation-report-template.html"
+
+# Run folder location. The PRD, optional addendum, decision log, and optional
+# validation report all land inside `{output_dir}/{output_folder_name}/`.
+output_dir = "{planning_artifacts}/prds"
+output_folder_name = "prd-{project_name}-{date}"
+
+# Document standards applied to human-consumed docs at finalize. Each entry is
+# a `skill:`, `file:`, or plain-text directive; the parent LLM applies the
+# findings before the user sees the draft. Encodes standards, not options.
+#
+# Examples:
+#   "skill:bmad-editorial-review-prose"
+#   "file:{project-root}/_bmad/style-guides/company-voice.md"
+#   "Convert all dates to ISO 8601 format."
+#
+# Suggested order (broader passes first, narrower last):
+#   1. Structural (cuts, reorganization, section sizing)
+#   2. Content/voice/conventions (org standards, tone, terminology, compliance)
+#   3. Prose mechanics (grammar, clarity, typos)
+#
+# Override the array in team/user TOML to add additional standards. Append-only:
+# base entries cannot be removed or replaced (resolver has no removal mechanism).
+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 during the workflow
+# when a relevant need surfaces. The LLM does NOT query these preemptively —
+# it consults them on demand (during Discovery, validation, drafting, etc.).
+# Each entry names the tool, the conditions for using it, and any fields the
+# tool needs. If a named MCP tool is unavailable at runtime, the LLM falls
+# back to standard behavior and notes the gap. Empty by default.
+#
+# Examples (set in team/user override TOML):
+#   "When researching internal product context, consult corp:kb_search (database='product-docs') before web search."
+#   "For competitive landscape during Discovery, query corp:competitive_db with category={project_name}."
+#   "When validating domain-compliance claims, cross-check against corp:hipaa_reference for healthcare or corp:pci_reference for fintech."
+external_sources = []
+
+# External-handoff routing. Natural-language directives the LLM applies at
+# Finalize to route outputs beyond local files (Confluence, Notion, Google
+# Drive, ticket systems, etc.). Each entry names the MCP tool, the destination,
+# and the fields the tool needs. Handoffs run after the artifact is polished
+# and before the final user-facing message. URLs or IDs returned by the
+# destination are captured and surfaced to the user. If a named tool is
+# unavailable at runtime, the handoff is skipped and flagged in the JSON
+# status; local files always exist regardless. Fires automatically — users
+# can opt out in their prompt for a specific run. Empty by default.
+#
+# Examples (set in team/user override TOML):
+#   "After finalize, upload prd.md and addendum.md to Confluence via corp:confluence_upload (space_key='PROD', parent_page='PRDs', label='prd', author={user_name})."
+#   "Mirror the PRD to Notion via notion:create_page (database_id='abc123', title='PRD: '+{project_name})."
+#   "When the PRD references a parent initiative, link via corp:jira_link on the epic key in frontmatter."
+external_handoffs = []

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

@@ -0,0 +1,79 @@
+# PRD Facilitation Guide
+
+Per-section conversation techniques for facilitative mode. Each entry names the coaching move that makes the section's conversation productive — not a checklist, a posture. Skip sections the PM has already resolved; spend more time where thinking is thin.
+
+---
+
+## Users and Personas
+
+**The move:** Ground personas in real people, not archetypes.
+
+Ask the PM to describe a specific person they have observed or talked to — not a type, an actual human. "Who is the clerk at your store? Tell me about them." Invented detail (name, age, backstory from nowhere) is persona theater — the team builds for a fiction. If the PM says "someone like..." push gently: "Is there a real person you're thinking of?"
+
+Once grounded: what does that person want to accomplish in the time they interact with this product? What would make them say this is easier than what they do today? What would make them abandon it?
+
+For the remote user or secondary persona: same grounding, different question — what question do they need answered in under ten seconds, and what do they do if they can't get it?
+
+Mark anything the PM could not ground in observation as `[ILLUSTRATIVE]` — and note it's a hypothesis to validate, not a spec to build for.
+
+---
+
+## Core User Journeys
+
+**The move:** Story structure, not use-case list.
+
+For each primary journey, walk through four beats:
+
+- **Opening scene** — where do we meet this person, what is their situation right now, what pain or need is present?
+- **Rising action** — what steps do they take, what do they discover or decide along the way?
+- **Climax** — the moment the product delivers real value; the thing they could not do before
+- **Resolution** — what is their new reality; how is their situation different?
+
+After each journey: what could go wrong at the climax? What is the recovery path? This is where edge cases that matter surface — not invented error states, but real failure modes for this person.
+
+Explicitly name what capability each journey reveals. "This journey requires the operator to log an entry with no internet — which means we need a decision on whether that's in or out of MVP." Journeys produce capability requirements; make the link visible.
+
+---
+
+## Key Feature Decisions
+
+**The move:** Surface the assumptions that would otherwise be silent.
+
+Before the draft exists, there are decisions the agent would silently make and the PM would never know were made. These are the ones worth a thirty-second conversation:
+
+- Decisions that drive the core UX model (e.g., one record per day vs. many; who can edit vs. view; what happens when the expected input doesn't exist)
+- Decisions where the "obvious" choice has real consequences the PM may not have considered
+- Decisions that, if wrong, require structural changes to fix later
+
+For each: state what you inferred, name the alternative, ask which is right. Do not present options as a quiz — present your inference and invite correction. "I'm assuming one sales tally per day replaces rather than adds. Is that right, or should the operator be able to log multiple?" Resolve and move on. Only tag as `[ASSUMPTION]` when the answer requires external input or research the PM cannot provide now.
+
+---
+
+## Scope Boundary
+
+**The move:** Establish MVP philosophy before listing features.
+
+Before asking what is in or out, ask what kind of MVP this is:
+
+- **Problem-solving MVP** — the minimum that proves the core problem is solved; rough edges acceptable
+- **Experience MVP** — the minimum that proves the interaction model works; quality matters
+- **Platform MVP** — the minimum infrastructure other things can build on; completeness of the base matters
+- **Revenue MVP** — the minimum someone will pay for; business viability is the test
+
+The answer changes what "minimum" means. A problem-solving MVP for a personal-use tool has different scope logic than an experience MVP aimed at non-tech-savvy users who will bounce at the first confusion.
+
+Once the philosophy is named, non-goals do as much work as in-scope items. Probe for the things the PM is tempted to add. "What keeps almost making it onto the list?" For each: is it truly out of MVP, or does it need to be in because the MVP fails without it?
+
+---
+
+## Success Metrics
+
+**The move:** Push every adjective to a measurement.
+
+"Users will love it" — what does that mean in behavior? "It'll be fast" — fast at what, for whom, measured how? "Good adoption" — what percentage, by when, doing what? Every quality claim needs a measurement or it is not a success criterion, it is a wish.
+
+For each metric surfaced: connect it back to the product's differentiator. If the differentiator is simplicity for non-tech users, the primary metric should measure whether non-tech users successfully complete the core action without help — not session count or feature usage breadth.
+
+Name counter-metrics explicitly — what this product should *not* optimize for. These prevent the wrong thing being built: more entries per day is not better if the goal is accurate daily records; longer dashboard sessions may indicate a broken IA, not high engagement. Counter-metrics are as load-bearing as primary metrics for downstream readers.
+
+For low-stakes or personal-use products: one sentence is enough. "Success: I use this daily and it replaces the notebook within a month." Do not impose metric rigor where the stakes do not warrant it.

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

@@ -0,0 +1,24 @@
+# Headless Mode
+
+Load this file when bmad-prd is invoked headless (no interactive user). Follow it for the whole run.
+
+## General
+
+Do not ask. Complete the intent using what is provided, what exists in `{doc_workspace}`, or what you can discover yourself. If intent remains ambiguous after inference, halt with a `blocked` JSON status and a `reason` field — do not prompt. Do not greet.
+
+End with a JSON response listing status, intent, and artifact paths. The `intent` field must match the detected intent: `"create"`, `"update"`, or `"validate"`. Omit keys for artifacts not produced. Full schemas with examples for each intent are in `assets/headless-schemas.md`. Minimal shape:
+
+```json
+{
+  "status": "complete",
+  "intent": "validate",
+  "validation_report": "{doc_workspace}/validation-report.md",
+  "offer_to_update": true
+}
+```
+
+## Mode-specific overrides
+
+**Update.** Log the reversal to `decision-log.md`, then apply. Halt `blocked` if intent is ambiguous.
+
+**Validate.** Always write `validation-report.md` to `{doc_workspace}` regardless of finding count. Always include `"offer_to_update": true` in the JSON status block.

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

@@ -0,0 +1,58 @@
+# Validation Rendering
+
+How the validator subagent's findings become a validation report. Loaded only when the user has explicitly asked for analysis — either Validate intent or a mid-session report request. The Finalize discipline pass during Create/Update does NOT render a report; its findings stay in-conversation.
+
+## Validator subagent output contract
+
+The subagent walks `{workflow.validation_checklist}` against `prd.md` (and `addendum.md` if present) and writes `{doc_workspace}/validation-findings.json`:
+
+```json
+{
+  "prd_name": "Plantsona",
+  "prd_path": "{doc_workspace}/prd.md",
+  "checklist_path": "{workflow.validation_checklist}",
+  "timestamp": "2026-05-11T09:14:00",
+  "overall_synthesis": "2-3 sentences of judgment about the PRD's overall state — what holds up, what's at risk. Written by the subagent, not the parent.",
+  "findings": [
+    {
+      "id": "Q-2",
+      "category": "Quality",
+      "title": "Measurability",
+      "status": "warn",
+      "severity": "medium",
+      "location": "§16 Success Metrics, lines 408-422",
+      "note": "Success Metrics list is measurable but counter-metrics are named only for premium conversion. Other metrics lack paired counter-metrics.",
+      "suggested_fix": "Add counter-metrics for engagement (e.g., DAU/MAU) and seasonal cadence."
+    }
+  ]
+}
+```
+
+Per-finding fields:
+
+- `id` (required) — checklist item ID (e.g., `Q-1`, `D-2`, `STK-1`, or org-custom prefixes).
+- `category` (optional) — explicit category name; if omitted, the renderer maps from the ID prefix.
+- `title` (optional but recommended) — the checklist item's short name.
+- `status` — `pass` | `warn` | `fail` | `n/a`.
+- `severity` — `low` | `medium` | `high` | `critical`.
+- `location` (optional) — section/line/range in the PRD where the finding lives. Cite specifics, never abstract criticism.
+- `note` (optional) — the finding itself, in one or two sentences.
+- `suggested_fix` (optional) — concrete next action.
+
+## Rendering invocation
+
+After the subagent writes findings:
+
+```bash
+python3 {skill-root}/scripts/render-validation-html.py \
+  --findings {doc_workspace}/validation-findings.json \
+  --template {workflow.validation_report_template} \
+  --output {doc_workspace}/validation-report.html \
+  --open
+```
+
+Include `--open` for interactive runs (auto-opens in default browser). Omit `--open` in headless runs.
+
+The script writes two artifacts side-by-side: the HTML report at `--output`, and a markdown companion at the same path with `.md` extension (e.g. `validation-report.md`). Both are always produced when the script runs — trigger gating happens upstream (the script is only invoked when the user has asked for analysis). It computes pass/warn/fail/na counts, derives a grade (Excellent / Good / Fair / Poor) from critical-fail and total-fail counts, renders an inline SVG score bar in the HTML, groups findings by category, and returns a one-line JSON summary on stdout: `{"output": "...", "markdown": "...", "grade": "...", "stats": {...}}`.
+
+Re-running validation overwrites the existing report files in place. Markdown form is what Update mode reads when rolling findings into a revision.

src/bmm-skills/2-plan-workflows/bmad-prd/scripts/render-validation-html.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# ///
+"""Render a PRD validation findings JSON into HTML + markdown reports.
+
+Reads structured findings produced by the validator subagent, groups them by
+category (explicit `category` field, else derived from ID prefix), computes a
+pass/warn/fail summary and grade, substitutes into the configured HTML
+template, writes a markdown companion at the same path with `.md` extension,
+and optionally opens the HTML in the default browser.
+"""
+
+import argparse
+import html
+import json
+import string
+import sys
+import webbrowser
+from datetime import datetime
+from pathlib import Path
+
+CATEGORY_FROM_PREFIX = {
+    "Q": "Quality",
+    "D": "Discipline",
+    "S": "Structural integrity",
+    "STK": "Stakes-gated",
+    "M": "Mechanical",
+}
+
+CATEGORY_ORDER = ["Quality", "Discipline", "Structural integrity", "Stakes-gated", "Mechanical"]
+
+
+def category_for(finding: dict) -> str:
+    explicit = finding.get("category")
+    if explicit:
+        return explicit
+    fid = finding.get("id", "")
+    prefix = fid.split("-", 1)[0] if "-" in fid else fid
+    return CATEGORY_FROM_PREFIX.get(prefix, prefix or "Other")
+
+
+def compute_stats(findings: list[dict]) -> dict:
+    total = len(findings)
+    by_status = {"pass": 0, "warn": 0, "fail": 0, "n/a": 0}
+    failed_critical = 0
+    failed_high = 0
+    for f in findings:
+        status = (f.get("status") or "n/a").lower()
+        if status in by_status:
+            by_status[status] += 1
+        if status == "fail":
+            sev = (f.get("severity") or "low").lower()
+            if sev == "critical":
+                failed_critical += 1
+            elif sev == "high":
+                failed_high += 1
+    return {
+        "total": total,
+        "passed": by_status["pass"],
+        "warned": by_status["warn"],
+        "failed": by_status["fail"],
+        "na": by_status["n/a"],
+        "failed_critical": failed_critical,
+        "failed_high": failed_high,
+    }
+
+
+def grade_from(stats: dict) -> tuple[str, str]:
+    if stats["failed_critical"] > 0:
+        return "Poor", "grade-poor"
+    if stats["failed_high"] >= 1 or stats["failed"] >= 4:
+        return "Fair", "grade-fair"
+    if stats["failed"] > 0 or stats["warned"] > 2:
+        return "Good", "grade-good"
+    return "Excellent", "grade-excellent"
+
+
+def render_score_bar(stats: dict, width: int = 480, height: int = 22) -> str:
+    total = max(stats["total"], 1)
+    p = stats["passed"] / total * width
+    w = stats["warned"] / total * width
+    f = stats["failed"] / total * width
+    n = stats["na"] / total * width
+    return (
+        f'<svg width="{width}" height="{height}" viewBox="0 0 {width} {height}" role="img" '
+        f'aria-label="Pass / warn / fail / n-a breakdown">'
+        f'<rect x="0" y="0" width="{p:.1f}" height="{height}" fill="#22c55e"/>'
+        f'<rect x="{p:.1f}" y="0" width="{w:.1f}" height="{height}" fill="#eab308"/>'
+        f'<rect x="{p + w:.1f}" y="0" width="{f:.1f}" height="{height}" fill="#ef4444"/>'
+        f'<rect x="{p + w + f:.1f}" y="0" width="{n:.1f}" height="{height}" fill="#94a3b8"/>'
+        f"</svg>"
+    )
+
+
+def render_finding(f: dict) -> str:
+    status = (f.get("status") or "n/a").lower()
+    severity = (f.get("severity") or "low").lower()
+    fid = html.escape(f.get("id") or "")
+    title = html.escape(f.get("title") or fid)
+    location = html.escape(f.get("location") or "")
+    note = html.escape(f.get("note") or "")
+    fix = html.escape(f.get("suggested_fix") or "")
+
+    status_class = "na" if status == "n/a" else status
+    parts = [
+        f'<article class="finding finding-{status_class}">',
+        '<header>',
+        f'<span class="badge badge-status badge-{status_class}">{status.upper()}</span>',
+        f'<span class="badge badge-severity badge-sev-{severity}">{severity}</span>',
+        f'<span class="finding-id">{fid}</span>',
+        f'<h3 class="finding-title">{title}</h3>',
+        '</header>',
+    ]
+    if location:
+        parts.append(f'<div class="finding-location"><strong>Location:</strong> {location}</div>')
+    if note:
+        parts.append(f'<div class="finding-note">{note}</div>')
+    if fix:
+        parts.append(f'<div class="finding-fix"><strong>Suggested fix:</strong> {fix}</div>')
+    parts.append("</article>")
+    return "\n".join(parts)
+
+
+def render_category(name: str, findings: list[dict]) -> str:
+    items = "\n".join(render_finding(f) for f in findings)
+    name_e = html.escape(name)
+    return (
+        f'<section class="category">'
+        f"<details open>"
+        f'<summary><h2>{name_e} <span class="count">({len(findings)})</span></h2></summary>'
+        f"{items}"
+        f"</details>"
+        f"</section>"
+    )
+
+
+SEVERITY_ORDER = ["critical", "high", "medium", "low"]
+
+
+def render_finding_md(f: dict) -> str:
+    status = (f.get("status") or "n/a").upper()
+    severity = (f.get("severity") or "low").lower()
+    fid = f.get("id") or ""
+    title = f.get("title") or fid
+    location = f.get("location") or ""
+    note = f.get("note") or ""
+    fix = f.get("suggested_fix") or ""
+
+    lines = [f"### [{status}] {fid} — {title} _(severity: {severity})_"]
+    if location:
+        lines.append(f"- **Location:** {location}")
+    if note:
+        lines.append(f"- **Finding:** {note}")
+    if fix:
+        lines.append(f"- **Suggested fix:** {fix}")
+    return "\n".join(lines)
+
+
+def render_markdown_report(data: dict, findings: list[dict], stats: dict, grade: str) -> str:
+    prd_name = data.get("prd_name") or "PRD"
+    prd_path = data.get("prd_path") or ""
+    checklist_path = data.get("checklist_path") or ""
+    timestamp = data.get("timestamp") or datetime.now().isoformat(timespec="seconds")
+    synthesis = data.get("overall_synthesis") or ""
+
+    out = [
+        f"# Validation Report — {prd_name}",
+        "",
+        f"- **PRD:** `{prd_path}`",
+        f"- **Checklist:** `{checklist_path}`",
+        f"- **Run at:** {timestamp}",
+        f"- **Grade:** {grade}",
+        "",
+        f"**Summary:** {stats['passed']} pass · {stats['warned']} warn · {stats['failed']} fail · {stats['na']} n/a "
+        f"(total {stats['total']}; critical fails: {stats['failed_critical']}, high fails: {stats['failed_high']})",
+    ]
+    if synthesis:
+        out += ["", "## Overall synthesis", "", synthesis]
+
+    # Group by severity then status: failed criticals first, then highs, etc.
+    by_sev: dict[str, list[dict]] = {s: [] for s in SEVERITY_ORDER}
+    other: list[dict] = []
+    for f in findings:
+        sev = (f.get("severity") or "low").lower()
+        if sev in by_sev:
+            by_sev[sev].append(f)
+        else:
+            other.append(f)
+
+    out += ["", "## Findings by severity"]
+    any_findings = False
+    for sev in SEVERITY_ORDER:
+        items = by_sev[sev]
+        if not items:
+            continue
+        any_findings = True
+        out += ["", f"### {sev.capitalize()} ({len(items)})", ""]
+        out += [render_finding_md(f) for f in items]
+    if other:
+        any_findings = True
+        out += ["", f"### Other ({len(other)})", ""]
+        out += [render_finding_md(f) for f in other]
+    if not any_findings:
+        out += ["", "_No findings._"]
+
+    return "\n".join(out) + "\n"
+
+
+def main(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(description="Render PRD validation findings to HTML.")
+    parser.add_argument("--findings", required=True, help="Path to validation-findings.json")
+    parser.add_argument("--template", required=True, help="Path to HTML template")
+    parser.add_argument("--output", required=True, help="Path to write the rendered HTML")
+    parser.add_argument("--open", action="store_true", help="Open the rendered HTML in the default browser")
+    args = parser.parse_args(argv)
+
+    findings_path = Path(args.findings)
+    template_path = Path(args.template)
+    output_path = Path(args.output)
+
+    try:
+        data = json.loads(findings_path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        print(f"error: findings file not found: {findings_path}", file=sys.stderr)
+        return 1
+    except json.JSONDecodeError as e:
+        print(f"error: findings file is not valid JSON ({findings_path}): {e}", file=sys.stderr)
+        return 1
+    try:
+        template = template_path.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        print(f"error: template file not found: {template_path}", file=sys.stderr)
+        return 1
+
+    findings = data.get("findings", []) or []
+
+    by_cat: dict[str, list[dict]] = {}
+    for f in findings:
+        by_cat.setdefault(category_for(f), []).append(f)
+
+    sorted_cats = sorted(
+        by_cat.keys(),
+        key=lambda c: (CATEGORY_ORDER.index(c) if c in CATEGORY_ORDER else 99, c),
+    )
+    categories_html = "\n".join(render_category(c, by_cat[c]) for c in sorted_cats)
+
+    stats = compute_stats(findings)
+    grade, grade_class = grade_from(stats)
+    score_svg = render_score_bar(stats)
+
+    timestamp = data.get("timestamp") or datetime.now().isoformat(timespec="seconds")
+    substitutions = {
+        "prd_name": html.escape(str(data.get("prd_name") or "PRD")),
+        "prd_path": html.escape(str(data.get("prd_path") or "")),
+        "checklist_path": html.escape(str(data.get("checklist_path") or "")),
+        "timestamp": html.escape(timestamp),
+        "overall_synthesis": html.escape(str(data.get("overall_synthesis") or "")),
+        "grade": grade,
+        "grade_class": grade_class,
+        "total": str(stats["total"]),
+        "passed": str(stats["passed"]),
+        "failed": str(stats["failed"]),
+        "warned": str(stats["warned"]),
+        "na": str(stats["na"]),
+        "score_svg": score_svg,
+        "categories_html": categories_html,
+    }
+
+    rendered = string.Template(template).safe_substitute(substitutions)
+    output_path.write_text(rendered, encoding="utf-8")
+
+    md_path = output_path.with_suffix(".md")
+    md_path.write_text(render_markdown_report(data, findings, stats, grade), encoding="utf-8")
+
+    print(json.dumps({
+        "output": str(output_path),
+        "markdown": str(md_path),
+        "grade": grade,
+        "stats": stats,
+    }))
+
+    if args.open:
+        webbrowser.open(output_path.resolve().as_uri())
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

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

@@ -1,104 +1,30 @@
 ---
 name: bmad-validate-prd
-description: 'Validate a PRD against standards. Use when the user says "validate this PRD" or "run PRD validation"'
+description: 'DEPRECATED — consolidated into bmad-prd validate intent - this skill will be removed in v7 in favor of `bmad-prd`.'
 ---
 
-# PRD Validate Workflow
+# DEPRECATED — forwards to bmad-prd (validate intent)
 
-**Goal:** Validate existing PRDs against BMAD standards through comprehensive review.
+This skill was consolidated into `bmad-prd`. It is retained as a thin compatibility shim so existing invocations by name and `_bmad/custom/bmad-validate-prd.toml` override files keep working. New work should invoke `bmad-prd` directly — it detects create / update / validate intent from the conversation.
-
-**Your Role:** Validation Architect and Quality Assurance Specialist.
-
-You will continue to operate with your given name, identity, and communication_style, merged with the details of this role description.
-
-## Conventions
-
-- Bare paths (e.g. `steps-v/step-v-01-discovery.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 **step-file architecture** for disciplined execution:
-
-### Core Principles
-
-- **Micro-file Design**: Each step is a self-contained instruction file that is a part of an overall workflow that must be followed exactly
-- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until told to do so
-- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
-- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array when a workflow produces a document
-- **Append-Only Building**: Build documents by appending content as directed to the output file
-
-### Step Processing Rules
-
-1. **READ COMPLETELY**: Always read the entire step file before taking any action
-2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
-3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
-4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
-5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
-6. **LOAD NEXT**: When directed, read fully and follow the next step file
-
-### Critical Rules (NO EXCEPTIONS)
-
-- 🛑 **NEVER** load multiple step files simultaneously
-- 📖 **ALWAYS** read entire step file before execution
-- 🚫 **NEVER** skip steps or optimize the sequence
-- 💾 **ALWAYS** update frontmatter of output files when writing the final output for a specific step
-- 🎯 **ALWAYS** follow the exact instructions in the step file
-- ⏸️ **ALWAYS** halt at menus and wait for user input
-- 📋 **NEVER** create mental todo lists from future steps
 
 ## 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-validate-prd.toml` and `bmad-validate-prd.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-validate-prd` is deprecated and will be removed in a future release. It now forwards to `bmad-prd` with validate intent. To silence this notice and access the full new customization surface (`prd_template`, `validation_checklist`, `doc_standards`, `external_sources`, `external_handoffs`, `output_dir`, `output_folder_name`), migrate `_bmad/custom/bmad-validate-prd.toml` to `_bmad/custom/bmad-prd.toml` and invoke `bmad-prd` 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-prd.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-prd` with the following context. Pass these as the activating context so `bmad-prd` honors them instead of resolving its own customization from scratch:
 
-### Step 2: Execute Prepend Steps
+   - **Intent:** `validate` — skip `bmad-prd`'s usual intent detection step.
+   - **Pre-resolved legacy customization** — use these in place of resolving from `bmad-prd`'s own `customize.toml` for the four legacy fields. For everything else (`prd_template`, `validation_checklist`, `validation_report_template`, `doc_standards`, `output_dir`, `output_folder_name`, `external_sources`, `external_handoffs`), use `bmad-prd`'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 (the target PRD path, etc.).
 
-Execute each entry in `{workflow.activation_steps_prepend}` in order before proceeding.
+   `bmad-prd` 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. Begin the workflow below.
-
-## Paths
-
-- `validateWorkflow` = `./steps-v/step-v-01-discovery.md`
-
-## Execution
-
-✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the configured `{communication_language}`.
-✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`.
-
-**Validate Mode: Validating an existing PRD against BMAD standards.**
-
-Then read fully and follow: `{validateWorkflow}` (steps-v/step-v-01-discovery.md)

src/bmm-skills/2-plan-workflows/bmad-validate-prd/data/domain-complexity.csv

@@ -1,15 +0,0 @@
-domain,signals,complexity,key_concerns,required_knowledge,suggested_workflow,web_searches,special_sections
-healthcare,"medical,diagnostic,clinical,FDA,patient,treatment,HIPAA,therapy,pharma,drug",high,"FDA approval;Clinical validation;HIPAA compliance;Patient safety;Medical device classification;Liability","Regulatory pathways;Clinical trial design;Medical standards;Data privacy;Integration requirements","domain-research","FDA software medical device guidance {date};HIPAA compliance software requirements;Medical software standards {date};Clinical validation software","clinical_requirements;regulatory_pathway;validation_methodology;safety_measures"
-fintech,"payment,banking,trading,investment,crypto,wallet,transaction,KYC,AML,funds,fintech",high,"Regional compliance;Security standards;Audit requirements;Fraud prevention;Data protection","KYC/AML requirements;PCI DSS;Open banking;Regional laws (US/EU/APAC);Crypto regulations","domain-research","fintech regulations {date};payment processing compliance {date};open banking API standards;cryptocurrency regulations {date}","compliance_matrix;security_architecture;audit_requirements;fraud_prevention"
-govtech,"government,federal,civic,public sector,citizen,municipal,voting",high,"Procurement rules;Security clearance;Accessibility (508);FedRAMP;Privacy;Transparency","Government procurement;Security frameworks;Accessibility standards;Privacy laws;Open data requirements","domain-research","government software procurement {date};FedRAMP compliance requirements;section 508 accessibility;government security standards","procurement_compliance;security_clearance;accessibility_standards;transparency_requirements"
-edtech,"education,learning,student,teacher,curriculum,assessment,K-12,university,LMS",medium,"Student privacy (COPPA/FERPA);Accessibility;Content moderation;Age verification;Curriculum standards","Educational privacy laws;Learning standards;Accessibility requirements;Content guidelines;Assessment validity","domain-research","educational software privacy {date};COPPA FERPA compliance;WCAG education requirements;learning management standards","privacy_compliance;content_guidelines;accessibility_features;curriculum_alignment"
-aerospace,"aircraft,spacecraft,aviation,drone,satellite,propulsion,flight,radar,navigation",high,"Safety certification;DO-178C compliance;Performance validation;Simulation accuracy;Export controls","Aviation standards;Safety analysis;Simulation validation;ITAR/export controls;Performance requirements","domain-research + technical-model","DO-178C software certification;aerospace simulation standards {date};ITAR export controls software;aviation safety requirements","safety_certification;simulation_validation;performance_requirements;export_compliance"
-automotive,"vehicle,car,autonomous,ADAS,automotive,driving,EV,charging",high,"Safety standards;ISO 26262;V2X communication;Real-time requirements;Certification","Automotive standards;Functional safety;V2X protocols;Real-time systems;Testing requirements","domain-research","ISO 26262 automotive software;automotive safety standards {date};V2X communication protocols;EV charging standards","safety_standards;functional_safety;communication_protocols;certification_requirements"
-scientific,"research,algorithm,simulation,modeling,computational,analysis,data science,ML,AI",medium,"Reproducibility;Validation methodology;Peer review;Performance;Accuracy;Computational resources","Scientific method;Statistical validity;Computational requirements;Domain expertise;Publication standards","technical-model","scientific computing best practices {date};research reproducibility standards;computational modeling validation;peer review software","validation_methodology;accuracy_metrics;reproducibility_plan;computational_requirements"
-legaltech,"legal,law,contract,compliance,litigation,patent,attorney,court",high,"Legal ethics;Bar regulations;Data retention;Attorney-client privilege;Court system integration","Legal practice rules;Ethics requirements;Court filing systems;Document standards;Confidentiality","domain-research","legal technology ethics {date};law practice management software requirements;court filing system standards;attorney client privilege technology","ethics_compliance;data_retention;confidentiality_measures;court_integration"
-insuretech,"insurance,claims,underwriting,actuarial,policy,risk,premium",high,"Insurance regulations;Actuarial standards;Data privacy;Fraud detection;State compliance","Insurance regulations by state;Actuarial methods;Risk modeling;Claims processing;Regulatory reporting","domain-research","insurance software regulations {date};actuarial standards software;insurance fraud detection;state insurance compliance","regulatory_requirements;risk_modeling;fraud_detection;reporting_compliance"
-energy,"energy,utility,grid,solar,wind,power,electricity,oil,gas",high,"Grid compliance;NERC standards;Environmental regulations;Safety requirements;Real-time operations","Energy regulations;Grid standards;Environmental compliance;Safety protocols;SCADA systems","domain-research","energy sector software compliance {date};NERC CIP standards;smart grid requirements;renewable energy software standards","grid_compliance;safety_protocols;environmental_compliance;operational_requirements"
-process_control,"industrial automation,process control,PLC,SCADA,DCS,HMI,operational technology,OT,control system,cyberphysical,MES,historian,instrumentation,I&C,P&ID",high,"Functional safety;OT cybersecurity;Real-time control requirements;Legacy system integration;Process safety and hazard analysis;Environmental compliance and permitting;Engineering authority and PE requirements","Functional safety standards;OT security frameworks;Industrial protocols;Process control architecture;Plant reliability and maintainability","domain-research + technical-model","IEC 62443 OT cybersecurity requirements {date};functional safety software requirements {date};industrial process control architecture;ISA-95 manufacturing integration","functional_safety;ot_security;process_requirements;engineering_authority"
-building_automation,"building automation,BAS,BMS,HVAC,smart building,lighting control,fire alarm,fire protection,fire suppression,life safety,elevator,access control,DDC,energy management,sequence of operations,commissioning",high,"Life safety codes;Building energy standards;Multi-trade coordination and interoperability;Commissioning and ongoing operational performance;Indoor environmental quality and occupant comfort;Engineering authority and PE requirements","Building automation protocols;HVAC and mechanical controls;Fire alarm, fire protection, and life safety design;Commissioning process and sequence of operations;Building codes and energy standards","domain-research","smart building software architecture {date};BACnet integration best practices;building automation cybersecurity {date};ASHRAE building standards","life_safety;energy_compliance;commissioning_requirements;engineering_authority"
-gaming,"game,player,gameplay,level,character,multiplayer,quest",redirect,"REDIRECT TO GAME WORKFLOWS","Game design","game-brief","NA","NA"
-general,"",low,"Standard requirements;Basic security;User experience;Performance","General software practices","continue","software development best practices {date}","standard_requirements"

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

@@ -1,197 +0,0 @@
-# BMAD PRD Purpose
-
-**The PRD is the top of the required funnel that feeds all subsequent product development work in rhw BMad Method.**
-
----
-
-## What is a BMAD PRD?
-
-A dual-audience document serving:
-1. **Human Product Managers and builders** - Vision, strategy, stakeholder communication
-2. **LLM Downstream Consumption** - UX Design → Architecture → Epics → Development AI Agents
-
-Each successive document becomes more AI-tailored and granular.
-
----
-
-## Core Philosophy: Information Density
-
-**High Signal-to-Noise Ratio**
-
-Every sentence must carry information weight. LLMs consume precise, dense content efficiently.
-
-**Anti-Patterns (Eliminate These):**
-- ❌ "The system will allow users to..." → ✅ "Users can..."
-- ❌ "It is important to note that..." → ✅ State the fact directly
-- ❌ "In order to..." → ✅ "To..."
-- ❌ Conversational filler and padding → ✅ Direct, concise statements
-
-**Goal:** Maximum information per word. Zero fluff.
-
----
-
-## The Traceability Chain
-
-**PRD starts the chain:**
-```
-Vision → Success Criteria → User Journeys → Functional Requirements → (future: User Stories)
-```
-
-**In the PRD, establish:**
-- Vision → Success Criteria alignment
-- Success Criteria → User Journey coverage
-- User Journey → Functional Requirement mapping
-- All requirements traceable to user needs
-
-**Why:** Each downstream artifact (UX, Architecture, Epics, Stories) must trace back to documented user needs and business objectives. This chain ensures we build the right thing.
-
----
-
-## What Makes Great Functional Requirements?
-
-### FRs are Capabilities, Not Implementation
-
-**Good FR:** "Users can reset their password via email link"
-**Bad FR:** "System sends JWT via email and validates with database" (implementation leakage)
-
-**Good FR:** "Dashboard loads in under 2 seconds for 95th percentile"
-**Bad FR:** "Fast loading time" (subjective, unmeasurable)
-
-### SMART Quality Criteria
-
-**Specific:** Clear, precisely defined capability
-**Measurable:** Quantifiable with test criteria
-**Attainable:** Realistic within constraints
-**Relevant:** Aligns with business objectives
-**Traceable:** Links to source (executive summary or user journey)
-
-### FR Anti-Patterns
-
-**Subjective Adjectives:**
-- ❌ "easy to use", "intuitive", "user-friendly", "fast", "responsive"
-- ✅ Use metrics: "completes task in under 3 clicks", "loads in under 2 seconds"
-
-**Implementation Leakage:**
-- ❌ Technology names, specific libraries, implementation details
-- ✅ Focus on capability and measurable outcomes
-
-**Vague Quantifiers:**
-- ❌ "multiple users", "several options", "various formats"
-- ✅ "up to 100 concurrent users", "3-5 options", "PDF, DOCX, TXT formats"
-
-**Missing Test Criteria:**
-- ❌ "The system shall provide notifications"
-- ✅ "The system shall send email notifications within 30 seconds of trigger event"
-
----
-
-## What Makes Great Non-Functional Requirements?
-
-### NFRs Must Be Measurable
-
-**Template:**
-```
-"The system shall [metric] [condition] [measurement method]"
-```
-
-**Examples:**
-- ✅ "The system shall respond to API requests in under 200ms for 95th percentile as measured by APM monitoring"
-- ✅ "The system shall maintain 99.9% uptime during business hours as measured by cloud provider SLA"
-- ✅ "The system shall support 10,000 concurrent users as measured by load testing"
-
-### NFR Anti-Patterns
-
-**Unmeasurable Claims:**
-- ❌ "The system shall be scalable" → ✅ "The system shall handle 10x load growth through horizontal scaling"
-- ❌ "High availability required" → ✅ "99.9% uptime as measured by cloud provider SLA"
-
-**Missing Context:**
-- ❌ "Response time under 1 second" → ✅ "API response time under 1 second for 95th percentile under normal load"
-
----
-
-## Domain-Specific Requirements
-
-**Auto-Detect and Enforce Based on Project Context**
-
-Certain industries have mandatory requirements that must be present:
-
-- **Healthcare:** HIPAA Privacy & Security Rules, PHI encryption, audit logging, MFA
-- **Fintech:** PCI-DSS Level 1, AML/KYC compliance, SOX controls, financial audit trails
-- **GovTech:** NIST framework, Section 508 accessibility (WCAG 2.1 AA), FedRAMP, data residency
-- **E-Commerce:** PCI-DSS for payments, inventory accuracy, tax calculation by jurisdiction
-
-**Why:** Missing these requirements in the PRD means they'll be missed in architecture and implementation, creating expensive rework. During PRD creation there is a step to cover this - during validation we want to make sure it was covered. For this purpose steps will utilize a domain-complexity.csv and project-types.csv.
-
----
-
-## Document Structure (Markdown, Human-Readable)
-
-### Required Sections
-1. **Executive Summary** - Vision, differentiator, target users
-2. **Success Criteria** - Measurable outcomes (SMART)
-3. **Product Scope** - MVP, Growth, Vision phases
-4. **User Journeys** - Comprehensive coverage
-5. **Domain Requirements** - Industry-specific compliance (if applicable)
-6. **Innovation Analysis** - Competitive differentiation (if applicable)
-7. **Project-Type Requirements** - Platform-specific needs
-8. **Functional Requirements** - Capability contract (FRs)
-9. **Non-Functional Requirements** - Quality attributes (NFRs)
-
-### Formatting for Dual Consumption
-
-**For Humans:**
-- Clear, professional language
-- Logical flow from vision to requirements
-- Easy for stakeholders to review and approve
-
-**For LLMs:**
-- ## Level 2 headers for all main sections (enables extraction)
-- Consistent structure and patterns
-- Precise, testable language
-- High information density
-
----
-
-## Downstream Impact
-
-**How the PRD Feeds Next Artifacts:**
-
-**UX Design:**
-- User journeys → interaction flows
-- FRs → design requirements
-- Success criteria → UX metrics
-
-**Architecture:**
-- FRs → system capabilities
-- NFRs → architecture decisions
-- Domain requirements → compliance architecture
-- Project-type requirements → platform choices
-
-**Epics & Stories (created after architecture):**
-- FRs → user stories (1 FR could map to 1-3 stories potentially)
-- Acceptance criteria → story acceptance tests
-- Priority → sprint sequencing
-- Traceability → stories map back to vision
-
-**Development AI Agents:**
-- Precise requirements → implementation clarity
-- Test criteria → automated test generation
-- Domain requirements → compliance enforcement
-- Measurable NFRs → performance targets
-
----
-
-## Summary: What Makes a Great BMAD PRD?
-
-✅ **High Information Density** - Every sentence carries weight, zero fluff
-✅ **Measurable Requirements** - All FRs and NFRs are testable with specific criteria
-✅ **Clear Traceability** - Each requirement links to user need and business objective
-✅ **Domain Awareness** - Industry-specific requirements auto-detected and included
-✅ **Zero Anti-Patterns** - No subjective adjectives, implementation leakage, or vague quantifiers
-✅ **Dual Audience Optimized** - Human-readable AND LLM-consumable
-✅ **Markdown Format** - Professional, clean, accessible to all stakeholders
-
----
-
-**Remember:** The PRD is the foundation. Quality here ripples through every subsequent phase. A dense, precise, well-traced PRD makes UX design, architecture, epic breakdown, and AI development dramatically more effective.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/data/project-types.csv

@@ -1,11 +0,0 @@
-project_type,detection_signals,key_questions,required_sections,skip_sections,web_search_triggers,innovation_signals
-api_backend,"API,REST,GraphQL,backend,service,endpoints","Endpoints needed?;Authentication method?;Data formats?;Rate limits?;Versioning?;SDK needed?","endpoint_specs;auth_model;data_schemas;error_codes;rate_limits;api_docs","ux_ui;visual_design;user_journeys","framework best practices;OpenAPI standards","API composition;New protocol"
-mobile_app,"iOS,Android,app,mobile,iPhone,iPad","Native or cross-platform?;Offline needed?;Push notifications?;Device features?;Store compliance?","platform_reqs;device_permissions;offline_mode;push_strategy;store_compliance","desktop_features;cli_commands","app store guidelines;platform requirements","Gesture innovation;AR/VR features"
-saas_b2b,"SaaS,B2B,platform,dashboard,teams,enterprise","Multi-tenant?;Permission model?;Subscription tiers?;Integrations?;Compliance?","tenant_model;rbac_matrix;subscription_tiers;integration_list;compliance_reqs","cli_interface;mobile_first","compliance requirements;integration guides","Workflow automation;AI agents"
-developer_tool,"SDK,library,package,npm,pip,framework","Language support?;Package managers?;IDE integration?;Documentation?;Examples?","language_matrix;installation_methods;api_surface;code_examples;migration_guide","visual_design;store_compliance","package manager best practices;API design patterns","New paradigm;DSL creation"
-cli_tool,"CLI,command,terminal,bash,script","Interactive or scriptable?;Output formats?;Config method?;Shell completion?","command_structure;output_formats;config_schema;scripting_support","visual_design;ux_principles;touch_interactions","CLI design patterns;shell integration","Natural language CLI;AI commands"
-web_app,"website,webapp,browser,SPA,PWA","SPA or MPA?;Browser support?;SEO needed?;Real-time?;Accessibility?","browser_matrix;responsive_design;performance_targets;seo_strategy;accessibility_level","native_features;cli_commands","web standards;WCAG guidelines","New interaction;WebAssembly use"
-game,"game,player,gameplay,level,character","REDIRECT TO USE THE BMad Method Game Module Agent and Workflows - HALT","game-brief;GDD","most_sections","game design patterns","Novel mechanics;Genre mixing"
-desktop_app,"desktop,Windows,Mac,Linux,native","Cross-platform?;Auto-update?;System integration?;Offline?","platform_support;system_integration;update_strategy;offline_capabilities","web_seo;mobile_features","desktop guidelines;platform requirements","Desktop AI;System automation"
-iot_embedded,"IoT,embedded,device,sensor,hardware","Hardware specs?;Connectivity?;Power constraints?;Security?;OTA updates?","hardware_reqs;connectivity_protocol;power_profile;security_model;update_mechanism","visual_ui;browser_support","IoT standards;protocol specs","Edge AI;New sensors"
-blockchain_web3,"blockchain,crypto,DeFi,NFT,smart contract","Chain selection?;Wallet integration?;Gas optimization?;Security audit?","chain_specs;wallet_support;smart_contracts;security_audit;gas_optimization","traditional_auth;centralized_db","blockchain standards;security patterns","Novel tokenomics;DAO structure"

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-01-discovery.md

@@ -1,221 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-02-format-detection.md'
-prdPurpose: '../data/prd-purpose.md'
----
-
-# Step 1: Document Discovery & Confirmation
-
-## STEP GOAL:
-
-Handle fresh context validation by confirming PRD path, discovering and loading input documents from frontmatter, and initializing the validation report.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring systematic validation expertise and analytical rigor
-- ✅ User brings domain knowledge and specific PRD context
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on discovering PRD and input documents, not validating yet
-- 🚫 FORBIDDEN to perform any validation checks in this step
-- 💬 Approach: Systematic discovery with clear reporting to user
-- 🚪 This is the setup step - get everything ready for validation
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Discover and confirm PRD to validate
-- 💾 Load PRD and all input documents from frontmatter
-- 📖 Initialize validation report next to PRD
-- 🚫 FORBIDDEN to load next step until user confirms setup
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD path (user-specified or discovered), workflow configuration
-- Focus: Document discovery and setup only
-- Limits: Don't perform validation, don't skip discovery
-- Dependencies: Configuration loaded from PRD workflow.md initialization
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Load PRD Purpose and Standards
-
-Load and read the complete file at:
-`{prdPurpose}`
-
-This file contains the BMAD PRD philosophy, standards, and validation criteria that will guide all validation checks. Internalize this understanding - it defines what makes a great BMAD PRD.
-
-### 2. Discover PRD to Validate
-
-**If PRD path provided as invocation parameter:**
-- Use provided path
-
-**If no PRD path provided, auto-discover:**
-- Search `{planning_artifacts}` for files matching `*prd*.md`
-- Also check for sharded PRDs: `{planning_artifacts}/*prd*/*.md`
-
-**If exactly ONE PRD found:**
-- Use it automatically
-- Inform user: "Found PRD: {discovered_path} — using it for validation."
-
-**If MULTIPLE PRDs found:**
-- List all discovered PRDs with numbered options
-- "I found multiple PRDs. Which one would you like to validate?"
-- Wait for user selection
-
-**If NO PRDs found:**
-- "I couldn't find any PRD files in {planning_artifacts}. Please provide the path to the PRD file you want to validate."
-- Wait for user to provide PRD path.
-
-### 3. Validate PRD Exists and Load
-
-Once PRD path is provided:
-
-- Check if PRD file exists at specified path
-- If not found: "I cannot find a PRD at that path. Please check the path and try again."
-- If found: Load the complete PRD file including frontmatter
-
-### 4. Extract Frontmatter and Input Documents
-
-From the loaded PRD frontmatter, extract:
-
-- `inputDocuments: []` array (if present)
-- Any other relevant metadata (classification, date, etc.)
-
-**If no inputDocuments array exists:**
-Note this and proceed with PRD-only validation
-
-### 5. Load Input Documents
-
-For each document listed in `inputDocuments`:
-
-- Attempt to load the document
-- Track successfully loaded documents
-- Note any documents that fail to load
-
-**Build list of loaded input documents:**
-- Product Brief (if present)
-- Research documents (if present)
-- Other reference materials (if present)
-
-### 6. Ask About Additional Reference Documents
-
-"**I've loaded the following documents from your PRD frontmatter:**
-
-{list loaded documents with file names}
-
-**Are there any additional reference documents you'd like me to include in this validation?**
-
-These could include:
-- Additional research or context documents
-- Project documentation not tracked in frontmatter
-- Standards or compliance documents
-- Competitive analysis or benchmarks
-
-Please provide paths to any additional documents, or type 'none' to proceed."
-
-**Load any additional documents provided by user.**
-
-### 7. Initialize Validation Report
-
-Create validation report at: `{validationReportPath}`
-
-**Initialize with frontmatter:**
-```yaml
----
-validationTarget: '{prd_path}'
-validationDate: '{current_date}'
-inputDocuments: [list of all loaded documents]
-validationStepsCompleted: []
-validationStatus: IN_PROGRESS
----
-```
-
-**Initial content:**
-```markdown
-# PRD Validation Report
-
-**PRD Being Validated:** {prd_path}
-**Validation Date:** {current_date}
-
-## Input Documents
-
-{list all documents loaded for validation}
-
-## Validation Findings
-
-[Findings will be appended as validation progresses]
-```
-
-### 8. Present Discovery Summary
-
-"**Setup Complete!**
-
-**PRD to Validate:** {prd_path}
-
-**Input Documents Loaded:**
-- PRD: {prd_name} ✓
-- Product Brief: {count} {if count > 0}✓{else}(none found){/if}
-- Research: {count} {if count > 0}✓{else}(none found){/if}
-- Additional References: {count} {if count > 0}✓{else}(none){/if}
-
-**Validation Report:** {validationReportPath}
-
-**Ready to begin validation.**"
-
-### 9. Present MENU OPTIONS
-
-Display: **Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Format Detection
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-- User can ask questions or add more documents - always respond and redisplay menu
-
-#### Menu Handling Logic:
-
-- IF A: Invoke the `bmad-advanced-elicitation` skill, and when finished redisplay the menu
-- IF P: Invoke the `bmad-party-mode` skill, and when finished redisplay the menu
-- IF C: Read fully and follow: {nextStepFile} to begin format detection
-- IF user provides additional document: Load it, update report, redisplay summary
-- IF Any other: help user, then redisplay menu
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- PRD path discovered and confirmed
-- PRD file exists and loads successfully
-- All input documents from frontmatter loaded
-- Additional reference documents (if any) loaded
-- Validation report initialized next to PRD
-- User clearly informed of setup status
-- Menu presented and user input handled correctly
-
-### ❌ SYSTEM FAILURE:
-
-- Proceeding with non-existent PRD file
-- Not loading input documents from frontmatter
-- Creating validation report in wrong location
-- Proceeding without user confirming setup
-- Not handling missing input documents gracefully
-
-**Master Rule:** Complete discovery and setup BEFORE validation. This step ensures everything is in place for systematic validation checks.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-02-format-detection.md

@@ -1,188 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-03-density-validation.md'
-altStepFile: './step-v-02b-parity-check.md'
-prdFile: '{prd_file_path}'
-validationReportPath: '{validation_report_path}'
----
-
-# Step 2: Format Detection & Structure Analysis
-
-## STEP GOAL:
-
-Detect if PRD follows BMAD format and route appropriately - classify as BMAD Standard / BMAD Variant / Non-Standard, with optional parity check for non-standard formats.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring systematic validation expertise and pattern recognition
-- ✅ User brings domain knowledge and PRD context
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on detecting format and classifying structure
-- 🚫 FORBIDDEN to perform other validation checks in this step
-- 💬 Approach: Analytical and systematic, clear reporting of findings
-- 🚪 This is a branch step - may route to parity check for non-standard PRDs
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Analyze PRD structure systematically
-- 💾 Append format findings to validation report
-- 📖 Route appropriately based on format classification
-- 🚫 FORBIDDEN to skip format detection or proceed without classification
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file loaded in step 1, validation report initialized
-- Focus: Format detection and classification only
-- Limits: Don't perform other validation, don't skip classification
-- Dependencies: Step 1 completed - PRD loaded and report initialized
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Extract PRD Structure
-
-Load the complete PRD file and extract:
-
-**All Level 2 (##) headers:**
-- Scan through entire PRD document
-- Extract all ## section headers
-- List them in order
-
-**PRD frontmatter:**
-- Extract classification.domain if present
-- Extract classification.projectType if present
-- Note any other relevant metadata
-
-### 2. Check for BMAD PRD Core Sections
-
-Check if the PRD contains the following BMAD PRD core sections:
-
-1. **Executive Summary** (or variations: ## Executive Summary, ## Overview, ## Introduction)
-2. **Success Criteria** (or: ## Success Criteria, ## Goals, ## Objectives)
-3. **Product Scope** (or: ## Product Scope, ## Scope, ## In Scope, ## Out of Scope)
-4. **User Journeys** (or: ## User Journeys, ## User Stories, ## User Flows)
-5. **Functional Requirements** (or: ## Functional Requirements, ## Features, ## Capabilities)
-6. **Non-Functional Requirements** (or: ## Non-Functional Requirements, ## NFRs, ## Quality Attributes)
-
-**Count matches:**
-- How many of these 6 core sections are present?
-- Which specific sections are present?
-- Which are missing?
-
-### 3. Classify PRD Format
-
-Based on core section count, classify:
-
-**BMAD Standard:**
-- 5-6 core sections present
-- Follows BMAD PRD structure closely
-
-**BMAD Variant:**
-- 3-4 core sections present
-- Generally follows BMAD patterns but may have structural differences
-- Missing some sections but recognizable as BMAD-style
-
-**Non-Standard:**
-- Fewer than 3 core sections present
-- Does not follow BMAD PRD structure
-- May be completely custom format, legacy format, or from another framework
-
-### 4. Report Format Findings to Validation Report
-
-Append to validation report:
-
-```markdown
-## Format Detection
-
-**PRD Structure:**
-[List all ## Level 2 headers found]
-
-**BMAD Core Sections Present:**
-- Executive Summary: [Present/Missing]
-- Success Criteria: [Present/Missing]
-- Product Scope: [Present/Missing]
-- User Journeys: [Present/Missing]
-- Functional Requirements: [Present/Missing]
-- Non-Functional Requirements: [Present/Missing]
-
-**Format Classification:** [BMAD Standard / BMAD Variant / Non-Standard]
-**Core Sections Present:** [count]/6
-```
-
-### 5. Route Based on Format Classification
-
-**IF format is BMAD Standard or BMAD Variant:**
-
-Display: "**Format Detected:** {classification}
-
-Proceeding to systematic validation checks..."
-
-Without delay, read fully and follow: {nextStepFile} (step-v-03-density-validation.md)
-
-**IF format is Non-Standard (< 3 core sections):**
-
-Display: "**Format Detected:** Non-Standard PRD
-
-This PRD does not follow BMAD standard structure (only {count}/6 core sections present).
-
-You have options:"
-
-Present MENU OPTIONS below for user selection
-
-### 6. Present MENU OPTIONS (Non-Standard PRDs Only)
-
-**[A] Parity Check** - Analyze gaps and estimate effort to reach BMAD PRD parity
-**[B] Validate As-Is** - Proceed with validation using current structure
-**[C] Exit** - Exit validation and review format findings
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input
-- Only proceed based on user selection
-
-#### Menu Handling Logic:
-
-- IF A (Parity Check): Read fully and follow: {altStepFile} (step-v-02b-parity-check.md)
-- IF B (Validate As-Is): Display "Proceeding with validation..." then read fully and follow: {nextStepFile}
-- IF C (Exit): Display format findings summary and exit validation
-- IF Any other: help user respond, then redisplay menu
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All ## Level 2 headers extracted successfully
-- BMAD core sections checked systematically
-- Format classified correctly based on section count
-- Findings reported to validation report
-- BMAD Standard/Variant PRDs proceed directly to next validation step
-- Non-Standard PRDs pause and present options to user
-- User can choose parity check, validate as-is, or exit
-
-### ❌ SYSTEM FAILURE:
-
-- Not extracting all headers before classification
-- Incorrect format classification
-- Not reporting findings to validation report
-- Not pausing for non-standard PRDs
-- Proceeding without user decision for non-standard formats
-
-**Master Rule:** Format detection determines validation path. Non-standard PRDs require user choice before proceeding.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-02b-parity-check.md

@@ -1,206 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-03-density-validation.md'
-prdFile: '{prd_file_path}'
-validationReportPath: '{validation_report_path}'
----
-
-# Step 2B: Document Parity Check
-
-## STEP GOAL:
-
-Analyze non-standard PRD and identify gaps to achieve BMAD PRD parity, presenting user with options for how to proceed.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring BMAD PRD standards expertise and gap analysis
-- ✅ User brings domain knowledge and PRD context
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on analyzing gaps and estimating parity effort
-- 🚫 FORBIDDEN to perform other validation checks in this step
-- 💬 Approach: Systematic gap analysis with clear recommendations
-- 🚪 This is an optional branch step - user chooses next action
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Analyze each BMAD PRD section for gaps
-- 💾 Append parity analysis to validation report
-- 📖 Present options and await user decision
-- 🚫 FORBIDDEN to proceed without user selection
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Non-standard PRD from step 2, validation report in progress
-- Focus: Parity analysis only - what's missing, what's needed
-- Limits: Don't perform validation checks, don't auto-proceed
-- Dependencies: Step 2 classified PRD as non-standard and user chose parity check
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Analyze Each BMAD PRD Section
-
-For each of the 6 BMAD PRD core sections, analyze:
-
-**Executive Summary:**
-- Does PRD have vision/overview?
-- Is problem statement clear?
-- Are target users identified?
-- Gap: [What's missing or incomplete]
-
-**Success Criteria:**
-- Are measurable goals defined?
-- Is success clearly defined?
-- Gap: [What's missing or incomplete]
-
-**Product Scope:**
-- Is scope clearly defined?
-- Are in-scope items listed?
-- Are out-of-scope items listed?
-- Gap: [What's missing or incomplete]
-
-**User Journeys:**
-- Are user types/personas identified?
-- Are user flows documented?
-- Gap: [What's missing or incomplete]
-
-**Functional Requirements:**
-- Are features/capabilities listed?
-- Are requirements structured?
-- Gap: [What's missing or incomplete]
-
-**Non-Functional Requirements:**
-- Are quality attributes defined?
-- Are performance/security/etc. requirements documented?
-- Gap: [What's missing or incomplete]
-
-### 2. Estimate Effort to Reach Parity
-
-For each missing or incomplete section, estimate:
-
-**Effort Level:**
-- Minimal - Section exists but needs minor enhancements
-- Moderate - Section missing but content exists elsewhere in PRD
-- Significant - Section missing, requires new content creation
-
-**Total Parity Effort:**
-- Based on individual section estimates
-- Classify overall: Quick / Moderate / Substantial effort
-
-### 3. Report Parity Analysis to Validation Report
-
-Append to validation report:
-
-```markdown
-## Parity Analysis (Non-Standard PRD)
-
-### Section-by-Section Gap Analysis
-
-**Executive Summary:**
-- Status: [Present/Missing/Incomplete]
-- Gap: [specific gap description]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-**Success Criteria:**
-- Status: [Present/Missing/Incomplete]
-- Gap: [specific gap description]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-**Product Scope:**
-- Status: [Present/Missing/Incomplete]
-- Gap: [specific gap description]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-**User Journeys:**
-- Status: [Present/Missing/Incomplete]
-- Gap: [specific gap description]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-**Functional Requirements:**
-- Status: [Present/Missing/Incomplete]
-- Gap: [specific gap description]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-**Non-Functional Requirements:**
-- Status: [Present/Missing/Incomplete]
-- Gap: [specific gap description]
-- Effort to Complete: [Minimal/Moderate/Significant]
-
-### Overall Parity Assessment
-
-**Overall Effort to Reach BMAD Standard:** [Quick/Moderate/Substantial]
-**Recommendation:** [Brief recommendation based on analysis]
-```
-
-### 4. Present Parity Analysis and Options
-
-Display:
-
-"**Parity Analysis Complete**
-
-Your PRD is missing {count} of 6 core BMAD PRD sections. The overall effort to reach BMAD standard is: **{effort level}**
-
-**Quick Summary:**
-[2-3 sentence summary of key gaps]
-
-**Recommendation:**
-{recommendation from analysis}
-
-**How would you like to proceed?**"
-
-### 5. Present MENU OPTIONS
-
-**[C] Continue Validation** - Proceed with validation using current structure
-**[E] Exit & Review** - Exit validation and review parity report
-**[S] Save & Exit** - Save parity report and exit
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input
-- Only proceed based on user selection
-
-#### Menu Handling Logic:
-
-- IF C (Continue): Display "Proceeding with validation..." then read fully and follow: {nextStepFile}
-- IF E (Exit): Display parity summary and exit validation
-- IF S (Save): Confirm saved, display summary, exit
-- IF Any other: help user respond, then redisplay menu
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All 6 BMAD PRD sections analyzed for gaps
-- Effort estimates provided for each gap
-- Overall parity effort assessed correctly
-- Parity analysis reported to validation report
-- Clear summary presented to user
-- User can choose to continue validation, exit, or save report
-
-### ❌ SYSTEM FAILURE:
-
-- Not analyzing all 6 sections systematically
-- Missing effort estimates
-- Not reporting parity analysis to validation report
-- Auto-proceeding without user decision
-- Unclear recommendations
-
-**Master Rule:** Parity check informs user of gaps and effort, but user decides whether to proceed with validation or address gaps first.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-03-density-validation.md

@@ -1,171 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-04-brief-coverage-validation.md'
-prdFile: '{prd_file_path}'
-validationReportPath: '{validation_report_path}'
----
-
-# Step 3: Information Density Validation
-
-## STEP GOAL:
-
-Validate PRD meets BMAD information density standards by scanning for conversational filler, wordy phrases, and redundant expressions that violate conciseness principles.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in systematic validation, not collaborative dialogue
-- ✅ You bring analytical rigor and attention to detail
-- ✅ This step runs autonomously - no user input needed
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on information density anti-patterns
-- 🚫 FORBIDDEN to validate other aspects in this step
-- 💬 Approach: Systematic scanning and categorization
-- 🚪 This is a validation sequence step - auto-proceeds when complete
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Scan PRD for density anti-patterns systematically
-- 💾 Append density findings to validation report
-- 📖 Display "Proceeding to next check..." and load next step
-- 🚫 FORBIDDEN to pause or request user input
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file, validation report with format findings
-- Focus: Information density validation only
-- Limits: Don't validate other aspects, don't pause for user input
-- Dependencies: Step 2 completed - format classification done
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Attempt Sub-Process Validation
-
-**Try to use Task tool to spawn a subprocess:**
-
-"Perform information density validation on this PRD:
-
-1. Load the PRD file
-2. Scan for the following anti-patterns:
-   - Conversational filler phrases (examples: 'The system will allow users to...', 'It is important to note that...', 'In order to')
-   - Wordy phrases (examples: 'Due to the fact that', 'In the event of', 'For the purpose of')
-   - Redundant phrases (examples: 'Future plans', 'Absolutely essential', 'Past history')
-3. Count violations by category with line numbers
-4. Classify severity: Critical (>10 violations), Warning (5-10), Pass (<5)
-
-Return structured findings with counts and examples."
-
-### 2. Graceful Degradation (if Task tool unavailable)
-
-If Task tool unavailable, perform analysis directly:
-
-**Scan for conversational filler patterns:**
-- "The system will allow users to..."
-- "It is important to note that..."
-- "In order to"
-- "For the purpose of"
-- "With regard to"
-- Count occurrences and note line numbers
-
-**Scan for wordy phrases:**
-- "Due to the fact that" (use "because")
-- "In the event of" (use "if")
-- "At this point in time" (use "now")
-- "In a manner that" (use "how")
-- Count occurrences and note line numbers
-
-**Scan for redundant phrases:**
-- "Future plans" (just "plans")
-- "Past history" (just "history")
-- "Absolutely essential" (just "essential")
-- "Completely finish" (just "finish")
-- Count occurrences and note line numbers
-
-### 3. Classify Severity
-
-**Calculate total violations:**
-- Conversational filler count
-- Wordy phrases count
-- Redundant phrases count
-- Total = sum of all categories
-
-**Determine severity:**
-- **Critical:** Total > 10 violations
-- **Warning:** Total 5-10 violations
-- **Pass:** Total < 5 violations
-
-### 4. Report Density Findings to Validation Report
-
-Append to validation report:
-
-```markdown
-## Information Density Validation
-
-**Anti-Pattern Violations:**
-
-**Conversational Filler:** {count} occurrences
-[If count > 0, list examples with line numbers]
-
-**Wordy Phrases:** {count} occurrences
-[If count > 0, list examples with line numbers]
-
-**Redundant Phrases:** {count} occurrences
-[If count > 0, list examples with line numbers]
-
-**Total Violations:** {total}
-
-**Severity Assessment:** [Critical/Warning/Pass]
-
-**Recommendation:**
-[If Critical] "PRD requires significant revision to improve information density. Every sentence should carry weight without filler."
-[If Warning] "PRD would benefit from reducing wordiness and eliminating filler phrases."
-[If Pass] "PRD demonstrates good information density with minimal violations."
-```
-
-### 5. Display Progress and Auto-Proceed
-
-Display: "**Information Density Validation Complete**
-
-Severity: {Critical/Warning/Pass}
-
-**Proceeding to next validation check...**"
-
-Without delay, read fully and follow: {nextStepFile} (step-v-04-brief-coverage-validation.md)
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- PRD scanned for all three anti-pattern categories
-- Violations counted with line numbers
-- Severity classified correctly
-- Findings reported to validation report
-- Auto-proceeds to next validation step
-- Subprocess attempted with graceful degradation
-
-### ❌ SYSTEM FAILURE:
-
-- Not scanning all anti-pattern categories
-- Missing severity classification
-- Not reporting findings to validation report
-- Pausing for user input (should auto-proceed)
-- Not attempting subprocess architecture
-
-**Master Rule:** Information density validation runs autonomously. Scan, classify, report, auto-proceed. No user interaction needed.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-04-brief-coverage-validation.md

@@ -1,211 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-05-measurability-validation.md'
-prdFile: '{prd_file_path}'
-productBrief: '{product_brief_path}'
-validationReportPath: '{validation_report_path}'
----
-
-# Step 4: Product Brief Coverage Validation
-
-## STEP GOAL:
-
-Validate that PRD covers all content from Product Brief (if brief was used as input), mapping brief content to PRD sections and identifying gaps.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in systematic validation, not collaborative dialogue
-- ✅ You bring analytical rigor and traceability expertise
-- ✅ This step runs autonomously - no user input needed
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on Product Brief coverage (conditional on brief existence)
-- 🚫 FORBIDDEN to validate other aspects in this step
-- 💬 Approach: Systematic mapping and gap analysis
-- 🚪 This is a validation sequence step - auto-proceeds when complete
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Check if Product Brief exists in input documents
-- 💬 If no brief: Skip this check and report "N/A - No Product Brief"
-- 🎯 If brief exists: Map brief content to PRD sections
-- 💾 Append coverage findings to validation report
-- 📖 Display "Proceeding to next check..." and load next step
-- 🚫 FORBIDDEN to pause or request user input
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file, input documents from step 1, validation report
-- Focus: Product Brief coverage only (conditional)
-- Limits: Don't validate other aspects, conditional execution
-- Dependencies: Step 1 completed - input documents loaded
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Check for Product Brief
-
-Check if Product Brief was loaded in step 1's inputDocuments:
-
-**IF no Product Brief found:**
-Append to validation report:
-```markdown
-## Product Brief Coverage
-
-**Status:** N/A - No Product Brief was provided as input
-```
-
-Display: "**Product Brief Coverage: Skipped** (No Product Brief provided)
-
-**Proceeding to next validation check...**"
-
-Without delay, read fully and follow: {nextStepFile}
-
-**IF Product Brief exists:** Continue to step 2 below
-
-### 2. Attempt Sub-Process Validation
-
-**Try to use Task tool to spawn a subprocess:**
-
-"Perform Product Brief coverage validation:
-
-1. Load the Product Brief
-2. Extract key content:
-   - Vision statement
-   - Target users/personas
-   - Problem statement
-   - Key features
-   - Goals/objectives
-   - Differentiators
-   - Constraints
-3. For each item, search PRD for corresponding coverage
-4. Classify coverage: Fully Covered / Partially Covered / Not Found / Intentionally Excluded
-5. Note any gaps with severity: Critical / Moderate / Informational
-
-Return structured coverage map with classifications."
-
-### 3. Graceful Degradation (if Task tool unavailable)
-
-If Task tool unavailable, perform analysis directly:
-
-**Extract from Product Brief:**
-- Vision: What is this product?
-- Users: Who is it for?
-- Problem: What problem does it solve?
-- Features: What are the key capabilities?
-- Goals: What are the success criteria?
-- Differentiators: What makes it unique?
-
-**For each item, search PRD:**
-- Scan Executive Summary for vision
-- Check User Journeys or user personas
-- Look for problem statement
-- Review Functional Requirements for features
-- Check Success Criteria section
-- Search for differentiators
-
-**Classify coverage:**
-- **Fully Covered:** Content present and complete
-- **Partially Covered:** Content present but incomplete
-- **Not Found:** Content missing from PRD
-- **Intentionally Excluded:** Content explicitly out of scope
-
-### 4. Assess Coverage and Severity
-
-**For each gap (Partially Covered or Not Found):**
-- Is this Critical? (Core vision, primary users, main features)
-- Is this Moderate? (Secondary features, some goals)
-- Is this Informational? (Nice-to-have features, minor details)
-
-**Note:** Some exclusions may be intentional (valid scoping decisions)
-
-### 5. Report Coverage Findings to Validation Report
-
-Append to validation report:
-
-```markdown
-## Product Brief Coverage
-
-**Product Brief:** {brief_file_name}
-
-### Coverage Map
-
-**Vision Statement:** [Fully/Partially/Not Found/Intentionally Excluded]
-[If gap: Note severity and specific missing content]
-
-**Target Users:** [Fully/Partially/Not Found/Intentionally Excluded]
-[If gap: Note severity and specific missing content]
-
-**Problem Statement:** [Fully/Partially/Not Found/Intentionally Excluded]
-[If gap: Note severity and specific missing content]
-
-**Key Features:** [Fully/Partially/Not Found/Intentionally Excluded]
-[If gap: List specific features with severity]
-
-**Goals/Objectives:** [Fully/Partially/Not Found/Intentionally Excluded]
-[If gap: Note severity and specific missing content]
-
-**Differentiators:** [Fully/Partially/Not Found/Intentionally Excluded]
-[If gap: Note severity and specific missing content]
-
-### Coverage Summary
-
-**Overall Coverage:** [percentage or qualitative assessment]
-**Critical Gaps:** [count] [list if any]
-**Moderate Gaps:** [count] [list if any]
-**Informational Gaps:** [count] [list if any]
-
-**Recommendation:**
-[If critical gaps exist] "PRD should be revised to cover critical Product Brief content."
-[If moderate gaps] "Consider addressing moderate gaps for complete coverage."
-[If minimal gaps] "PRD provides good coverage of Product Brief content."
-```
-
-### 6. Display Progress and Auto-Proceed
-
-Display: "**Product Brief Coverage Validation Complete**
-
-Overall Coverage: {assessment}
-
-**Proceeding to next validation check...**"
-
-Without delay, read fully and follow: {nextStepFile} (step-v-05-measurability-validation.md)
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Checked for Product Brief existence correctly
-- If no brief: Reported "N/A" and skipped gracefully
-- If brief exists: Mapped all key brief content to PRD sections
-- Coverage classified appropriately (Fully/Partially/Not Found/Intentionally Excluded)
-- Severity assessed for gaps (Critical/Moderate/Informational)
-- Findings reported to validation report
-- Auto-proceeds to next validation step
-- Subprocess attempted with graceful degradation
-
-### ❌ SYSTEM FAILURE:
-
-- Not checking for brief existence before attempting validation
-- If brief exists: not mapping all key content areas
-- Missing coverage classifications
-- Not reporting findings to validation report
-- Not auto-proceeding
-
-**Master Rule:** Product Brief coverage is conditional - skip if no brief, validate thoroughly if brief exists. Always auto-proceed.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-05-measurability-validation.md

@@ -1,225 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-06-traceability-validation.md'
-prdFile: '{prd_file_path}'
-validationReportPath: '{validation_report_path}'
----
-
-# Step 5: Measurability Validation
-
-## STEP GOAL:
-
-Validate that all Functional Requirements (FRs) and Non-Functional Requirements (NFRs) are measurable, testable, and follow proper format without implementation details.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in systematic validation, not collaborative dialogue
-- ✅ You bring analytical rigor and requirements engineering expertise
-- ✅ This step runs autonomously - no user input needed
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on FR and NFR measurability
-- 🚫 FORBIDDEN to validate other aspects in this step
-- 💬 Approach: Systematic requirement-by-requirement analysis
-- 🚪 This is a validation sequence step - auto-proceeds when complete
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Extract all FRs and NFRs from PRD
-- 💾 Validate each for measurability and format
-- 📖 Append findings to validation report
-- 📖 Display "Proceeding to next check..." and load next step
-- 🚫 FORBIDDEN to pause or request user input
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file, validation report
-- Focus: FR and NFR measurability only
-- Limits: Don't validate other aspects, don't pause for user input
-- Dependencies: Steps 2-4 completed - initial validation checks done
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Attempt Sub-Process Validation
-
-**Try to use Task tool to spawn a subprocess:**
-
-"Perform measurability validation on this PRD:
-
-**Functional Requirements (FRs):**
-1. Extract all FRs from Functional Requirements section
-2. Check each FR for:
-   - '[Actor] can [capability]' format compliance
-   - No subjective adjectives (easy, fast, simple, intuitive, etc.)
-   - No vague quantifiers (multiple, several, some, many, etc.)
-   - No implementation details (technology names, library names, data structures unless capability-relevant)
-3. Document violations with line numbers
-
-**Non-Functional Requirements (NFRs):**
-1. Extract all NFRs from Non-Functional Requirements section
-2. Check each NFR for:
-   - Specific metrics with measurement methods
-   - Template compliance (criterion, metric, measurement method, context)
-   - Context included (why this matters, who it affects)
-3. Document violations with line numbers
-
-Return structured findings with violation counts and examples."
-
-### 2. Graceful Degradation (if Task tool unavailable)
-
-If Task tool unavailable, perform analysis directly:
-
-**Functional Requirements Analysis:**
-
-Extract all FRs and check each for:
-
-**Format compliance:**
-- Does it follow "[Actor] can [capability]" pattern?
-- Is actor clearly defined?
-- Is capability actionable and testable?
-
-**No subjective adjectives:**
-- Scan for: easy, fast, simple, intuitive, user-friendly, responsive, quick, efficient (without metrics)
-- Note line numbers
-
-**No vague quantifiers:**
-- Scan for: multiple, several, some, many, few, various, number of
-- Note line numbers
-
-**No implementation details:**
-- Scan for: React, Vue, Angular, PostgreSQL, MongoDB, AWS, Docker, Kubernetes, Redux, etc.
-- Unless capability-relevant (e.g., "API consumers can access...")
-- Note line numbers
-
-**Non-Functional Requirements Analysis:**
-
-Extract all NFRs and check each for:
-
-**Specific metrics:**
-- Is there a measurable criterion? (e.g., "response time < 200ms", not "fast response")
-- Can this be measured or tested?
-
-**Template compliance:**
-- Criterion defined?
-- Metric specified?
-- Measurement method included?
-- Context provided?
-
-### 3. Tally Violations
-
-**FR Violations:**
-- Format violations: count
-- Subjective adjectives: count
-- Vague quantifiers: count
-- Implementation leakage: count
-- Total FR violations: sum
-
-**NFR Violations:**
-- Missing metrics: count
-- Incomplete template: count
-- Missing context: count
-- Total NFR violations: sum
-
-**Total violations:** FR violations + NFR violations
-
-### 4. Report Measurability Findings to Validation Report
-
-Append to validation report:
-
-```markdown
-## Measurability Validation
-
-### Functional Requirements
-
-**Total FRs Analyzed:** {count}
-
-**Format Violations:** {count}
-[If violations exist, list examples with line numbers]
-
-**Subjective Adjectives Found:** {count}
-[If found, list examples with line numbers]
-
-**Vague Quantifiers Found:** {count}
-[If found, list examples with line numbers]
-
-**Implementation Leakage:** {count}
-[If found, list examples with line numbers]
-
-**FR Violations Total:** {total}
-
-### Non-Functional Requirements
-
-**Total NFRs Analyzed:** {count}
-
-**Missing Metrics:** {count}
-[If missing, list examples with line numbers]
-
-**Incomplete Template:** {count}
-[If incomplete, list examples with line numbers]
-
-**Missing Context:** {count}
-[If missing, list examples with line numbers]
-
-**NFR Violations Total:** {total}
-
-### Overall Assessment
-
-**Total Requirements:** {FRs + NFRs}
-**Total Violations:** {FR violations + NFR violations}
-
-**Severity:** [Critical if >10 violations, Warning if 5-10, Pass if <5]
-
-**Recommendation:**
-[If Critical] "Many requirements are not measurable or testable. Requirements must be revised to be testable for downstream work."
-[If Warning] "Some requirements need refinement for measurability. Focus on violating requirements above."
-[If Pass] "Requirements demonstrate good measurability with minimal issues."
-```
-
-### 5. Display Progress and Auto-Proceed
-
-Display: "**Measurability Validation Complete**
-
-Total Violations: {count} ({severity})
-
-**Proceeding to next validation check...**"
-
-Without delay, read fully and follow: {nextStepFile} (step-v-06-traceability-validation.md)
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All FRs extracted and analyzed for measurability
-- All NFRs extracted and analyzed for measurability
-- Violations documented with line numbers
-- Severity assessed correctly
-- Findings reported to validation report
-- Auto-proceeds to next validation step
-- Subprocess attempted with graceful degradation
-
-### ❌ SYSTEM FAILURE:
-
-- Not analyzing all FRs and NFRs
-- Missing line numbers for violations
-- Not reporting findings to validation report
-- Not assessing severity
-- Not auto-proceeding
-
-**Master Rule:** Requirements must be testable to be useful. Validate every requirement for measurability, document violations, auto-proceed.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-06-traceability-validation.md

@@ -1,214 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-07-implementation-leakage-validation.md'
-prdFile: '{prd_file_path}'
-validationReportPath: '{validation_report_path}'
----
-
-# Step 6: Traceability Validation
-
-## STEP GOAL:
-
-Validate the traceability chain from Executive Summary → Success Criteria → User Journeys → Functional Requirements is intact, ensuring every requirement traces back to a user need or business objective.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in systematic validation, not collaborative dialogue
-- ✅ You bring analytical rigor and traceability matrix expertise
-- ✅ This step runs autonomously - no user input needed
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on traceability chain validation
-- 🚫 FORBIDDEN to validate other aspects in this step
-- 💬 Approach: Systematic chain validation and orphan detection
-- 🚪 This is a validation sequence step - auto-proceeds when complete
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Build and validate traceability matrix
-- 💾 Identify broken chains and orphan requirements
-- 📖 Append findings to validation report
-- 📖 Display "Proceeding to next check..." and load next step
-- 🚫 FORBIDDEN to pause or request user input
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file, validation report
-- Focus: Traceability chain validation only
-- Limits: Don't validate other aspects, don't pause for user input
-- Dependencies: Steps 2-5 completed - initial validations done
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Attempt Sub-Process Validation
-
-**Try to use Task tool to spawn a subprocess:**
-
-"Perform traceability validation on this PRD:
-
-1. Extract content from Executive Summary (vision, goals)
-2. Extract Success Criteria
-3. Extract User Journeys (user types, flows, outcomes)
-4. Extract Functional Requirements (FRs)
-5. Extract Product Scope (in-scope items)
-
-**Validate chains:**
-- Executive Summary → Success Criteria: Does vision align with defined success?
-- Success Criteria → User Journeys: Are success criteria supported by user journeys?
-- User Journeys → Functional Requirements: Does each FR trace back to a user journey?
-- Scope → FRs: Do MVP scope FRs align with in-scope items?
-
-**Identify orphans:**
-- FRs not traceable to any user journey or business objective
-- Success criteria not supported by user journeys
-- User journeys without supporting FRs
-
-Build traceability matrix and identify broken chains and orphan FRs.
-
-Return structured findings with chain status and orphan list."
-
-### 2. Graceful Degradation (if Task tool unavailable)
-
-If Task tool unavailable, perform analysis directly:
-
-**Step 1: Extract key elements**
-- Executive Summary: Note vision, goals, objectives
-- Success Criteria: List all criteria
-- User Journeys: List user types and their flows
-- Functional Requirements: List all FRs
-- Product Scope: List in-scope items
-
-**Step 2: Validate Executive Summary → Success Criteria**
-- Does Executive Summary mention the success dimensions?
-- Are Success Criteria aligned with vision?
-- Note any misalignment
-
-**Step 3: Validate Success Criteria → User Journeys**
-- For each success criterion, is there a user journey that achieves it?
-- Note success criteria without supporting journeys
-
-**Step 4: Validate User Journeys → FRs**
-- For each user journey/flow, are there FRs that enable it?
-- List FRs with no clear user journey origin
-- Note orphan FRs (requirements without traceable source)
-
-**Step 5: Validate Scope → FR Alignment**
-- Does MVP scope align with essential FRs?
-- Are in-scope items supported by FRs?
-- Note misalignments
-
-**Step 6: Build traceability matrix**
-- Map each FR to its source (journey or business objective)
-- Note orphan FRs
-- Identify broken chains
-
-### 3. Tally Traceability Issues
-
-**Broken chains:**
-- Executive Summary → Success Criteria gaps: count
-- Success Criteria → User Journeys gaps: count
-- User Journeys → FRs gaps: count
-- Scope → FR misalignments: count
-
-**Orphan elements:**
-- Orphan FRs (no traceable source): count
-- Unsupported success criteria: count
-- User journeys without FRs: count
-
-**Total issues:** Sum of all broken chains and orphans
-
-### 4. Report Traceability Findings to Validation Report
-
-Append to validation report:
-
-```markdown
-## Traceability Validation
-
-### Chain Validation
-
-**Executive Summary → Success Criteria:** [Intact/Gaps Identified]
-{If gaps: List specific misalignments}
-
-**Success Criteria → User Journeys:** [Intact/Gaps Identified]
-{If gaps: List unsupported success criteria}
-
-**User Journeys → Functional Requirements:** [Intact/Gaps Identified]
-{If gaps: List journeys without supporting FRs}
-
-**Scope → FR Alignment:** [Intact/Misaligned]
-{If misaligned: List specific issues}
-
-### Orphan Elements
-
-**Orphan Functional Requirements:** {count}
-{List orphan FRs with numbers}
-
-**Unsupported Success Criteria:** {count}
-{List unsupported criteria}
-
-**User Journeys Without FRs:** {count}
-{List journeys without FRs}
-
-### Traceability Matrix
-
-{Summary table showing traceability coverage}
-
-**Total Traceability Issues:** {total}
-
-**Severity:** [Critical if orphan FRs exist, Warning if gaps, Pass if intact]
-
-**Recommendation:**
-[If Critical] "Orphan requirements exist - every FR must trace back to a user need or business objective."
-[If Warning] "Traceability gaps identified - strengthen chains to ensure all requirements are justified."
-[If Pass] "Traceability chain is intact - all requirements trace to user needs or business objectives."
-```
-
-### 5. Display Progress and Auto-Proceed
-
-Display: "**Traceability Validation Complete**
-
-Total Issues: {count} ({severity})
-
-**Proceeding to next validation check...**"
-
-Without delay, read fully and follow: {nextStepFile} (step-v-07-implementation-leakage-validation.md)
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All traceability chains validated systematically
-- Orphan FRs identified with numbers
-- Broken chains documented
-- Traceability matrix built
-- Severity assessed correctly
-- Findings reported to validation report
-- Auto-proceeds to next validation step
-- Subprocess attempted with graceful degradation
-
-### ❌ SYSTEM FAILURE:
-
-- Not validating all traceability chains
-- Missing orphan FR detection
-- Not building traceability matrix
-- Not reporting findings to validation report
-- Not auto-proceeding
-
-**Master Rule:** Every requirement should trace to a user need or business objective. Orphan FRs indicate broken traceability that must be fixed.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-07-implementation-leakage-validation.md

@@ -1,202 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-08-domain-compliance-validation.md'
-prdFile: '{prd_file_path}'
-validationReportPath: '{validation_report_path}'
----
-
-# Step 7: Implementation Leakage Validation
-
-## STEP GOAL:
-
-Ensure Functional Requirements and Non-Functional Requirements don't include implementation details - they should specify WHAT, not HOW.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in systematic validation, not collaborative dialogue
-- ✅ You bring analytical rigor and separation of concerns expertise
-- ✅ This step runs autonomously - no user input needed
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on implementation leakage detection
-- 🚫 FORBIDDEN to validate other aspects in this step
-- 💬 Approach: Systematic scanning for technology and implementation terms
-- 🚪 This is a validation sequence step - auto-proceeds when complete
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Scan FRs and NFRs for implementation terms
-- 💾 Distinguish capability-relevant vs leakage
-- 📖 Append findings to validation report
-- 📖 Display "Proceeding to next check..." and load next step
-- 🚫 FORBIDDEN to pause or request user input
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file, validation report
-- Focus: Implementation leakage detection only
-- Limits: Don't validate other aspects, don't pause for user input
-- Dependencies: Steps 2-6 completed - initial validations done
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Attempt Sub-Process Validation
-
-**Try to use Task tool to spawn a subprocess:**
-
-"Perform implementation leakage validation on this PRD:
-
-**Scan for:**
-1. Technology names (React, Vue, Angular, PostgreSQL, MongoDB, AWS, GCP, Azure, Docker, Kubernetes, etc.)
-2. Library names (Redux, axios, lodash, Express, Django, Rails, Spring, etc.)
-3. Data structures (JSON, XML, CSV) unless relevant to capability
-4. Architecture patterns (MVC, microservices, serverless) unless business requirement
-5. Protocol names (HTTP, REST, GraphQL, WebSockets) - check if capability-relevant
-
-**For each term found:**
-- Is this capability-relevant? (e.g., 'API consumers can access...' - API is capability)
-- Or is this implementation detail? (e.g., 'React component for...' - implementation)
-
-Document violations with line numbers and explanation.
-
-Return structured findings with leakage counts and examples."
-
-### 2. Graceful Degradation (if Task tool unavailable)
-
-If Task tool unavailable, perform analysis directly:
-
-**Implementation leakage terms to scan for:**
-
-**Frontend Frameworks:**
-React, Vue, Angular, Svelte, Solid, Next.js, Nuxt, etc.
-
-**Backend Frameworks:**
-Express, Django, Rails, Spring, Laravel, FastAPI, etc.
-
-**Databases:**
-PostgreSQL, MySQL, MongoDB, Redis, DynamoDB, Cassandra, etc.
-
-**Cloud Platforms:**
-AWS, GCP, Azure, Cloudflare, Vercel, Netlify, etc.
-
-**Infrastructure:**
-Docker, Kubernetes, Terraform, Ansible, etc.
-
-**Libraries:**
-Redux, Zustand, axios, fetch, lodash, jQuery, etc.
-
-**Data Formats:**
-JSON, XML, YAML, CSV (unless capability-relevant)
-
-**For each term found in FRs/NFRs:**
-- Determine if it's capability-relevant or implementation leakage
-- Example: "API consumers can access data via REST endpoints" - API/REST is capability
-- Example: "React components fetch data using Redux" - implementation leakage
-
-**Count violations and note line numbers**
-
-### 3. Tally Implementation Leakage
-
-**By category:**
-- Frontend framework leakage: count
-- Backend framework leakage: count
-- Database leakage: count
-- Cloud platform leakage: count
-- Infrastructure leakage: count
-- Library leakage: count
-- Other implementation details: count
-
-**Total implementation leakage violations:** sum
-
-### 4. Report Implementation Leakage Findings to Validation Report
-
-Append to validation report:
-
-```markdown
-## Implementation Leakage Validation
-
-### Leakage by Category
-
-**Frontend Frameworks:** {count} violations
-{If violations, list examples with line numbers}
-
-**Backend Frameworks:** {count} violations
-{If violations, list examples with line numbers}
-
-**Databases:** {count} violations
-{If violations, list examples with line numbers}
-
-**Cloud Platforms:** {count} violations
-{If violations, list examples with line numbers}
-
-**Infrastructure:** {count} violations
-{If violations, list examples with line numbers}
-
-**Libraries:** {count} violations
-{If violations, list examples with line numbers}
-
-**Other Implementation Details:** {count} violations
-{If violations, list examples with line numbers}
-
-### Summary
-
-**Total Implementation Leakage Violations:** {total}
-
-**Severity:** [Critical if >5 violations, Warning if 2-5, Pass if <2]
-
-**Recommendation:**
-[If Critical] "Extensive implementation leakage found. Requirements specify HOW instead of WHAT. Remove all implementation details - these belong in architecture, not PRD."
-[If Warning] "Some implementation leakage detected. Review violations and remove implementation details from requirements."
-[If Pass] "No significant implementation leakage found. Requirements properly specify WHAT without HOW."
-
-**Note:** API consumers, GraphQL (when required), and other capability-relevant terms are acceptable when they describe WHAT the system must do, not HOW to build it.
-```
-
-### 5. Display Progress and Auto-Proceed
-
-Display: "**Implementation Leakage Validation Complete**
-
-Total Violations: {count} ({severity})
-
-**Proceeding to next validation check...**"
-
-Without delay, read fully and follow: {nextStepFile} (step-v-08-domain-compliance-validation.md)
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Scanned FRs and NFRs for all implementation term categories
-- Distinguished capability-relevant from implementation leakage
-- Violations documented with line numbers and explanations
-- Severity assessed correctly
-- Findings reported to validation report
-- Auto-proceeds to next validation step
-- Subprocess attempted with graceful degradation
-
-### ❌ SYSTEM FAILURE:
-
-- Not scanning all implementation term categories
-- Not distinguishing capability-relevant from leakage
-- Missing line numbers for violations
-- Not reporting findings to validation report
-- Not auto-proceeding
-
-**Master Rule:** Requirements specify WHAT, not HOW. Implementation details belong in architecture documents, not PRDs.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-08-domain-compliance-validation.md

@@ -1,240 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-09-project-type-validation.md'
-prdFile: '{prd_file_path}'
-prdFrontmatter: '{prd_frontmatter}'
-validationReportPath: '{validation_report_path}'
-domainComplexityData: '../data/domain-complexity.csv'
----
-
-# Step 8: Domain Compliance Validation
-
-## STEP GOAL:
-
-Validate domain-specific requirements are present for high-complexity domains (Healthcare, Fintech, GovTech, etc.), ensuring regulatory and compliance requirements are properly documented.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in systematic validation, not collaborative dialogue
-- ✅ You bring domain expertise and compliance knowledge
-- ✅ This step runs autonomously - no user input needed
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on domain-specific compliance requirements
-- 🚫 FORBIDDEN to validate other aspects in this step
-- 💬 Approach: Conditional validation based on domain classification
-- 🚪 This is a validation sequence step - auto-proceeds when complete
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Check classification.domain from PRD frontmatter
-- 💬 If low complexity (general): Skip detailed checks
-- 🎯 If high complexity: Validate required special sections
-- 💾 Append compliance findings to validation report
-- 📖 Display "Proceeding to next check..." and load next step
-- 🚫 FORBIDDEN to pause or request user input
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file with frontmatter classification, validation report
-- Focus: Domain compliance only (conditional on domain complexity)
-- Limits: Don't validate other aspects, conditional execution
-- Dependencies: Steps 2-7 completed - format and requirements validation done
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Load Domain Complexity Data
-
-Load and read the complete file at:
-`{domainComplexityData}` (../data/domain-complexity.csv)
-
-This CSV contains:
-- Domain classifications and complexity levels (high/medium/low)
-- Required special sections for each domain
-- Key concerns and requirements for regulated industries
-
-Internalize this data - it drives which domains require special compliance sections.
-
-### 2. Extract Domain Classification
-
-From PRD frontmatter, extract:
-- `classification.domain` - what domain is this PRD for?
-
-**If no domain classification found:**
-Treat as "general" (low complexity) and proceed to step 4
-
-### 2. Determine Domain Complexity
-
-**Low complexity domains (skip detailed checks):**
-- General
-- Consumer apps (standard e-commerce, social, productivity)
-- Content websites
-- Business tools (standard)
-
-**High complexity domains (require special sections):**
-- Healthcare / Healthtech
-- Fintech / Financial services
-- GovTech / Public sector
-- EdTech (educational records, accredited courses)
-- Legal tech
-- Other regulated domains
-
-### 3. For High-Complexity Domains: Validate Required Special Sections
-
-**Attempt subprocess validation:**
-
-"Perform domain compliance validation for {domain}:
-
-Based on {domain} requirements, check PRD for:
-
-**Healthcare:**
-- Clinical Requirements section
-- Regulatory Pathway (FDA, HIPAA, etc.)
-- Safety Measures
-- HIPAA Compliance (data privacy, security)
-- Patient safety considerations
-
-**Fintech:**
-- Compliance Matrix (SOC2, PCI-DSS, GDPR, etc.)
-- Security Architecture
-- Audit Requirements
-- Fraud Prevention measures
-- Financial transaction handling
-
-**GovTech:**
-- Accessibility Standards (WCAG 2.1 AA, Section 508)
-- Procurement Compliance
-- Security Clearance requirements
-- Data residency requirements
-
-**Other regulated domains:**
-- Check for domain-specific regulatory sections
-- Compliance requirements
-- Special considerations
-
-For each required section:
-- Is it present in PRD?
-- Is it adequately documented?
-- Note any gaps
-
-Return compliance matrix with presence/adequacy assessment."
-
-**Graceful degradation (if no Task tool):**
-- Manually check for required sections based on domain
-- List present sections and missing sections
-- Assess adequacy of documentation
-
-### 5. For Low-Complexity Domains: Skip Detailed Checks
-
-Append to validation report:
-```markdown
-## Domain Compliance Validation
-
-**Domain:** {domain}
-**Complexity:** Low (general/standard)
-**Assessment:** N/A - No special domain compliance requirements
-
-**Note:** This PRD is for a standard domain without regulatory compliance requirements.
-```
-
-Display: "**Domain Compliance Validation Skipped**
-
-Domain: {domain} (low complexity)
-
-**Proceeding to next validation check...**"
-
-Without delay, read fully and follow: {nextStepFile}
-
-### 6. Report Compliance Findings (High-Complexity Domains)
-
-Append to validation report:
-
-```markdown
-## Domain Compliance Validation
-
-**Domain:** {domain}
-**Complexity:** High (regulated)
-
-### Required Special Sections
-
-**{Section 1 Name}:** [Present/Missing/Adequate]
-{If missing or inadequate: Note specific gaps}
-
-**{Section 2 Name}:** [Present/Missing/Adequate]
-{If missing or inadequate: Note specific gaps}
-
-[Continue for all required sections]
-
-### Compliance Matrix
-
-| Requirement | Status | Notes |
-|-------------|--------|-------|
-| {Requirement 1} | [Met/Partial/Missing] | {Notes} |
-| {Requirement 2} | [Met/Partial/Missing] | {Notes} |
-[... continue for all requirements]
-
-### Summary
-
-**Required Sections Present:** {count}/{total}
-**Compliance Gaps:** {count}
-
-**Severity:** [Critical if missing regulatory sections, Warning if incomplete, Pass if complete]
-
-**Recommendation:**
-[If Critical] "PRD is missing required domain-specific compliance sections. These are essential for {domain} products."
-[If Warning] "Some domain compliance sections are incomplete. Strengthen documentation for full compliance."
-[If Pass] "All required domain compliance sections are present and adequately documented."
-```
-
-### 7. Display Progress and Auto-Proceed
-
-Display: "**Domain Compliance Validation Complete**
-
-Domain: {domain} ({complexity})
-Compliance Status: {status}
-
-**Proceeding to next validation check...**"
-
-Without delay, read fully and follow: {nextStepFile} (step-v-09-project-type-validation.md)
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Domain classification extracted correctly
-- Complexity assessed appropriately
-- Low complexity domains: Skipped with clear "N/A" documentation
-- High complexity domains: All required sections checked
-- Compliance matrix built with status for each requirement
-- Severity assessed correctly
-- Findings reported to validation report
-- Auto-proceeds to next validation step
-- Subprocess attempted with graceful degradation
-
-### ❌ SYSTEM FAILURE:
-
-- Not checking domain classification before proceeding
-- Performing detailed checks on low complexity domains
-- For high complexity: missing required section checks
-- Not building compliance matrix
-- Not reporting findings to validation report
-- Not auto-proceeding
-
-**Master Rule:** Domain compliance is conditional. High-complexity domains require special sections - low complexity domains skip these checks.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-09-project-type-validation.md

@@ -1,260 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-10-smart-validation.md'
-prdFile: '{prd_file_path}'
-prdFrontmatter: '{prd_frontmatter}'
-validationReportPath: '{validation_report_path}'
-projectTypesData: '../data/project-types.csv'
----
-
-# Step 9: Project-Type Compliance Validation
-
-## STEP GOAL:
-
-Validate project-type specific requirements are properly documented - different project types (api_backend, web_app, mobile_app, etc.) have different required and excluded sections.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in systematic validation, not collaborative dialogue
-- ✅ You bring project type expertise and architectural knowledge
-- ✅ This step runs autonomously - no user input needed
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on project-type compliance
-- 🚫 FORBIDDEN to validate other aspects in this step
-- 💬 Approach: Validate required sections present, excluded sections absent
-- 🚪 This is a validation sequence step - auto-proceeds when complete
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Check classification.projectType from PRD frontmatter
-- 🎯 Validate required sections for that project type are present
-- 🎯 Validate excluded sections for that project type are absent
-- 💾 Append compliance findings to validation report
-- 📖 Display "Proceeding to next check..." and load next step
-- 🚫 FORBIDDEN to pause or request user input
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file with frontmatter classification, validation report
-- Focus: Project-type compliance only
-- Limits: Don't validate other aspects, don't pause for user input
-- Dependencies: Steps 2-8 completed - domain and requirements validation done
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Load Project Types Data
-
-Load and read the complete file at:
-`{projectTypesData}` (../data/project-types.csv)
-
-This CSV contains:
-- Detection signals for each project type
-- Required sections for each project type
-- Skip/excluded sections for each project type
-- Innovation signals
-
-Internalize this data - it drives what sections must be present or absent for each project type.
-
-### 2. Extract Project Type Classification
-
-From PRD frontmatter, extract:
-- `classification.projectType` - what type of project is this?
-
-**Common project types:**
-- api_backend
-- web_app
-- mobile_app
-- desktop_app
-- data_pipeline
-- ml_system
-- library_sdk
-- infrastructure
-- other
-
-**If no projectType classification found:**
-Assume "web_app" (most common) and note in findings
-
-### 3. Determine Required and Excluded Sections from CSV Data
-
-**From loaded project-types.csv data, for this project type:**
-
-**Required sections:** (from required_sections column)
-These MUST be present in the PRD
-
-**Skip sections:** (from skip_sections column)
-These MUST NOT be present in the PRD
-
-**Example mappings from CSV:**
-- api_backend: Required=[endpoint_specs, auth_model, data_schemas], Skip=[ux_ui, visual_design]
-- mobile_app: Required=[platform_reqs, device_permissions, offline_mode], Skip=[desktop_features, cli_commands]
-- cli_tool: Required=[command_structure, output_formats, config_schema], Skip=[visual_design, ux_principles, touch_interactions]
-- etc.
-
-### 4. Validate Against CSV-Based Requirements
-
-**Based on project type, determine:**
-
-**api_backend:**
-- Required: Endpoint Specs, Auth Model, Data Schemas, API Versioning
-- Excluded: UX/UI sections, mobile-specific sections
-
-**web_app:**
-- Required: User Journeys, UX/UI Requirements, Responsive Design
-- Excluded: None typically
-
-**mobile_app:**
-- Required: Mobile UX, Platform specifics (iOS/Android), Offline mode
-- Excluded: Desktop-specific sections
-
-**desktop_app:**
-- Required: Desktop UX, Platform specifics (Windows/Mac/Linux)
-- Excluded: Mobile-specific sections
-
-**data_pipeline:**
-- Required: Data Sources, Data Transformation, Data Sinks, Error Handling
-- Excluded: UX/UI sections
-
-**ml_system:**
-- Required: Model Requirements, Training Data, Inference Requirements, Model Performance
-- Excluded: UX/UI sections (unless ML UI)
-
-**library_sdk:**
-- Required: API Surface, Usage Examples, Integration Guide
-- Excluded: UX/UI sections, deployment sections
-
-**infrastructure:**
-- Required: Infrastructure Components, Deployment, Monitoring, Scaling
-- Excluded: Feature requirements (this is infrastructure, not product)
-
-### 4. Attempt Sub-Process Validation
-
-"Perform project-type compliance validation for {projectType}:
-
-**Check that required sections are present:**
-{List required sections for this project type}
-For each: Is it present in PRD? Is it adequately documented?
-
-**Check that excluded sections are absent:**
-{List excluded sections for this project type}
-For each: Is it absent from PRD? (Should not be present)
-
-Build compliance table showing:
-- Required sections: [Present/Missing/Incomplete]
-- Excluded sections: [Absent/Present] (Present = violation)
-
-Return compliance table with findings."
-
-**Graceful degradation (if no Task tool):**
-- Manually check PRD for required sections
-- Manually check PRD for excluded sections
-- Build compliance table
-
-### 5. Build Compliance Table
-
-**Required sections check:**
-- For each required section: Present / Missing / Incomplete
-- Count: Required sections present vs total required
-
-**Excluded sections check:**
-- For each excluded section: Absent / Present (violation)
-- Count: Excluded sections present (violations)
-
-**Total compliance score:**
-- Required: {present}/{total}
-- Excluded violations: {count}
-
-### 6. Report Project-Type Compliance Findings to Validation Report
-
-Append to validation report:
-
-```markdown
-## Project-Type Compliance Validation
-
-**Project Type:** {projectType}
-
-### Required Sections
-
-**{Section 1}:** [Present/Missing/Incomplete]
-{If missing or incomplete: Note specific gaps}
-
-**{Section 2}:** [Present/Missing/Incomplete]
-{If missing or incomplete: Note specific gaps}
-
-[Continue for all required sections]
-
-### Excluded Sections (Should Not Be Present)
-
-**{Section 1}:** [Absent/Present] ✓
-{If present: This section should not be present for {projectType}}
-
-**{Section 2}:** [Absent/Present] ✓
-{If present: This section should not be present for {projectType}}
-
-[Continue for all excluded sections]
-
-### Compliance Summary
-
-**Required Sections:** {present}/{total} present
-**Excluded Sections Present:** {violations} (should be 0)
-**Compliance Score:** {percentage}%
-
-**Severity:** [Critical if required sections missing, Warning if incomplete, Pass if complete]
-
-**Recommendation:**
-[If Critical] "PRD is missing required sections for {projectType}. Add missing sections to properly specify this type of project."
-[If Warning] "Some required sections for {projectType} are incomplete. Strengthen documentation."
-[If Pass] "All required sections for {projectType} are present. No excluded sections found."
-```
-
-### 7. Display Progress and Auto-Proceed
-
-Display: "**Project-Type Compliance Validation Complete**
-
-Project Type: {projectType}
-Compliance: {score}%
-
-**Proceeding to next validation check...**"
-
-Without delay, read fully and follow: {nextStepFile} (step-v-10-smart-validation.md)
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Project type extracted correctly (or default assumed)
-- Required sections validated for presence and completeness
-- Excluded sections validated for absence
-- Compliance table built with status for all sections
-- Severity assessed correctly
-- Findings reported to validation report
-- Auto-proceeds to next validation step
-- Subprocess attempted with graceful degradation
-
-### ❌ SYSTEM FAILURE:
-
-- Not checking project type before proceeding
-- Missing required section checks
-- Missing excluded section checks
-- Not building compliance table
-- Not reporting findings to validation report
-- Not auto-proceeding
-
-**Master Rule:** Different project types have different requirements. API PRDs don't need UX sections - validate accordingly.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-10-smart-validation.md

@@ -1,206 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-11-holistic-quality-validation.md'
-prdFile: '{prd_file_path}'
-validationReportPath: '{validation_report_path}'
----
-
-# Step 10: SMART Requirements Validation
-
-## STEP GOAL:
-
-Validate Functional Requirements meet SMART quality criteria (Specific, Measurable, Attainable, Relevant, Traceable), ensuring high-quality requirements.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in systematic validation, not collaborative dialogue
-- ✅ You bring requirements engineering expertise and quality assessment
-- ✅ This step runs autonomously - no user input needed
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on FR quality assessment using SMART framework
-- 🚫 FORBIDDEN to validate other aspects in this step
-- 💬 Approach: Score each FR on SMART criteria (1-5 scale)
-- 🚪 This is a validation sequence step - auto-proceeds when complete
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Extract all FRs from PRD
-- 🎯 Score each FR on SMART criteria (Specific, Measurable, Attainable, Relevant, Traceable)
-- 💾 Flag FRs with score < 3 in any category
-- 📖 Append scoring table and suggestions to validation report
-- 📖 Display "Proceeding to next check..." and load next step
-- 🚫 FORBIDDEN to pause or request user input
-
-## CONTEXT BOUNDARIES:
-
-- Available context: PRD file, validation report
-- Focus: FR quality assessment only using SMART framework
-- Limits: Don't validate NFRs or other aspects, don't pause for user input
-- Dependencies: Steps 2-9 completed - comprehensive validation checks done
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Extract All Functional Requirements
-
-From the PRD's Functional Requirements section, extract:
-- All FRs with their FR numbers (FR-001, FR-002, etc.)
-- Count total FRs
-
-### 2. Attempt Sub-Process Validation
-
-**Try to use Task tool to spawn a subprocess:**
-
-"Perform SMART requirements validation on these Functional Requirements:
-
-{List all FRs}
-
-**For each FR, score on SMART criteria (1-5 scale):**
-
-**Specific (1-5):**
-- 5: Clear, unambiguous, well-defined
-- 3: Somewhat clear but could be more specific
-- 1: Vague, ambiguous, unclear
-
-**Measurable (1-5):**
-- 5: Quantifiable metrics, testable
-- 3: Partially measurable
-- 1: Not measurable, subjective
-
-**Attainable (1-5):**
-- 5: Realistic, achievable with constraints
-- 3: Probably achievable but uncertain
-- 1: Unrealistic, technically infeasible
-
-**Relevant (1-5):**
-- 5: Clearly aligned with user needs and business objectives
-- 3: Somewhat relevant but connection unclear
-- 1: Not relevant, doesn't align with goals
-
-**Traceable (1-5):**
-- 5: Clearly traces to user journey or business objective
-- 3: Partially traceable
-- 1: Orphan requirement, no clear source
-
-**For each FR with score < 3 in any category:**
-- Provide specific improvement suggestions
-
-Return scoring table with all FR scores and improvement suggestions for low-scoring FRs."
-
-**Graceful degradation (if no Task tool):**
-- Manually score each FR on SMART criteria
-- Note FRs with low scores
-- Provide improvement suggestions
-
-### 3. Build Scoring Table
-
-For each FR:
-- FR number
-- Specific score (1-5)
-- Measurable score (1-5)
-- Attainable score (1-5)
-- Relevant score (1-5)
-- Traceable score (1-5)
-- Average score
-- Flag if any category < 3
-
-**Calculate overall FR quality:**
-- Percentage of FRs with all scores ≥ 3
-- Percentage of FRs with all scores ≥ 4
-- Average score across all FRs and categories
-
-### 4. Report SMART Findings to Validation Report
-
-Append to validation report:
-
-```markdown
-## SMART Requirements Validation
-
-**Total Functional Requirements:** {count}
-
-### Scoring Summary
-
-**All scores ≥ 3:** {percentage}% ({count}/{total})
-**All scores ≥ 4:** {percentage}% ({count}/{total})
-**Overall Average Score:** {average}/5.0
-
-### Scoring Table
-
-| FR # | Specific | Measurable | Attainable | Relevant | Traceable | Average | Flag |
-|------|----------|------------|------------|----------|-----------|--------|------|
-| FR-001 | {s1} | {m1} | {a1} | {r1} | {t1} | {avg1} | {X if any <3} |
-| FR-002 | {s2} | {m2} | {a2} | {r2} | {t2} | {avg2} | {X if any <3} |
-[Continue for all FRs]
-
-**Legend:** 1=Poor, 3=Acceptable, 5=Excellent
-**Flag:** X = Score < 3 in one or more categories
-
-### Improvement Suggestions
-
-**Low-Scoring FRs:**
-
-**FR-{number}:** {specific suggestion for improvement}
-[For each FR with score < 3 in any category]
-
-### Overall Assessment
-
-**Severity:** [Critical if >30% flagged FRs, Warning if 10-30%, Pass if <10%]
-
-**Recommendation:**
-[If Critical] "Many FRs have quality issues. Revise flagged FRs using SMART framework to improve clarity and testability."
-[If Warning] "Some FRs would benefit from SMART refinement. Focus on flagged requirements above."
-[If Pass] "Functional Requirements demonstrate good SMART quality overall."
-```
-
-### 5. Display Progress and Auto-Proceed
-
-Display: "**SMART Requirements Validation Complete**
-
-FR Quality: {percentage}% with acceptable scores ({severity})
-
-**Proceeding to next validation check...**"
-
-Without delay, read fully and follow: {nextStepFile} (step-v-11-holistic-quality-validation.md)
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All FRs extracted from PRD
-- Each FR scored on all 5 SMART criteria (1-5 scale)
-- FRs with scores < 3 flagged for improvement
-- Improvement suggestions provided for low-scoring FRs
-- Scoring table built with all FR scores
-- Overall quality assessment calculated
-- Findings reported to validation report
-- Auto-proceeds to next validation step
-- Subprocess attempted with graceful degradation
-
-### ❌ SYSTEM FAILURE:
-
-- Not scoring all FRs on all SMART criteria
-- Missing improvement suggestions for low-scoring FRs
-- Not building scoring table
-- Not calculating overall quality metrics
-- Not reporting findings to validation report
-- Not auto-proceeding
-
-**Master Rule:** FRs should be high-quality, not just present. SMART framework provides objective quality measure.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-11-holistic-quality-validation.md

@@ -1,261 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-12-completeness-validation.md'
-prdFile: '{prd_file_path}'
-validationReportPath: '{validation_report_path}'
----
-
-# Step 11: Holistic Quality Assessment
-
-## STEP GOAL:
-
-Assess the PRD as a cohesive, compelling document - evaluating document flow, dual audience effectiveness (humans and LLMs), BMAD PRD principles compliance, and overall quality rating.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in systematic validation, not collaborative dialogue
-- ✅ You bring analytical rigor and document quality expertise
-- ✅ This step runs autonomously - no user input needed
-- ✅ Uses Advanced Elicitation for multi-perspective evaluation
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on holistic document quality assessment
-- 🚫 FORBIDDEN to validate individual components (done in previous steps)
-- 💬 Approach: Multi-perspective evaluation using Advanced Elicitation
-- 🚪 This is a validation sequence step - auto-proceeds when complete
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Use Advanced Elicitation for multi-perspective assessment
-- 🎯 Evaluate document flow, dual audience, BMAD principles
-- 💾 Append comprehensive assessment to validation report
-- 📖 Display "Proceeding to next check..." and load next step
-- 🚫 FORBIDDEN to pause or request user input
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Complete PRD file, validation report with findings from steps 1-10
-- Focus: Holistic quality - the WHOLE document
-- Limits: Don't re-validate individual components, don't pause for user input
-- Dependencies: Steps 1-10 completed - all systematic checks done
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Attempt Sub-Process with Advanced Elicitation
-
-**Try to use Task tool to spawn a subprocess using Advanced Elicitation:**
-
-"Perform holistic quality assessment on this PRD using multi-perspective evaluation:
-
-**Advanced Elicitation workflow:**
-Invoke the `bmad-advanced-elicitation` skill
-
-**Evaluate the PRD from these perspectives:**
-
-**1. Document Flow & Coherence:**
-- Read entire PRD
-- Evaluate narrative flow - does it tell a cohesive story?
-- Check transitions between sections
-- Assess consistency - is it coherent throughout?
-- Evaluate readability - is it clear and well-organized?
-
-**2. Dual Audience Effectiveness:**
-
-**For Humans:**
-- Executive-friendly: Can executives understand vision and goals quickly?
-- Developer clarity: Do developers have clear requirements to build from?
-- Designer clarity: Do designers understand user needs and flows?
-- Stakeholder decision-making: Can stakeholders make informed decisions?
-
-**For LLMs:**
-- Machine-readable structure: Is the PRD structured for LLM consumption?
-- UX readiness: Can an LLM generate UX designs from this?
-- Architecture readiness: Can an LLM generate architecture from this?
-- Epic/Story readiness: Can an LLM break down into epics and stories?
-
-**3. BMAD PRD Principles Compliance:**
-- Information density: Every sentence carries weight?
-- Measurability: Requirements testable?
-- Traceability: Requirements trace to sources?
-- Domain awareness: Domain-specific considerations included?
-- Zero anti-patterns: No filler or wordiness?
-- Dual audience: Works for both humans and LLMs?
-- Markdown format: Proper structure and formatting?
-
-**4. Overall Quality Rating:**
-Rate the PRD on 5-point scale:
-- Excellent (5/5): Exemplary, ready for production use
-- Good (4/5): Strong with minor improvements needed
-- Adequate (3/5): Acceptable but needs refinement
-- Needs Work (2/5): Significant gaps or issues
-- Problematic (1/5): Major flaws, needs substantial revision
-
-**5. Top 3 Improvements:**
-Identify the 3 most impactful improvements to make this a great PRD
-
-Return comprehensive assessment with all perspectives, rating, and top 3 improvements."
-
-**Graceful degradation (if no Task tool or Advanced Elicitation unavailable):**
-- Perform holistic assessment directly in current context
-- Read complete PRD
-- Evaluate document flow, coherence, transitions
-- Assess dual audience effectiveness
-- Check BMAD principles compliance
-- Assign overall quality rating
-- Identify top 3 improvements
-
-### 2. Synthesize Assessment
-
-**Compile findings from multi-perspective evaluation:**
-
-**Document Flow & Coherence:**
-- Overall assessment: [Excellent/Good/Adequate/Needs Work/Problematic]
-- Key strengths: [list]
-- Key weaknesses: [list]
-
-**Dual Audience Effectiveness:**
-- For Humans: [assessment]
-- For LLMs: [assessment]
-- Overall dual audience score: [1-5]
-
-**BMAD Principles Compliance:**
-- Principles met: [count]/7
-- Principles with issues: [list]
-
-**Overall Quality Rating:** [1-5 with label]
-
-**Top 3 Improvements:**
-1. [Improvement 1]
-2. [Improvement 2]
-3. [Improvement 3]
-
-### 3. Report Holistic Quality Findings to Validation Report
-
-Append to validation report:
-
-```markdown
-## Holistic Quality Assessment
-
-### Document Flow & Coherence
-
-**Assessment:** [Excellent/Good/Adequate/Needs Work/Problematic]
-
-**Strengths:**
-{List key strengths}
-
-**Areas for Improvement:**
-{List key weaknesses}
-
-### Dual Audience Effectiveness
-
-**For Humans:**
-- Executive-friendly: [assessment]
-- Developer clarity: [assessment]
-- Designer clarity: [assessment]
-- Stakeholder decision-making: [assessment]
-
-**For LLMs:**
-- Machine-readable structure: [assessment]
-- UX readiness: [assessment]
-- Architecture readiness: [assessment]
-- Epic/Story readiness: [assessment]
-
-**Dual Audience Score:** {score}/5
-
-### BMAD PRD Principles Compliance
-
-| Principle | Status | Notes |
-|-----------|--------|-------|
-| Information Density | [Met/Partial/Not Met] | {notes} |
-| Measurability | [Met/Partial/Not Met] | {notes} |
-| Traceability | [Met/Partial/Not Met] | {notes} |
-| Domain Awareness | [Met/Partial/Not Met] | {notes} |
-| Zero Anti-Patterns | [Met/Partial/Not Met] | {notes} |
-| Dual Audience | [Met/Partial/Not Met] | {notes} |
-| Markdown Format | [Met/Partial/Not Met] | {notes} |
-
-**Principles Met:** {count}/7
-
-### Overall Quality Rating
-
-**Rating:** {rating}/5 - {label}
-
-**Scale:**
-- 5/5 - Excellent: Exemplary, ready for production use
-- 4/5 - Good: Strong with minor improvements needed
-- 3/5 - Adequate: Acceptable but needs refinement
-- 2/5 - Needs Work: Significant gaps or issues
-- 1/5 - Problematic: Major flaws, needs substantial revision
-
-### Top 3 Improvements
-
-1. **{Improvement 1}**
-   {Brief explanation of why and how}
-
-2. **{Improvement 2}**
-   {Brief explanation of why and how}
-
-3. **{Improvement 3}**
-   {Brief explanation of why and how}
-
-### Summary
-
-**This PRD is:** {one-sentence overall assessment}
-
-**To make it great:** Focus on the top 3 improvements above.
-```
-
-### 4. Display Progress and Auto-Proceed
-
-Display: "**Holistic Quality Assessment Complete**
-
-Overall Rating: {rating}/5 - {label}
-
-**Proceeding to final validation checks...**"
-
-Without delay, read fully and follow: {nextStepFile} (step-v-12-completeness-validation.md)
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Advanced Elicitation used for multi-perspective evaluation (or graceful degradation)
-- Document flow & coherence assessed
-- Dual audience effectiveness evaluated (humans and LLMs)
-- BMAD PRD principles compliance checked
-- Overall quality rating assigned (1-5 scale)
-- Top 3 improvements identified
-- Comprehensive assessment reported to validation report
-- Auto-proceeds to next validation step
-- Subprocess attempted with graceful degradation
-
-### ❌ SYSTEM FAILURE:
-
-- Not using Advanced Elicitation for multi-perspective evaluation
-- Missing document flow assessment
-- Missing dual audience evaluation
-- Not checking all BMAD principles
-- Not assigning overall quality rating
-- Missing top 3 improvements
-- Not reporting comprehensive assessment to validation report
-- Not auto-proceeding
-
-**Master Rule:** This evaluates the WHOLE document, not just components. Answers "Is this a good PRD?" and "What would make it great?"

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-12-completeness-validation.md

@@ -1,239 +0,0 @@
----
-# File references (ONLY variables used in this step)
-nextStepFile: './step-v-13-report-complete.md'
-prdFile: '{prd_file_path}'
-prdFrontmatter: '{prd_frontmatter}'
-validationReportPath: '{validation_report_path}'
----
-
-# Step 12: Completeness Validation
-
-## STEP GOAL:
-
-Final comprehensive completeness check - validate no template variables remain, each section has required content, section-specific completeness, and frontmatter is properly populated.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in systematic validation, not collaborative dialogue
-- ✅ You bring attention to detail and completeness verification
-- ✅ This step runs autonomously - no user input needed
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on completeness verification
-- 🚫 FORBIDDEN to validate quality (done in step 11) or other aspects
-- 💬 Approach: Systematic checklist-style verification
-- 🚪 This is a validation sequence step - auto-proceeds when complete
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Check template completeness (no variables remaining)
-- 🎯 Validate content completeness (each section has required content)
-- 🎯 Validate section-specific completeness
-- 🎯 Validate frontmatter completeness
-- 💾 Append completeness matrix to validation report
-- 📖 Display "Proceeding to final step..." and load next step
-- 🚫 FORBIDDEN to pause or request user input
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Complete PRD file, frontmatter, validation report
-- Focus: Completeness verification only (final gate)
-- Limits: Don't assess quality, don't pause for user input
-- Dependencies: Steps 1-11 completed - all validation checks done
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Attempt Sub-Process Validation
-
-**Try to use Task tool to spawn a subprocess:**
-
-"Perform completeness validation on this PRD - final gate check:
-
-**1. Template Completeness:**
-- Scan PRD for any remaining template variables
-- Look for: {variable}, {{variable}}, {placeholder}, [placeholder], etc.
-- List any found with line numbers
-
-**2. Content Completeness:**
-- Executive Summary: Has vision statement? ({key content})
-- Success Criteria: All criteria measurable? ({metrics present})
-- Product Scope: In-scope and out-of-scope defined? ({both present})
-- User Journeys: User types identified? ({users listed})
-- Functional Requirements: FRs listed with proper format? ({FRs present})
-- Non-Functional Requirements: NFRs with metrics? ({NFRs present})
-
-For each section: Is required content present? (Yes/No/Partial)
-
-**3. Section-Specific Completeness:**
-- Success Criteria: Each has specific measurement method?
-- User Journeys: Cover all user types?
-- Functional Requirements: Cover MVP scope?
-- Non-Functional Requirements: Each has specific criteria?
-
-**4. Frontmatter Completeness:**
-- stepsCompleted: Populated?
-- classification: Present (domain, projectType)?
-- inputDocuments: Tracked?
-- date: Present?
-
-Return completeness matrix with status for each check."
-
-**Graceful degradation (if no Task tool):**
-- Manually scan for template variables
-- Manually check each section for required content
-- Manually verify frontmatter fields
-- Build completeness matrix
-
-### 2. Build Completeness Matrix
-
-**Template Completeness:**
-- Template variables found: count
-- List if any found
-
-**Content Completeness by Section:**
-- Executive Summary: Complete / Incomplete / Missing
-- Success Criteria: Complete / Incomplete / Missing
-- Product Scope: Complete / Incomplete / Missing
-- User Journeys: Complete / Incomplete / Missing
-- Functional Requirements: Complete / Incomplete / Missing
-- Non-Functional Requirements: Complete / Incomplete / Missing
-- Other sections: [List completeness]
-
-**Section-Specific Completeness:**
-- Success criteria measurable: All / Some / None
-- Journeys cover all users: Yes / Partial / No
-- FRs cover MVP scope: Yes / Partial / No
-- NFRs have specific criteria: All / Some / None
-
-**Frontmatter Completeness:**
-- stepsCompleted: Present / Missing
-- classification: Present / Missing
-- inputDocuments: Present / Missing
-- date: Present / Missing
-
-**Overall completeness:**
-- Sections complete: X/Y
-- Critical gaps: [list if any]
-
-### 3. Report Completeness Findings to Validation Report
-
-Append to validation report:
-
-```markdown
-## Completeness Validation
-
-### Template Completeness
-
-**Template Variables Found:** {count}
-{If count > 0, list variables with line numbers}
-{If count = 0, note: No template variables remaining ✓}
-
-### Content Completeness by Section
-
-**Executive Summary:** [Complete/Incomplete/Missing]
-{If incomplete or missing, note specific gaps}
-
-**Success Criteria:** [Complete/Incomplete/Missing]
-{If incomplete or missing, note specific gaps}
-
-**Product Scope:** [Complete/Incomplete/Missing]
-{If incomplete or missing, note specific gaps}
-
-**User Journeys:** [Complete/Incomplete/Missing]
-{If incomplete or missing, note specific gaps}
-
-**Functional Requirements:** [Complete/Incomplete/Missing]
-{If incomplete or missing, note specific gaps}
-
-**Non-Functional Requirements:** [Complete/Incomplete/Missing]
-{If incomplete or missing, note specific gaps}
-
-### Section-Specific Completeness
-
-**Success Criteria Measurability:** [All/Some/None] measurable
-{If Some or None, note which criteria lack metrics}
-
-**User Journeys Coverage:** [Yes/Partial/No] - covers all user types
-{If Partial or No, note missing user types}
-
-**FRs Cover MVP Scope:** [Yes/Partial/No]
-{If Partial or No, note scope gaps}
-
-**NFRs Have Specific Criteria:** [All/Some/None]
-{If Some or None, note which NFRs lack specificity}
-
-### Frontmatter Completeness
-
-**stepsCompleted:** [Present/Missing]
-**classification:** [Present/Missing]
-**inputDocuments:** [Present/Missing]
-**date:** [Present/Missing]
-
-**Frontmatter Completeness:** {complete_fields}/4
-
-### Completeness Summary
-
-**Overall Completeness:** {percentage}% ({complete_sections}/{total_sections})
-
-**Critical Gaps:** [count] [list if any]
-**Minor Gaps:** [count] [list if any]
-
-**Severity:** [Critical if template variables exist or critical sections missing, Warning if minor gaps, Pass if complete]
-
-**Recommendation:**
-[If Critical] "PRD has completeness gaps that must be addressed before use. Fix template variables and complete missing sections."
-[If Warning] "PRD has minor completeness gaps. Address minor gaps for complete documentation."
-[If Pass] "PRD is complete with all required sections and content present."
-```
-
-### 4. Display Progress and Auto-Proceed
-
-Display: "**Completeness Validation Complete**
-
-Overall Completeness: {percentage}% ({severity})
-
-**Proceeding to final step...**"
-
-Without delay, read fully and follow: {nextStepFile} (step-v-13-report-complete.md)
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Scanned for template variables systematically
-- Validated each section for required content
-- Validated section-specific completeness (measurability, coverage, scope)
-- Validated frontmatter completeness
-- Completeness matrix built with all checks
-- Severity assessed correctly
-- Findings reported to validation report
-- Auto-proceeds to final step
-- Subprocess attempted with graceful degradation
-
-### ❌ SYSTEM FAILURE:
-
-- Not scanning for template variables
-- Missing section-specific completeness checks
-- Not validating frontmatter
-- Not building completeness matrix
-- Not reporting findings to validation report
-- Not auto-proceeding
-
-**Master Rule:** Final gate to ensure document is complete before presenting findings. Template variables or critical gaps must be fixed.

src/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-13-report-complete.md

@@ -1,230 +0,0 @@
----
-# File references (ONLY variables used in this step)
-validationReportPath: '{validation_report_path}'
-prdFile: '{prd_file_path}'
----
-
-# Step 13: Validation Report Complete
-
-## STEP GOAL:
-
-Finalize validation report, summarize all findings from steps 1-12, present summary to user conversationally, and offer actionable next steps.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a Validation Architect and Quality Assurance Specialist
-- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring synthesis and summary expertise
-- ✅ This is the FINAL step - requires user interaction
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on summarizing findings and presenting options
-- 🚫 FORBIDDEN to perform additional validation
-- 💬 Approach: Conversational summary with clear next steps
-- 🚪 This is the final step - no next step after this
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Load complete validation report
-- 🎯 Summarize all findings from steps 1-12
-- 🎯 Update report frontmatter with final status
-- 💬 Present summary to user conversationally
-- 💬 Offer menu options for next actions
-- 🚫 FORBIDDEN to proceed without user selection
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Complete validation report with findings from all validation steps
-- Focus: Summary and presentation only (no new validation)
-- Limits: Don't add new findings, just synthesize existing
-- Dependencies: Steps 1-12 completed - all validation checks done
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Load Complete Validation Report
-
-Read the entire validation report from {validationReportPath}
-
-Extract all findings from:
-- Format Detection (Step 2)
-- Parity Analysis (Step 2B, if applicable)
-- Information Density (Step 3)
-- Product Brief Coverage (Step 4)
-- Measurability (Step 5)
-- Traceability (Step 6)
-- Implementation Leakage (Step 7)
-- Domain Compliance (Step 8)
-- Project-Type Compliance (Step 9)
-- SMART Requirements (Step 10)
-- Holistic Quality (Step 11)
-- Completeness (Step 12)
-
-### 2. Update Report Frontmatter with Final Status
-
-Update validation report frontmatter:
-
-```yaml
----
-validationTarget: '{prd_path}'
-validationDate: '{current_date}'
-inputDocuments: [list of documents]
-validationStepsCompleted: ['step-v-01-discovery', 'step-v-02-format-detection', 'step-v-03-density-validation', 'step-v-04-brief-coverage-validation', 'step-v-05-measurability-validation', 'step-v-06-traceability-validation', 'step-v-07-implementation-leakage-validation', 'step-v-08-domain-compliance-validation', 'step-v-09-project-type-validation', 'step-v-10-smart-validation', 'step-v-11-holistic-quality-validation', 'step-v-12-completeness-validation']
-validationStatus: COMPLETE
-holisticQualityRating: '{rating from step 11}'
-overallStatus: '{Pass/Warning/Critical based on all findings}'
----
-```
-
-### 3. Create Summary of Findings
-
-**Overall Status:**
-- Determine from all validation findings
-- **Pass:** All critical checks pass, minor warnings acceptable
-- **Warning:** Some issues found but PRD is usable
-- **Critical:** Major issues that prevent PRD from being fit for purpose
-
-**Quick Results Table:**
-- Format: [classification]
-- Information Density: [severity]
-- Measurability: [severity]
-- Traceability: [severity]
-- Implementation Leakage: [severity]
-- Domain Compliance: [status]
-- Project-Type Compliance: [compliance score]
-- SMART Quality: [percentage]
-- Holistic Quality: [rating/5]
-- Completeness: [percentage]
-
-**Critical Issues:** List from all validation steps
-**Warnings:** List from all validation steps
-**Strengths:** List positives from all validation steps
-
-**Holistic Quality Rating:** From step 11
-**Top 3 Improvements:** From step 11
-
-**Recommendation:** Based on overall status
-
-### 4. Present Summary to User Conversationally
-
-Display:
-
-"**✓ PRD Validation Complete**
-
-**Overall Status:** {Pass/Warning/Critical}
-
-**Quick Results:**
-{Present quick results table with key findings}
-
-**Critical Issues:** {count or "None"}
-{If any, list briefly}
-
-**Warnings:** {count or "None"}
-{If any, list briefly}
-
-**Strengths:**
-{List key strengths}
-
-**Holistic Quality:** {rating}/5 - {label}
-
-**Top 3 Improvements:**
-1. {Improvement 1}
-2. {Improvement 2}
-3. {Improvement 3}
-
-**Recommendation:**
-{Based on overall status:
-- Pass: "PRD is in good shape. Address minor improvements to make it great."
-- Warning: "PRD is usable but has issues that should be addressed. Review warnings and improve where needed."
-- Critical: "PRD has significant issues that should be fixed before use. Focus on critical issues above."}
-
-**What would you like to do next?**"
-
-### 5. Present MENU OPTIONS
-
-Display:
-
-**[R] Review Detailed Findings** - Walk through validation report section by section
-**[E] Use Edit Workflow** - Use validation report with Edit workflow for systematic improvements
-**[F] Fix Simpler Items** - Immediate fixes for simple issues (anti-patterns, leakage, missing headers)
-**[X] Exit** - Exit and Suggest Next Steps.
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input after presenting menu
-- Only proceed based on user selection
-
-#### Menu Handling Logic:
-
-- **IF R (Review Detailed Findings):**
-  - Walk through validation report section by section
-  - Present findings from each validation step
-  - Allow user to ask questions
-  - After review, return to menu
-
-- **IF E (Use Edit Workflow):**
-  - Explain: "The Edit workflow can use this validation report to systematically address issues. Edit mode will guide you through discovering what to edit, reviewing the PRD, and applying targeted improvements."
-  - Offer: "Would you like to launch Edit mode now? It will help you fix validation findings systematically."
-  - If yes: Invoke the `bmad-edit-prd` skill, passing the validation report path as context
-  - If no: Return to menu
-
-- **IF F (Fix Simpler Items):**
-  - Offer immediate fixes for:
-    - Template variables (fill in with appropriate content)
-    - Conversational filler (remove wordy phrases)
-    - Implementation leakage (remove technology names from FRs/NFRs)
-    - Missing section headers (add ## headers)
-  - Ask: "Which simple fixes would you like me to make?"
-  - If user specifies fixes, make them and update validation report
-  - Return to menu
-
-- **IF X (Exit):**
-  - Display: "**Validation Report Saved:** {validationReportPath}"
-  - Display: "**Summary:** {overall status} - {recommendation}"
-  - PRD Validation complete. Invoke the `bmad-help` skill.
-  - Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow.on_complete` — if the resolved value is non-empty, follow it as the final terminal instruction before exiting.
-
-- **IF Any other:** Help user, then redisplay menu
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Complete validation report loaded successfully
-- All findings from steps 1-12 summarized
-- Report frontmatter updated with final status
-- Overall status determined correctly (Pass/Warning/Critical)
-- Quick results table presented
-- Critical issues, warnings, and strengths listed
-- Holistic quality rating included
-- Top 3 improvements presented
-- Clear recommendation provided
-- Menu options presented with clear explanations
-- User can review findings, get help, or exit
-
-### ❌ SYSTEM FAILURE:
-
-- Not loading complete validation report
-- Missing summary of findings
-- Not updating report frontmatter
-- Not determining overall status
-- Missing menu options
-- Unclear next steps
-
-**Master Rule:** User needs clear summary and actionable next steps. Edit workflow is best for complex issues; immediate fixes available for simpler ones.

src/bmm-skills/4-implementation/bmad-agent-dev/customize.toml

@@ -88,3 +88,8 @@ skill = "bmad-create-story"
 code = "ER"
 description = "Party mode review of all work completed across an epic"
 skill = "bmad-retrospective"
+
+[[agent.menu]]
+code = "IN"
+description = "Forensic case investigation with evidence-graded findings, calibrated to the input"
+skill = "bmad-investigate"

src/bmm-skills/4-implementation/bmad-investigate/SKILL.md

@@ -0,0 +1,194 @@
+---
+name: bmad-investigate
+description: Forensic case investigation with evidence-graded findings, calibrated to the input. Use when the user asks to investigate a bug, trace what caused an incident, walk through unfamiliar code, or build a mental model of a code area before working on it.
+---
+
+# Investigate
+
+## Overview
+
+Reconstruct what's happening, or what an unfamiliar area does, from the available evidence. Produce a structured case
+file another engineer can pick up cold. Calibrate continuously between defect-chasing (symptom-driven) and
+area-exploration (no symptom); the same discipline applies on both ends.
+
+**Args:** A ticket ID, log file path, diagnostic archive, error message, code area name, problem description, or a path
+to an existing case file. The last form resumes a prior investigation; everything else opens a new case.
+
+**Output:** `{implementation_artifacts}/{workflow.case_file_subdir}/{workflow.case_file_filename}`. Reference inputs
+are recorded; raw content is not read into the parent context until an outcome calls for it.
+
+`{slug}` is the ticket ID when one is provided, otherwise a short descriptive name agreed with the user, sanitized to
+lowercase alphanumeric with hyphens. On collision with an existing case file at the resolved path, ask whether to
+rename to `slug-YYYY-MM-DD.md` or resume the existing file (resuming routes to Outcome 0).
+
+After every outcome, present what was learned and pause for the user before continuing.
+
+## Principles
+
+- **Evidence grading.**
+  - **Confirmed.** Directly observed; cite `path:line`, log timestamp, or commit hash.
+  - **Deduced.** Logically follows from Confirmed evidence; show the chain.
+  - **Hypothesized.** Plausible but unconfirmed; state what would confirm or refute it.
+- **Stronghold first.** Anchor in one Confirmed piece of evidence and expand outward. Never start from a theory and
+  hunt for support. When evidence is sparse, switch to evidence-light mode (Outcome 1 branch).
+- **Challenge the premise.** The user's description is a hypothesis, not a fact. Verify independently; if evidence
+  contradicts, say so.
+- **Follow the evidence, not the narrative.** When evidence contradicts the working theory, update the theory — never
+  the other way around. Resist confirmation bias even when the user is convinced.
+- **Hypotheses are never deleted.** Update Status (Open / Confirmed / Refuted) and add a Resolution. Wrong turns are
+  part of the deliverable.
+- **Missing evidence is itself a finding.** Document the gap, what it would resolve, and how to obtain it.
+- **Write it down early.** Initialize the case file as soon as the slug is agreed; it is the persistent state across
+  interruptions.
+- **Path:line citations** use CWD-relative format, no leading `/`, so they're clickable in IDE-embedded terminals.
+- **Delegation discipline.** When a step requires reading 5+ files or any file >10K tokens, delegate to a subagent
+  that returns structured JSON only. Cite `path:line` from the result; don't re-read in the parent.
+- **Issue independent operations in parallel** (multi-grep, multi-read, parallel inventories) — one message, multiple
+  tool calls.
+- **Communication.** Evidence-first language ("the evidence shows", "unconfirmed, requires X to verify"). No hedging,
+  no narrative.
+
+## On Activation
+
+### Step 1: Resolve the workflow block
+
+Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`
+
+If the script fails, stop and surface the error.
+
+### Step 2: Execute prepend steps
+
+Run each entry in `{workflow.activation_steps_prepend}` in order.
+
+### Step 3: Load persistent facts
+
+Treat each entry in `{workflow.persistent_facts}` as foundational context. `file:` prefixes are paths or globs under
+`{project-root}` (load contents); other entries are facts verbatim.
+
+### Step 4: Load config
+
+Load `{project-root}/_bmad/bmm/config.yaml` and resolve `{user_name}`, `{communication_language}`,
+`{document_output_language}`, `{implementation_artifacts}`, `{project_knowledge}`. If `{implementation_artifacts}` is
+unresolved, fall back to `./investigations/` and surface the fallback before initializing.
+
+### Step 5: Greet
+
+Greet `{user_name}` in `{communication_language}`.
+
+### Step 6: Execute append steps
+
+Run each entry in `{workflow.activation_steps_append}` in order.
+
+### Step 7: Acknowledge and route
+
+Acknowledge the input as a reference (record paths and IDs; don't read raw content). Path to an existing case file →
+Outcome 0. Otherwise → Outcome 1.
+
+## Procedure
+
+### Outcome 0: Existing case is loaded and surfaced
+
+Read the case file. Surface, in order: open hypotheses (Status = Open) with their confirm/refute criteria; open
+backlog (Status ≠ Done); missing-evidence rows; last Conclusion with confidence. Ask which thread to pull. New
+evidence opens a new `## Follow-up: {YYYY-MM-DD}` block (append `#2`, `#3` on same-day reentry). Pause for user with the recap above; wait for direction.
+
+### Outcome 1: Scope and stronghold are established
+
+Acknowledge each input shape — record location, scope, time window only; bulk reads happen in Outcome 2.
+
+- **Issue tracker ticket.** Fetch full details via available MCP tools.
+- **Diagnostic archive.** Record path, file count, time window.
+- **Log file or stack trace.** Record path and time window; only the stack frame already in the user's message is in
+  scope here.
+- **Free-text description.** Capture verbatim; treat as hypothesis.
+- **Code area name** (no symptom). Record entry point.
+- **Recent commit area.** Record commit range.
+
+If the user arrived with a hypothesis, register it as Hypothesis #1. Find the stronghold *independently*; the user's
+hypothesis is one of the things the stronghold validates or refutes.
+
+Find a stronghold: a Confirmed piece of evidence (error message, function name, HTTP route, config parameter, test
+case). Anchor here.
+
+**Initialize `{case_file}` before branching.** The path is
+`{implementation_artifacts}/{workflow.case_file_subdir}/{workflow.case_file_filename}` with `{slug}` substituted (slug
+and collision rules in Overview). Create the file from `{workflow.case_file_template}` and fill Hand-off Brief
+(rough), Case Info, Problem Statement, initial Evidence Inventory.
+
+**Evidence-light branch.** When no Confirmed evidence is reachable: mark the case evidence-light in the Hand-off
+Brief; populate the Investigation Backlog with prioritized data-collection items; record "to make progress, I need one
+of: …"; pause for the user to provide evidence or authorize Outcome 2 to scan more broadly.
+
+Otherwise present scope, stronghold, file path, proposed approach. Pause for user with the recap above; wait for direction.
+
+### Outcome 2: Evidence perimeter is mapped
+
+Survey the scene: inventory available evidence in parallel across these independent categories: diagnostic archives;
+issue tracker; version control; test results; static analysis; source code. For any category exceeding ~10K tokens,
+delegate to a subagent that returns a JSON manifest (paths, sizes, time windows, key fragments cited as `path:line`).
+
+Classify each Available, Partial, or Missing — Missing is itself a finding. Update Evidence Inventory and Investigation
+Backlog. Pause for user with the recap above; wait for direction.
+
+### Outcome 3: Cause is reasoned about with discipline
+
+- **Trace causality.** Symptom-driven: trace backward from the symptom to producing conditions and the state that
+  emerged. Exploration: trace backward from outputs (returns, side effects, messages sent) to producing conditions.
+  Same technique, different anchor.
+- **Reconstruct the timeline** by cross-referencing logs, system events, version control, user observations.
+- **Form and test hypotheses.** State, identify confirming/refuting evidence, search, grade
+  (Confirmed / Refuted / Open). Update Status. Never delete.
+- **Refutation pass.** Each time a hypothesis transitions toward Confirmed, actively look for refuting evidence first.
+  Record the attempt in Resolution.
+- **Verify the user's premise.** If evidence contradicts, say so explicitly.
+- **Add discovered paths to the backlog.** Stay focused on the current thread.
+
+Update Confirmed Findings, Deduced Conclusions, Hypothesized Paths, Backlog, Timeline. Highlight contradictions to the
+original premise. Pause for user with the recap above; wait for direction.
+
+### Outcome 4: Source has been traced where it matters
+
+Issue these first-pass scans as parallel tool calls in one message: grep for exact error strings; glob the affected
+directory for parallel implementations; `git log` for recent changes.
+
+Then sequentially: read the surrounding code; follow the caller chain; watch for language and process boundary
+crossings (compiled→scripts, IPC, host→device, configuration flow).
+
+Lean by case type:
+
+- **Exploration:** I/O mapping (triggers, outputs, dependencies); frequent-terms scan; control-flow filtering
+  (branches, loops, error handling, state-machine transitions).
+- **Symptom-driven:** depth assessment — is the root cause reachable from local context, or is a broader area model
+  required? Surface escalations; never silently expand scope. Trivial-fix assessment — off-by-one, missing null check,
+  swapped argument → one-line code suggestion or draft diff in the report; non-trivial → stop at the root cause area.
+
+Investigation stops at the diagnosis; implementation is out of scope. Update Source Code Trace (Error origin, Trigger,
+Condition, Related files; area model when broader). Pause for user with the recap above; wait for direction.
+
+### Outcome 5: Report is finalized and the hand-off is clean
+
+Update `{case_file}`:
+
+- **Hand-off Brief** rewritten to final form (3 sentences, 15-second read).
+- **Final Conclusion** with confidence: **High** (Confirmed root cause, deterministic repro), **Medium** (Deduced;
+  minor uncertainty), **Low** (Hypothesized; clear data gap).
+- **Fix direction** when applicable (categorize by mechanism if multiple combine).
+- **Diagnostic steps** if uncertainty remains.
+- **Reproduction Plan** when applicable, or a verification plan for exploration cases.
+- **Status:** Active / Concluded / Blocked on evidence.
+
+Present the conclusion, then a concrete next-steps menu: trivial fix → `bmad-quick-dev`; scope/plan adjustment →
+`bmad-correct-course`; tracked story → `bmad-create-story`; fresh review → `bmad-code-review`. Recommend the
+highest-value action. Mitigations and workarounds are generated only on explicit request — investigation stops at the
+diagnosis. Execute `{workflow.on_complete}` if non-empty. Pause for user with the recap above; wait for direction.
+
+## Follow-up Iterations
+
+Continue work by appending to `{case_file}` under a new `## Follow-up: {YYYY-MM-DD}` block (`#2`, `#3` on same-day
+reentry). The investigation is complete when:
+
+- Root cause is Confirmed.
+- Root cause is Hypothesized with a clear data gap.
+- The mental model is sufficient for the user's stated goal (exploration cases).
+- The backlog contains only items requiring unavailable evidence.
+- The user explicitly concludes.

src/bmm-skills/4-implementation/bmad-investigate/customize.toml

@@ -0,0 +1,62 @@
+# DO NOT EDIT -- overwritten on every update.
+#
+# Workflow customization surface for bmad-investigate. Mirrors the
+# agent customization shape under the [workflow] namespace.
+
+[workflow]
+
+# --- Configurable below. Overrides merge per BMad structural rules: ---
+#   scalars: override wins • arrays (persistent_facts, activation_steps_*): append
+#   arrays-of-tables with `code`/`id`: replace matching items, append new ones.
+
+# Steps to run before the standard activation (config load, greet).
+# Overrides append. Use for pre-flight loads, compliance checks, etc.
+
+activation_steps_prepend = []
+
+# Steps to run after greet but before the workflow begins.
+# Overrides append. Use for context-heavy setup that should happen
+# once the user has been acknowledged.
+
+activation_steps_append = []
+
+# Persistent facts the workflow keeps in mind for the whole run.
+# Use for citation conventions (path:line vs path#L42), grading-scale
+# overrides (ITIL severity 1-5 instead of High/Medium/Low), tone
+# directives (engineering vs exec-facing), or compliance constraints
+# the case file must respect.
+# Distinct from the runtime memory sidecar — these are static context
+# loaded on activation. Overrides append.
+#
+# Each entry is either:
+#   - a literal sentence, e.g. "Use ITIL severity 1-5 instead of High/Medium/Low for confidence."
+#   - a file reference prefixed with `file:`, e.g. "file:{project-root}/docs/standards.md"
+#     (glob patterns are supported; the file's contents are loaded and treated as facts).
+
+persistent_facts = [
+  "file:{project-root}/**/project-context.md",
+]
+
+# Scalar: path to the case-file template, resolved from the skill root.
+# Override to point at an org-shaped template (compliance sections,
+# SLA fields, post-mortem hooks, ITIL fields).
+
+case_file_template = "references/case-file-template.md"
+
+# Scalar: subdirectory under {implementation_artifacts} where case files land.
+# Override for org taxonomies (forensics/, cases/, incidents/, bug-bash/).
+
+case_file_subdir = "investigations"
+
+# Scalar: filename pattern for new case files. {slug} expands to the
+# ticket ID or a short user-agreed name.
+
+case_file_filename = "{slug}-investigation.md"
+
+# Scalar: executed when the workflow finalizes the case file at Outcome 5,
+# after the conclusion is presented. Override wins. Use for post-case
+# automation: post the case to Slack/Teams, push fields back to ticketing,
+# link the case to a sprint, trigger a follow-up retro.
+# Leave empty for no custom post-completion behavior.
+
+on_complete = ""

src/bmm-skills/4-implementation/bmad-investigate/references/case-file-template.md

@@ -0,0 +1,127 @@
+# Investigation: {title}
+
+## Hand-off Brief
+
+1. **What happened.** {one-sentence problem statement, evidence-graded}
+2. **Where the case stands.** {status, last finding, what would unblock progress}
+3. **What's needed next.** {single recommended action with rationale}
+
+## Case Info
+
+| Field            | Value                                                                      |
+| ---------------- | -------------------------------------------------------------------------- |
+| Ticket           | {ticket-id or "N/A"}                                                       |
+| Date opened      | {date}                                                                     |
+| Status           | Active                                                                     |
+| System           | {OS, version, relevant environment details}                                |
+| Evidence sources | {diagnostic archive, logs, crash dump, code, version control, etc.}        |
+
+## Problem Statement
+
+{User-reported description; the initial claim. May be refined or contradicted by evidence.}
+
+## Evidence Inventory
+
+| Source   | Status                          | Notes     |
+| -------- | ------------------------------- | --------- |
+| {source} | {Available / Partial / Missing} | {details} |
+
+## Investigation Backlog
+
+| # | Path to Explore | Priority              | Status                                | Notes     |
+| - | --------------- | --------------------- | ------------------------------------- | --------- |
+| 1 | {description}   | {High / Medium / Low} | {Open / In Progress / Done / Blocked} | {context} |
+
+## Timeline of Events
+
+| Time        | Event               | Source                | Confidence            |
+| ----------- | ------------------- | --------------------- | --------------------- |
+| {timestamp} | {event description} | {log file, commit, …} | {Confirmed / Deduced} |
+
+## Confirmed Findings
+
+### Finding 1: {title}
+
+**Evidence:** {citation — `path:line`, log timestamp, or commit hash}
+
+**Detail:** {description}
+
+## Deduced Conclusions
+
+### Deduction 1: {title}
+
+**Based on:** {which Confirmed Findings}
+
+**Reasoning:** {logical chain}
+
+**Conclusion:** {what follows}
+
+## Hypothesized Paths
+
+### Hypothesis 1: {title}
+
+**Status:** {Open / Confirmed / Refuted}
+
+**Theory:** {description}
+
+**Supporting indicators:** {what makes this plausible}
+
+**Would confirm:** {specific evidence that would prove this}
+
+**Would refute:** {specific evidence that would disprove this}
+
+**Resolution:** {when Status changes from Open, what evidence settled it}
+
+## Missing Evidence
+
+| Gap              | Impact                               | How to Obtain   |
+| ---------------- | ------------------------------------ | --------------- |
+| {what's missing} | {what it would confirm or eliminate} | {how to get it} |
+
+## Source Code Trace
+
+| Element       | Detail                                      |
+| ------------- | ------------------------------------------- |
+| Error origin  | {file:line, function name}                  |
+| Trigger       | {what causes this code to execute}          |
+| Condition     | {what state produces the observed behavior} |
+| Related files | {other files in the same code path}         |
+
+## Conclusion
+
+**Confidence:** {High / Medium / Low}
+
+{Summary stating what is Confirmed vs. what remains Hypothesized. If a root cause is identified, state it; otherwise
+name the most promising hypothesized paths and what would resolve the remaining uncertainty.}
+
+## Recommended Next Steps
+
+### Fix direction
+
+{What needs to change and why. Categorize by mechanism when multiple issues combine.}
+
+### Diagnostic
+
+{Steps to confirm the root cause: additional logging, targeted tests, data to collect.}
+
+## Reproduction Plan
+
+{Setup, trigger, expected results. Scale from isolated proof to full system reproduction.}
+
+## Side Findings
+
+Tangential observations surfaced during the investigation, evidence-graded, with citation when applicable.
+
+- {observation}
+
+## Follow-up: {date}
+
+### New Evidence
+
+### Additional Findings
+
+### Updated Hypotheses
+
+### Backlog Changes
+
+### Updated Conclusion

src/bmm-skills/module-help.csv

@@ -1,4 +1,4 @@
-module,skill,display-name,menu-code,description,action,args,phase,after,before,required,output-location,outputs
+module,skill,display-name,menu-code,description,action,args,phase,preceded-by,followed-by,required,output-location,outputs
 BMad Method,_meta,,,,,,,,,false,https://docs.bmad-method.org/llms.txt,
 BMad Method,bmad-document-project,Document Project,DP,Analyze an existing project to produce useful documentation.,,,anytime,,,false,project-knowledge,*
 BMad Method,bmad-generate-project-context,Generate Project Context,GPC,Scan existing codebase to generate a lean LLM-optimized project-context.md. Essential for brownfield projects.,,,anytime,,,false,output_folder,project context
@@ -15,10 +15,8 @@ BMad Method,bmad-domain-research,Domain Research,DR,Industry domain deep dive su
 BMad Method,bmad-technical-research,Technical Research,TR,Technical feasibility architecture options and implementation approaches.,,,1-analysis,,,false,planning_artifacts|project_knowledge,research documents
 BMad Method,bmad-product-brief,Create Brief,CB,An expert guided experience to nail down your product idea in a brief. a gentler approach than PRFAQ when you are already sure of your concept and nothing will sway you.,,-A,1-analysis,,,false,planning_artifacts,product brief
 BMad Method,bmad-prfaq,PRFAQ Challenge,WB,Working Backwards guided experience to forge and stress-test your product concept to ensure you have a great product that users will love and need through the PRFAQ gauntlet to determine feasibility and alignment with user needs. alternative to product brief.,,-H,1-analysis,,,false,planning_artifacts,prfaq document
-BMad Method,bmad-create-prd,Create PRD,CP,Expert led facilitation to produce your Product Requirements Document.,,,2-planning,,,true,planning_artifacts,prd
+BMad Method,bmad-prd,Create Edit and Review PRD,PRD,"Facilitated PRD workflow — create a new PRD via coached discovery, update an existing one against a change signal, or validate a finished PRD against a checklist with an HTML findings report.",,,2-planning,bmad-product-brief,,true,planning_artifacts,prd
-BMad Method,bmad-validate-prd,Validate PRD,VP,,,[path],2-planning,bmad-create-prd,,false,planning_artifacts,prd validation report
+BMad Method,bmad-create-ux-design,Create UX,CU,"Guidance through realizing the plan for your UX, strongly recommended if a UI is a primary piece of the proposed project.",,,2-planning,bmad-prd,,false,planning_artifacts,ux design
-BMad Method,bmad-edit-prd,Edit PRD,EP,,,[path],2-planning,bmad-validate-prd,,false,planning_artifacts,updated prd
-BMad Method,bmad-create-ux-design,Create UX,CU,"Guidance through realizing the plan for your UX, strongly recommended if a UI is a primary piece of the proposed project.",,,2-planning,bmad-create-prd,,false,planning_artifacts,ux design
 BMad Method,bmad-create-architecture,Create Architecture,CA,Guided workflow to document technical decisions.,,,3-solutioning,,,true,planning_artifacts,architecture
 BMad Method,bmad-create-epics-and-stories,Create Epics and Stories,CE,,,,3-solutioning,bmad-create-architecture,,true,planning_artifacts,epics and stories
 BMad Method,bmad-check-implementation-readiness,Check Implementation Readiness,IR,Ensure PRD UX Architecture and Epics Stories are aligned.,,,3-solutioning,bmad-create-epics-and-stories,,true,planning_artifacts,readiness report
@@ -31,3 +29,4 @@ BMad Method,bmad-code-review,Code Review,CR,Story cycle: If issues back to DS if
 BMad Method,bmad-checkpoint-preview,Checkpoint,CK,Guided walkthrough of a change from purpose and context into details. Use for human review of commits branches or PRs.,,,4-implementation,,,false,,
 BMad Method,bmad-qa-generate-e2e-tests,QA Automation Test,QA,Generate automated API and E2E tests for implemented code. NOT for code review or story validation — use CR for that.,,,4-implementation,bmad-dev-story,,false,implementation_artifacts,test suite
 BMad Method,bmad-retrospective,Retrospective,ER,Optional at epic end: Review completed work lessons learned and next epic or if major issues consider CC.,,,4-implementation,bmad-code-review,,false,implementation_artifacts,retrospective
+BMad Method,bmad-investigate,Investigate,IN,Forensic case investigation calibrated to the input. Evidence-graded analysis with hypothesis tracking. Produces a structured case file.,,4-implementation,,,false,implementation_artifacts,investigation report

src/core-skills/bmad-customize/SKILL.md

@@ -48,7 +48,7 @@ If a team or user override already exists, read it first and summarize what's al
 
 **Cross-cutting intent — walk both surfaces with the user:**
 - Every workflow a given agent runs → agent surface (e.g. `bmad-agent-pm.toml` with `persistent_facts`, `principles`).
-- One workflow only → workflow surface (e.g. `bmad-create-prd.toml` with `activation_steps_prepend`).
+- One workflow only → workflow surface (e.g. `bmad-prd.toml` with `activation_steps_prepend`).
 - Several specific workflows → multiple workflow overrides in sequence, not an agent override.
 
 **Single-surface heuristic:**

src/core-skills/bmad-distillator/resources/distillate-format-reference.md

@@ -139,7 +139,7 @@ parts: 1
 
 ## Solution Architecture
 - Plugins: skill bundles with Anthropic plugin standard as base format + bmad-manifest.json extending for BMAD-specific metadata (installer options, capabilities, help integration, phase ordering, dependencies)
-- Existing manifest example: `{"module-code":"bmm","replaces-skill":"bmad-create-product-brief","capabilities":[{"name":"create-brief","menu-code":"CB","supports-headless":true,"phase-name":"1-analysis","after":["brainstorming"],"before":["create-prd"],"is-required":true}]}`
+- Existing manifest example: `{"module-code":"bmm","replaces-skill":"bmad-create-product-brief","capabilities":[{"name":"create-brief","menu-code":"CB","supports-headless":true,"phase-name":"1-analysis","preceded-by":["brainstorming"],"followed-by":["create-prd"],"is-required":true}]}`
 - Vercel skills CLI handles platform translation; integration pattern (wrap/fork/call) is PRD decision
 - bmad-setup: global skill scanning installed bmad-manifest.json files, registering capabilities, configuring project settings; always included as base skill in every bundle (solves bootstrapping)
 - bmad-update: plugin update path without full reinstall; technical approach (diff/replace/preserve customizations) is PRD decision

src/core-skills/bmad-help/SKILL.md

@@ -33,16 +33,16 @@ When this skill completes, the user should:
 The catalog uses this format:
 
 ```
-module,skill,display-name,menu-code,description,action,args,phase,after,before,required,output-location,outputs
+module,skill,display-name,menu-code,description,action,args,phase,preceded-by,followed-by,required,output-location,outputs
 ```
 
 **Phases** determine the high-level flow:
 - `anytime` — available regardless of workflow state
 - Numbered phases (`1-analysis`, `2-planning`, etc.) flow in order; naming varies by module
 
-**Dependencies** determine ordering within and across phases:
+**Sequencing** determines recommended ordering within and across phases (these are soft suggestions, not hard gates — see `required` for gating):
-- `after` — skills that should ideally complete before this one
+- `preceded-by` — skills that should ideally complete before this one
-- `before` — skills that should run after this one
+- `followed-by` — skills that should ideally run after this one
 - Format: `skill-name` for single-action skills, `skill-name:action` for multi-action skills
 
 **Required gates**:
@@ -59,8 +59,8 @@ module,skill,display-name,menu-code,description,action,args,phase,after,before,r
 ## Response Format
 
 For each recommended item, present:
-- `[menu-code]` **Display name** — e.g., "[CP] Create PRD"
+- `[menu-code]` **Display name** — e.g., "[PR] PRD"
-- Skill name in backticks — e.g., `bmad-create-prd`
+- Skill name in backticks — e.g., `bmad-prd`
 - For multi-action skills: action invocation context — e.g., "tech-writer lets create a mermaid diagram!"
 - Description if present in CSV; otherwise your existing knowledge of the skill suffices
 - Args if available

src/core-skills/module-help.csv

@@ -1,4 +1,4 @@
-module,skill,display-name,menu-code,description,action,args,phase,after,before,required,output-location,outputs
+module,skill,display-name,menu-code,description,action,args,phase,preceded-by,followed-by,required,output-location,outputs
 Core,_meta,,,,,,,,,false,https://docs.bmad-method.org/llms.txt,
 Core,bmad-brainstorming,Brainstorming,BSP,Use early in ideation or when stuck generating ideas.,,,anytime,,,false,{output_folder}/brainstorming,brainstorming session
 Core,bmad-party-mode,Party Mode,PM,Orchestrate multi-agent discussions when you need multiple perspectives or want agents to collaborate.,,,anytime,,,false,,

test/test-installation-components.js

@@ -285,6 +285,10 @@ async function runTests() {
     const opencodeInstaller = platformCodes.platforms.opencode?.installer;
 
     assert(opencodeInstaller?.target_dir === '.agents/skills', 'OpenCode target_dir uses native skills path');
+    assert(
+      opencodeInstaller?.commands_target_dir === '.opencode/commands',
+      'OpenCode commands_target_dir is configured for /<skill> slash commands',
+    );
 
     const tempProjectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'bmad-opencode-test-'));
     const installedBmadDir = await createTestBmadFixture();
@@ -301,6 +305,55 @@ async function runTests() {
     const skillFile = path.join(tempProjectDir, '.agents', 'skills', 'bmad-master', 'SKILL.md');
     assert(await fs.pathExists(skillFile), 'OpenCode install writes SKILL.md directory output');
 
+    // Command pointer assertions: a /<canonicalId> slash command should exist
+    // for each installed skill so users can invoke skills directly without
+    // going through the /skills menu.
+    const commandFile = path.join(tempProjectDir, '.opencode', 'commands', 'bmad-master.md');
+    assert(await fs.pathExists(commandFile), 'OpenCode install writes per-skill command pointer file');
+
+    const commandContent = await fs.readFile(commandFile, 'utf8');
+    assert(commandContent.includes('@skills/bmad-master'), 'Command pointer body references the skill via @skills/<canonicalId>');
+    assert(commandContent.includes('description:'), 'Command pointer carries a description in YAML frontmatter');
+
+    // Idempotency: re-running install must not duplicate or rewrite pointers.
+    const result2 = await ideManager.setup('opencode', tempProjectDir, installedBmadDir, {
+      silent: true,
+      selectedModules: ['bmm'],
+    });
+    assert(result2.success === true, 'Second OpenCode install succeeds (idempotent)');
+    assert(await fs.pathExists(commandFile), 'Command pointer survives a second install pass');
+
+    // Description-update propagation: when the manifest description changes
+    // and the on-disk pointer still matches the generator pattern, refresh
+    // the file so users see the updated description.
+    const csvPath = path.join(installedBmadDir, '_config', 'skill-manifest.csv');
+    const updatedCsv =
+      'canonicalId,name,description,module,path\n' +
+      '"bmad-master","bmad-master","UPDATED description for the test agent","core","_bmad/core/bmad-master/SKILL.md"\n';
+    await fs.writeFile(csvPath, updatedCsv);
+    const result3 = await ideManager.setup('opencode', tempProjectDir, installedBmadDir, {
+      silent: true,
+      selectedModules: ['bmm'],
+    });
+    assert(result3.success === true, 'Third OpenCode install succeeds after description update');
+    const refreshed = await fs.readFile(commandFile, 'utf8');
+    assert(refreshed.includes('UPDATED description'), 'Generator-shaped pointer is refreshed when manifest description changes');
+
+    // Hand-edit preservation across the production install flow. The
+    // installer passes previousSkillIds — without the cleanup-side spare,
+    // hand edits would be wiped here.
+    const SENTINEL = 'HAND_EDITED_BY_USER_SHOULD_SURVIVE';
+    const handEditedBody = `---\ndescription: my custom description\n---\n\n${SENTINEL}\n`;
+    await fs.writeFile(commandFile, handEditedBody);
+    const result4 = await ideManager.setup('opencode', tempProjectDir, installedBmadDir, {
+      silent: true,
+      selectedModules: ['bmm'],
+      previousSkillIds: new Set(['bmad-master']),
+    });
+    assert(result4.success === true, 'Fourth OpenCode install succeeds with hand-edited pointer present');
+    const afterReinstall = await fs.readFile(commandFile, 'utf8');
+    assert(afterReinstall.includes(SENTINEL), 'Hand-edited pointer survives a routine reinstall (cleanup spares active-manifest IDs)');
+
     await fs.remove(tempProjectDir);
     await fs.remove(path.dirname(installedBmadDir));
   } catch (error) {
@@ -504,10 +557,83 @@ async function runTests() {
     const copilotInstaller = platformCodes17.platforms['github-copilot']?.installer;
 
     assert(copilotInstaller?.target_dir === '.agents/skills', 'GitHub Copilot target_dir uses native skills path');
+    assert(
+      copilotInstaller?.commands_target_dir === '.github/agents',
+      'GitHub Copilot commands_target_dir is configured for the Custom Agents picker',
+    );
+    assert(copilotInstaller?.commands_extension === '.agent.md', 'GitHub Copilot uses .agent.md extension for Custom Agents files');
+    assert(
+      typeof copilotInstaller?.commands_body_template === 'string' && copilotInstaller.commands_body_template.includes('{canonicalId}'),
+      'GitHub Copilot defines a commands_body_template with {canonicalId} placeholder',
+    );
+    assert(
+      copilotInstaller?.commands_filter === 'agents-only',
+      'GitHub Copilot filters Custom Agents picker to persona agents only (agents-only)',
+    );
 
     const tempProjectDir17 = await fs.mkdtemp(path.join(os.tmpdir(), 'bmad-copilot-test-'));
     const installedBmadDir17 = await createTestBmadFixture();
 
+    // Extend the fixture to exercise the agents-only filter, which detects
+    // persona agents by the `[agent]` section in each skill's source
+    // customize.toml. Five skill types covered:
+    //
+    //   1. Persona agent — has customize.toml with [agent]      → INCLUDED
+    //   2. Persona with non-conventional id — also has [agent]   → INCLUDED
+    //      (verifies the filter doesn't depend on `-agent-` naming)
+    //   3. Meta-skill whose id contains `-agent-` but isn't a
+    //      persona — has customize.toml with [workflow]          → EXCLUDED
+    //      (mirrors `bmad-agent-builder` in the real manifest)
+    //   4. Workflow skill — no customize.toml at all             → EXCLUDED
+    //   5. `bmad-help` — meta-help skill with no customize.toml;
+    //      every persona agent's activation already advertises it,
+    //      so it's correctly excluded from the picker as redundant    → EXCLUDED
+    const fixtureCsvPath17 = path.join(installedBmadDir17, '_config', 'skill-manifest.csv');
+    await fs.writeFile(
+      fixtureCsvPath17,
+      [
+        'canonicalId,name,description,module,path',
+        '"bmad-master","bmad-master","Workflow with no customize.toml — should NOT appear in Copilot agents picker","core","_bmad/core/bmad-master/SKILL.md"',
+        '"bmad-agent-fixture","bmad-agent-fixture","Persona agent — customize.toml has [agent], SHOULD appear","core","_bmad/core/bmad-agent-fixture/SKILL.md"',
+        '"bmad-tea","bmad-tea","Non-conventional id but [agent] in customize.toml — SHOULD appear","core","_bmad/core/bmad-tea/SKILL.md"',
+        '"bmad-agent-builder","bmad-agent-builder","Skill-builder workflow — id contains -agent- but customize.toml has [workflow] — should NOT appear","core","_bmad/core/bmad-agent-builder/SKILL.md"',
+        '"bmad-help","bmad-help","Meta-help skill — no customize.toml; SHOULD NOT appear in agents picker (toml-driven filter)","core","_bmad/core/bmad-help/SKILL.md"',
+        '',
+      ].join('\n'),
+    );
+
+    // Materialise the source skill directories so the agents-only filter
+    // can read their customize.toml. The bmad-master and bmad-agent-builder
+    // SKILL.md files were already populated by createTestBmadFixture (they
+    // share the bmad-master target_dir layout); only the customize.toml
+    // and the new agent fixtures need to be created here.
+    for (const id of ['bmad-agent-fixture', 'bmad-tea', 'bmad-agent-builder', 'bmad-help']) {
+      const dir17 = path.join(installedBmadDir17, 'core', id);
+      await fs.ensureDir(dir17);
+      await fs.writeFile(
+        path.join(dir17, 'SKILL.md'),
+        ['---', `name: ${id}`, `description: fixture for ${id}`, '---', '', `Body of ${id}.`].join('\n'),
+      );
+    }
+    // Note: bmad-help intentionally has NO customize.toml — it exercises
+    // the toml-driven filter's exclusion path (a skill with no
+    // customize.toml is correctly kept out of the Copilot agents picker).
+    // [agent] customize.toml for the two persona fixtures.
+    await fs.writeFile(
+      path.join(installedBmadDir17, 'core', 'bmad-agent-fixture', 'customize.toml'),
+      ['[agent]', 'name = "Fixture Agent"', 'title = "Test Persona"', ''].join('\n'),
+    );
+    await fs.writeFile(
+      path.join(installedBmadDir17, 'core', 'bmad-tea', 'customize.toml'),
+      ['[agent]', 'name = "Murat"', 'title = "Test Architect"', ''].join('\n'),
+    );
+    // [workflow] customize.toml for the meta-skill — its id contains `-agent-`
+    // but it is NOT a persona (mirrors bmad-agent-builder in production).
+    await fs.writeFile(
+      path.join(installedBmadDir17, 'core', 'bmad-agent-builder', 'customize.toml'),
+      ['[workflow]', '', '# Meta-skill that builds agents but is not itself a persona.', ''].join('\n'),
+    );
+
     const copilotInstructionsPath17 = path.join(tempProjectDir17, '.github', 'copilot-instructions.md');
     await fs.ensureDir(path.dirname(copilotInstructionsPath17));
     await fs.writeFile(
@@ -543,6 +669,56 @@ async function runTests() {
       'GitHub Copilot setup preserves user content in copilot-instructions.md',
     );
 
+    // Custom Agents picker integration: persona agents (those with [agent]
+    // in their source customize.toml) get .agent.md files in
+    // .github/agents/. Workflows and meta-skills with [workflow] (or no
+    // customize.toml at all) do NOT — the agents-only filter keeps the
+    // picker uncluttered and the signal is naming-independent.
+    const agentsDir17 = path.join(tempProjectDir17, '.github', 'agents');
+    const agentFileForPersona17 = path.join(agentsDir17, 'bmad-agent-fixture.agent.md');
+    const agentFileForTea17 = path.join(agentsDir17, 'bmad-tea.agent.md');
+    const agentFileForWorkflow17 = path.join(agentsDir17, 'bmad-master.agent.md');
+    const agentFileForMetaSkill17 = path.join(agentsDir17, 'bmad-agent-builder.agent.md');
+    const agentFileForBmadHelp17 = path.join(agentsDir17, 'bmad-help.agent.md');
+
+    assert(
+      await fs.pathExists(agentFileForPersona17),
+      'Persona agent ([agent] in customize.toml) gets a .agent.md file in .github/agents/',
+    );
+    assert(await fs.pathExists(agentFileForTea17), 'Non-conventional id with [agent] in customize.toml is included (no allowlist needed)');
+    assert(!(await fs.pathExists(agentFileForWorkflow17)), 'Workflow skill (no customize.toml) is FILTERED OUT of .github/agents/');
+    assert(
+      !(await fs.pathExists(agentFileForBmadHelp17)),
+      'bmad-help is excluded from Copilot agents picker (no customize.toml; allowlist removed per maintainer feedback)',
+    );
+    assert(
+      !(await fs.pathExists(agentFileForMetaSkill17)),
+      'Meta-skill with -agent- in id but [workflow] in customize.toml is FILTERED OUT (signal is behavior, not naming)',
+    );
+
+    // Body content of the persona agent file: frontmatter description +
+    // LOAD pattern referencing the skill's SKILL.md path under target_dir.
+    const personaAgentContent17 = await fs.readFile(agentFileForPersona17, 'utf8');
+    assert(
+      personaAgentContent17.includes('description:'),
+      'Copilot agent pointer carries a description in YAML frontmatter (drives the agents picker label)',
+    );
+    assert(
+      personaAgentContent17.includes('{project-root}/.agents/skills/bmad-agent-fixture/SKILL.md'),
+      'Copilot agent pointer body resolves to the skill via LOAD {project-root}/<target_dir>/<id>/SKILL.md',
+    );
+
+    // Idempotency: re-running setup must not duplicate or rewrite the agent
+    // pointer when the source manifest is unchanged, AND must not start
+    // emitting workflow-skill agent files.
+    const result17b = await ideManager17.setup('github-copilot', tempProjectDir17, installedBmadDir17, {
+      silent: true,
+      selectedModules: ['bmm'],
+    });
+    assert(result17b.success === true, 'Second GitHub Copilot install succeeds (idempotent)');
+    assert(await fs.pathExists(agentFileForPersona17), 'Persona agent pointer survives a second install pass');
+    assert(!(await fs.pathExists(agentFileForWorkflow17)), 'Workflow skill remains filtered out of agents picker on second install');
+
     await fs.remove(tempProjectDir17);
     await fs.remove(path.dirname(installedBmadDir17));
   } catch (error) {
@@ -2737,6 +2913,113 @@ async function runTests() {
 
   console.log('');
 
+  // ============================================================
+  // Test Suite 40c: OpenCode command pointers in multi-IDE batches
+  // ============================================================
+  // Regression: when OpenCode is the *peer* in a setupBatch sharing
+  // .agents/skills (e.g. with openhands), the skill write is dedup-skipped
+  // but the per-IDE .opencode/commands/ pointers must still be generated.
+  // Symmetrically, partial uninstall while a peer remains must still clean
+  // up OpenCode's own command pointers.
+  console.log(`${colors.yellow}Test Suite 40c: OpenCode command pointers in shared-target batches${colors.reset}\n`);
+
+  try {
+    clearCache();
+    const platformCodes40c = await loadPlatformCodes();
+    const opencodeTarget40c = platformCodes40c.platforms.opencode?.installer?.target_dir;
+    const openhandsTarget40c = platformCodes40c.platforms.openhands?.installer?.target_dir;
+    assert(
+      opencodeTarget40c === '.agents/skills' && openhandsTarget40c === '.agents/skills',
+      'OpenCode and OpenHands share .agents/skills target_dir',
+    );
+
+    // Order A: opencode first → opencode is the writer.
+    const projA = await fs.mkdtemp(path.join(os.tmpdir(), 'bmad-opencode-batch-a-'));
+    const bmadA = await createTestBmadFixture();
+    const mgrA = new IdeManager();
+    await mgrA.ensureInitialized();
+    const resultsA = await mgrA.setupBatch(['opencode', 'openhands'], projA, bmadA, {
+      silent: true,
+      selectedModules: ['core'],
+    });
+    const cmdA = path.join(projA, '.opencode', 'commands', 'bmad-master.md');
+    assert(
+      resultsA.every((r) => r.success === true),
+      'opencode-first batch: all platforms succeed',
+    );
+    assert(await fs.pathExists(cmdA), 'opencode-first batch: command pointer is created');
+
+    // Order B: openhands first → opencode is the peer (skipTarget=true).
+    // Without the fix, the early-return would bypass installCommandPointers.
+    const projB = await fs.mkdtemp(path.join(os.tmpdir(), 'bmad-opencode-batch-b-'));
+    const bmadB = await createTestBmadFixture();
+    const mgrB = new IdeManager();
+    await mgrB.ensureInitialized();
+    const resultsB = await mgrB.setupBatch(['openhands', 'opencode'], projB, bmadB, {
+      silent: true,
+      selectedModules: ['core'],
+    });
+    const cmdB = path.join(projB, '.opencode', 'commands', 'bmad-master.md');
+    const opencodeResultB = resultsB.find((r) => r.ide === 'opencode');
+    assert(
+      resultsB.every((r) => r.success === true),
+      'openhands-first batch: all platforms succeed',
+    );
+    assert(
+      opencodeResultB?.handlerResult?.results?.sharedTargetHandledByPeer === true,
+      'openhands-first batch: opencode is marked sharedTargetHandledByPeer (skill write deduped)',
+    );
+    assert(await fs.pathExists(cmdB), 'openhands-first batch: command pointer is generated even when skill write is deduped');
+
+    // Cleanup symmetry: uninstall opencode while openhands remains.
+    // Uses an in-project bmadDir so the cleanup path can compute removalSet
+    // from the manifest (the production layout). The cross-temp-dir fixture
+    // above can't exercise this — same constraint Test Suite 40 documents.
+    const projC = await fs.mkdtemp(path.join(os.tmpdir(), 'bmad-opencode-batch-c-'));
+    const bmadC = path.join(projC, '_bmad');
+    await fs.ensureDir(path.join(bmadC, '_config'));
+    await fs.writeFile(
+      path.join(bmadC, '_config', 'skill-manifest.csv'),
+      'canonicalId,name,description,module,path\n' +
+        '"bmad-master","bmad-master","Minimal test agent fixture","core","_bmad/core/bmad-master/SKILL.md"\n',
+    );
+    const skillC = path.join(bmadC, 'core', 'bmad-master');
+    await fs.ensureDir(skillC);
+    await fs.writeFile(
+      path.join(skillC, 'SKILL.md'),
+      ['---', 'name: bmad-master', 'description: Minimal test agent fixture', '---', '', 'You are a test agent.'].join('\n'),
+    );
+
+    const mgrC = new IdeManager();
+    await mgrC.ensureInitialized();
+    await mgrC.setupBatch(['openhands', 'opencode'], projC, bmadC, {
+      silent: true,
+      selectedModules: ['core'],
+    });
+    const cmdC = path.join(projC, '.opencode', 'commands', 'bmad-master.md');
+    assert(await fs.pathExists(cmdC), 'in-project fixture: pointer is generated for opencode peer');
+
+    const cleanupResultsC = await mgrC.cleanupByList(projC, ['opencode'], {
+      silent: true,
+      remainingIdes: ['openhands'],
+    });
+    assert(cleanupResultsC[0].success !== false, 'opencode partial-uninstall reports success');
+    const sharedSurvivesC = await fs.pathExists(path.join(projC, '.agents', 'skills', 'bmad-master', 'SKILL.md'));
+    assert(sharedSurvivesC, 'shared .agents/skills/ survives partial uninstall (peer still uses it)');
+    assert(!(await fs.pathExists(cmdC)), 'opencode command pointer is removed on partial uninstall even when peer remains');
+
+    await fs.remove(projA).catch(() => {});
+    await fs.remove(path.dirname(bmadA)).catch(() => {});
+    await fs.remove(projB).catch(() => {});
+    await fs.remove(path.dirname(bmadB)).catch(() => {});
+    await fs.remove(projC).catch(() => {});
+  } catch (error) {
+    console.log(`${colors.red}Test Suite 40c setup failed: ${error.message}${colors.reset}`);
+    failed++;
+  }
+
+  console.log('');
+
   // ============================================================
   // Test Suite 41: Custom-module skill ownership (non-bmad prefix)
   // ============================================================