siesa-agents 2.1.78 → 2.1.80

package/claude/skills/bmad-validate-prd/steps-v/step-v-05-measurability-validation.md

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

package/claude/skills/bmad-validate-prd/steps-v/step-v-06-traceability-validation.md

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

package/claude/skills/bmad-validate-prd/steps-v/step-v-07-implementation-leakage-validation.md

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