bms-speckit-plugin 3.9.0 → 4.0.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "bms-speckit",
-  "version": "2.0.0",
-  "description": "Single-command automated development pipeline. /bms-speckit takes requirements and runs the full engineering workflow with TDD and quality gates.",
+  "version": "4.0.0",
+  "description": "Chain-orchestrated development pipeline with per-step error handling. /bms-speckit runs brainstorm → constitution → specify → plan → tasks → analyze → implement → verify.",
   "author": {
     "name": "manoirx"
   },

package/blueprints/bms-speckit-pipeline.yaml

@@ -0,0 +1,247 @@
+# BMS Speckit Development Pipeline — Chain Blueprint
+# Compatible with Skene Cookbook chain pattern (https://github.com/SkeneTechnologies/skene-cookbook)
+#
+# This blueprint defines the chain sequence, I/O contracts, error handling,
+# and timeout constraints for each step. The SKILL.md orchestrator executes
+# this chain via Claude Code's Skill tool.
+
+id: bms_speckit_development_pipeline
+version: 4.0.0
+name: BMS Speckit Automated Development Pipeline
+description: >
+  Full engineering workflow from requirement to verified implementation.
+  Chains brainstorming, constitution, specification, planning, task generation,
+  analysis, implementation (TDD), and final verification.
+category: Development
+
+# ─── Chain Sequence ────────────────────────────────────────────────────────────
+
+chain_sequence:
+
+  # ── Phase 1: Specification & Planning (subagent context) ──────────────────
+
+  - step_id: step_0_brainstorm
+    skill_id: superpowers.brainstorm
+    action: execute
+    phase: 1
+    description: Explore intent, requirements, and design before implementation
+    timeout_seconds: 300
+    input:
+      requirement: "$ARGUMENTS"
+    output:
+      artifacts: [detailed_specification]
+    error_handling:
+      on_failure: stop
+      max_retries: 1
+    opinionated_prompts:
+      system_context: >
+        Write a detailed specification from the user's requirement.
+        Explore edge cases, constraints, and design alternatives.
+
+  - step_id: step_1_constitution
+    skill_id: speckit.constitution
+    action: execute
+    phase: 1
+    description: Establish and enforce engineering principles
+    timeout_seconds: 300
+    input:
+      principles: >
+        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:
+      artifacts: [specs/constitution.md]
+    error_handling:
+      on_failure: stop
+      max_retries: 1
+    opinionated_prompts:
+      system_context: >
+        TDD is non-negotiable. Constitution must enforce testing at all levels,
+        atomic commits, reusable components, and centralized business logic.
+
+  - step_id: step_2_claude_md_sync
+    skill_id: internal.claude_md_verify
+    action: execute
+    phase: 1
+    description: Verify CLAUDE.md complies with constitution
+    timeout_seconds: 120
+    input:
+      constitution_path: specs/constitution.md
+      target_path: CLAUDE.md
+    error_handling:
+      on_failure: continue
+      max_retries: 1
+    opinionated_prompts:
+      system_context: >
+        Read CLAUDE.md and verify it complies with specs/constitution.md.
+        Update CLAUDE.md if it conflicts with or is missing constitution rules.
+
+  - step_id: step_3_specify
+    skill_id: speckit.specify
+    action: execute
+    phase: 1
+    description: Create feature specification from brainstorm output
+    timeout_seconds: 300
+    input:
+      requirement: "{{step_0_brainstorm.output}}"
+    output:
+      artifacts: [specs/*/spec.md]
+    error_handling:
+      on_failure: stop
+      max_retries: 2
+    opinionated_prompts:
+      system_context: >
+        Generate a complete, testable specification. Include acceptance criteria,
+        data models, API contracts, and edge cases.
+
+  - step_id: step_4_plan
+    skill_id: speckit.plan
+    action: execute
+    phase: 1
+    description: Generate implementation plan from specification
+    timeout_seconds: 300
+    input:
+      source: "{{step_3_specify.artifacts}}"
+    output:
+      artifacts: [specs/*/plan.md]
+    error_handling:
+      on_failure: stop
+      max_retries: 2
+    opinionated_prompts:
+      system_context: >
+        Plan in ordered steps. Include file paths, component boundaries,
+        test strategy, and rollback considerations.
+
+  - step_id: step_5_tasks
+    skill_id: speckit.tasks
+    action: execute
+    phase: 1
+    description: Generate dependency-ordered task list
+    timeout_seconds: 300
+    input:
+      source: "{{step_4_plan.artifacts}}"
+    output:
+      artifacts: [specs/*/tasks.md]
+    error_handling:
+      on_failure: stop
+      max_retries: 2
+    opinionated_prompts:
+      system_context: >
+        Tasks must be atomic, dependency-ordered, and each independently testable.
+        Include clear acceptance criteria per task.
+
+  - step_id: step_6_analyze
+    skill_id: speckit.analyze
+    action: execute
+    phase: 1
+    description: Cross-artifact consistency and quality check
+    timeout_seconds: 300
+    input:
+      source: "{{step_5_tasks.artifacts}}"
+    output:
+      artifacts: [analysis_report]
+    error_handling:
+      on_failure: continue
+      max_retries: 1
+    opinionated_prompts:
+      system_context: >
+        Check spec ↔ plan ↔ tasks consistency. Flag gaps, contradictions,
+        and missing test coverage. Non-destructive — report only.
+
+  - step_id: step_7_commit
+    skill_id: internal.git_commit_push
+    action: execute
+    phase: 1
+    description: Commit all specification artifacts and push
+    timeout_seconds: 120
+    error_handling:
+      on_failure: continue
+      max_retries: 1
+    opinionated_prompts:
+      system_context: >
+        Commit all files in specs/ with a descriptive message.
+        Push to remote if configured.
+
+  # ── Phase 2: Implementation (main context) ────────────────────────────────
+
+  - step_id: step_8_compact
+    skill_id: internal.compact
+    action: execute
+    phase: 2
+    description: Free context window before implementation
+    timeout_seconds: 30
+    error_handling:
+      on_failure: continue
+      max_retries: 0
+
+  - step_id: step_9_implement
+    skill_id: speckit.implement
+    action: execute_loop
+    phase: 2
+    description: Execute all tasks with TDD workflow via ralph-loop
+    timeout_seconds: 3600
+    input:
+      tasks_path: "specs/*/tasks.md"
+      loop_engine: ralph-loop
+      completion_promise: "FINISHED"
+      max_iterations: 10
+    output:
+      artifacts: [source_code, tests, commits]
+    error_handling:
+      on_failure: continue
+      max_retries: 3
+    opinionated_prompts:
+      system_context: >
+        Systematically execute speckit.implement to complete every task.
+        Enforce TDD: write and pass tests before marking any task complete.
+        Ensure code quality through linting, static analysis, and consistent
+        architecture with reusable components and centralized business logic.
+        Maintain atomic commits after each successful task.
+        After all tasks: invoke speckit.analyze for full validation,
+        apply improvements, re-run all tests, confirm zero regression.
+        Only output FINISHED after everything is validated.
+
+  - step_id: step_10_verify
+    skill_id: speckit.analyze
+    action: execute
+    phase: 2
+    description: Final validation pass — confirm production-grade quality
+    timeout_seconds: 300
+    error_handling:
+      on_failure: stop
+      max_retries: 1
+    opinionated_prompts:
+      system_context: >
+        Final gate. Verify all tasks completed, tests passing,
+        no regressions, code quality standards met.
+
+# ─── Metadata ──────────────────────────────────────────────────────────────────
+
+metadata:
+  author: manoirx
+  created_at: "2026-03-29"
+  tags: [speckit, tdd, workflow, development, chain, engineering]
+  estimated_duration_seconds: 6000
+  phases:
+    phase_1:
+      name: Specification & Planning
+      steps: [step_0 through step_7]
+      execution: subagent
+      reason: Preserve main context window for implementation
+    phase_2:
+      name: Implementation & Verification
+      steps: [step_8 through step_10]
+      execution: main_context
+      reason: Implementation needs full tool access and ralph-loop

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "bms-speckit-plugin",
-  "version": "3.9.0",
-  "description": "Single-command automated development pipeline: /bms-speckit takes requirements and runs constitution → specify → plan → tasks → analyze → implement → verify",
+  "version": "4.0.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/",
-    "skills/"
+    "skills/",
+    "blueprints/"
   ],
   "keywords": [
     "claude-code-plugin",

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

@@ -3,40 +3,111 @@ name: bms-speckit-auto
 description: Full automated development workflow. This skill should be used when the user asks to "build an application", "create a dashboard", "develop a feature", "speckit", "bms-speckit", or provides a software requirement to implement end-to-end with TDD, specifications, and quality gates. Usage /bms-speckit:bms-speckit-auto <your requirement description>
 ---
 
-# BMS Speckit — Automated Development Pipeline
+# BMS Speckit — Chain Orchestrator
 
-Execute the following steps in exact order. Do NOT ask for confirmation between steps.
+Chain blueprint: `blueprints/bms-speckit-pipeline.yaml`
 
-## Phase 1: Specification & Planning (run in subagent)
+## Execution Rules
 
-Dispatch a subagent with the following prompt. The subagent MUST use the Skill tool to invoke each speckit skill — do NOT use slash command syntax inside the subagent.
+1. Execute steps **sequentially** in chain order — never skip steps
+2. Use the **Skill tool** for all skill invocations (no slash commands in subagents)
+3. On step failure, check the **error policy** before proceeding:
+   - `on_failure: stop` → halt the chain and report which step failed
+   - `on_failure: continue` → log the failure and proceed to next step
+4. Pass `$ARGUMENTS` (the user's requirement) to step 0 (brainstorm). Step 3 (specify) receives the **output from step 0**, not raw `$ARGUMENTS`
+5. Do NOT ask for confirmation between steps
 
-Subagent prompt:
+---
 
-"""
-You are running the BMS Speckit specification and planning phase. Execute these steps in order using the Skill tool. Do NOT ask for confirmation.
+## Phase 1: Specification & Planning
 
-Step 1: Use the Skill tool to invoke "speckit.constitution" with this argument: "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."
+> **Execution context:** Dispatch ALL Phase 1 steps in a single subagent to preserve the main context window for implementation.
 
-Step 2: Read CLAUDE.md and verify it complies with the constitution in specs/constitution.md. Update CLAUDE.md if needed.
+Subagent prompt:
 
-Step 3: Use the Skill tool to invoke "speckit.specify" with this argument: "$ARGUMENTS"
+"""
+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.
+
+### Step 0 — Brainstorm `[on_failure: STOP]`
+- **Skill:** `superpowers.brainstorm`
+- **Input:** "$ARGUMENTS"
+- **Purpose:** Explore intent, requirements, design alternatives, and edge cases
+- **Output:** Detailed specification document
+- **Timeout:** 300s
+
+### Step 1 — Constitution `[on_failure: STOP]`
+- **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
+
+### Step 2 — CLAUDE.md Sync `[on_failure: CONTINUE]`
+- **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
+
+### Step 3 — Specify `[on_failure: STOP]`
+- **Skill:** `speckit.specify`
+- **Input:** Use the detailed specification output from Step 0 (brainstorm) as the argument
+- **Output:** `specs/*/spec.md`
+- **Timeout:** 300s
+- **Retry:** up to 2 attempts
+
+### Step 4 — Plan `[on_failure: STOP]`
+- **Skill:** `speckit.plan`
+- **Input:** reads from step 3 artifacts
+- **Output:** `specs/*/plan.md`
+- **Timeout:** 300s
+- **Retry:** up to 2 attempts
+
+### Step 5 — Tasks `[on_failure: STOP]`
+- **Skill:** `speckit.tasks`
+- **Input:** reads from step 4 artifacts
+- **Output:** `specs/*/tasks.md`
+- **Timeout:** 300s
+- **Retry:** up to 2 attempts
+
+### Step 6 — Analyze `[on_failure: CONTINUE]`
+- **Skill:** `speckit.analyze`
+- **Purpose:** Cross-artifact consistency check (spec ↔ plan ↔ tasks). Non-destructive — report only.
+- **Timeout:** 300s
+
+### Step 7 — Commit & Push `[on_failure: CONTINUE]`
+- **Action:** Commit all files and push to remote if configured.
+- **Timeout:** 120s
 
-Step 4: Use the Skill tool to invoke "speckit.plan"
+After all steps complete, return: the feature name, number of tasks created, and the path to tasks.md.
+"""
 
-Step 5: Use the Skill tool to invoke "speckit.tasks"
+---
 
-Step 6: Use the Skill tool to invoke "speckit.analyze"
+## Phase 2: Implementation
 
-Step 7: Commit all files and push to remote if configured.
+> **Execution context:** Runs in main context after subagent completes.
 
-After all steps complete, return: the feature name, number of tasks created, and the path to tasks.md.
-"""
+### Step 8 — Compact `[on_failure: CONTINUE]`
+- **Action:** Run `/compact` to free context window before implementation.
 
-## Phase 2: Implementation (run in main context)
+### Step 9 — Implement (loop) `[on_failure: CONTINUE | max_retries: 3]`
+- **Engine:** ralph-loop
+- **Completion promise:** `FINISHED`
+- **Max iterations:** 10
+- **Action:** Run:
 
-After the subagent completes:
+`/ralph-loop:ralph-loop "systematically execute speckit.implement via the Skill tool to complete every task defined in specs/*/tasks.md with strict adherence to specification requirements, enforce TDD workflow including writing and passing unit, integration, and end-to-end tests before marking any task complete, ensure code quality through linting, static analysis, and consistent architecture with reusable components and centralized business logic, 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`
 
-8. Run `/compact` to free context window.
+---
 
-9. Run: `/ralph-loop:ralph-loop "use the Skill tool to invoke speckit.implement until all tasks in specs/*/tasks.md are finished, do not ask for any confirmation, once all tasks are done, use the Skill tool to invoke speckit.analyze to recheck and update tasks, accept any recommendations, and output <promise>FINISHED</promise> only after all tasks are completed and revalidated" --completion-promise "FINISHED" --max-iterations 10`
+## Chain Summary
+
+```
+Phase 1 (subagent)                    Phase 2 (main context)
+─────────────────────                 ──────────────────────
+Step 0: brainstorm ──STOP──┐          Step 8:  compact
+Step 1: constitution ─STOP─┤          Step 9:  implement (ralph-loop)
+Step 2: CLAUDE.md sync ────┤          Step 10: verify (via step 9)
+Step 3: specify ──────STOP─┤
+Step 4: plan ─────────STOP─┤
+Step 5: tasks ────────STOP─┤
+Step 6: analyze ───────────┤
+Step 7: commit & push ─────┘
+```