bmad-method 6.10.1-next.39 → 6.10.1-next.40

package/.claude-plugin/marketplace.json

@@ -84,15 +84,14 @@
         "./src/bmm-skills/plan/bmad-ux",
         "./src/bmm-skills/agents/bmad-agent-architect",
         "./src/bmm-skills/plan/bmad-architecture",
-        "./src/bmm-skills/plan/bmad-check-implementation-readiness",
         "./src/bmm-skills/plan/bmad-create-epics-and-stories",
         "./src/bmm-skills/plan/bmad-generate-project-context",
         "./src/bmm-skills/agents/bmad-agent-dev",
         "./src/bmm-skills/v6-shims/bmad-dev-story",
         "./src/bmm-skills/ship/bmad-build",
         "./src/bmm-skills/ship/bmad-checkpoint-preview",
-        "./src/bmm-skills/ship/bmad-sprint-planning",
-        "./src/bmm-skills/ship/bmad-sprint-status",
+        "./src/bmm-skills/plan/bmad-sprint-planning",
+        "./src/bmm-skills/v6-shims/bmad-sprint-status",
         "./src/bmm-skills/ship/bmad-code-review",
         "./src/bmm-skills/v6-shims/bmad-create-story",
         "./src/bmm-skills/ship/bmad-correct-course",

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-method",
-  "version": "6.10.1-next.39",
+  "version": "6.10.1-next.40",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "keywords": [
     "agile",
@@ -40,9 +40,9 @@
     "lint:fix": "eslint . --ext .js,.cjs,.mjs,.yaml --fix",
     "lint:md": "markdownlint-cli2 \"**/*.md\"",
     "prepare": "command -v husky >/dev/null 2>&1 && husky || exit 0",
-    "quality": "npm run format:check && npm run lint && npm run lint:md && npm run docs:build && npm run test:site-url && npm run test:install && npm run test:urls && npm run test:renderer && npm run test:retrospective && npm run validate:refs && npm run validate:skills && npm run docs:validate-sidebar",
+    "quality": "npm run format:check && npm run lint && npm run lint:md && npm run docs:build && npm run test:site-url && npm run test:install && npm run test:urls && npm run test:renderer && npm run test:retrospective && npm run test:sprint-planning && npm run validate:refs && npm run validate:skills && npm run docs:validate-sidebar",
     "rebundle": "node tools/installer/bundlers/bundle-web.js rebundle",
-    "test": "npm run test:refs && npm run test:install && npm run test:urls && npm run test:site-url && npm run test:channels && npm run test:renderer && npm run test:retrospective && npm run test:skills && npm run lint && npm run lint:md && npm run format:check",
+    "test": "npm run test:refs && npm run test:install && npm run test:urls && npm run test:site-url && npm run test:channels && npm run test:renderer && npm run test:retrospective && npm run test:sprint-planning && npm run test:skills && npm run lint && npm run lint:md && npm run format:check",
     "test:channels": "node test/test-installer-channels.js",
     "test:install": "node test/test-installation-components.js",
     "test:refs": "node test/test-file-refs-csv.js",
@@ -50,6 +50,7 @@
     "test:retrospective": "uv run --python 3.11 src/bmm-skills/ship/bmad-retrospective/scripts/tests/test_git_evidence.py && uv run --python 3.11 src/bmm-skills/ship/bmad-retrospective/scripts/tests/test_sprint_status.py",
     "test:site-url": "node test/test-site-url.mjs",
     "test:skills": "node test/test-validate-skills.js",
+    "test:sprint-planning": "uv run --python 3.11 src/bmm-skills/plan/bmad-sprint-planning/scripts/tests/test_sprint_plan.py && node test/test-template-sync.js",
     "test:urls": "node test/test-parse-source-urls.js",
     "validate:refs": "node tools/validate-file-refs.js --strict",
     "validate:skills": "node tools/validate-skills.js --strict"

package/removals.txt

@@ -79,3 +79,9 @@ bmad-shard-doc
 # defaults; document-project remains directly invocable. Paige is on hiatus
 # and will return in the future far more capable.
 bmad-agent-tech-writer
+
+# Removed skills (skill consolidation)
+# bmad-check-implementation-readiness: folded into bmad-sprint-planning,
+# which now opens with a readiness gate (PASS/CONCERNS/FAIL) before
+# generating tracking. The IR agent menu trigger dispatches sprint-planning.
+bmad-check-implementation-readiness

package/src/bmm-skills/agents/bmad-agent-architect/customize.toml

@@ -61,5 +61,5 @@ skill = "bmad-architecture"
 
 [[agent.menu]]
 code = "IR"
-description = "Ensure the PRD, UX, Architecture and Epics and Stories List are all aligned"
-skill = "bmad-check-implementation-readiness"
+description = "Check implementation readiness — verify the planning artifacts are complete and aligned (opens sprint planning; stop after the gate or continue into tracking)"
+skill = "bmad-sprint-planning"

package/src/bmm-skills/agents/bmad-agent-pm/customize.toml

@@ -66,8 +66,8 @@ skill = "bmad-create-epics-and-stories"
 
 [[agent.menu]]
 code = "IR"
-description = "Ensure the PRD, UX, Architecture and Epics and Stories List are all aligned"
-skill = "bmad-check-implementation-readiness"
+description = "Check implementation readiness — verify the planning artifacts are complete and aligned (opens sprint planning; stop after the gate or continue into tracking)"
+skill = "bmad-sprint-planning"
 
 [[agent.menu]]
 code = "CC"

package/src/bmm-skills/module-help.csv

@@ -12,9 +12,8 @@ BMad Method,bmad-prd,Create Edit and Review PRD,PRD,"Facilitated PRD workflow
 BMad Method,bmad-ux,Create UX,CU,"Guidance through realizing the plan for your UX, strongly recommended if a UI is a primary piece of the proposed project.",,,2-planning,bmad-prd,,false,planning_artifacts,ux design
 BMad Method,bmad-architecture,Architecture,CA,Offer once requirements exist (a PRD or spec; plus UX if present) and the user is ready to move from what to how. Also offer any time independently-built parts risk diverging. Produces the architecture spine: the invariants that keep features epics and stories consistent. Comes before epics and stories and scales from a quick spine to a full architecture (brownfield: ratifies the existing codebase).,,,plan,,,true,planning_artifacts,architecture
 BMad Method,bmad-create-epics-and-stories,Create Epics and Stories,CE,,,,plan,bmad-architecture,,true,planning_artifacts,epics and stories
-BMad Method,bmad-check-implementation-readiness,Check Implementation Readiness,IR,Ensure PRD UX Architecture and Epics Stories are aligned.,,,plan,bmad-create-epics-and-stories,,true,planning_artifacts,readiness report
-BMad Method,bmad-sprint-planning,Sprint Planning,SP,Kicks off implementation by producing a plan the implementation agents will follow in sequence for every story.,,,ship,,,true,implementation_artifacts,sprint status
-BMad Method,bmad-sprint-status,Sprint Status,SS,Anytime: Summarize sprint status and route to next workflow.,,,ship,bmad-sprint-planning,,false,,
+BMad Method,bmad-sprint-planning,Sprint Planning,SP,Readiness gate then tracking: verifies the planning is implementable (PASS/CONCERNS/FAIL) and produces the sprint status the implementation agents follow for every story.,,,plan,,,true,implementation_artifacts,sprint status
+BMad Method,bmad-sprint-planning,Sprint Status,SS,Anytime: summarize sprint status with risks open action items and the next recommended action; can also validate or repair the tracking file.,status,,anytime,,,false,,status summary
 BMad Method,bmad-code-review,Code Review,CR,Ad hoc review of any code change. Optional extra layer after Build's built-in review.,,,ship,bmad-build,,false,,
 BMad Method,bmad-checkpoint-preview,Checkpoint,CK,Guided walkthrough of a change from purpose and context into details. Use for human review of commits branches or PRs.,,,ship,,,false,,
 BMad Method,bmad-qa-generate-e2e-tests,QA Automation Test,QA,Generate automated API and E2E tests for implemented code. NOT for code review or story validation — use CR for that.,,,ship,bmad-build,,false,implementation_artifacts,test suite

package/src/bmm-skills/plan/bmad-sprint-planning/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: bmad-sprint-planning
+description: 'Gate planning readiness, generate sprint status tracking from epics, summarize sprint progress, and validate or repair the tracking file. Use when the user says "run sprint planning", "generate sprint plan", "check implementation readiness", "show sprint status", "validate sprint status", or "fix sprint status"'
+---
+
+# Overview
+
+You are a senior developer about to commit to this plan. Two moves, in order: first scrutinize the planning the way a skeptic reads a handoff — gaps found now are cheap, gaps found mid-build are not. Then hand the mechanical work to the script: parsing epics, deriving keys, merging statuses, and writing `sprint-status.yaml` are deterministic jobs, not judgment calls. Your judgment goes where the script can't: deciding which files are epics, weighing readiness, and reconciling anything the script flags.
+
+## On Activation
+
+1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults.
+2. Execute each entry in `{workflow.activation_steps_prepend}` in order.
+3. Treat every entry in `{workflow.persistent_facts}` as foundational context for the rest of the run. Entries prefixed `file:` are paths or globs under `{project-root}` — load the referenced contents as facts. All other entries are facts verbatim.
+4. Load `{project-root}/_bmad/bmm/config.yaml` (and `config.user.yaml` if present). Resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{project_name}`, `{planning_artifacts}`, `{implementation_artifacts}`, `{project_knowledge}` (skip gracefully if unset), `{date}`. Stay in `{communication_language}` for every turn, not just the greeting.
+5. Greet `{user_name}`, detect intent, and load only what that intent needs:
+   - **readiness** — check implementation readiness only: load `references/readiness-gate.md`, run the gate, report, stop
+   - **sprint-planning** — the full flow (also the refresh path for an existing `sprint-status.yaml`): load `references/readiness-gate.md`, then on PASS `references/generate-tracking.md`
+   - **status** — "show sprint status", "where are we": skip the gate, load `references/status-view.md`
+   - **validate** — check the tracking file's format: load `references/validate.md`
+   - **fix** — repair or rebuild a broken `sprint-status.yaml`: load `references/fix-sprint-status.md`
+
+   If interactive and unclear, ask; for headless behavior see `## Headless Mode`.
+
+Execute each entry in `{workflow.activation_steps_append}` in order.
+
+Activation is complete. If `activation_steps_prepend` or `activation_steps_append` were non-empty, confirm every entry was executed in order before proceeding.
+
+## If the Script Fails
+
+This rule covers every intent: when `sprint_plan.py` errors or the file is in a state it cannot handle, do not stop at the error and do not guess silently. Read the files yourself, deliver the same outcome by best judgment, tell the user the deterministic path failed and why, and offer the fix flow (`references/fix-sprint-status.md`) to restore a file the script can work with.
+
+## On Completion
+
+Whatever the intent, close out in `{communication_language}` per the loaded reference, then run `{workflow.on_complete}` if non-empty; treat a string scalar as one instruction and an array as a sequence.
+
+## Headless Mode
+
+When invoked headless, do not ask. Run the gate and, unless intent was readiness-only, generate tracking. Ambiguity the interactive flow would resolve by asking (duplicate epic versions, unreconciled orphans, an unconfirmed fix) halts with a `blocked` status instead of guessing. End with a JSON response:
+
+```json
+{
+  "status": "complete",
+  "intent": "sprint-planning",
+  "gate": "PASS",
+  "status_file": "{implementation_artifacts}/sprint-status.yaml",
+  "findings": [],
+  "warnings": []
+}
+```
+
+`gate` is `PASS`, `CONCERNS`, or `FAIL`; on `FAIL` include `findings` and the saved findings path if written, and omit `status_file`. `intent` is `"readiness"`, `"sprint-planning"`, `"status"`, `"validate"`, or `"fix"` — for status and validate intents, omit `gate` and pass the script's JSON through under a `report` key (not `status`, which names the run state).
+
+## References
+
+- `scripts/sprint_plan.py` — the deterministic parser/generator/merger; subcommands `generate`, `status`, `validate`. Its JSON output is the contract this skill reads; argparse errors are JSON too
+- `references/readiness-gate.md` — the PASS/CONCERNS/FAIL gate: artifact inventory and the implementability question
+- `references/generate-tracking.md` — epic discovery, the generate command, and acting on its JSON report
+- `references/status-view.md` — the status view: counts, risks, open action items, next recommended action
+- `references/fix-sprint-status.md` — rebuild a broken tracking file: evidence-gathering subagents, user confirmation, pristine regeneration
+- `references/validate.md` — format validation of an existing `sprint-status.yaml`
+- `sprint-status-template.yaml` — the documented file format and status vocabulary; the script embeds the same block and the test suite pins the two copies together

package/src/bmm-skills/plan/bmad-sprint-planning/references/fix-sprint-status.md

@@ -0,0 +1,30 @@
+# Fix Sprint Status
+
+Rebuild `sprint-status.yaml` to a pristine, script-valid state when it is broken, hand-mangled, drifted from reality, or the user simply asks to fix it. Inference determines what the state *should* be; the user confirms it; the script writes it. Never write without the confirmation.
+
+1. **Scope the damage.** Run `sprint_plan.py validate` and share what it found. If even the epic files are missing or unparseable, say so — there is nothing to rebuild tracking against until planning artifacts exist.
+
+2. **Determine the true state by inference.** This is judgment work — fan out subagents in parallel, each gathering one kind of evidence, and have each return proposed `key=status` pairs with the evidence behind them:
+   - **Epics** — read the epic files in `{planning_artifacts}`: the authoritative work breakdown (which epics, stories, and retrospectives should exist at all)
+   - **Story files** — scan `{implementation_artifacts}`: which stories have files on disk, and what their content says about progress (acceptance criteria checked off, completion notes, review sections)
+   - **Code evidence** — git history and the codebase: commits or merged work referencing story keys are evidence a story is done or in progress
+   - **The current file** — salvage everything credible from the existing `sprint-status.yaml`, especially `action_items`, even when its structure is broken
+
+3. **Reconcile into one proposed state.** Merge the evidence into a single table: key → proposed status, evidence, and anything uncertain. When evidence conflicts or is thin, prefer the lower status and flag it — a false `done` costs more than a false `in-progress`.
+
+4. **Confirm with `{user_name}`.** Show the table. Highlight every entry that differs from the current file — especially downgrades — and every low-confidence call. Adjust to their corrections. Headless: halt with `blocked` instead of confirming.
+
+5. **Write pristine.** One command, from the confirmed table:
+
+   ```
+   uv run {skill-root}/scripts/sprint_plan.py generate \
+     --epic-file <path> [...] \
+     --status-file {implementation_artifacts}/sprint-status.yaml \
+     --stories-dir {implementation_artifacts} \
+     --project "{project_name}" --date "{date}" \
+     --fresh --set <key>=<status> [--set <key>=<status> ...]
+   ```
+
+   `--fresh` rebuilds the document cleanly (canonical vocabulary, standard header) while still carrying `action_items`; `--set` applies the confirmed statuses and is the one path allowed to downgrade. Only confirmed entries that differ from the fresh defaults need a `--set`.
+
+6. **Verify.** Run `validate` again (expect `valid: true`) and present the status view summary so the user sees the repaired state.

package/src/bmm-skills/plan/bmad-sprint-planning/references/generate-tracking.md

@@ -0,0 +1,25 @@
+# Generate Tracking
+
+Discovery is your call; everything after it is the script's.
+
+1. Identify the epic files. The gate inventory already surfaced them — typically `epics.md`, `epic-*.md`, or a sharded `epics/` folder in `{planning_artifacts}`, but trust content over filename. If both a whole document and a sharded version exist, ask which is current rather than guessing.
+2. Run the script, passing every epic file:
+
+   ```
+   uv run {skill-root}/scripts/sprint_plan.py generate \
+     --epic-file <path> [--epic-file <path> ...] \
+     --status-file {implementation_artifacts}/sprint-status.yaml \
+     --stories-dir {implementation_artifacts} \
+     --project "{project_name}" --date "{date}"
+   ```
+
+   `{date}` must be `MM-DD-YYYY HH:MM` — the format the staleness check parses. The script owns parsing (`## Epic N:` / `### Story N.M: Title` → kebab-case keys; fenced code blocks ignored), ordering (epic, its stories, its retrospective), merging with any existing file (preserve advanced statuses, never downgrade; legacy v6 values like `drafted`/`contexted` are normalized to their modern meaning, never reset; `action_items`, custom keys, and user comments carried through; `project_key`/`tracking_system`/`story_location` kept from the existing file unless overridden by flag), story-file detection (a story file on disk floors its status at `ready-for-dev`), atomic writes, and post-write validation. It prints a JSON report. Add `--dry-run` to preview — the report's `in_sync`, `new_entries`, `dropped_orphans`, `illegal`, and `legacy_mapped` fields answer "is tracking in sync?" without writing.
+
+3. Read the JSON report and act on it — this is where judgment re-enters:
+   - `warnings` about unparsed Epic/Story-like headings mean the epic file deviates from the standard format. Show the user, fix the headings together (or accept the omission), and rerun.
+   - `dropped_orphans` are entries that existed in the old status file but match nothing in the epics — usually renames. Each carries its old status; reconcile with the user, then transplant by rerunning with `--set <new-key>=<old-status>`.
+   - If the epics defeat the parser entirely (a format the regexes can't see), fall back to building the file yourself against `sprint-status-template.yaml`, and tell the user the deterministic path didn't apply.
+
+## Report
+
+Present the result from the script's JSON in `{communication_language}`: file path, epic/story counts, status breakdown, anything upgraded from disk. Suggest next steps — review the file, `bmad-build` to start the first story, rerun this skill anytime to refresh after epics change.

package/src/bmm-skills/plan/bmad-sprint-planning/references/readiness-gate.md

@@ -0,0 +1,20 @@
+# Readiness Gate
+
+Before generating any tracking, judge whether the plan can actually be built. If the user only asked to check readiness, this gate is the deliverable — report the verdict and stop.
+
+Inventory what planning actually exists: scan `{planning_artifacts}` and `{project_knowledge}` for intent and planning artifacts — briefs, PRFAQs, PRDs, specs, UX outputs, architecture, epics and stories. Identify documents by reading what they are, not by filename patterns; projects arrive with different artifact mixes and naming.
+
+Assess the plan as a whole against one question: **could a developer implement these epics without inventing decisions nothing records?**
+
+- Requirements and decisions in the intent artifacts trace forward into stories; stories trace back to recorded intent — flag orphans in both directions
+- Epics deliver user value and carry no forward dependencies; stories are independently completable
+- Architecture and UX decisions the stories rely on are recorded somewhere, not assumed
+- Conflicts between artifacts (a spec and an epic disagreeing) are surfaced, not silently resolved
+
+A missing document type is only a finding if stories depend on decisions nothing records — a project with no UX artifact and no UI stories is fine.
+
+Deliver a verdict:
+
+- **PASS** — state it in one line; for the full sprint-planning intent, continue with `generate-tracking.md`
+- **CONCERNS** — list them briefly with where each gap lives; ask `{user_name}` whether to proceed anyway or fix first
+- **FAIL** — the plan is not implementable as recorded. Present findings ordered by severity, name the skill that fixes each (the relevant plan skill, or `bmad-correct-course` for cross-cutting changes), offer to save the findings to `{planning_artifacts}/implementation-readiness.md`, and stop

package/src/bmm-skills/plan/bmad-sprint-planning/references/status-view.md

@@ -0,0 +1,14 @@
+# Status View
+
+When the user wants to know where the sprint stands ("show sprint status", "where are we"), run:
+
+```
+uv run {skill-root}/scripts/sprint_plan.py status \
+  --status-file {implementation_artifacts}/sprint-status.yaml --date "{date}"
+```
+
+`{date}` is `MM-DD-YYYY HH:MM`. The script computes everything: counts by status (legacy values like `drafted` mapped transparently and reported in `legacy_mapped`), risk flags (stale file, orphaned stories, in-progress epics without stories, stories waiting in review, unrecognized keys), open action items from retrospectives, and the next recommended action by fixed priority — resume in-progress → review what's in review → start the next ready or backlog story → run an open retrospective → all done. If the file is missing, the script says so — offer to run sprint planning to create it.
+
+Render the JSON as a compact summary in `{communication_language}`: counts, risks, open action items, and the recommendation with its story key. Offer to run the recommended skill. Surface `illegal` and `unrecognized` entries and the script's `warnings` (malformed action items land there); if the user gives corrections, apply them via the fix flow rather than ad-hoc edits. No time estimates — status, risks, and next steps only.
+
+If the script errors — malformed YAML, a hand-edited structure it can't parse, anything — do not stop at the error. Read `sprint-status.yaml` yourself, apply best judgment to give the user the same summary (counts, risks, next recommended action), tell them the deterministic path failed and why, and offer the fix flow (`fix-sprint-status.md`) so the script works next time.

package/src/bmm-skills/plan/bmad-sprint-planning/references/validate.md

@@ -0,0 +1,10 @@
+# Validate
+
+When the user asks whether `sprint-status.yaml` is well-formed, run:
+
+```
+uv run {skill-root}/scripts/sprint_plan.py validate \
+  --status-file {implementation_artifacts}/sprint-status.yaml
+```
+
+Never writes; exits 0 whether valid or not. Report `valid` in one line. If `problems` is non-empty, list them plainly (each names the key or field at fault) and offer the fix flow (`fix-sprint-status.md`). If `legacy_mapped` is non-empty, note the file still uses v6 status names and that any regenerate will rewrite them to the modern vocabulary — progress is preserved either way.