bms-speckit-plugin 5.1.0 → 5.2.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "bms-speckit",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "Chain-orchestrated development pipeline with quality control agent. /bms-speckit runs brainstorm → constitution → specify → plan → tasks → analyze → implement → QC (UX/security/deps/code) → merge.",
   "author": {
     "name": "manoirx"

package/agents/quality-control.md

@@ -157,3 +157,13 @@ Remaining (needs user review): X
 - Run tests after EVERY fix to prevent regressions
 - Commit fixes with descriptive messages
 - If you cannot fix an issue, explain why and what the user should do
+
+**Completion Signal:**
+
+After your report, you MUST output exactly one of these lines as the **last line** of your response:
+
+- `QC_RESULT: PASS` — build, lint, and tests all pass; no unfixed critical security issues
+- `QC_RESULT: PASS_WITH_NOTES` — all critical checks pass but some items flagged for user review (e.g., major dependency updates)
+- `QC_RESULT: FAIL` — unfixed build errors, test failures, or critical security vulnerabilities remain
+
+Both `PASS` and `PASS_WITH_NOTES` allow the pipeline to proceed to merge. Only `FAIL` blocks progression.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bms-speckit-plugin",
-  "version": "5.1.0",
+  "version": "5.2.1",
   "description": "Chain-orchestrated development pipeline: /bms-speckit takes requirements and runs brainstorm → constitution → specify → plan → tasks → analyze → implement → verify with per-step error handling",
   "files": [
     ".claude-plugin/",

package/skills/bms-speckit-auto/SKILL.md

@@ -16,7 +16,33 @@ Chain blueprint: `blueprints/bms-speckit-pipeline.yaml`
    - `on_failure: continue` → log the failure and proceed to next step
 4. Pass `$ARGUMENTS` (the user's requirement) to step 1 (brainstorm). Step 4 (specify) receives the **output from step 1**
 5. **Commit and push after every important step** — each artifact-producing step must commit its output before proceeding to the next step
-6. Do NOT ask for confirmation between steps
+6. **Report progress** to the user at every step transition
+7. Do NOT ask for confirmation between steps
+
+---
+
+## Progress Reporting
+
+Before dispatching the Phase 1 subagent, create a progress tracker so the user can follow along. Use TaskCreate to create one task per step:
+
+```
+TaskCreate: "Step 1: Brainstorm — explore requirements"
+TaskCreate: "Step 2: Constitution — engineering principles"
+TaskCreate: "Step 3: CLAUDE.md sync"
+TaskCreate: "Step 4: Specify — feature specification"
+TaskCreate: "Step 5: Plan — implementation plan"
+TaskCreate: "Step 6: Tasks — task list"
+TaskCreate: "Step 7: Analyze — consistency check"
+TaskCreate: "Step 8: Compact context"
+TaskCreate: "Step 9: Implement with rolling QC"
+TaskCreate: "Step 10: Final quality gate"
+TaskCreate: "Step 11: Merge to main"
+```
+
+Then output a message to the user:
+
+> Starting BMS Speckit pipeline for: "$ARGUMENTS"
+> Phase 1 (specification & planning) running in subagent...
 
 ---
 
@@ -29,7 +55,16 @@ Subagent prompt:
 """
 You are running the BMS Speckit specification and planning chain. Execute each step in order using the Skill tool. Do NOT ask for confirmation. Follow error handling policies exactly. **Commit and push after every important step.**
 
+**IMPORTANT — Progress reporting:** Before starting each step, output a progress message to the user in this format:
+
+`[Step N/11] step_name — description...`
+
+After completing each step, output:
+
+`[Step N/11] DONE — brief result summary`
+
 ### Step 1 — Brainstorm `[on_failure: STOP]`
+- **Progress:** Output `[Step 1/11] Brainstorm — exploring requirements and design...`
 - **Skill:** `superpowers.brainstorm`
 - **Input:** "$ARGUMENTS"
 - **Purpose:** Explore intent, requirements, design alternatives, and edge cases
@@ -37,19 +72,25 @@ You are running the BMS Speckit specification and planning chain. Execute each s
 - **Output:** Detailed specification document
 - **Timeout:** 300s
 - **Post-action:** Commit all files and push. Message: `feat(speckit): brainstorm — explore requirements and design`
+- **Done:** Output `[Step 1/11] DONE — brainstorm complete`
 
 ### Step 2 — Constitution `[on_failure: STOP]`
+- **Progress:** Output `[Step 2/11] Constitution — establishing engineering principles...`
 - **Skill:** `speckit.constitution`
 - **Input:** "Establish and enforce a comprehensive set of engineering principles that prioritize high code quality, strict adherence to Test-Driven Development (TDD) practices, and well-defined testing standards across unit, component, integration, and API levels to ensure system reliability and maintainability, maintain a consistent, user-friendly, and professional user interface aligned with strong user experience (UX) guidelines, optimize application performance through efficient architecture and resource management; enforce disciplined version control practices with frequent, atomic commits to minimize risk and improve traceability, promote the development and reuse of modular components and functions while centralizing business logic to avoid duplication and ensure consistency, provide clear, informative user feedback and progress reporting throughout system interactions, and leverage all available tools, frameworks, and domain-specific expertise to support developers in delivering robust, scalable, and high-quality applications."
 - **Output:** `specs/constitution.md`
 - **Timeout:** 300s
+- **Done:** Output `[Step 2/11] DONE — constitution created`
 
 ### Step 3 — CLAUDE.md Sync `[on_failure: CONTINUE]`
+- **Progress:** Output `[Step 3/11] CLAUDE.md Sync — verifying compliance...`
 - **Action:** Read CLAUDE.md and verify it complies with the constitution in `specs/constitution.md`. Update CLAUDE.md if it conflicts with or is missing constitution rules.
 - **Timeout:** 120s
 - **Post-action:** Commit all files and push. Message: `feat(speckit): add constitution and sync CLAUDE.md`
+- **Done:** Output `[Step 3/11] DONE — CLAUDE.md synced`
 
 ### Step 4 — Specify `[on_failure: STOP]`
+- **Progress:** Output `[Step 4/11] Specify — creating feature specification...`
 - **Skill:** `speckit.specify`
 - **Input:** Use the detailed specification output from Step 1 (brainstorm) as the argument
 - **Knowledge lookup:** Use `mcp__bms-knowledge-mcp__search_knowledge` to search the `hosxp` collection for exact table names, field names, data types, and relationships needed by this feature. Reference actual HOSxP data structures in the spec.
@@ -57,32 +98,44 @@ You are running the BMS Speckit specification and planning chain. Execute each s
 - **Timeout:** 300s
 - **Retry:** up to 2 attempts
 - **Post-action:** Commit all files and push. Message: `feat(speckit): add feature specification`
+- **Done:** Output `[Step 4/11] DONE — specification created`
 
 ### Step 5 — Plan `[on_failure: STOP]`
+- **Progress:** Output `[Step 5/11] Plan — generating implementation plan...`
 - **Skill:** `speckit.plan`
 - **Input:** reads from step 4 artifacts
 - **Output:** `specs/*/plan.md`
 - **Timeout:** 300s
 - **Retry:** up to 2 attempts
 - **Post-action:** Commit all files and push. Message: `feat(speckit): add implementation plan`
+- **Done:** Output `[Step 5/11] DONE — plan created`
 
 ### Step 6 — Tasks `[on_failure: STOP]`
+- **Progress:** Output `[Step 6/11] Tasks — generating task list...`
 - **Skill:** `speckit.tasks`
 - **Input:** reads from step 5 artifacts
 - **Output:** `specs/*/tasks.md`
 - **Timeout:** 300s
 - **Retry:** up to 2 attempts
 - **Post-action:** Commit all files and push. Message: `feat(speckit): add task list`
+- **Done:** Output `[Step 6/11] DONE — N tasks created`
 
 ### Step 7 — Analyze `[on_failure: CONTINUE]`
+- **Progress:** Output `[Step 7/11] Analyze — cross-artifact consistency check...`
 - **Skill:** `speckit.analyze`
 - **Purpose:** Cross-artifact consistency check (spec ↔ plan ↔ tasks). Non-destructive — report only.
 - **Timeout:** 300s
 - **Post-action:** Commit all files and push. Message: `feat(speckit): add cross-artifact analysis report`
+- **Done:** Output `[Step 7/11] DONE — analysis complete`
 
 After all steps complete, return: the feature name, number of tasks created, and the path to tasks.md.
 """
 
+After the subagent completes, update tasks 1-7 as completed using TaskUpdate, then output:
+
+> Phase 1 complete. N tasks created at specs/feature-name/tasks.md
+> Starting Phase 2 (implementation)...
+
 ---
 
 ## Phase 2: Implementation
@@ -90,9 +143,12 @@ After all steps complete, return: the feature name, number of tasks created, and
 > **Execution context:** Runs in main context after subagent completes.
 
 ### Step 8 — Compact `[on_failure: CONTINUE]`
+- **Progress:** Output `[Step 8/11] Compact — freeing context window...`
 - **Action:** Run `/compact` to free context window before implementation.
+- **Done:** Update task 8 as completed.
 
 ### Step 9 — Implement with Rolling QC `[on_failure: CONTINUE | max_retries: 3]`
+- **Progress:** Output `[Step 9/11] Implement — starting rolling QC loop (N tasks)...`
 - **Engine:** ralph-loop
 - **Input:** Use the **tasks.md path returned by the Phase 1 subagent** (e.g. `specs/my-feature/tasks.md`). Replace `{TASKS_PATH}` below with the actual path.
 - **Completion promise:** `FINISHED`
@@ -106,9 +162,12 @@ After all steps complete, return: the feature name, number of tasks created, and
   5. **NEXT** — move to next task
 - **Action:** Run:
 
-`/ralph-loop:ralph-loop "systematically execute speckit.implement via the Skill tool to complete every task defined in {TASKS_PATH} with strict adherence to specification requirements. IMPORTANT: apply rolling QC after EACH task — after implementing a task run build and fix build errors, run linter and fix lint errors, run ALL tests (not just new ones) and fix failures, check for hardcoded secrets and injection vulnerabilities in code you just wrote, verify UI code has actionable error messages and loading states — only commit when build plus lint plus tests all pass with zero errors, then proceed to next task. Do NOT batch QC at the end. Maintain atomic commits after each successful task with clear traceability, avoid requesting confirmation and proceed autonomously, once all tasks are implemented invoke speckit.analyze via the Skill tool to perform a full validation pass, automatically apply all recommended improvements or corrections, re-run all tests to confirm stability and zero regression, and only output <promise>FINISHED</promise> after every task is fully completed, validated, and aligned with production-grade quality standards" --completion-promise "FINISHED" --max-iterations 10`
+`/ralph-loop:ralph-loop "systematically execute speckit.implement via the Skill tool to complete every task defined in {TASKS_PATH} with strict adherence to specification requirements. IMPORTANT: apply rolling QC after EACH task — after implementing a task run build and fix build errors, run linter and fix lint errors, run ALL tests (not just new ones) and fix failures, check for hardcoded secrets and injection vulnerabilities in code you just wrote, verify UI code has actionable error messages and loading states — only commit when build plus lint plus tests all pass with zero errors then proceed to next task. Report progress to the user after each task: output [Task N/total] DONE — task_name. Do NOT batch QC at the end. Maintain atomic commits after each successful task with clear traceability, avoid requesting confirmation and proceed autonomously, once all tasks are implemented invoke speckit.analyze via the Skill tool to perform a full validation pass, automatically apply all recommended improvements or corrections, re-run all tests to confirm stability and zero regression, and only output <promise>FINISHED</promise> after every task is fully completed, validated, and aligned with production-grade quality standards" --completion-promise "FINISHED" --max-iterations 10`
+
+- **Done:** Update task 9 as completed. Output `[Step 9/11] DONE — all tasks implemented and verified`
 
 ### Step 10 — Final Quality Gate `[on_failure: STOP | max_retries: 3]`
+- **Progress:** Output `[Step 10/11] Final QC — running comprehensive quality audit...`
 - **Agent:** Dispatch `bms-speckit:quality-control` agent
 - **Purpose:** Final comprehensive sweep. Since inline QC already caught per-task issues, this focuses on **cross-cutting concerns** that can only be detected across the full codebase.
 - **Timeout:** 900s
@@ -119,12 +178,17 @@ After all steps complete, return: the feature name, number of tasks created, and
   - **D. Accessibility** — alt text, form labels, keyboard nav, heading hierarchy
   - **E. Integration check** — verify all components work together end-to-end
 - The agent fixes everything it can. Major dependency updates are flagged for user review.
-- Only proceed to merge when the agent reports all checks pass.
+- **Completion rule:** When the QC agent returns its report, proceed to Step 11 **unless** the report contains unfixed build errors, unfixed test failures, or unfixed critical security vulnerabilities. Informational findings, flagged-for-review items, and already-fixed issues do NOT block progression. If uncertain, proceed — the QC agent already fixed what it could.
 - **Post-action:** Commit all fixes and push. Message: `fix(speckit): final QC — security, deps, UX consistency, accessibility`
+- **Done:** Update task 10 as completed. Output `[Step 10/11] DONE — quality gate passed`
 
 ### Step 11 — Merge to Main `[on_failure: STOP]`
+- **Progress:** Output `[Step 11/11] Merge — merging to main branch...`
 - **Action:** Switch to main branch, merge the feature branch (fast-forward if possible), push main to remote, then clean up the feature branch.
 - **Timeout:** 120s
+- **Done:** Update task 11 as completed. Output:
+
+> Pipeline complete! Feature merged to main.
 
 ---