@mark-gozner/aigile-method 0.4.5

package/core/prompts/technical-project-analyze.prompt.md

@@ -0,0 +1,43 @@
+---
+description: Analyze the project structure, architecture, and design patterns.
+mode: agent
+---
+
+Your goal is to produce a comprehensive, actionable analysis of the codebase structure, architecture, and dependencies.
+
+
+# Primary objectives:
+
+Repository scanning — produce a navigable map of the codebase (file tree, module/package boundaries, important files).
+Architecture visualization — produce diagrams showing components, services, key modules, data flows, and integration points.
+Dependency analysis — enumerate external (third-party) and internal dependencies, versions where available, license risks, and high-level vulnerability pointers.
+
+# Deliverables (formats required):
+`docs/architecture.md` human-readable explanation of components, responsibilities, and integration points.
+`docs/file-tree.md` — machine-readable tree (paths, sizes, lines).
+`docs/internal-dependencies.mmd`. — Mermaid diagram of internal dependencies (packages/modules).
+`docs/external-dependencies.mmd`. — Mermaid diagram of external dependencies (third-party services).
+
+# Required output constraints:
+JSON must be valid and include confidence scores (0.0–1.0) for inferred relationships.
+Diagrams must be Mermaid syntax
+
+# Permissions & safety:
+
+Only read the code (no changes unless explicitly authorized).
+Do not attempt to access external private services unless credentials are provided.
+If execution environment differs from CI (e.g., Windows vs Linux), note differences and adapt commands.
+
+# TODO checklist (actionable items) (agent must follow these steps):
+
+- [ ] Run `.github/prompts/file-tree-generator.prompt.md` with VISUALIZATION_STYLE = Markdown List; produce `docs/file-tree.md` as output
+- [ ] Run `.github/prompts/architecture-blueprint-generator.prompt.md` with appropriate parameters; produce `docs/architecture.md` as output
+- [ ] Generate an internal dependency graph (internal packages/modules) and export as Mermaid to `docs/internal-dependencies.mmd`.
+- [ ] Generate an external dependency graph (third-party services) and export as Mermaid to `docs/external-dependencies.mmd`.
+
+
+# Behavior rules:
+- MUST follow the TODO checklist step-by-step.
+- NEVER modify existing files.
+- NEVER hallucinate missing sections—if absent, report them.
+- KEEP findings deterministic: if rerun without changes, produce consistent IDs and counts.

package/core/tasks/advanced-elicitation.md

@@ -0,0 +1,119 @@
+<!-- Powered by BMAD™ Core -->
+
+# Advanced Elicitation Task
+
+## Purpose
+
+- Provide optional reflective and brainstorming actions to enhance content quality
+- Enable deeper exploration of ideas through structured elicitation techniques
+- Support iterative refinement through multiple analytical perspectives
+- Usable during template-driven document creation or any chat conversation
+
+## Usage Scenarios
+
+### Scenario 1: Template Document Creation
+
+After outputting a section during document creation:
+
+1. **Section Review**: Ask user to review the drafted section
+2. **Offer Elicitation**: Present 9 carefully selected elicitation methods
+3. **Simple Selection**: User types a number (0-8) to engage method, or 9 to proceed
+4. **Execute & Loop**: Apply selected method, then re-offer choices until user proceeds
+
+### Scenario 2: General Chat Elicitation
+
+User can request advanced elicitation on any agent output:
+
+- User says "do advanced elicitation" or similar
+- Agent selects 9 relevant methods for the context
+- Same simple 0-9 selection process
+
+## Task Instructions
+
+### 1. Intelligent Method Selection
+
+**Context Analysis**: Before presenting options, analyze:
+
+- **Content Type**: Technical specs, user stories, architecture, requirements, etc.
+- **Complexity Level**: Simple, moderate, or complex content
+- **Stakeholder Needs**: Who will use this information
+- **Risk Level**: High-impact decisions vs routine items
+- **Creative Potential**: Opportunities for innovation or alternatives
+
+**Method Selection Strategy**:
+
+1. **Always Include Core Methods** (choose 3-4):
+   - Expand or Contract for Audience
+   - Critique and Refine
+   - Identify Potential Risks
+   - Assess Alignment with Goals
+
+2. **Context-Specific Methods** (choose 4-5):
+   - **Technical Content**: Tree of Thoughts, ReWOO, Meta-Prompting
+   - **User-Facing Content**: Agile Team Perspective, Stakeholder Roundtable
+   - **Creative Content**: Innovation Tournament, Escape Room Challenge
+   - **Strategic Content**: Red Team vs Blue Team, Hindsight Reflection
+
+3. **Always Include**: "Proceed / No Further Actions" as option 9
+
+### 2. Section Context and Review
+
+When invoked after outputting a section:
+
+1. **Provide Context Summary**: Give a brief 1-2 sentence summary of what the user should look for in the section just presented
+
+2. **Explain Visual Elements**: If the section contains diagrams, explain them briefly before offering elicitation options
+
+3. **Clarify Scope Options**: If the section contains multiple distinct items, inform the user they can apply elicitation actions to:
+   - The entire section as a whole
+   - Individual items within the section (specify which item when selecting an action)
+
+### 3. Present Elicitation Options
+
+**Review Request Process:**
+
+- Ask the user to review the drafted section
+- In the SAME message, inform them they can suggest direct changes OR select an elicitation method
+- Present 9 intelligently selected methods (0-8) plus "Proceed" (9)
+- Keep descriptions short - just the method name
+- Await simple numeric selection
+
+**Action List Presentation Format:**
+
+```text
+**Advanced Elicitation Options**
+Choose a number (0-8) or 9 to proceed:
+
+0. [Method Name]
+1. [Method Name]
+2. [Method Name]
+3. [Method Name]
+4. [Method Name]
+5. [Method Name]
+6. [Method Name]
+7. [Method Name]
+8. [Method Name]
+9. Proceed / No Further Actions
+```
+
+**Response Handling:**
+
+- **Numbers 0-8**: Execute the selected method, then re-offer the choice
+- **Number 9**: Proceed to next section or continue conversation
+- **Direct Feedback**: Apply user's suggested changes and continue
+
+### 4. Method Execution Framework
+
+**Execution Process:**
+
+1. **Retrieve Method**: Access the specific elicitation method from the elicitation-methods data file
+2. **Apply Context**: Execute the method from your current role's perspective
+3. **Provide Results**: Deliver insights, critiques, or alternatives relevant to the content
+4. **Re-offer Choice**: Present the same 9 options again until user selects 9 or gives direct feedback
+
+**Execution Guidelines:**
+
+- **Be Concise**: Focus on actionable insights, not lengthy explanations
+- **Stay Relevant**: Tie all elicitation back to the specific content being analyzed
+- **Identify Personas**: For multi-persona methods, clearly identify which viewpoint is speaking
+- **Maintain Flow**: Keep the process moving efficiently

package/core/tasks/check-story-implemented.md

@@ -0,0 +1,44 @@
+<!-- BMAD-style verification tailored for Dev; pairs with QA Gate -->
+
+# Dev Task: Check if Story is Implemented
+
+Assess whether code and tests satisfy a Jira story's acceptance criteria and quality bar.
+
+## Inputs
+
+```yaml
+required:
+  - urlOrId: 'ENG-123' | 'https://your.atlassian.net/browse/ENG-123'
+optional:
+  - story_path: '{devStoryLocation}/{epic}.{story}.*.md'
+```
+
+## Process (Sequential)
+
+1. Read Issue and AC
+   - Fetch from Jira; restate AC in Given/When/Then
+2. Locate Implementation
+   - Search branches/commits/tags by issue key
+   - Identify feature flags, migrations, config toggles
+3. Compare AC vs Code/Tests
+   - Verify positive, negative, and boundary behavior
+   - Confirm error handling and logging
+4. Run Tests
+   - Unit first, then integration/E2E as relevant
+   - Add missing unit tests if low-risk and straightforward
+5. Non-Functional Pass
+   - Check basics of performance, a11y, i18n, and security (as applicable)
+6. Findings and Next Actions
+   - Provide PASS/CONCERNS/FAIL with specific gaps and minimal-change fixes
+
+## Outputs
+
+- Short report with verdict and evidence
+- Optional story note in `Dev Agent Record` with findings and follow-ups
+
+## Checklist
+
+- [ ] AC → Test traceability captured
+- [ ] Edge and error handling verified
+- [ ] No secrets in logs; logging level appropriate
+- [ ] Docs or story record updated as needed

package/core/tasks/code-arch-review-with-github.md

@@ -0,0 +1,40 @@
+<!-- BMAD-style architecture review via GitHub context -->
+
+# Architect Task: Code Architecture Review (GitHub)
+
+Assess architecture concerns using GitHub code search, discussions, and historical patterns; recommend targeted refactors with minimal disruption.
+
+## Inputs
+
+```yaml
+required:
+  - target_areas: ['path/to/module', 'path/to/service']
+optional:
+  - concerns: ['coupling', 'performance', 'testability']
+  - related_issues: []
+```
+
+## Process (Sequential)
+
+1. Define Scope
+	- Clarify specific concerns (e.g., coupling, boundaries, layering)
+	- Identify modules/services in scope
+2. Evidence Gathering
+	- Use GitHub search to find usages, cycles, divergence from conventions
+	- Review PR history and discussions for context and constraints
+3. Analysis
+	- Evaluate layering, dependency direction, and module boundaries
+	- Identify anti-patterns (God objects, feature envy, excessive mocks)
+	- Note performance and resilience hotspots
+4. Recommendations
+	- Propose small, incremental refactors aligned with current patterns
+	- Include risks, alternatives, and expected impact
+5. Next Steps
+	- Link recommended changes to stories/PRs
+	- Suggest test adjustments to lock behavior
+
+## Outputs
+
+- Short review document with: scope, findings, recommendations
+- Links to code locations and prior PRs/issues for context
+- Optional: ADR or doc snippet to `docs/architecture` if decisions are made

package/core/tasks/create-architecture-doc.md

@@ -0,0 +1,55 @@
+<!-- Architect produce architecture documentation based on core-config, with sharded/monolithic output -->
+
+# Architect Task: Create Architecture Doc
+
+Produce or update the architecture documentation following core/core-config.yaml settings. Supports monolithic docs/architecture.md or sharded docs/architecture/*.md.
+
+## Inputs
+
+```yaml
+required: []
+optional:
+  - forceSharded: null   # true|false|null; null = follow config
+  - savePrompt: true     # always ask to write files
+```
+
+## Process (Sequential)
+
+1. Read Configuration
+   - core-config.yaml → architecture.architectureSharded, architectureFile, architectureShardedLocation
+2. Discover Context
+   - Source tree, tech stack, coding standards (see devLoadAlwaysFiles), ADRs if present
+3. Draft Structure
+   - If monolithic: sections = Overview, Context, Architecture Diagrams, Modules, Data, Integrations, Quality Attributes, Decisions (ADRs), Risks
+   - If sharded: create/update files under docs/architecture/: tech-stack.md, source-tree.md, coding-standards.md, decisions.md, overview.md, integrations.md, data.md
+4. Preview
+   - Present outline and key sections to confirm
+5. Save Files
+   - Write docs/architecture.md (monolithic) or update/create sharded files under docs/architecture
+
+## Outputs
+
+- Updated architecture documentation according to config
+
+### Output (Structured)
+
+```yaml
+architecture:
+  mode: monolithic|sharded
+  files:
+    - docs/architecture.md
+    - docs/architecture/overview.md
+    - docs/architecture/tech-stack.md
+    - docs/architecture/source-tree.md
+    - docs/architecture/coding-standards.md
+    - docs/architecture/integrations.md
+    - docs/architecture/data.md
+    - docs/architecture/decisions.md
+```
+
+## Quality Checklist
+
+- [ ] Architecture reflects the current code reality (brownfield first)
+- [ ] Key quality attributes and risks are documented
+- [ ] Diagrams or references included where helpful
+- [ ] ADRs or decisions are logged

package/core/tasks/create-jira-epic-from-confluence.md

@@ -0,0 +1,70 @@
+<!-- BMAD-style PO epic creation with Jira fallback and save-to-docs option -->
+
+# PO Task: Create Jira Epic from Confluence Doc
+
+Create a Jira Epic from a Confluence page, preview before creation, and optionally save a local markdown copy under docs/epics with cross-links.
+
+## Inputs
+
+```yaml
+required:
+  - confluenceUrl: 'https://your.atlassian.net/wiki/spaces/PROJ/pages/12345'
+optional:
+  - projectKey: 'ENG'
+  - labels: []
+  - components: []
+  - summaryOverride: ''
+  - savePrompt: true   # Always ask to save docs; if headless, treat as true
+```
+
+## Process (Sequential)
+
+1. Parse Source Document
+   - Extract purpose, problem/opportunity, scope, constraints, explicit exclusions.
+   - Identify initial success metrics and high-level acceptance themes.
+2. Draft Epic
+   - Title: concise, outcome-focused; use summaryOverride if provided.
+   - Description sections: Context, Goals/Non-Goals, Scope/Out-of-Scope, Constraints, Initial Risks, Success Metrics.
+   - Metadata: projectKey, labels, components.
+3. Preview and Confirm
+   - Present the epic draft to the user for confirmation or edits.
+4. Create in Jira (if available)
+   - If an Atlassian MCP tool supports write, create the epic in Jira and capture key and URL.
+   - If write is not available, DO NOT fail: return the full epic content as output for manual creation.
+5. Offer to Save Locally (docs/epics)
+   - Ask: “Save a local copy under docs/epics and cross-link later stories to this epic?”
+   - If yes, write docs/epics/epic-{key-or-slug}.md with frontmatter and content.
+6. Cross-link Guidance
+   - Provide snippet to link from stories to this epic: “Epic: [ENG-123](https://…/browse/ENG-123)” or local file link if no Jira key.
+
+## Output
+
+- Jira Epic created (key and URL), or a complete epic markdown for manual creation
+- Optional local file saved under docs/epics/epic-{key-or-slug}.md
+- Link snippet for downstream stories
+
+### Output (Structured)
+
+```yaml
+epic:
+  summary: "<title>"
+  description: |
+    <markdown body>
+  jira:
+    created: true|false
+    key: ENG-123 | null
+    url: https://your.atlassian.net/browse/ENG-123 | null
+  files:
+    saved: true|false
+    path: docs/epics/epic-eng-123.md | docs/epics/epic-new-foo.md | null
+  linkSnippet: |
+    Epic: [ENG-123](https://your.atlassian.net/browse/ENG-123)
+```
+
+## Quality Checklist
+
+- [ ] Clear goal(s) and success metrics
+- [ ] Scope and explicit out-of-scope listed
+- [ ] Constraints/risks captured
+- [ ] Labels/components added if used
+- [ ] Preview validated with stakeholders

package/core/tasks/create-jira-story-from-confluence.md

@@ -0,0 +1,39 @@
+<!-- BMAD-style PO story creation from Confluence -->
+
+# PO Task: Create Jira Story from Confluence Doc
+
+Turn a Confluence document into a well-formed Jira story with clear AC.
+
+## Inputs
+
+```yaml
+required:
+  - confluenceUrl: 'https://your.atlassian.net/wiki/spaces/PROJ/pages/12345'
+optional:
+  - labels: []
+  - components: []
+	- projectKey: 'ENG'
+	- epicKey: ''
+	- savePrompt: true   # Offer to save to docs/stories
+```
+
+## Process (Sequential)
+
+1. Parse the Document
+	- Extract objective, scope, constraints, and key decisions
+2. Draft Story and AC
+	- Use GWT; include happy, negative, and boundary cases
+3. Link Context
+	- Source Confluence page and related docs
+4. Metadata
+	- Labels, components, priority, estimate (if used)
+5. Review and Create
+	- Share with PM/Dev/QA; then create in correct backlog
+	- If Jira write is not available, DO NOT fail: return full story markdown for manual creation
+6. Offer to Save Locally (docs/stories)
+	- Ask to save as docs/stories/story-{key-or-slug}.md with cross-links (epic if provided)
+
+## Outputs
+
+- Jira story created with description, AC, links, and metadata; or full markdown for manual creation
+- Optional local file saved under docs/stories/story-{key-or-slug}.md

package/core/tasks/create-jira-story-from-text.md

@@ -0,0 +1,39 @@
+<!-- BMAD-style PO story creation from freeform text -->
+
+# PO Task: Create Jira Story from Text
+
+Convert a user-provided description into a Jira story with testable AC.
+
+## Inputs
+
+```yaml
+required:
+  - text: 'Freeform description of the need or change'
+optional:
+  - labels: []
+  - components: []
+	- projectKey: 'ENG'
+	- epicKey: ''
+	- savePrompt: true
+```
+
+## Process (Sequential)
+
+1. Structure the Input
+	- Extract objective, constraints, measurable outcomes
+2. Draft AC in GWT
+	- Include happy, negative, and boundary cases where relevant
+3. Add Metadata
+	- Labels, components, estimate, and dependencies
+4. Create Story
+	- In the correct project and backlog
+	- If Jira write is not available, return a full story markdown for manual creation
+5. Share and Iterate
+	- Triage/refine with PM/Dev/QA as needed
+6. Offer to Save Locally (docs/stories)
+	- Ask to save as docs/stories/story-{key-or-slug}.md with cross-links (epic if provided)
+
+## Outputs
+
+- Jira story created or a full markdown for manual creation
+- Optional local file saved under docs/stories/story-{key-or-slug}.md

package/core/tasks/create-next-story.md

@@ -0,0 +1,35 @@
+# create-next-story
+
+```yaml
+id: create-next-story
+role: pm
+whenToUse: Need to produce the next ready story from roadmap / epic context.
+elicit: true
+outcome: Draft story with acceptance criteria and initial sizing.
+```
+
+## Objective
+Generate the next logical story derived from a roadmap item, epic, or product goal.
+
+## Preconditions
+- Provide epic reference, goal statement, or backlog context.
+
+## Steps
+1. Ask for: Epic/Goal, Target user persona, Desired outcome, Constraints.
+2. Derive a succinct story statement: As a <user> I want <capability> so that <benefit>.
+3. Draft initial Acceptance Criteria in Given/When/Then format (numbered).
+4. Identify dependencies, assumptions, risks.
+5. Propose thin-slice alternatives if scope too large.
+6. Provide sizing guidance (e.g., S/M/L or T-shirt) and rationale.
+7. Ask user to confirm or request refinement.
+
+## Outputs
+- Story draft:
+  - Story statement
+  - Acceptance Criteria (GWT)
+  - Dependencies / Risks / Assumptions
+  - Suggested Size
+
+## Guidance
+- Keep AC testable and outcome-focused, not implementation-focused.
+- Offer at least one smaller alternative if story seems large.

package/core/tasks/create-prd-doc.md

@@ -0,0 +1,54 @@
+<!-- PM/PO create a Product Requirements Document based on core-config prd settings -->
+
+# PM Task: Create PRD Document
+
+Create or update a Product Requirements Document (PRD) for the project following core/core-config.yaml prd settings. Supports monolithic docs/prd.md or sharded docs/prd/*.
+
+## Inputs
+
+```yaml
+required: []
+optional:
+  - forceSharded: null   # true|false|null; null = follow config
+  - savePrompt: true
+```
+
+## Process (Sequential)
+
+1. Read Configuration
+   - prd.prdSharded, prdFile, prdShardedLocation from core-config.yaml
+2. Gather Inputs
+   - Vision, Personas, Use cases, High-level features/Epics, Non-functional requirements, Constraints
+3. Draft Content
+   - If monolithic: docs/prd.md using core/templates/prd-tmpl.yaml as structure guidance
+   - If sharded: create/update files under docs/prd/: vision.md, personas.md, use-cases.md, epics.md, nfr.md, constraints.md
+4. Preview
+   - Present the outline and key sections for confirmation
+5. Save Files
+   - Write to target locations per config
+
+## Outputs
+
+- PRD documentation created or updated in the repository
+
+### Output (Structured)
+
+```yaml
+prd:
+  mode: monolithic|sharded
+  files:
+    - docs/prd.md
+    - docs/prd/vision.md
+    - docs/prd/personas.md
+    - docs/prd/use-cases.md
+    - docs/prd/epics.md
+    - docs/prd/nfr.md
+    - docs/prd/constraints.md
+```
+
+## Quality Checklist
+
+- [ ] Clear problem statement and goals
+- [ ] Personas and use cases documented
+- [ ] NFRs explicit and testable
+- [ ] Constraints and dependencies listed

package/core/tasks/create-stories-from-epic.md

@@ -0,0 +1,66 @@
+<!-- Create multiple stories from an epic (Jira or local), with Jira fallback and save-to-docs prompts -->
+
+# PO Task: Create Stories from Epic
+
+Generate a set of user stories from an epic (Jira epic key/URL or local epic markdown), and optionally save stories under docs/stories with cross-links. Create in Jira when possible; otherwise return ready-to-paste story markdown.
+
+## Inputs
+
+```yaml
+required:
+  - epicRef: 'ENG-100' | 'https://your.atlassian.net/browse/ENG-100' | 'docs/epics/epic-foo.md'
+optional:
+  - projectKey: 'ENG'
+  - defaultLabels: []
+  - components: []
+  - howMany: auto | 3
+  - savePrompt: true
+```
+
+## Process (Sequential)
+
+1. Resolve Epic
+   - If Jira URL/key: fetch epic summary/description via Atlassian MCP (read-only is sufficient)
+   - If local file: parse sections (Goals, Scope, Constraints, Risks)
+2. Story Breakdown
+   - Derive capabilities and group into coherent stories
+   - For each story: one-sentence objective, rationale, dependencies
+3. Author Acceptance Criteria
+   - Use Given/When/Then with happy, negative, and boundary cases where applicable
+4. Preview and Edit
+   - Present the list and allow edits (rename, merge/split, re-order)
+5. Create in Jira (if available)
+   - If write tools exist, create stories under the epic (issue link) and capture keys/URLs
+   - If not, produce full story markdown for manual creation
+6. Offer to Save Locally
+   - Ask to save each story under devStoryLocation (core-config: docs/stories) as story-{key-or-slug}.md
+   - Insert cross-links: Epic link, related stories, and future tasks area
+
+## Outputs
+
+- A set of stories created in Jira or returned as markdown
+- Optional files saved under docs/stories/story-*.md with cross-links to the epic
+
+### Output (Structured)
+
+```yaml
+stories:
+  - summary: "<title>"
+    ac: ["Given … When … Then …", "…"]
+    jira:
+      created: true|false
+      key: ENG-101 | null
+      url: https://your.atlassian.net/browse/ENG-101 | null
+    files:
+      saved: true|false
+      path: docs/stories/story-eng-101.md | docs/stories/story-add-login.md | null
+    links:
+      epic: "ENG-100" | "docs/epics/epic-foo.md"
+```
+
+## Quality Checklist
+
+- [ ] Each story is independently valuable, testable, and small enough
+- [ ] AC include happy, negative, and boundary cases when relevant
+- [ ] Stories link back to the epic and each other where appropriate
+- [ ] Labels/components applied consistently

package/core/tasks/create-tasks-for-story.md

@@ -0,0 +1,60 @@
+<!-- Create implementation tasks from a story, with Jira fallback and save-to-docs prompts -->
+
+# PO Task: Create Tasks for a Story
+
+Create a set of implementable tasks for a given story (Jira or text), with optional local save under docs/tasks and cross-linking to the story and epic.
+
+## Inputs
+
+```yaml
+required:
+  - storyRef: 'ENG-123' | 'https://your.atlassian.net/browse/ENG-123' | inline-text
+optional:
+  - defaultAssignee: ''
+  - components: []
+  - taskTypes: ['dev', 'qa', 'docs']
+  - savePrompt: true
+```
+
+## Process (Sequential)
+
+1. Resolve Story
+   - If Jira: fetch summary, description, AC; if local: parse story file sections
+2. Derive Tasks
+   - Break down into dev, qa, and docs tasks; ensure each is small, testable, and has a clear DoD
+3. Preview and Edit
+   - Present tasks, allow edits: add/remove, re-order, assign types/owners
+4. Create in Jira (if available)
+   - Create sub-tasks or linked tasks; capture keys/URLs; otherwise return markdown
+5. Offer to Save Locally
+   - Save docs/tasks/task-{key-or-slug}.md for each task with links to story and epic
+
+## Outputs
+
+- Tasks created in Jira or returned as markdown
+- Optional files saved under docs/tasks with cross-links to the story
+
+### Output (Structured)
+
+```yaml
+tasks:
+  - summary: "Implement API endpoint"
+    type: dev | qa | docs
+    jira:
+      created: true|false
+      key: ENG-124 | null
+      url: https://your.atlassian.net/browse/ENG-124 | null
+    files:
+      saved: true|false
+      path: docs/tasks/task-eng-124.md | docs/tasks/task-implement-endpoint.md | null
+    links:
+      story: "ENG-123" | "docs/stories/story-add-login.md"
+      epic: "ENG-100" | null
+```
+
+## Quality Checklist
+
+- [ ] Tasks are small, clear, and testable
+- [ ] Each task has an explicit Definition of Done
+- [ ] Tasks link to the story (and epic if applicable)
+- [ ] Task types cover dev, qa, and docs as needed