npm - bmad-plus - Versions diffs - 0.12.2 → 0.14.0 - Mend

bmad-plus 0.12.2 → 0.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (127) hide show

package/src/bmad-plus/packs/pack-dev-studio/categories/architecture/steps/step-07-validation.md CHANGED Viewed

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

package/src/bmad-plus/packs/pack-dev-studio/categories/architecture/steps/step-08-complete.md CHANGED Viewed

@@ -1,82 +1,17 @@
-# Step 8: Architecture Completion & Handoff
+# Architecture compatibility guide — hand off the design
-## MANDATORY EXECUTION RULES (READ FIRST):
+This retained path corresponds to procedure step 8 of
+[create-architecture](../create-architecture.md). Follow the common
+[execution guide](../../../shared/execution.md).
-- 🛑 NEVER generate content without user input
+Review the report for consistency between requirements, decisions, interfaces and
+delivery order. Keep actual validation results separate from proposed checks.
+Identify which decisions are accepted, provisional or superseded.
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
-- ✅ ALWAYS treat this as collaborative completion between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on successful workflow completion and implementation handoff
-- 🎯 PROVIDE clear next steps for implementation phase
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+State the first useful implementation slice, its acceptance path and any unresolved
+prerequisite. The report may be delivered as a draft when a consequential decision
+lacks evidence. Do not turn document completion into a claim of verified software.
-## EXECUTION PROTOCOLS:
-- 🎯 Show your analysis before taking any action
-- 🎯 Present completion summary and implementation guidance
-- 📖 Update frontmatter with final workflow state
-- 🚫 THIS IS THE FINAL STEP IN THIS WORKFLOW
-## YOUR TASK:
-Complete the architecture workflow, provide a comprehensive completion summary, and guide the user to the next phase of their project development.
-## COMPLETION SEQUENCE:
-### 1. Congratulate the User on Completion
-Both you and the User completed something amazing here - give a summary of what you achieved together and really congratulate the user on a job well done.
-### 2. Update the created document's frontmatter
-```yaml
-stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]
-workflowType: 'architecture'
-lastStep: 8
-status: 'complete'
-completedAt: '{{current_date}}'
-```
-### 3. Next Steps Guidance
-Architecture complete. Invoke the `bmad-help` skill.
-Upon Completion of task output: offer to answer any questions about the Architecture Document.
-## SUCCESS METRICS:
-✅ Complete architecture document delivered with all sections
-✅ All architectural decisions documented and validated
-✅ Implementation patterns and consistency rules finalized
-✅ Project structure complete with all files and directories
-✅ User provided with clear next steps and implementation guidance
-✅ Workflow status properly updated
-✅ User collaboration maintained throughout completion process
-## FAILURE MODES:
-❌ Not providing clear implementation guidance
-❌ Missing final validation of document completeness
-❌ Not updating workflow status appropriately
-❌ Failing to celebrate the successful completion
-❌ Not providing specific next steps for the user
-❌ Rushing completion without proper summary
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-## WORKFLOW COMPLETE:
-This is the final step of the Architecture workflow. The user now has a complete, validated architecture document ready for AI agent implementation.
-The architecture will serve as the single source of truth for all technical decisions, ensuring consistent implementation across the entire project development lifecycle.
-## On Complete
-<!-- Adapted for BMAD+: original script dependency removed -->
-If the resolved `workflow.on_complete` is non-empty, follow it as the final terminal instruction before exiting.
+Preserve human additions and provide the changed artifact locations. Continuation
+starts by comparing current inputs with this handoff, then resumes the earliest
+affected work. This path does not commit, publish or start another workflow.

package/src/bmad-plus/packs/pack-dev-studio/categories/implementation/checkpoint-preview.md CHANGED Viewed

@@ -1,68 +1,55 @@
----
+---
 name: bmad-checkpoint-preview
-description: 'LLM-assisted human-in-the-loop review. Make sense of a change, focus attention where it matters, test. Use when the user says "checkpoint", "human review", or "walk me through this change".'
+description: Prepare a focused walkthrough of a change with actual evidence and explicit review decisions.
 ---
-# Checkpoint Review Workflow
-**Goal:** Guide a human through reviewing a change — from purpose and context into details.
-**Your Role:** You are assisting the user in reviewing a change.
-## Conventions
-- Bare paths (e.g. `step-01-orientation.md`) resolve from the skill root.
-- `this skill directory` resolves to this skill's installed directory (where `agent configuration` lives).
-- `{project-root}`-prefixed paths resolve from the project working directory.
-- `{skill-name}` resolves to the skill directory's basename.
-## On Activation
-### Step 1: Resolve the Workflow Block
-<!-- Adapted for BMAD+: original script dependency removed -->
-**If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver:
-1. `this skill file` — defaults
-2. `{project-root}/custom/{skill-name}.toml` — team overrides
-3. `{project-root}/custom/{skill-name}.user.toml` — personal overrides
-Any missing file is skipped. Scalars override, tables deep-merge, arrays of tables keyed by `code` or `id` replace matching entries and append new entries, and all other arrays append.
-### Step 2: Execute Prepend Steps
-Execute each entry in `{workflow.activation_steps_prepend}` in order before proceeding.
-### Step 3: Load Persistent Facts
-Treat every entry in `{workflow.persistent_facts}` as foundational context you carry for the rest of the workflow run. Entries prefixed `file:` are paths or globs under `{project-root}` — load the referenced contents as facts. All other entries are facts verbatim.
-### Step 4: Load Config
-Load config from `{project-root}/project config` and resolve:
-- `implementation_artifacts`
-- `planning_artifacts`
-- `communication_language`
-- `document_output_language`
-### Step 5: Greet the User
-Greet the user, 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.
-## Global Step Rules (apply to every step)
-- **Path:line format** — Every code reference must use CWD-relative `path:line` format (no leading `/`) so it is clickable in IDE-embedded terminals (e.g., `src/auth/middleware.ts:42`).
-- **Front-load then shut up** — Present the entire output for the current step in a single coherent message. Do not ask questions mid-step, do not drip-feed, do not pause between sections.
-- **Language** — Speak in `{communication_language}`. Write any file output in `{document_output_language}`.
-## FIRST STEP
-Read fully and follow `./step-01-orientation.md` to begin.
+# Checkpoint preview
+Read the [execution guide](../../shared/execution.md) and
+[Oholiab's role](dev-agent.md).
+## Inputs
+A change artifact or request identifying the work to preview. Inspect the actual
+diff, intended behavior and available verification results. Establish the
+revision or working-tree state the preview describes.
+## Procedure
+1. Identify the reviewer's decision and the changed user or system behavior.
+   Read the relevant implementation and existing checks. Separate a requested
+   walkthrough from approval to publish, merge or modify the product.
+2. Select the few paths that best demonstrate acceptance and consequential
+   failure behavior. Explain the prior and current behavior using actual inputs
+   and outputs, not an invented demo scenario presented as executed evidence.
+3. Prepare a reproducible local preview using the project's existing commands
+   and suitable test data. Check what those commands do before running them.
+   Execute within the task's scope and avoid exposing credentials or user data.
+4. Inspect the preview with the host capabilities that exist. For a UI, check
+   relevant interaction, states and accessibility with an actual browser when
+   available. For a CLI or API, show observed results. If execution is unavailable,
+   provide source-backed guidance and label runtime behavior unreviewed.
+5. Show the evidence and focus attention on meaningful decisions, tradeoffs or
+   residual uncertainty. State which acceptance criteria were exercised and which
+   remain unverified. A screenshot alone does not establish interaction behavior.
+6. Record feedback and the resulting action. Apply follow-up changes already
+   authorized by the user, then refresh affected evidence. If an essential new
+   decision is required, preserve the preview as reviewable work while that
+   dependent action waits.
+## Output and acceptance
+Write the report for checkpoint-preview with baseline, review purpose, setup and
+reproduction steps, observed before/after behavior, evidence locations, unresolved
+checks and decisions. Include actual preview URLs only when a running or deployed
+preview exists; state its limitations and lifetime when known.
+The result is useful when another reviewer can understand the change and reproduce
+the relevant checks. Record an actual approval only when the authorized reviewer
+gave it; absence of feedback is not approval.
+## Continue
+Compare the current revision with the preview baseline. Rebuild or rerun affected
+scenarios after changes and preserve prior feedback. Do not reuse screenshots,
+test results or approval for behavior that changed after they were recorded.