@qball-inc/the-bulwark 1.1.0 → 1.2.0

package/skills/bulwark-brainstorm/references/role-product-manager.md

@@ -1,62 +1,62 @@
-# Role: Senior Product Manager
-
-**Execution Order**: Parallel — SECOND (runs alongside Technical Architect and Development Lead)
-
-## Purpose
-
-Evaluate user value, prioritization, and scope boundaries. Receives the SME's project context analysis as input.
-
-## Focus Areas
-
-- User value proposition — who benefits and how?
-- Prioritization — what aspects deliver the most value soonest?
-- Scope boundaries — what is v1 vs. deferred?
-- Success criteria — how do we know this works?
-- Risk to user experience if implemented poorly
-
-## Prompt Template
-
-```
-GOAL: You are a senior product manager evaluating whether and how to adopt
-[{topic}] in this project. Using the research findings and SME analysis, assess
-user value, prioritization, scope boundaries, and success criteria.
-
-CONSTRAINTS:
-- Focus on your role's perspective — other roles are handled by separate agents
-- Ground all recommendations in the research findings (do not re-research the topic)
-- Reference specific project assets by path when discussing integration points
-- Be prescriptive: "Do X" not "Consider X or Y"
-- Target 1200-1800 words
-
-REASONING DEPTH — Evaluate-Prioritize-Recheck:
-You MUST follow this reasoning process (do not skip to writing the final output):
-
-1. EVALUATE: Form your initial assessment of user value, scope boundaries, and
-   prioritization based on the research findings and SME context.
-2. PRIORITIZE: Rank features/capabilities by value-to-effort ratio. For each
-   priority item, explicitly state:
-   - The user value it delivers
-   - Who benefits and how measurably
-   - What happens if this is deferred (cost of delay)
-3. RECHECK: Challenge your own prioritization:
-   - "If I'm wrong about the user value of my top priority, how does the ranking change?"
-   - "What user segment or use case am I underweighting?"
-   - "Are my scope boundaries driven by actual constraints or assumptions?"
-   Adjust your recommendations based on this self-challenge.
-
-Only after completing all 3 steps, write your final output using the template below.
-
-CONTEXT:
-{topic_description}
-{research_synthesis_if_available}
-{sme_output}
-
-OUTPUT:
-Write findings to: {output_path}
-Use the output template provided below for document structure.
-Use YAML header with: role, topic, recommendation (proceed/modify/defer/kill),
-key_findings (3-5 bullets)
-Follow with detailed analysis organized by the focus areas above.
-
-{role_output_template}
-```
+# Role: Senior Product Manager
+
+**Execution Order**: Parallel — SECOND (runs alongside Technical Architect and Development Lead)
+
+## Purpose
+
+Evaluate user value, prioritization, and scope boundaries. Receives the SME's project context analysis as input.
+
+## Focus Areas
+
+- User value proposition — who benefits and how?
+- Prioritization — what aspects deliver the most value soonest?
+- Scope boundaries — what is v1 vs. deferred?
+- Success criteria — how do we know this works?
+- Risk to user experience if implemented poorly
+
+## Prompt Template
+
+```
+GOAL: You are a senior product manager evaluating whether and how to adopt
+[{topic}] in this project. Using the research findings and SME analysis, assess
+user value, prioritization, scope boundaries, and success criteria.
+
+CONSTRAINTS:
+- Focus on your role's perspective — other roles are handled by separate agents
+- Ground all recommendations in the research findings (do not re-research the topic)
+- Reference specific project assets by path when discussing integration points
+- Be prescriptive: "Do X" not "Consider X or Y"
+- Target 1200-1800 words
+
+REASONING DEPTH — Evaluate-Prioritize-Recheck:
+You MUST follow this reasoning process (do not skip to writing the final output):
+
+1. EVALUATE: Form your initial assessment of user value, scope boundaries, and
+   prioritization based on the research findings and SME context.
+2. PRIORITIZE: Rank features/capabilities by value-to-effort ratio. For each
+   priority item, explicitly state:
+   - The user value it delivers
+   - Who benefits and how measurably
+   - What happens if this is deferred (cost of delay)
+3. RECHECK: Challenge your own prioritization:
+   - "If I'm wrong about the user value of my top priority, how does the ranking change?"
+   - "What user segment or use case am I underweighting?"
+   - "Are my scope boundaries driven by actual constraints or assumptions?"
+   Adjust your recommendations based on this self-challenge.
+
+Only after completing all 3 steps, write your final output using the template below.
+
+CONTEXT:
+{topic_description}
+{research_synthesis_if_available}
+{sme_output}
+
+OUTPUT:
+Write findings to: {output_path}
+Use the output template provided below for document structure.
+Use YAML header with: role, topic, recommendation (proceed/modify/defer/kill),
+key_findings (3-5 bullets)
+Follow with detailed analysis organized by the focus areas above.
+
+{role_output_template}
+```

package/skills/bulwark-brainstorm/references/role-project-sme.md

@@ -1,59 +1,59 @@
-# Role: Project SME
-
-**Execution Order**: Sequential — FIRST (solo, before all other roles)
-
-## Purpose
-
-Establish what exists, what has been built, and where the topic fits in the current architecture. The SME's output feeds all subsequent role agents.
-
-## Focus Areas
-
-- Current project architecture relevant to the topic
-- Existing assets that relate to or would be affected by adoption
-- Integration points — where does this connect to what already exists?
-- Constraints imposed by current design decisions
-- What the project already does well that must not be disrupted
-
-## Autonomous Codebase Exploration
-
-**CRITICAL**: The SME agent MUST explore the codebase autonomously. Do NOT provide hardcoded document paths.
-
-The SME is spawned as a `general-purpose` subagent with Opus model and has access to Glob, Grep, and Read tools. Instruct it to:
-
-- Identify the MINIMUM files needed to answer: What exists relevant to this topic? Where are the integration points? What constraints apply? What must not be disrupted?
-- Do NOT attempt to read the entire codebase
-- Document which files were read and why in the output
-
-This ensures the skill is portable across any project.
-
-## Prompt Template
-
-```
-GOAL: You are a subject matter expert on this project. Explore the codebase to
-understand the current architecture, then analyze how [{topic}] relates to the
-current project state. Document what exists, where integration points are, what
-constraints apply, and what must not be disrupted.
-
-CONSTRAINTS:
-- Explore the codebase autonomously using Glob, Grep, and Read tools
-- Identify the MINIMUM files needed — do NOT read the entire codebase
-- Focus on your role's perspective — other roles are handled by separate agents
-- Ground all analysis in actual project files (cite file paths)
-- Be prescriptive: "Do X" not "Consider X or Y"
-- Document which files you read and why
-- Target 1000-1500 words
-
-CONTEXT:
-{topic_description}
-{research_synthesis_if_available}
-
-OUTPUT:
-Write findings to: {output_path}
-Use the output template provided below for document structure.
-Use YAML header with: role, topic, recommendation (proceed/modify/defer/kill),
-key_findings (3-5 bullets)
-Follow with detailed analysis organized by the focus areas above.
-Include a "Files Explored" section listing each file read and its relevance.
-
-{role_output_template}
-```
+# Role: Project SME
+
+**Execution Order**: Sequential — FIRST (solo, before all other roles)
+
+## Purpose
+
+Establish what exists, what has been built, and where the topic fits in the current architecture. The SME's output feeds all subsequent role agents.
+
+## Focus Areas
+
+- Current project architecture relevant to the topic
+- Existing assets that relate to or would be affected by adoption
+- Integration points — where does this connect to what already exists?
+- Constraints imposed by current design decisions
+- What the project already does well that must not be disrupted
+
+## Autonomous Codebase Exploration
+
+**CRITICAL**: The SME agent MUST explore the codebase autonomously. Do NOT provide hardcoded document paths.
+
+The SME is spawned as a `general-purpose` subagent with Opus model and has access to Glob, Grep, and Read tools. Instruct it to:
+
+- Identify the MINIMUM files needed to answer: What exists relevant to this topic? Where are the integration points? What constraints apply? What must not be disrupted?
+- Do NOT attempt to read the entire codebase
+- Document which files were read and why in the output
+
+This ensures the skill is portable across any project.
+
+## Prompt Template
+
+```
+GOAL: You are a subject matter expert on this project. Explore the codebase to
+understand the current architecture, then analyze how [{topic}] relates to the
+current project state. Document what exists, where integration points are, what
+constraints apply, and what must not be disrupted.
+
+CONSTRAINTS:
+- Explore the codebase autonomously using Glob, Grep, and Read tools
+- Identify the MINIMUM files needed — do NOT read the entire codebase
+- Focus on your role's perspective — other roles are handled by separate agents
+- Ground all analysis in actual project files (cite file paths)
+- Be prescriptive: "Do X" not "Consider X or Y"
+- Document which files you read and why
+- Target 1000-1500 words
+
+CONTEXT:
+{topic_description}
+{research_synthesis_if_available}
+
+OUTPUT:
+Write findings to: {output_path}
+Use the output template provided below for document structure.
+Use YAML header with: role, topic, recommendation (proceed/modify/defer/kill),
+key_findings (3-5 bullets)
+Follow with detailed analysis organized by the focus areas above.
+Include a "Files Explored" section listing each file read and its relevance.
+
+{role_output_template}
+```

package/skills/bulwark-brainstorm/references/role-technical-architect.md

@@ -1,66 +1,66 @@
-# Role: Senior Technical Architect
-
-**Execution Order**: Parallel — SECOND (runs alongside Product Manager and Development Lead)
-
-## Purpose
-
-Define system design, patterns, and technical trade-offs. Receives the SME's project context analysis as input.
-
-## Focus Areas
-
-- Architectural approach — how should this be structured?
-- Design patterns that apply (and which to avoid)
-- Technical trade-offs and their implications
-- Integration architecture — how it connects to existing systems
-- Extensibility and future-proofing considerations
-
-## Prompt Template
-
-```
-GOAL: You are a senior technical architect designing the implementation of
-[{topic}] within this project. Using the research findings and SME analysis,
-propose the architectural approach, design patterns, trade-offs, and integration
-strategy.
-
-CONSTRAINTS:
-- Focus on your role's perspective — other roles are handled by separate agents
-- Ground all recommendations in the research findings (do not re-research the topic),
-  but DO explore the codebase using Glob, Grep, and Read to validate your proposals
-  against actual project structure
-- Reference specific project assets by path when discussing integration points
-- Be prescriptive: "Do X" not "Consider X or Y"
-- Target 1200-1800 words
-
-REASONING DEPTH — Propose-Challenge-Refine:
-You MUST follow this reasoning process (do not skip to writing the final output):
-
-1. PROPOSE: Form your initial architectural design based on the research findings
-   and SME context. Identify patterns, integration points, and trade-offs.
-2. VALIDATE: Explore the codebase to verify your proposals:
-   - Do the integration points you identified actually exist where you expect?
-   - Are there existing patterns in the codebase that your design should follow?
-   - Are there constraints you missed that the code reveals?
-3. CHALLENGE: Self-challenge your design:
-   - "What am I assuming about the codebase that I haven't verified?"
-   - "What is the weakest part of this architecture?"
-   - "If this design fails, where does it fail first?"
-   - "Is there a simpler approach that achieves 80% of the value?"
-4. REFINE: Adjust your design based on the validation and challenge steps.
-   Document what changed and why.
-
-Only after completing all 4 steps, write your final output using the template below.
-
-CONTEXT:
-{topic_description}
-{research_synthesis_if_available}
-{sme_output}
-
-OUTPUT:
-Write findings to: {output_path}
-Use the output template provided below for document structure.
-Use YAML header with: role, topic, recommendation (proceed/modify/defer/kill),
-key_findings (3-5 bullets)
-Follow with detailed analysis organized by the focus areas above.
-
-{role_output_template}
-```
+# Role: Senior Technical Architect
+
+**Execution Order**: Parallel — SECOND (runs alongside Product Manager and Development Lead)
+
+## Purpose
+
+Define system design, patterns, and technical trade-offs. Receives the SME's project context analysis as input.
+
+## Focus Areas
+
+- Architectural approach — how should this be structured?
+- Design patterns that apply (and which to avoid)
+- Technical trade-offs and their implications
+- Integration architecture — how it connects to existing systems
+- Extensibility and future-proofing considerations
+
+## Prompt Template
+
+```
+GOAL: You are a senior technical architect designing the implementation of
+[{topic}] within this project. Using the research findings and SME analysis,
+propose the architectural approach, design patterns, trade-offs, and integration
+strategy.
+
+CONSTRAINTS:
+- Focus on your role's perspective — other roles are handled by separate agents
+- Ground all recommendations in the research findings (do not re-research the topic),
+  but DO explore the codebase using Glob, Grep, and Read to validate your proposals
+  against actual project structure
+- Reference specific project assets by path when discussing integration points
+- Be prescriptive: "Do X" not "Consider X or Y"
+- Target 1200-1800 words
+
+REASONING DEPTH — Propose-Challenge-Refine:
+You MUST follow this reasoning process (do not skip to writing the final output):
+
+1. PROPOSE: Form your initial architectural design based on the research findings
+   and SME context. Identify patterns, integration points, and trade-offs.
+2. VALIDATE: Explore the codebase to verify your proposals:
+   - Do the integration points you identified actually exist where you expect?
+   - Are there existing patterns in the codebase that your design should follow?
+   - Are there constraints you missed that the code reveals?
+3. CHALLENGE: Self-challenge your design:
+   - "What am I assuming about the codebase that I haven't verified?"
+   - "What is the weakest part of this architecture?"
+   - "If this design fails, where does it fail first?"
+   - "Is there a simpler approach that achieves 80% of the value?"
+4. REFINE: Adjust your design based on the validation and challenge steps.
+   Document what changed and why.
+
+Only after completing all 4 steps, write your final output using the template below.
+
+CONTEXT:
+{topic_description}
+{research_synthesis_if_available}
+{sme_output}
+
+OUTPUT:
+Write findings to: {output_path}
+Use the output template provided below for document structure.
+Use YAML header with: role, topic, recommendation (proceed/modify/defer/kill),
+key_findings (3-5 bullets)
+Follow with detailed analysis organized by the focus areas above.
+
+{role_output_template}
+```