ma-agents 3.4.9 → 3.5.0

package/skills/prioritize-backlog/SKILL.md

@@ -0,0 +1,203 @@
+# Prioritize Backlog
+
+Reprioritize backlog items in `sprint-status.yaml` using multiple criteria: severity, business value, dependencies, type, and age.
+
+<workflow>
+
+<step n="0" goal="Load configuration and validate file existence">
+  <action>Read `_bmad-output/implementation-artifacts/sprint-status.yaml` — the single source of truth for all sprint and backlog state.</action>
+  <check if="sprint-status.yaml does not exist">
+    <output>No sprint-status.yaml found. Run sprint planning first to initialize the file.</output>
+    <action>Exit workflow — do not create any file.</action>
+  </check>
+  <action>Parse the full file: read `epics`, `backlog`, and `sprints` sections plus all metadata fields (`generated`, `last_updated`, `project`, `project_key`, `tracking_system`, `story_location`). Store the entire parsed structure as {{file_data}} for later atomic write.</action>
+  <check if="legacy backlog.yaml exists in _bmad-output/implementation-artifacts/">
+    <output>Note: Legacy backlog.yaml detected. Run migration to consolidate.</output>
+    <action>Continue — do NOT read from or write to the legacy file. Operate on sprint-status.yaml only.</action>
+  </check>
+  <check if="{{file_data.backlog}} is empty or null">
+    <output>Backlog is empty. Nothing to prioritize.</output>
+    <action>Exit workflow — do not modify the file.</action>
+  </check>
+  <action>Store {{backlog_items}} = {{file_data.backlog}} (the array of items to work with).</action>
+  <action>Store {{original_order}} = copy of {{backlog_items}} with their current priority values, for use in the change summary later.</action>
+</step>
+
+<step n="1" goal="Display current backlog order">
+  <action>Read {{backlog_items}} in their current array order (position 0 = highest priority).</action>
+  <output>
+## Current Backlog ({{backlog_items.length}} items)
+
+| Priority | ID | Title | Type | Epic | Severity | Status |
+|---|---|---|---|---|---|---|
+{{#each backlog_items}}
+| {{priority}} | {{id}} | {{title}} | {{type}} | {{#if epic}}epic-{{epic}}{{else}}—{{/if}} | {{severity or "—"}} | {{status}} |
+{{/each}}
+
+*Note: Items assigned to sprints are not shown — only unassigned backlog items are listed here.*
+  </output>
+</step>
+
+<step n="2" goal="Choose prioritization mode">
+  <ask>Select a prioritization mode:
+
+**[f] Full** — Interactive: generates a suggested order, presents current vs proposed side-by-side. You review and approve (or adjust) before any write occurs.
+**[q] Quick** — Automated: applies default multi-criteria rules immediately, then shows a summary of what moved.
+**[a] Auto-suggest** — Read-only: shows the suggested order with per-item rationale. No file is modified.
+**[x] Cancel** — Exit without changes.
+
+Choice:</ask>
+  <check if="user selects 'x'">
+    <output>Cancelled — no changes made.</output>
+    <action>Exit workflow.</action>
+  </check>
+  <action>Store {{selected_mode}} = user choice.</action>
+</step>
+
+<step n="3" goal="Multi-criteria prioritization analysis">
+  <action>For each item in {{backlog_items}}, compute a composite priority score using the following weighted criteria (highest weight listed first):</action>
+
+  <action>**1. Severity weight (highest impact):**
+  - `severity: critical` → +40 points
+  - `severity: high`     → +30 points
+  - `severity: medium`   → +10 points
+  - `severity: low`      → +5 points
+  - `severity: null`     → +0 points (no adjustment for stories)
+  </action>
+
+  <action>**2. Business value weight:**
+  - Use the item's existing `priority` value as a signal for current business value ranking. Items with lower `priority` values (higher priority) receive a proportional boost: score += max(0, ({{backlog_items.length}} - current_priority + 1) * 2). This preserves existing prioritization signals while allowing other criteria to override.
+  - Items from lower-numbered epics (or `epic: null`) receive a slight additional boost: score += max(0, (20 - epic_number)) * 1, treating null as epic 0.
+  </action>
+
+  <action>**3. Dependency weight:**
+  - Read `_bmad-output/planning-artifacts/epics.md` if it exists to identify explicit inter-story dependencies.
+  - Within the same epic, items with lower story numbers are assumed to be prerequisites for higher-numbered stories. Items that block others get a +15 point boost.
+  - Items that are explicitly blocked by other UNASSIGNED backlog items get a -10 point adjustment (they cannot proceed anyway).
+  - If epics.md cannot be read or does not define explicit dependencies, use only the intra-epic ordering heuristic.
+  </action>
+
+  <action>**4. Type weight (tiebreaker):**
+  - `type: bug` → +3 points (bugs receive a slight boost over stories at equal composite score)
+  - `type: story` → +0 points
+  </action>
+
+  <action>**5. Age weight (starvation prevention — weakest signal):**
+  - Items from epics with lower epic numbers receive +1 point per 5 epic numbers below the maximum epic in the backlog (e.g., if max epic is 17, epic-12 gets +1, epic-7 gets +2).
+  - Items with `epic: null` are treated as oldest (receive the maximum age boost among all items).
+  - This is a tiebreaker only — it prevents starvation but does not override higher-priority signals.
+  </action>
+
+  <action>Compute {{composite_score}} for each item = severity_score + business_value_score + dependency_score + type_score + age_score.</action>
+  <action>Sort items by {{composite_score}} descending (highest score = priority 1). Break ties by current `priority` value (lower = higher priority stays higher).</action>
+  <action>Store {{suggested_order}} = sorted list of items. Store {{rationale_map}} = per-item map of score breakdown and reason summary.</action>
+</step>
+
+<step n="3a" goal="Full mode: present comparison and get approval" condition="{{selected_mode}} == 'f'">
+  <output>
+## Prioritization Analysis: Current vs Suggested
+
+| Current Priority | ID | Suggested Priority | Change | Key Rationale |
+|---|---|---|---|---|
+{{#each original_order}}
+| {{priority}} | {{id}} | {{suggested_position}} | {{change_indicator}} | {{rationale}} |
+{{/each}}
+
+*Items highlighted with ↑ move up, ↓ move down, = stay in place.*
+  </output>
+  <ask>Options:
+- **[a]** Accept the suggested order as-is
+- **[m]** Manually adjust — enter item IDs in your preferred order (comma-separated)
+- **[c]** Cancel — exit without changes
+
+Choice:</ask>
+  <check if="user selects 'c'">
+    <output>Cancelled — no changes made.</output>
+    <action>Exit workflow.</action>
+  </check>
+  <check if="user selects 'a'">
+    <action>Set {{final_order}} = {{suggested_order}}.</action>
+  </check>
+  <check if="user selects 'm'">
+    <ask>Enter item IDs in your preferred priority order (highest priority first), comma-separated. You MUST include all {{backlog_items.length}} items — no duplicates or omissions allowed:
+Example: 17-10-rework-generate-backlog, 17-11-rework-add-to-sprint, ...</ask>
+    <action>Parse the user-provided list into {{manual_order_ids}}.</action>
+    <action>Validate:
+    - Count must equal {{backlog_items.length}} (no missing items)
+    - All IDs must exist in {{backlog_items}} (no unknown IDs)
+    - No duplicate IDs
+    </action>
+    <check if="validation fails">
+      <output>Invalid input: {{validation_error}}. Please re-enter the complete list of all {{backlog_items.length}} item IDs in your preferred order.</output>
+      <action>Repeat the manual-entry prompt until valid input is received or user cancels.</action>
+    </check>
+    <action>Reorder {{backlog_items}} to match {{manual_order_ids}} sequence. Set {{final_order}} = reordered list.</action>
+  </check>
+  <action>Proceed to Step 4 with {{final_order}}.</action>
+</step>
+
+<step n="3b" goal="Quick mode: apply suggested order automatically" condition="{{selected_mode}} == 'q'">
+  <action>Set {{final_order}} = {{suggested_order}}.</action>
+  <action>Proceed to Step 4 with {{final_order}}.</action>
+</step>
+
+<step n="3c" goal="Auto-suggest mode: display suggestions without writing" condition="{{selected_mode}} == 'a'">
+  <output>
+## Suggested Backlog Order (Read-Only — No Changes Written)
+
+| New Priority | ID | Title | Old Priority | Change | Rationale |
+|---|---|---|---|---|---|
+{{#each suggested_order}}
+| {{new_priority}} | {{id}} | {{title}} | {{old_priority}} | {{change_indicator}} | {{rationale}} |
+{{/each}}
+
+**Summary:**
+- Items that would move up: {{move_up_count}}
+- Items that would move down: {{move_down_count}}
+- Items unchanged: {{unchanged_count}}
+
+Suggestions displayed. No changes written. Run again in Full or Quick mode to apply.
+  </output>
+  <action>Exit workflow — do NOT proceed to Step 4.</action>
+</step>
+
+<step n="4" goal="Apply reordering and persist">
+  <action>Take {{final_order}} (from Full or Quick mode).</action>
+  <action>Renumber `priority` field on each item sequentially: position 0 in the array gets `priority: 1`, position 1 gets `priority: 2`, and so on through position N-1 gets `priority: N`. This keeps the denormalized index in sync with array position (schema section 3.3).</action>
+  <action>Get the current ISO-8601 timestamp (format: YYYY-MM-DDTHH:MM:SS). Update {{file_data.last_updated}} to this timestamp.</action>
+  <action>Preserve {{file_data.generated}} unchanged.</action>
+  <action>Preserve {{file_data.epics}} section unchanged — do NOT modify any epic entries.</action>
+  <action>Preserve {{file_data.sprints}} section unchanged — do NOT modify any sprint entries or items within sprints.</action>
+  <action>Set {{file_data.backlog}} = {{final_order}} (the reordered array with renumbered priorities).</action>
+  <action>Write the complete updated {{file_data}} back to `_bmad-output/implementation-artifacts/sprint-status.yaml` in a single atomic write (read-modify-write pattern). This single write replaces the file entirely — no partial updates.</action>
+</step>
+
+<step n="5" goal="Display summary output">
+  <action>Compute change summary by comparing {{original_order}} (old positions) against {{final_order}} (new positions).</action>
+  <output>
+## Reprioritization Complete
+
+**Mode:** {{mode_label}} ({{current_datetime}})
+**Items reordered:** {{backlog_items.length}} total
+
+### Changes Made
+
+| ID | Title | Old Priority | New Priority | Direction |
+|---|---|---|---|---|
+{{#each changed_items}}
+| {{id}} | {{title}} | {{old_priority}} | {{new_priority}} | {{direction}} |
+{{/each}}
+
+{{#if unchanged_items.length > 0}}
+**Unchanged ({{unchanged_items.length}} items):** {{unchanged_ids_list}}
+{{/if}}
+
+**sprint-status.yaml updated successfully.**
+
+**Next steps:**
+- `/add-to-sprint` — Assign the top-priority backlog items to the current sprint
+- `/sprint-status-view` — View overall sprint progress and capacity
+  </output>
+</step>
+
+</workflow>

package/skills/prioritize-backlog/skill.json

@@ -0,0 +1,7 @@
+{
+  "name": "prioritize-backlog",
+  "version": "1.0.0",
+  "description": "Reprioritize backlog items using multiple criteria -- severity, business value, dependencies, type, age",
+  "category": "workflow",
+  "tags": ["backlog", "prioritization", "sprint-management"]
+}

package/skills/remove-from-sprint/SKILL.md

@@ -0,0 +1,174 @@
+# Remove-from-Sprint Skill
+
+Guided workflow to move sprint items back to the backlog in the unified `sprint-status.yaml` using reverse movement semantics (inverse of `add-to-sprint`).
+
+<workflow>
+
+<step n="0" goal="Load configuration and validate file existence">
+  <action>Read `_bmad-output/implementation-artifacts/sprint-status.yaml` — the unified single source of truth for sprint and backlog state</action>
+  <check if="file does not exist">
+    <output>No sprint-status.yaml found. Run sprint planning first to initialize the file.</output>
+    <action>Exit workflow</action>
+  </check>
+  <action>Parse the full file: metadata fields (`generated`, `last_updated`, `project`, `project_key`, `tracking_system`, `story_location`), `epics` section, `backlog` array, and `sprints` map</action>
+  <action>Store parsed data as {{sprint_file}}</action>
+</step>
+
+<step n="1" goal="Identify sprints with removable items">
+  <action>Scan the `sprints` map in {{sprint_file}}. For each sprint entry, check if its `items` array has at least one element.</action>
+  <action>Build {{sprints_with_items}} = list of sprints where `items` is non-empty, ordered by sprint key (sprint-1, sprint-2, …)</action>
+  <check if="{{sprints_with_items}} is empty">
+    <output>No sprints with assigned items found. Nothing to remove.</output>
+    <action>Exit workflow</action>
+  </check>
+  <check if="exactly one sprint has items">
+    <action>Auto-select that sprint. Store as {{selected_sprint_id}} and {{selected_sprint}}</action>
+    <output>Auto-selected the only sprint with items: **{{selected_sprint.name}}** ({{selected_sprint.status}})</output>
+  </check>
+  <check if="multiple sprints have items">
+    <output>
+## Sprints with Assigned Items
+
+| # | Sprint ID | Name | Status | Capacity | Items |
+|---|-----------|------|--------|----------|-------|
+{{#each sprints_with_items}}
+| {{@index+1}} | {{id}} | {{name}} | {{status}} | {{capacity}} | {{items.length}} |
+{{/each}}
+    </output>
+    <ask>Select sprint to remove items from (enter number):</ask>
+    <action>Store selected sprint as {{selected_sprint_id}} and {{selected_sprint}}</action>
+  </check>
+  <check if="selected_sprint.status == 'closed'">
+    <output>Cannot remove items from a closed sprint. Closed sprints are immutable (schema section 6.7). Use `/close-sprint` or `/cleanup-done` to disposition items in closed sprints.</output>
+    <action>Exit workflow</action>
+  </check>
+</step>
+
+<step n="2" goal="Display sprint items and identify eligible items for removal">
+  <action>Read {{selected_sprint.items}} array</action>
+  <action>Partition items into two groups:
+    - {{ineligible_items}} = items where `status` is `done` or `cancelled`
+    - {{eligible_items}} = all other items (status: ready-for-dev, in-progress, review, on-hold, backlog)
+  </action>
+  <check if="{{ineligible_items}} is non-empty">
+    <output>
+> **Note:** {{ineligible_items.length}} done/cancelled item(s) cannot be removed. Use `/cleanup-done` or `/close-sprint` to archive them.
+>
+> Ineligible items: {{#each ineligible_items}}{{id}} ({{status}}){{#unless @last}}, {{/unless}}{{/each}}
+    </output>
+  </check>
+  <check if="{{eligible_items}} is empty">
+    <output>All items in **{{selected_sprint.name}}** are done or cancelled. Use `/cleanup-done` or `/close-sprint` to archive them.</output>
+    <action>Exit workflow</action>
+  </check>
+  <output>
+## Items in {{selected_sprint.name}} — Eligible for Removal
+
+| # | ID | Title | Type | Epic | Status | Severity |
+|---|----|-------|------|------|--------|----------|
+{{#each eligible_items}}
+| {{@index+1}} | {{id}} | {{title}} | {{type}} | {{epic ?? "—"}} | {{status}} | {{severity ?? "—"}} |
+{{/each}}
+
+*Sprint capacity: {{selected_sprint.items.length}}/{{selected_sprint.capacity}}*
+  </output>
+</step>
+
+<step n="3" goal="Select items to remove">
+  <ask>Which items do you want to remove from the sprint? Enter item numbers (comma-separated) or "all" to remove all eligible items:</ask>
+  <check if="user enters 'all'">
+    <action>Set {{items_to_remove}} = all items in {{eligible_items}}</action>
+  </check>
+  <check if="user enters item numbers">
+    <action>Resolve entered numbers against the eligible_items table. Validate all numbers are in range.</action>
+    <check if="any number is out of range">
+      <output>Invalid selection: number(s) out of range. Please enter valid item numbers from the table above.</output>
+      <goto step="3" />
+    </check>
+    <action>Set {{items_to_remove}} = items at the specified positions in {{eligible_items}}</action>
+  </check>
+</step>
+
+<step n="4" goal="Confirmation — warn about status resets">
+  <output>
+## Confirm Removal from {{selected_sprint.name}}
+
+The following items will be moved back to the backlog:
+
+| ID | Title | Current Status | Backlog Status After |
+|----|-------|---------------|----------------------|
+{{#each items_to_remove}}
+| {{id}} | {{title}} | {{status}} | ready-for-dev{{#if (ne status "ready-for-dev")}} ⚠️ status will be reset{{/if}} |
+{{/each}}
+
+**Effect on sprint capacity:** {{selected_sprint.items.length}} → {{selected_sprint.items.length - items_to_remove.length}} / {{selected_sprint.capacity}} items
+
+**Note:** Each removed item will be appended to the end of the backlog with `status: ready-for-dev`. Run `/prioritize-backlog` after this operation to reorder the backlog.
+  </output>
+  <check if="any item_to_remove has status != 'ready-for-dev'">
+    <output>
+> **Warning:** {{#each items_to_remove}}{{#if (ne status "ready-for-dev")}}**{{id}}** is currently `{{status}}` — its status will be reset to `ready-for-dev`. Any in-progress work tracking will be lost.{{/if}}{{/each}}
+    </output>
+  </check>
+  <ask>Options: [c] Confirm removal / [x] Cancel:</ask>
+  <check if="user selects 'x'">
+    <output>Removal cancelled — no changes made.</output>
+    <action>Exit workflow</action>
+  </check>
+</step>
+
+<step n="5" goal="Execute reverse movement — atomic write">
+  <action>Load current {{sprint_file}} state (re-read if needed to get latest data)</action>
+
+  <action>**Pre-write: single-location invariant check.** Build {{current_backlog_ids}} = set of all item IDs currently in {{sprint_file}}.backlog. For each item in {{items_to_remove}}: check if its ID exists in {{current_backlog_ids}}. If ANY match is found:
+    <output>**Error:** Data integrity violation — item {{item.id}} already exists in the backlog. Aborting to prevent duplicate. The sprint-status.yaml file may be corrupted. No changes have been written.</output>
+    <action>Exit workflow without writing</action>
+  </action>
+
+  <action>**Pre-write: required field validation.** For each item in {{items_to_remove}}: verify it has all 6 required backlog fields present (the key must exist; epic and severity may be null by schema): id, type, epic, title, status, severity. (priority will be assigned by this skill.) If ANY item is missing a required field:
+    <output>**Error:** Item {{item.id}} is missing required field '{{missing_field}}'. Cannot safely return this item to the backlog. No changes have been written. Please inspect sprint-status.yaml manually.</output>
+    <action>Exit workflow without writing</action>
+  </action>
+
+  <action>Determine {{current_max_priority}}:
+    - If {{sprint_file.backlog}} is empty, set {{current_max_priority}} = 0
+    - Otherwise, set {{current_max_priority}} = max(item.priority for item in sprint_file.backlog)
+  </action>
+  <action>For each item in {{items_to_remove}} (in the order they appear in the sprint's items array):
+    1. REMOVE the item object from {{selected_sprint_id}}.items in the sprints map
+    2. INCREMENT {{current_max_priority}} by 1
+    3. SET item.status = "ready-for-dev"
+    4. ADD item.priority = {{current_max_priority}}
+    5. APPEND the item (with fields: id, type, epic, title, priority, status, severity) to the backlog array
+  </action>
+  <action>After all items are moved: renumber ALL backlog items' priority values sequentially (1..N) to match their array positions. First item in array gets priority 1, second gets priority 2, etc. Track each removed item's final renumbered priority in {{items_to_remove[n].final_priority}} for use in the summary.</action>
+  <action>Set {{sprint_file.last_updated}} = current ISO-8601 timestamp (e.g., "2026-04-06T12:00:00Z")</action>
+  <action>Write the complete updated sprint-status.yaml in a SINGLE atomic operation. The write MUST include all three sections (epics, backlog, sprints) and all metadata fields. Preserve the `generated` timestamp unchanged.</action>
+</step>
+
+<step n="6" goal="Display removal summary">
+  <output>
+## Removal Complete
+
+**Sprint:** {{selected_sprint.name}}
+**Items removed this session:** {{items_to_remove.length}}
+**Updated sprint capacity:** {{selected_sprint.items.length - items_to_remove.length}}/{{selected_sprint.capacity}} items
+
+### Removed Items — Now in Backlog
+
+| ID | Title | Backlog Priority | Status |
+|----|-------|-----------------|--------|
+{{#each items_to_remove}}
+| {{id}} | {{title}} | {{final_priority}} | ready-for-dev |
+{{/each}}
+
+**Updated backlog count:** {{sprint_file.backlog.length}} items
+
+**Next Steps:**
+- Run `/prioritize-backlog` to reorder the backlog after removals
+- Run `/add-to-sprint` to reassign items to a sprint
+- Run `/sprint-status-view` to view the updated sprint status
+  </output>
+</step>
+
+</workflow>

package/skills/remove-from-sprint/skill.json

@@ -0,0 +1,7 @@
+{
+  "name": "remove-from-sprint",
+  "version": "1.0.0",
+  "description": "Guided workflow to move sprint items back to the backlog in the unified sprint-status.yaml using reverse movement semantics",
+  "category": "workflow",
+  "tags": ["sprint-management", "backlog", "movement-semantics"]
+}

package/skills/sprint-status-view/SKILL.md

@@ -0,0 +1,173 @@
+# Sprint Status View
+
+Display a formatted, read-only dashboard of all sprint, backlog, and epic data from the unified `sprint-status.yaml` file.
+
+> **READ-ONLY SKILL:** This skill NEVER writes to `sprint-status.yaml` or any other file. It is purely a display/reporting skill.
+
+---
+
+## Step 1 — Load sprint-status.yaml
+
+Read `_bmad-output/implementation-artifacts/sprint-status.yaml`.
+
+If the file does not exist:
+- Output: "No sprint-status.yaml found. Run `/bmad-sprint-planning` to initialize."
+- Exit without error.
+
+Parse all sections from the file:
+- **Metadata:** `project`, `last_updated` (plus `generated`, `project_key`, `tracking_system`, `story_location` if present)
+- **`epics`** — map of epic entries (keys: `epic-N`)
+- **`backlog`** — array of unassigned item objects
+- **`sprints`** — map of sprint entries (keys: `sprint-N`)
+
+If the file exists but uses the old flat `development_status` schema (no `epics`/`backlog`/`sprints` sections), output:
+"sprint-status.yaml uses the pre-Epic-17 schema. Run `/bmad-sprint-planning` to migrate to the unified schema."
+Then exit.
+
+---
+
+## Step 2 — Classify Sprints
+
+Partition the `sprints` map into three groups:
+- **active** — entries where `status: active`
+- **planning** — entries where `status: planning`
+- **closed** — entries where `status: closed`
+
+Sort each group by sprint key (`sprint-N`) ascending by numeric value of N.
+
+---
+
+## Step 3 — Render Header
+
+Output:
+
+```
+# Sprint Status — {project}
+*Last updated: {last_updated}*
+
+---
+```
+
+---
+
+## Step 4 — Render Active Sprints
+
+If there are active sprints, output a `## Active Sprints` section header.
+
+For each active sprint (sorted by key ascending):
+
+1. Sprint header:
+   ```
+   ### {sprint.name}
+   **Status:** active | **Capacity:** {items.length} / {capacity} | **Start:** {start or "—"} | **End:** {end or "—"}
+   ```
+   If `items.length > capacity`, append inline: `⚠️ over capacity by {items.length - capacity} item(s)`
+
+2. Items table (if items array is non-empty):
+   ```
+   | Item | Title | Type | Status | Severity |
+   |------|-------|------|--------|----------|
+   | {id} | {title} | Story | {status} | — |
+   | {id} | {title} | Bug   | {status} | {severity} |
+   ```
+   - Type column: use "Story" for `type: story`, "Bug" for `type: bug`
+   - Severity column: show severity value for bugs, "—" for stories
+
+3. If items array is empty, output: `*(No items assigned to this sprint)*`
+
+---
+
+## Step 5 — Render Planning Sprints
+
+If there are planning sprints, output a `## Planning Sprints` section header.
+
+For each planning sprint (sorted by key ascending), use the same format as active sprints (Step 4) with `status: planning`.
+
+---
+
+## Step 6 — Render Closed Sprint Summaries
+
+If there are closed sprints, output a `## Closed Sprints` section header followed by a summary table:
+
+```
+| Sprint | Items | Start | End |
+|--------|-------|-------|-----|
+| {sprint.name} | {items.length} items (archived) | {start or "—"} | {end or "—"} |
+```
+
+Do NOT list individual items within closed sprints (collapsed view by default).
+
+---
+
+## Step 7 — Render Backlog
+
+Count total backlog items: `{backlog.length}`.
+
+Output a `## Backlog — {backlog.length} items` section header.
+
+If backlog is empty, output: `*(No items in backlog)*`
+
+Otherwise, output a table in array order (position = priority):
+
+```
+| # | Item | Title | Type | Status | Severity |
+|---|------|-------|------|--------|----------|
+| 1 | {id} | {title} | Story | {status} | — |
+| 2 | {id} | {title} | Bug   | {status} | {severity} |
+```
+
+- `#` column: 1-based position in the array (= priority rank)
+- Severity column: show severity for bugs, "—" for stories
+
+---
+
+## Step 8 — Render Epics Overview
+
+Output a `## Epics` section header.
+
+If the `epics` map is empty, output: `*(No epics defined)*`
+
+Otherwise, for each epic in the map (sorted by key ascending by numeric value of N):
+
+1. Count items referencing this epic across all sections:
+   - Scan `backlog` items where `epic == N` (N = epic number, e.g., `17` for `epic-17`)
+   - Scan all `sprints[*].items` where `epic == N`
+   - Tally counts by status
+
+2. Output a table (header once, one row per epic):
+   ```
+   | Epic | Status | Retrospective | Items (active) |
+   |------|--------|---------------|----------------|
+   | {epic-key} | {epic.status} | {epic.retrospective or "—"} | {total_count} total ({status_breakdown}) |
+   ```
+   - Status breakdown: list non-zero status counts, e.g., "2 in-progress, 1 ready-for-dev"
+   - If no items reference the epic, show "0 total" (omit the parenthetical)
+   - `retrospective` field: show value or "—" if null
+
+---
+
+## Step 9 — Render Alerts (Conditional)
+
+Scan for alert conditions:
+
+1. **Over-capacity sprints:** Any sprint where `items.length > capacity`
+   - Alert: `Over capacity: {sprint.name} is over capacity by {items.length - capacity} item(s) ({items.length} / {capacity})`
+
+2. **Stale in-progress items:** Items with `status: in-progress` in **active** sprints where the sprint's `start` date is more than 14 days before today's date
+   - Alert: `Stale in-progress: {item.id} has been in-progress for {N} days ({sprint.name} started {start})`
+
+3. **Empty active sprints:** Active sprints with zero items
+   - Alert: `Empty active sprint: {sprint.name} is active but has no items assigned`
+
+If NO alert conditions exist, omit this section entirely (do not output "No alerts" or any placeholder).
+
+If alerts exist, output a `## Alerts` section header followed by a bulleted list.
+
+---
+
+## Notes
+
+- All data comes exclusively from `sprint-status.yaml`. No secondary file reads.
+- Empty strings in `start`/`end` fields display as "—".
+- This skill is invoked on demand. It does not auto-load for every task.
+- For interactive next-actions (assign items, modify sprints), use the BMAD `/sprint-status-view` workflow which adds an interactive menu.

package/skills/sprint-status-view/skill.json

@@ -0,0 +1,7 @@
+{
+  "name": "sprint-status-view",
+  "version": "1.0.0",
+  "description": "Display formatted sprint progress, backlog, and epic status from the unified sprint-status.yaml",
+  "category": "workflow",
+  "tags": ["sprint-status", "sprint-management", "dashboard", "read-only"]
+}

package/skills/story-status-lookup/SKILL.md

@@ -37,9 +37,20 @@ Derive the story slug from the available context, in this order of preference:
 2. The git branch name — strip prefixes (`feature/`, `fix/`, `chore/`) and normalize: lowercase, replace spaces and underscores with hyphens, remove non-alphanumeric characters except hyphens
 3. Any explicit story reference in the current task description
 
-### Step 2 — Look up the slug
+### Step 2 — Search for the slug across all sections
 
-Find the slug as a key under `development_status` in `sprint-status.yaml`.
+Read `sprint-status.yaml` and search the following sections in order. Stop at the first match.
+
+**2a. Backlog search:** Iterate the `backlog` array. For each item, check if `item.id` equals the derived slug.
+- If found: record the item's `status` field value and note location as `"in backlog (unassigned)"`.
+
+**2b. Sprint search:** Iterate the `sprints` map. For each sprint entry, iterate its `items` array. For each item, check if `item.id` equals the derived slug.
+- If found: record the item's `status` field value and note location as `"in {sprint-id}"` (e.g., `"in sprint-3"`).
+
+**2c. Done archive fallback:** If the slug was not found in any section above, check for a file at `{story_location}/done/{slug}.md`, where `story_location` is the metadata field from `sprint-status.yaml` (default: `_bmad-output/implementation-artifacts`).
+- If the file exists: classify as **Delivered** — report `"Story {id} is archived (done)"`.
+
+**2d. Not found:** If not found in backlog, sprints, or done archive, report `"Story {id} not found in sprint-status.yaml or done/ archive"` and classify as **WIP**.
 
 ### Step 3 — Map status to delivered / WIP
 
@@ -51,13 +62,17 @@ Find the slug as a key under `development_status` in `sprint-status.yaml`.
 | `ready-for-dev` | WIP | Do not flag |
 | `backlog` | WIP | Do not flag |
 | `on-hold` | WIP | Do not flag |
+| `cancelled` | WIP | Do not flag |
 
 ### Fallback rule
 
-If any of the following are true, **classify as WIP and do not flag**:
-- The story slug cannot be determined from context
-- The slug is not found in `sprint-status.yaml`
-- The status file does not exist
+Apply the first matching rule; do not continue down the list:
+
+1. Slug cannot be determined from context → **WIP**
+2. Slug not found in `sprint-status.yaml` → check `done/` archive (Step 2c)
+3. Found in `done/` archive → **Delivered**
+4. Not found anywhere → **WIP**
+5. Status file does not exist → **WIP**
 
 Never guess or assume delivered status. When in doubt, WIP.
 

package/skills/story-status-lookup/skill.json

@@ -1,7 +1,7 @@
 {
   "name": "story-status-lookup",
-  "version": "1.0.0",
-  "description": "Looks up the current status of a story to classify code as delivered or work-in-progress. Supports file-system backend now; Jira backend reserved for future configuration.",
+  "version": "2.0.0",
+  "description": "Looks up the current status of a story by searching the unified sprint-status.yaml (backlog and sprint items arrays) to classify code as delivered or work-in-progress. Supports file-system backend; Jira backend reserved for future configuration.",
   "category": "workflow",
   "tags": ["story-status", "sprint-management", "bug-detection"],
   "always_load": true