ma-agents 3.4.8 → 3.5.0

package/lib/bmad-extension/skills/generate-backlog/SKILL.md

@@ -1,182 +1,194 @@
 ---
 name: generate-backlog
-description: Generate or refresh a flat backlog.yaml from epics and bug stories, preserving existing priority and sprint assignments
+description: Generate or refresh the backlog section of sprint-status.yaml from epics and bug stories, preserving existing priorities and sprint assignments
 type: skill
 triggers:
   - "generate backlog"
   - "refresh backlog"
+  - "update backlog"
 ---
 
-# Generate Backlog Workflow
+# Generate Backlog
 
-Generate or refresh a flat `backlog.yaml` from epic stories and bug reports. Preserves existing priority and sprint assignments, appends new items, removes stale items, and re-numbers priorities 1..N.
+Generate or refresh the `backlog` section of `sprint-status.yaml` from epics and bug story files, while preserving existing sprint assignments and priorities.
+
+## Purpose
+
+This skill reads `epics.md` and `bug-*.md` files and writes the `backlog` and `epics` sections of `sprint-status.yaml`. The `sprints` section is preserved unchanged. This implements the single-source-of-truth model from Architecture Decision P2-11: all unassigned stories and bugs live in the `backlog` section of the unified file.
+
+**Output target:** `{sprint_management_path}/_bmad-output/implementation-artifacts/sprint-status.yaml` (`backlog` and `epics` sections only — `sprints` section is preserved unchanged)
+**Never writes:** A standalone `backlog.yaml` file.
+**Path resolution:** Use `_bmad/bmm/config.yaml` → `sprint_management_path` to resolve the project root. If not set, default to the project root.
+
+---
 
 <workflow>
 
-<step n="1" goal="Load sources">
-  <action>Read `_bmad-output/planning-artifacts/epics.md` — this is the master list of epics with their stories.</action>
-  <check if="epics.md does not exist">
-    <output>**Error:** `_bmad-output/planning-artifacts/epics.md` not found. Cannot generate backlog without an epics file.</output>
+<step n="1" goal="Resolve paths and load existing sprint-status.yaml state">
+  <action>Read `_bmad/bmm/config.yaml` to resolve `sprint_management_path` (default: project root if not set)</action>
+  <action>Resolve the sprint-status file path: `{sprint_management_path}/_bmad-output/implementation-artifacts/sprint-status.yaml`</action>
+  <action>Resolve the epics file path: `{sprint_management_path}/_bmad-output/planning-artifacts/epics.md`</action>
+  <action>Resolve the bug files glob: `{sprint_management_path}/_bmad-output/implementation-artifacts/bug-*.md`</action>
+  <action>Resolve the done archive path: `{sprint_management_path}/_bmad-output/implementation-artifacts/done/`</action>
+
+  <check if="sprint-status.yaml does not exist">
+    <output>ERROR: `sprint-status.yaml` not found at `{resolved_path}`. Run `/bmad-sprint-planning` first to bootstrap the file before using `generate-backlog`.</output>
     <action>Exit workflow</action>
   </check>
 
-  <action>Glob `_bmad-output/implementation-artifacts/bug-*.md` to discover all bug story files.</action>
-  <action>Store the list of bug files as {{bug_files}} (may be empty — zero bugs is valid).</action>
-
-  <action>Read `_bmad-output/implementation-artifacts/sprint-status.yaml` if it exists — this provides the current status of each story (done, in-progress, backlog, etc.).</action>
-  <action>Store the status map as {{status_map}} (keyed by story id). If the file does not exist, use an empty map.</action>
-
-  <action>Read `_bmad-output/implementation-artifacts/backlog.yaml` if it exists — this is the existing backlog to merge with.</action>
-  <action>Store the existing backlog items as {{existing_items}} (list). If the file does not exist, use an empty list.</action>
+  <action>Read and parse `sprint-status.yaml`</action>
+  <action>Parse the `sprints` section (map keyed by sprint-N). For each sprint, collect all item IDs from the sprint's `items` array. Build {{sprint_item_ids}} = flat set of all item IDs across ALL sprints (planning, active, and closed).</action>
+  <action>Parse the `backlog` section (array). Build {{existing_backlog_map}} = map from item ID to the full item object (to preserve priority and status during merge).</action>
+  <action>Preserve the top-level metadata fields: {{generated}}, {{project}}, {{project_key}}, {{tracking_system}}, {{story_location}}</action>
+  <action>Preserve the full {{sprints}} section verbatim (passed through unchanged on write)</action>
+  <action>Preserve the existing {{epics}} section for status/retrospective merge in Step 7</action>
+</step>
 
-  <output>
-**Sources loaded:**
-- epics.md: found
-- Bug files: {{bug_files | length}} file(s)
-- sprint-status.yaml: {{status_map exists ? "found" : "not found (empty status)"}}
-- Existing backlog.yaml: {{existing_items | length}} item(s)
-  </output>
+<step n="2" goal="Build done-items exclusion set from done/ archive">
+  <action>List files in `{sprint_management_path}/_bmad-output/implementation-artifacts/done/` matching `*.md`</action>
+  <action>For each file found, derive the item ID from the filename (strip `.md` extension, use basename)</action>
+  <action>Build {{done_item_ids}} = set of all archived item IDs</action>
+  <check if="no done/ files found">
+    <action>Set {{done_item_ids}} = empty set</action>
+  </check>
 </step>
 
-<step n="2" goal="Extract stories from epics">
-  <action>Parse `epics.md` to extract every story from every epic. Each epic is a level-2 heading (`## Epic N: ...`) and each story within it is a level-3 heading (`### Story N.M: ...`) or a list item following the pattern `- **Story N.M:** Title` or `- N.M: Title`.</action>
-
-  <action>For each story found:
-    - Derive {{story_id}} as a kebab-case slug: `"{epic_number}-{story_number}-{title_slug}"` (e.g., `"5-5-explicit-parameter-passing"`)
-      - Title slug: lowercase, replace spaces/underscores with hyphens, remove non-alphanumeric/non-hyphen characters, collapse consecutive hyphens, trim leading/trailing hyphens
-    - Set {{epic}} to the epic number (integer)
-    - Set {{title}} to the story title text
-    - Look up status from {{status_map}} using the story identifier. If found and status is `done`, skip this story (exclude from backlog). If found, use that status. If not found, default to `backlog`.
-    - Set {{type}} = `story`
-    - Set {{severity}} = `null`
-    - Set {{sprint}} = `null`
-    - Set {{priority}} = `null` (will be assigned during merge/sort)
+<step n="3" goal="Extract stories from epics.md">
+  <action>Read `{resolved_epics_path}`</action>
+  <check if="file does not exist">
+    <output>WARNING: `epics.md` not found at `{resolved_epics_path}`. No stories will be extracted from epics. Continuing with bug-only backlog.</output>
+    <action>Set {{epic_stories}} = [] and {{parsed_epics}} = []</action>
+  </check>
+  <action>Parse epics.md to extract:
+    - Each epic: epic number (N from "Epic N" header), epic title, epic status (if present in the file)
+    - Each story under each epic: story number (M from "Story N.M" format), story title
   </action>
-
-  <action>Store the extracted stories as {{extracted_stories}} list.</action>
-  <output>Extracted {{extracted_stories | length}} active stories from epics (done items excluded).</output>
+  <action>For each story, generate the kebab-case item ID: `{epic_number}-{story_number}-{title-slug}` where title-slug is the title lowercased, spaces replaced with hyphens, non-alphanumeric characters (except hyphens) removed, consecutive hyphens collapsed</action>
+  <action>Exclude stories whose derived ID is in {{sprint_item_ids}} (already assigned to a sprint)</action>
+  <action>Exclude stories whose derived ID is in {{done_item_ids}} (archived)</action>
+  <action>Store remaining stories as {{epic_stories}} — list of objects with: id, epic (integer), title, type="story", severity=null</action>
+  <action>Store parsed epics as {{parsed_epics}} — list of objects with: epic_id (e.g., "epic-5"), epic_number (integer), title</action>
 </step>
 
-<step n="3" goal="Extract bugs">
-  <action>For each file in {{bug_files}}:
-    - Read the file and parse the YAML frontmatter (between `---` delimiters)
-    - Extract `title`, `severity`, and `status` from frontmatter
-    - Derive {{bug_id}} from the **filename**, not the title: strip the `bug-` prefix and `.md` extension, then uppercase to `"BUG-{slug}"` (e.g., `bug-login-crash.md` → `BUG-login-crash`)
-    - Use `status` from frontmatter directly (bugs track their own status). If `status` is missing, default to `backlog`. If status is `done`, skip this bug (exclude from backlog).
-    - Build a backlog item:
-      - id: {{bug_id}}
-      - type: `bug`
-      - epic: `null`
-      - title: {{title}}
-      - priority: `null` (assigned during merge/sort)
-      - status: {{frontmatter_status or "backlog"}}
-      - sprint: `null`
-      - severity: {{severity}}
+<step n="4" goal="Extract bugs from bug-*.md files">
+  <action>Glob `{resolved_bug_glob}` to discover all bug story files</action>
+  <check if="no bug files found">
+    <action>Set {{bug_stories}} = []</action>
+  </check>
+  <action>For each bug file found:
+    - Parse YAML frontmatter to extract: `id` (or derive from filename), `title`, `severity` (critical/high/medium/low), `status`
+    - If `id` is not in frontmatter, derive from filename: strip `bug-` prefix and `.md` extension, prefix with `BUG-`
+    - If `status` is not in frontmatter, default to `backlog`
+    - Exclude bugs whose ID is in {{sprint_item_ids}} or {{done_item_ids}}
+    - Create bug item: {id, type="bug", epic=null, title, severity, status}
   </action>
-
-  <action>Store the extracted bugs as {{extracted_bugs}} list.</action>
-  <output>Extracted {{extracted_bugs | length}} active bugs (done items excluded).</output>
+  <action>Store as {{bug_stories}}</action>
 </step>
 
-<step n="4" goal="Merge with existing backlog">
-  <action>Combine {{extracted_stories}} and {{extracted_bugs}} into {{new_items}} list.</action>
+<step n="5" goal="Merge with existing backlog — preserve priorities, detect orphans">
+  <action>Build {{all_source_ids}} = set of all IDs from {{epic_stories}} + {{bug_stories}}</action>
 
-  <action>Build a lookup map from {{existing_items}} keyed by `id`.</action>
+  <action>**Orphan detection:** For each item in {{existing_backlog_map}} whose ID is NOT in {{all_source_ids}} AND NOT in {{sprint_item_ids}} AND NOT in {{done_item_ids}}:
+    - Flag the item as orphaned
+    - Collect orphaned items in {{orphaned_items}} list
+    - Keep the orphaned item in the backlog (do NOT auto-remove — human review required)
+  </action>
 
-  <action>For each item in {{new_items}}:
-    - If an item with the same `id` exists in {{existing_items}}:
-      - **Preserve** the existing `priority` value
-      - **Preserve** the existing `sprint` assignment
-      - **Update** `status` from the freshly extracted value (which may reflect sprint-status.yaml changes)
-      - **Update** `title`, `type`, `epic`, `severity` from the freshly extracted values (source of truth)
-    - If no matching item exists in {{existing_items}}:
-      - This is a new item — keep all freshly extracted values
-      - Set `priority` to `null` (will be placed at the end during sort)
+  <action>**New item detection:** For each item in {{epic_stories}} and {{bug_stories}} whose ID is NOT in {{existing_backlog_map}}:
+    - Assign status = "backlog"
+    - Mark as new in {{new_items}} list
   </action>
 
-  <action>Identify stale items: any item in {{existing_items}} whose `id` does NOT appear in {{new_items}}. These items no longer exist in the source files and should be removed.</action>
+  <action>**Existing item preservation:** For each item in {{epic_stories}} and {{bug_stories}} whose ID IS in {{existing_backlog_map}}:
+    - Preserve the existing item's `priority` and `status` values from {{existing_backlog_map}}
+    - Update title from the source file (in case it was renamed)
+  </action>
 
-  <action>Store the final merged list as {{merged_items}}.</action>
-  <action>Store the count of new items added as {{new_count}}.</action>
-  <action>Store the count of stale items removed as {{stale_count}}.</action>
-  <action>Store the count of preserved items as {{preserved_count}}.</action>
+  <action>Assemble {{merged_items}} = all items from {{epic_stories}} (with preserved or new priority/status) + all items from {{bug_stories}} (with preserved or new priority/status) + all items from {{orphaned_items}} (with existing priority/status preserved)</action>
 
-  <output>
-**Merge results:**
-- Preserved (existing): {{preserved_count}}
-- New items added: {{new_count}}
-- Stale items removed: {{stale_count}}
-  </output>
+  <action>**Backlog-sprint conflict detection:** Set {{backlog_sprint_conflicts}} = list of items that were in {{existing_backlog_map}} AND in {{sprint_item_ids}} (items found in both the backlog and a sprint — data integrity violation corrected by removing them from the backlog; sprint assignment takes precedence)</action>
 </step>
 
-<step n="5" goal="Write backlog.yaml">
-  <action>Sort {{merged_items}} for final output:
-    1. Items WITH an existing numeric `priority` come first, sorted ascending by priority
-    2. Items WITHOUT a priority (`null`) come after, sorted by:
-       a. `type`: bugs before stories (bugs get priority attention)
-       b. `severity` for bugs: critical > high > medium > low
-       c. `epic` number ascending for stories (lower epics first)
-       d. `id` alphabetically as final tiebreaker
+<step n="6" goal="Sort and renumber backlog items by priority">
+  <action>Sort {{merged_items}} by the following criteria (most important first):
+    1. **Critical bugs first:** Items with type="bug" AND severity="critical" rank highest
+       - Among critical bugs: existing items ordered by their current priority (ascending); new critical bugs ordered by their position in the discovered bug file list (alphabetical by filename)
+    2. **Explicit priority (preserved from existing backlog):** Items that existed in the previous backlog are ranked by their preserved priority value (lower number = higher rank)
+    3. **New items by epic order:** New items (not in existing backlog) are ranked by their epic number (ascending), then by story number within the epic (ascending)
+    4. **Bugs without explicit priority:** New bugs (not in existing backlog) are appended after all stories, sorted by severity (high → medium → low → null)
+    5. **Orphaned items:** Orphaned items are appended last, maintaining their relative order
   </action>
+  <action>Re-number priorities sequentially: assign priority = 1 to the first item, priority = 2 to the second, etc. (position 0 in array = priority 1)</action>
+  <action>Store as {{sorted_backlog}}</action>
+</step>
 
-  <action>Re-number priorities sequentially 1..N across all items in the sorted list.</action>
-
-  <action>Get current ISO timestamp as {{generated_at}}.</action>
-
-  <action>Write `_bmad-output/implementation-artifacts/backlog.yaml` with this structure:
-
-```yaml
-# Flat Backlog — auto-generated by generate-backlog
-# Generated: {{generated_at}}
-# Total items: {{merged_items | length}}
-#
-# Schema per item:
-#   id, type, epic, title, priority, status, sprint, severity
-
-backlog:
-  - id: "5-5-explicit-parameter-passing"
-    type: story
-    epic: 5
-    title: "Explicit Parameter Passing"
-    priority: 1
-    status: backlog
-    sprint: null
-    severity: null
-  # ... remaining items ...
-```
-
-  **YAML output rules:**
-  - Always quote `id` and `title` fields (they contain hyphens and special characters)
-  - `epic` is an integer for stories, `null` for bugs
-  - `sprint` is a string like `"sprint-3"` if assigned, or `null`
-  - `severity` is a string (`critical`, `high`, `medium`, `low`) for bugs, `null` for stories
-  - `status` is one of: `backlog`, `ready-for-dev`, `in-progress`, `review` (done items excluded)
-  - `priority` is always a positive integer (1 = highest priority)
-  - Use 2-space indentation for YAML
+<step n="7" goal="Build refreshed epics section">
+  <action>For each epic in {{parsed_epics}}:
+    - Look up the epic in the existing {{epics}} section by key (e.g., "epic-5")
+    - If the epic already exists: preserve its `status` and `retrospective` values. Do NOT downgrade status (e.g., if existing status is "in-progress" and the source implies "backlog", keep "in-progress").
+    - If the epic is new (not in existing epics): set status = "backlog", retrospective = "optional"
   </action>
+  <action>Build {{refreshed_epics}} = map of all epics from the existing file PLUS any newly discovered epics. Existing epics not present in parsed_epics are preserved unchanged (do not remove epics — they may be in-progress or done).</action>
+</step>
 
-  <output>Backlog written to `_bmad-output/implementation-artifacts/backlog.yaml` with {{merged_items | length}} items.</output>
+<step n="8" goal="Write sprint-status.yaml atomically">
+  <action>Assemble the complete file content:
+    1. Preserve top-level metadata: `generated`, `project`, `project_key`, `tracking_system`, `story_location` (unchanged)
+    2. Set `last_updated` = current ISO-8601 datetime string (e.g., "2026-04-06T10:00:00Z")
+    3. Write `epics` section from {{refreshed_epics}}
+    4. Write `backlog` section from {{sorted_backlog}} (array, ordered by priority)
+    5. Write `sprints` section from the preserved {{sprints}} section (verbatim, NO changes)
+  </action>
+  <action>Validate before writing:
+    - Every backlog item has all 7 required fields: id, type, epic, title, priority, status, severity
+    - priority values are sequential starting from 1 and match array position
+    - No item ID appears in both backlog and any sprint's items array (single-location invariant)
+    - Every epic has both status and retrospective fields
+  </action>
+  <action>Write the assembled content to `{resolved_sprint_status_path}` as a single atomic write (read-modify-write pattern)</action>
 </step>
 
-<step n="6" goal="Report summary">
+<step n="9" goal="Report summary">
   <output>
-## Backlog Generation Complete
-
-| Metric              | Count |
-|----------------------|-------|
-| Total items          | {{merged_items | length}} |
-| Stories              | {{story_count}} |
-| Bugs                 | {{bug_count}} |
-| New items added      | {{new_count}} |
-| Stale items removed  | {{stale_count}} |
-| Items preserved      | {{preserved_count}} |
-
-**Output:** `_bmad-output/implementation-artifacts/backlog.yaml`
-
-**Next Steps:**
-- Review priorities — new items are appended at the end; reorder as needed
-- Use `/add-to-sprint` to assign high-priority items to the current sprint
-- Use `/sprint-status-view` to see sprint progress
+## Generate Backlog — Complete
+
+**Backlog section refreshed in `sprint-status.yaml`**
+
+| Metric | Count |
+|--------|-------|
+| Total stories from epics.md | {{epic_story_count}} |
+| Total bugs from bug-*.md | {{bug_count}} |
+| New items added to backlog | {{new_items_count}} |
+| Existing items preserved | {{preserved_count}} |
+| Items excluded (sprint-assigned) | {{sprint_excluded_count}} |
+| Items excluded (archived in done/) | {{done_excluded_count}} |
+| Items corrected (removed from backlog — already in sprint) | {{backlog_sprint_conflicts.length}} |
+| Total backlog items | {{total_backlog_count}} |
+
+{{#if backlog_sprint_conflicts}}
+⚠️ **Data integrity corrections:**
+The following items were found in both the backlog and a sprint. They have been removed from the backlog (sprint assignment takes precedence):
+{{#each backlog_sprint_conflicts}}
+- {{id}} — {{title}}
+{{/each}}
+
+{{/if}}
+{{#if orphaned_items}}
+### Orphaned Items (WARNING — Human Review Required)
+
+The following items exist in the backlog but were NOT found in `epics.md` or any `bug-*.md` file. They have been kept in the backlog but should be reviewed:
+
+{{#each orphaned_items}}
+- `{{id}}` — {{title}} (priority: {{priority}}, status: {{status}})
+{{/each}}
+
+These items may represent: renamed stories, deleted epics, or manually added items. Remove them manually if they are no longer needed.
+{{/if}}
+
+**Next steps:**
+- Use `/prioritize-backlog` to reorder items
+- Use `/add-to-sprint` to assign items to a sprint
+- Use `/bmad-sprint-planning` to plan a full sprint
   </output>
 </step>
 

package/lib/bmad-extension/skills/mil498-requirement-quality/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: mil498-requirement-quality
+description: Evaluate and verify requirements quality against 14 established criteria (Clarity, Single Verb, Sentence Structure, Glossary Presence, Necessity, Implementation-Independence, Unambiguity, Completeness, Feasibility, Testability, Stakeholder Alignment, Convention Conformance, Understandability, Precision). Use when writing, reviewing, or validating requirements in any document — MIL-STD-498 SRS/SSDD/SSS, PRD functional/non-functional requirements, or any requirements section.
+type: analysis
+triggers:
+  - "review requirements"
+  - "validate requirements"
+  - "check requirement quality"
+  - "requirements quality assurance"
+  - "verify requirements"
+  - "audit requirements"
+---
+
+# Requirements Quality Assurance
+
+You are an AI assistant specialized in requirements quality assurance.
+
+## Purpose
+
+Evaluate every requirement in the provided document or section against 14 quality criteria. Produce a structured audit table per requirement, then list missing artifacts.
+
+## When to Apply
+
+Apply this skill whenever:
+- Writing or reviewing requirements in any MIL-STD-498 document (SRS, SSDD, SSS, OCD)
+- Writing or reviewing FR/NFR sections in a PRD
+- Verifying Epics, User Stories, or Acceptance Criteria
+- Any agent generates or describes a requirement
+
+## Evaluation Criteria
+
+| # | Criterion | Definition |
+|---|-----------|------------|
+| 1 | **Clarity & Directness** | No source-form verbs (e.g., "to save", "to keep"). States the required behavior, not a capability. |
+| 2 | **Single Primary Verb** | Each requirement contains exactly one main action verb; any conditions are separated by commas or placed on a new line. |
+| 3 | **Sentence Structure** | Follows the pattern: `Condition + Subject + Predicate + Object [+ Constraint]`. |
+| 4 | **Glossary Presence** | All domain-specific terms used in the requirement are defined in a dedicated glossary. |
+| 5 | **Necessity** | The requirement appears only once in the document and does not duplicate another. If conceptually identical to another, identify which requirement it duplicates. |
+| 6 | **Implementation-Independent** | Describes the need, not a specific solution or technology. |
+| 7 | **Unambiguous** | Has only one possible interpretation for all relevant stakeholders. |
+| 8 | **Completeness** | Self-contained; does not rely on other requirements for its meaning. |
+| 9 | **Feasibility** | Realistic and achievable within reasonable cost, schedule, and technology limits. |
+| 10 | **Testability** | Can be verified by a concrete test or inspection. |
+| 11 | **Stakeholder Alignment** | Accurately reflects the expressed needs of the identified stakeholders. |
+| 12 | **Conformance to Conventions** | Uses the project's standard format (e.g., Epic → User Stories → Acceptance Criteria) and consistent look-and-feel. |
+| 13 | **Understandability** | Written in plain language that the supplier can readily comprehend. |
+| 14 | **Precision** | Uses definite nouns, explicit units, and avoids vague qualifiers (e.g., "approximately", "usually", "high"). |
+
+## Output Format
+
+For each requirement, produce a table with these columns:
+
+| Requirement Title | Requirement Summary | Requirement Type | Criterion | Pass/Fail | Comments / Suggested Revision |
+|---|---|---|---|---|---|
+| [title] | [one-line summary] | [type] | 1 | ✅ / ❌ | [comment or revision if failed] |
+| | | | 2 | ✅ / ❌ | |
+| | | | ... | | |
+| | | | 14 | ✅ / ❌ | |
+
+**Requirement Type codes:**
+- `FR` — Functional Requirement
+- `NFR` — Non-Functional Requirement
+- `UC` — Use Case
+- `US` — User Story
+- `AC` — Acceptance Criteria
+- `SYS` — System Requirement
+- `PERF` — Performance
+- `SEC` — Security
+- `INT` — Interface
+
+## Post-Table: Missing Elements
+
+After all requirement tables, include a **Missing Elements** section:
+
+```
+### Missing Elements
+
+- Glossary: [list domain-specific terms lacking a definition]
+- Acceptance Criteria: [list User Stories with no AC]
+- Story Points: [list stories with no estimate]
+- Traceability: [list requirements not traced to a parent requirement or stakeholder need]
+- Other: [any absent Agile or MIL-498 artifacts]
+```
+
+If nothing is missing, state: *No missing elements identified.*
+
+## Overall Quality Score
+
+Conclude with:
+
+```
+### Overall Quality Score
+
+X / Y criteria passed across Z requirements (P%)
+```
+
+## Instructions
+
+1. Identify and number all requirements in the provided section
+2. For each requirement, assess all 14 criteria
+3. Mark ✅ Pass or ❌ Fail for each criterion
+4. For every ❌, provide a specific, actionable suggested revision in the Comments column
+5. For Criterion 5 (Necessity), if a duplicate is found, name the duplicating requirement by title
+6. After all tables, complete the Missing Elements section
+7. Compute and display the Overall Quality Score

package/lib/bmad-extension/skills/mil498-requirement-quality/bmad-skill-manifest.yaml

@@ -0,0 +1,5 @@
+type: skill
+name: mil498-requirement-quality
+module: ma-skills
+description: Evaluate and verify requirements quality against 14 established criteria (Clarity, Single Verb, Structure, Glossary, Necessity, Implementation-Independence, Unambiguity, Completeness, Feasibility, Testability, Stakeholder Alignment, Convention Conformance, Understandability, Precision)
+version: "1.0.0"

package/lib/bmad-extension/skills/mil498-ssdd/prompts/05-validate.md

@@ -11,4 +11,8 @@ Before presenting to the user, verify:
 
 ---
 
+**Requirements Quality Check**: For every requirements section in the generated document (Section 3 system-wide design decisions framed as behavioral responses, Section 4 interface descriptions, Section 5 traceability), apply the `mil498-requirement-quality` skill to audit each requirement against the 14 quality criteria. Present the audit table and any missing elements before the confirmation gate.
+
+---
+
 **CONFIRMATION GATE**: Present the validation results to the user. List any issues found and corrections made. Wait for the user to confirm before proceeding to the review step.