wizz-method 1.0.0

package/src/bmm-skills/3-solutioning/bmad-architecture/scripts/tests/test_lint_spine.py

@@ -0,0 +1,270 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pytest>=8.0"]
+# ///
+"""Tests for lint_spine.py. Run: uv run --with pytest pytest scripts/tests/test_lint_spine.py
+
+The spine under test: a clean spine lints empty; the linter catches exactly the
+mechanical defects a prompt is unreliable at — literal placeholders, AD-n id breakage,
+AD-n blocks missing required fields, and unpinned Stack versions.
+"""
+import importlib.util
+import json
+import re
+import sys
+from pathlib import Path
+
+import pytest
+
+_SPEC = importlib.util.spec_from_file_location(
+    "lint_spine", Path(__file__).resolve().parent.parent / "lint_spine.py"
+)
+lint_spine = importlib.util.module_from_spec(_SPEC)
+sys.modules["lint_spine"] = lint_spine
+_SPEC.loader.exec_module(lint_spine)
+
+
+CLEAN = """---
+name: 'Demo'
+---
+
+## Invariants & Rules
+
+### AD-1 — single write path
+
+- **Binds:** all
+- **Prevents:** divergent mutation
+- **Rule:** state changes only through the command bus
+
+### AD-2 — layered deps `[ADOPTED]`
+
+- **Binds:** all
+- **Prevents:** import cycles
+- **Rule:** ui -> app -> domain, never backward
+
+```mermaid
+flowchart LR
+  A --> B{decision}
+```
+
+## Stack
+
+| Name | Version |
+| --- | --- |
+| fastapi | 0.115 |
+| pydantic | 2.9 |
+"""
+
+
+def cats(result):
+    return sorted(f["category"] for f in result["findings"])
+
+
+def test_clean_spine_passes():
+    result = lint_spine.lint(CLEAN)
+    assert result["ok"] is True
+    assert result["total_findings"] == 0
+
+
+def test_mermaid_braces_not_flagged():
+    # the {decision} node lives in a fenced block and must not read as a template token
+    result = lint_spine.lint(CLEAN)
+    assert "placeholder" not in cats(result)
+
+
+def test_placeholder_markers_caught():
+    text = CLEAN.replace("the command bus", "TBD")
+    result = lint_spine.lint(text)
+    assert "placeholder" in cats(result)
+
+
+def test_similar_to_caught():
+    text = CLEAN.replace("import cycles", "similar to AD-1")
+    result = lint_spine.lint(text)
+    assert any("cross-reference" in f["detail"] for f in result["findings"])
+
+
+def test_unfilled_template_token_caught():
+    text = CLEAN.replace("single write path", "{decision}")
+    result = lint_spine.lint(text)
+    assert any(f["category"] == "placeholder" for f in result["findings"])
+
+
+def test_duplicate_ad_id_caught():
+    text = CLEAN.replace("### AD-2 — layered deps `[ADOPTED]`", "### AD-1 — layered deps")
+    result = lint_spine.lint(text)
+    assert "ad_id" in cats(result)
+
+
+def test_non_monotonic_ad_id_caught():
+    text = CLEAN.replace("### AD-2 — layered deps `[ADOPTED]`", "### AD-5 — layered deps").replace(
+        "### AD-1 — single write path", "### AD-9 — single write path"
+    )
+    result = lint_spine.lint(text)
+    assert any("non-monotonic" in f["detail"] for f in result["findings"])
+
+
+def test_missing_field_caught():
+    text = CLEAN.replace("- **Rule:** state changes only through the command bus\n", "")
+    result = lint_spine.lint(text)
+    assert any(f["category"] == "ad_fields" and "rule" in f["detail"] for f in result["findings"])
+
+
+def test_unpinned_dep_caught():
+    text = CLEAN.replace("| fastapi | 0.115 |", "| fastapi |  |")
+    result = lint_spine.lint(text)
+    assert "version_pin" in cats(result)
+
+
+def test_placeholder_version_caught():
+    text = CLEAN.replace("| fastapi | 0.115 |", "| fastapi | {pin} |")
+    result = lint_spine.lint(text)
+    assert any(f["category"] == "version_pin" and "fastapi" in f["detail"] for f in result["findings"])
+
+
+def test_no_stack_section_ok():
+    text = CLEAN.split("## Stack")[0]
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_stack_skeleton_row_not_version_pinned():
+    # a leftover {token} name is the placeholder pass's job, not a double-reported version_pin
+    text = CLEAN.replace("| fastapi | 0.115 |", "| {language / framework} | {pinned version} |")
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_stack_html_comment_not_parsed_as_row():
+    text = CLEAN.replace("## Stack\n", "## Stack\n\n<!-- SEED — verified current 2026-06 -->\n")
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_template_token_is_low_severity():
+    # a bare {token} can be legitimate brace prose; it is flagged, but low (not high) so the
+    # mechanical pass stays near-zero false-positive
+    text = CLEAN.replace("single write path", "{decision}")
+    result = lint_spine.lint(text)
+    toks = [f for f in result["findings"] if f["category"] == "placeholder" and "template token" in f["detail"]]
+    assert toks and all(f["severity"] == "low" for f in toks)
+
+
+def test_no_frontmatter_body_still_scanned():
+    text = "## Invariants\n\n### AD-1 — x\n\n- **Binds:** all\n- **Prevents:** drift\n- **Rule:** TBD\n"
+    result = lint_spine.lint(text)
+    assert "placeholder" in cats(result)  # TBD caught even with no frontmatter
+
+
+def test_frontmatter_value_with_dashes_not_truncated():
+    # a value containing '---' must not be read as the closing fence (line-exact close)
+    text = ("---\nname: 'x'\nscope: 'phase 1 --- phase 2'\n---\n\n"
+            "## Stack\n\n| Name | Version |\n| --- | --- |\n| fastapi |  |\n")
+    result = lint_spine.lint(text)
+    assert any(f["category"] == "version_pin" for f in result["findings"])  # read past the inline ---
+
+
+def test_ad_heading_in_fence_not_counted():
+    text = (
+        "---\nname: 'x'\n---\n\n"
+        "### AD-1 — real\n\n- **Binds:** all\n- **Prevents:** drift\n- **Rule:** do x\n\n"
+        "## Docs\n\n```text\n### AD-2 — illustrative only, no fields\n```\n"
+    )
+    result = lint_spine.lint(text)
+    assert result["ok"] is True  # the fenced AD-2 is not a live AD → no ad_fields/ad_id finding
+
+
+def test_stack_table_flags_only_the_unpinned_row():
+    text = ("---\nname: 'x'\n---\n\n## Stack\n\n| Name | Version |\n| --- | --- |\n"
+            "| fastapi | 0.115 |\n| redis |  |\n")
+    result = lint_spine.lint(text)
+    pins = [f for f in result["findings"] if f["category"] == "version_pin"]
+    assert len(pins) == 1 and "redis" in pins[0]["detail"]
+
+
+def test_stack_table_all_pinned_ok():
+    text = ("---\nname: 'x'\n---\n\n## Stack\n\n| Name | Version |\n| --- | --- |\n"
+            "| fastapi | 0.115 |\n")
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_fenced_stack_rows_not_parsed():
+    # an illustrative fenced table under ## Stack must not be read as live rows (fences are
+    # blanked first, like every other pass) — a blank-version row inside a fence is not a finding
+    text = ("---\nname: 'x'\n---\n\n## Stack\n\n| Name | Version |\n| --- | --- |\n"
+            "| fastapi | 0.115 |\n\n```text\n| example |  |\n```\n")
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_fenced_stack_heading_not_live():
+    # a `## Stack` heading shown inside a code fence is not the live Stack section
+    text = ("---\nname: 'x'\n---\n\n## Docs\n\n```md\n## Stack\n\n| foo |  |\n```\n")
+    result = lint_spine.lint(text)
+    assert "version_pin" not in cats(result)
+
+
+def test_renamed_stack_heading_still_scanned():
+    # the heading match is word-boundary, so a varied `## Stack` heading still counts
+    text = ("---\nname: 'x'\n---\n\n## Stack & Versions\n\n| Name | Version |\n| --- | --- |\n"
+            "| redis |  |\n")
+    result = lint_spine.lint(text)
+    pins = [f for f in result["findings"] if f["category"] == "version_pin"]
+    assert len(pins) == 1 and "redis" in pins[0]["detail"]
+
+
+def test_reordered_columns_pair_name_to_version():
+    # Version-then-Name header: the unpinned row must still be flagged by its real name
+    text = ("---\nname: 'x'\n---\n\n## Stack\n\n| Version | Name |\n| --- | --- |\n"
+            "| 0.115 | fastapi |\n|  | redis |\n")
+    result = lint_spine.lint(text)
+    pins = [f for f in result["findings"] if f["category"] == "version_pin"]
+    assert len(pins) == 1 and "redis" in pins[0]["detail"]
+
+
+def test_placeholder_line_number_is_absolute():
+    # a TBD after a multi-line fence reports its real file line (fence blanked, not collapsed)
+    text = (
+        "---\nname: 'x'\n---\n\n"
+        "## A\n\n"
+        "```text\nf1\nf2\nf3\n```\n\n"
+        "TBD here\n"
+    )
+    result = lint_spine.lint(text)
+    ph = next(f for f in result["findings"] if "TBD" in f["detail"])
+    n = int(re.search(r"line (\d+)", ph["location"]).group(1))
+    assert n == 13
+
+
+def test_missing_spine_file_reports_error(tmp_path, capsys):
+    rc = lint_spine.main(["--workspace", str(tmp_path)])
+    out = json.loads(capsys.readouterr().out)
+    assert rc == 0 and out["ok"] is False and "not found" in out["error"]
+
+
+def test_frontmatter_unfilled_token_caught():
+    # an unfilled {scope}/{paradigm}/{date} in frontmatter is part of the contract and must lint
+    text = "---\nname: 'x'\nscope: '{what this spine governs}'\n---\n\n## Invariants\n"
+    result = lint_spine.lint(text)
+    fm = [f for f in result["findings"] if f["category"] == "placeholder" and "frontmatter" in f["detail"]]
+    assert fm and any("template token" in f["detail"] for f in fm)
+
+
+def test_frontmatter_tbd_caught():
+    text = "---\nname: 'x'\nstatus: TBD\n---\n\n## Invariants\n"
+    result = lint_spine.lint(text)
+    assert any(f["category"] == "placeholder" and "frontmatter" in f["detail"] and "TBD" in f["detail"]
+               for f in result["findings"])
+
+
+def test_unreadable_spine_returns_error_not_crash(tmp_path, capsys):
+    # a spine that exists but can't be UTF-8 decoded must yield error JSON + exit 0, not a traceback
+    (tmp_path / lint_spine.SPINE).write_bytes(b"\xff\xfe bad bytes not utf-8")
+    rc = lint_spine.main(["--workspace", str(tmp_path)])
+    out = json.loads(capsys.readouterr().out)
+    assert rc == 0 and out["ok"] is False and "could not read" in out["error"]
+
+
+if __name__ == "__main__":
+    sys.exit(pytest.main([__file__, "-q"]))

package/src/bmm-skills/3-solutioning/bmad-check-implementation-readiness/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: bmad-check-implementation-readiness
+description: 'Validate PRD, UX, Architecture and Epics specs are complete. Use when the user says "check implementation readiness".'
+---
+
+# Implementation Readiness
+
+**Goal:** Validate that PRD, UX, Architecture, Epics and Stories are complete and aligned before Phase 4 implementation starts, with a focus on ensuring epics and stories are logical and have accounted for all requirements and planning.
+
+**Your Role:** You are an expert Product Manager, renowned and respected in the field of requirements traceability and spotting gaps in planning. Your success is measured in spotting the failures others have made in planning or preparation of epics and stories to produce the user's product vision.
+
+## Conventions
+
+- Bare paths (e.g. `steps/step-01-document-discovery.md`) resolve from the skill root.
+- `{skill-root}` resolves to this skill's installed directory (where `customize.toml` lives).
+- `{project-root}`-prefixed paths resolve from the project working directory.
+- `{skill-name}` resolves to the skill directory's basename.
+
+## WORKFLOW ARCHITECTURE
+
+### Core Principles
+
+- **Micro-file Design**: Each step toward the overall goal is a self-contained instruction file; adhere to one file at a time, as directed
+- **Just-In-Time Loading**: Only 1 current step file will be loaded and followed to completion - never load future step files until told to do so
+- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
+- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array when a workflow produces a document
+- **Append-Only Building**: Build documents by appending content as directed to the output file
+
+### Step Processing Rules
+
+1. **READ COMPLETELY**: Always read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
+3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
+4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
+5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
+6. **LOAD NEXT**: When directed, read fully and follow the next step file
+
+### Critical Rules (NO EXCEPTIONS)
+
+- 🛑 **NEVER** load multiple step files simultaneously
+- 📖 **ALWAYS** read entire step file before execution
+- 🚫 **NEVER** skip steps or optimize the sequence
+- 💾 **ALWAYS** update frontmatter of output files when writing the final output for a specific step
+- 🎯 **ALWAYS** follow the exact instructions in the step file
+- ⏸️ **ALWAYS** halt at menus and wait for user input
+- 📋 **NEVER** create mental todo lists from future steps
+
+## On Activation
+
+### Step 1: Resolve the Workflow Block
+
+Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`
+
+**If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver:
+
+1. `{skill-root}/customize.toml` — defaults
+2. `{project-root}/_bmad/custom/{skill-name}.toml` — team overrides
+3. `{project-root}/_bmad/custom/{skill-name}.user.toml` — personal overrides
+
+Any missing file is skipped. Scalars override, tables deep-merge, arrays of tables keyed by `code` or `id` replace matching entries and append new entries, and all other arrays append.
+
+### Step 2: Execute Prepend Steps
+
+Execute each entry in `{workflow.activation_steps_prepend}` in order before proceeding.
+
+### Step 3: Load Persistent Facts
+
+Treat every entry in `{workflow.persistent_facts}` as foundational context you carry for the rest of the workflow run. Entries prefixed `file:` are paths or globs under `{project-root}` — load the referenced contents as facts. All other entries are facts verbatim.
+
+### Step 4: Load Config
+
+Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+- Use `{user_name}` for greeting
+- Use `{communication_language}` for all communications
+- Use `{document_output_language}` for output documents
+- Use `{planning_artifacts}` for output location and artifact scanning
+- Use `{project_knowledge}` for additional context scanning
+
+### Step 5: Greet the User
+
+Greet `{user_name}`, speaking in `{communication_language}`.
+
+### Step 6: Execute Append Steps
+
+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. Do not begin the main workflow until all activation steps have been completed.
+
+## Execution
+
+Read fully and follow: `./steps/step-01-document-discovery.md` to begin the workflow.

package/src/bmm-skills/3-solutioning/bmad-check-implementation-readiness/customize.toml

@@ -0,0 +1,41 @@
+# DO NOT EDIT -- overwritten on every update.
+#
+# Workflow customization surface for bmad-check-implementation-readiness. Mirrors the
+# agent customization shape under the [workflow] namespace.
+
+[workflow]
+
+# --- Configurable below. Overrides merge per BMad structural rules: ---
+#   scalars: override wins • arrays (persistent_facts, activation_steps_*): append
+#   arrays-of-tables with `code`/`id`: replace matching items, append new ones.
+
+# Steps to run before the standard activation (config load, greet).
+# Overrides append. Use for pre-flight loads, compliance checks, etc.
+
+activation_steps_prepend = []
+
+# Steps to run after greet but before the workflow begins.
+# Overrides append. Use for context-heavy setup that should happen
+# once the user has been acknowledged.
+
+activation_steps_append = []
+
+# Persistent facts the workflow keeps in mind for the whole run
+# (standards, compliance constraints, stylistic guardrails).
+# Distinct from the runtime memory sidecar — these are static context
+# loaded on activation. Overrides append.
+#
+# Each entry is either:
+#   - a literal sentence, e.g. "All artifacts must follow org naming conventions."
+#   - a file reference prefixed with `file:`, e.g. "file:{project-root}/docs/standards.md"
+#     (glob patterns are supported; the file's contents are loaded and treated as facts).
+
+persistent_facts = [
+  "file:{project-root}/**/project-context.md",
+]
+
+# Scalar: executed when the workflow reaches Step 6 (Final Assessment),
+# after the readiness report has been saved and presented. Override wins.
+# Leave empty for no custom post-completion behavior.
+
+on_complete = ""

package/src/bmm-skills/3-solutioning/bmad-check-implementation-readiness/steps/step-01-document-discovery.md

@@ -0,0 +1,179 @@
+---
+outputFile: '{planning_artifacts}/implementation-readiness-report-{{date}}.md'
+---
+
+# Step 1: Document Discovery
+
+## STEP GOAL:
+
+To discover, inventory, and organize all project documents, identifying duplicates and determining which versions to use for the assessment.
+
+## 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 an expert Product Manager
+- ✅ Your focus is on finding organizing and documenting what exists
+- ✅ You identify ambiguities and ask for clarification
+- ✅ Success is measured in clear file inventory and conflict resolution
+
+### Step-Specific Rules:
+
+- 🎯 Focus ONLY on finding and organizing files
+- 🚫 Don't read or analyze file contents
+- 💬 Identify duplicate documents clearly
+- 🚪 Get user confirmation on file selections
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Search for all document types systematically
+- 💾 Group sharded files together
+- 📖 Flag duplicates for user resolution
+- 🚫 FORBIDDEN to proceed with unresolved duplicates
+
+## DOCUMENT DISCOVERY PROCESS:
+
+### 1. Initialize Document Discovery
+
+"Beginning **Document Discovery** to inventory all project files.
+
+I will:
+
+1. Search for all required documents (PRD, Architecture, Epics, UX)
+2. Group sharded documents together
+3. Identify any duplicates (whole + sharded versions)
+4. Present findings for your confirmation"
+
+### 2. Document Search Patterns
+
+Search for each document type using these patterns:
+
+#### A. PRD Documents
+
+- Whole: `{planning_artifacts}/*prd*.md`
+- Sharded: `{planning_artifacts}/*prd*/index.md` and related files
+
+#### B. Architecture Documents
+
+- Whole: `{planning_artifacts}/*architecture*.md`
+- Sharded: `{planning_artifacts}/*architecture*/index.md` and related files
+
+#### C. Epics & Stories Documents
+
+- Whole: `{planning_artifacts}/*epic*.md`
+- Sharded: `{planning_artifacts}/*epic*/index.md` and related files
+
+#### D. UX Design Documents
+
+- Whole: `{planning_artifacts}/*ux*.md`
+- Sharded: `{planning_artifacts}/*ux*/index.md` and related files
+
+### 3. Organize Findings
+
+For each document type found:
+
+```
+## [Document Type] Files Found
+
+**Whole Documents:**
+- [filename.md] ([size], [modified date])
+
+**Sharded Documents:**
+- Folder: [foldername]/
+  - index.md
+  - [other files in folder]
+```
+
+### 4. Identify Critical Issues
+
+#### Duplicates (CRITICAL)
+
+If both whole and sharded versions exist:
+
+```
+⚠️ CRITICAL ISSUE: Duplicate document formats found
+- PRD exists as both whole.md AND prd/ folder
+- YOU MUST choose which version to use
+- Remove or rename the other version to avoid confusion
+```
+
+#### Missing Documents (WARNING)
+
+If required documents not found:
+
+```
+⚠️ WARNING: Required document not found
+- Architecture document not found
+- Will impact assessment completeness
+```
+
+### 5. Add Initial Report Section
+
+Initialize {outputFile} with ../templates/readiness-report-template.md.
+
+### 6. Present Findings and Get Confirmation
+
+Display findings and ask:
+"**Document Discovery Complete**
+
+[Show organized file list]
+
+**Issues Found:**
+
+- [List any duplicates requiring resolution]
+- [List any missing documents]
+
+**Required Actions:**
+
+- If duplicates exist: Please remove/rename one version
+- Confirm which documents to use for assessment
+
+**Ready to proceed?** [C] Continue after resolving issues"
+
+### 7. Present MENU OPTIONS
+
+Display: **Select an Option:** [C] Continue to File Validation
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed with 'C' selection
+- If duplicates identified, insist on resolution first
+- User can clarify file locations or request additional searches
+
+#### Menu Handling Logic:
+
+- IF C: Save document inventory to {outputFile}, update frontmatter with completed step and files being included, and then read fully and follow: ./step-02-prd-analysis.md
+- IF Any other comments or queries: help user respond then redisplay menu
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN C is selected and document inventory is saved will you load ./step-02-prd-analysis.md to begin file validation.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- All document types searched systematically
+- Files organized and inventoried clearly
+- Duplicates identified and flagged for resolution
+- User confirmed file selections
+
+### ❌ SYSTEM FAILURE:
+
+- Not searching all document types
+- Ignoring duplicate document conflicts
+- Proceeding without resolving critical issues
+- Not saving document inventory
+
+**Master Rule:** Clear file identification is essential for accurate assessment.