jumpstart-mode 1.1.13 → 1.1.14

package/.jumpstart/skills/jira-delivery-builder/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: jira-delivery-builder
+description: Use this skill when creating, reviewing, organizing, importing, or refining Jira work items from discovery notes, workshop outputs, PRDs, BRDs, SOWs, MVP scopes, POCs, transcripts, architecture documents, backlog ideas, or delivery plans. The skill produces Jira-ready epics, stories, tasks, subtasks, bugs, spikes, acceptance criteria, dependencies, labels, priorities, estimates, and CSV import files.
+---
+
+# Jira Delivery Builder Skill
+
+## Purpose
+
+Convert unstructured discovery, planning, and delivery input into Jira-ready work items that are clear, testable, traceable, and useful for human developers and AI coding agents.
+
+This skill is tailored to AI Innovation Pod and JumpStart workflows where work often starts as workshops, transcripts, scorecards, architecture notes, and proposal artifacts.
+
+## Use This Skill When
+
+Use this skill when the user asks to:
+
+- create Jira tickets, epics, stories, tasks, bugs, spikes, or subtasks
+- convert notes or documents into a delivery backlog
+- build a backlog hierarchy for MVP or phased delivery
+- create Jira CSV imports
+- review backlog quality and readiness
+- split oversized stories
+- write acceptance criteria or definition of done language
+- create source traceability from client artifacts to Jira work
+- prepare implementation tickets for Copilot, Cursor, Claude Code, or delivery teams
+- generate JQL filters or report-ready issue groupings
+
+## Bundled Assets
+
+Use the bundled resources to keep outputs consistent:
+
+- References:
+  - `./references/jira-issue-types.md`
+  - `./references/backlog-decomposition.md`
+  - `./references/story-writing-standards.md`
+  - `./references/acceptance-criteria-guide.md`
+  - `./references/ai-ticket-patterns.md`
+  - `./references/dependency-mapping.md`
+  - `./references/definition-of-ready.md`
+  - `./references/definition-of-done.md`
+  - `./references/csv-import-guide.md`
+  - `./references/jql-cheatsheet.md`
+  - `./references/jira-reporting.md`
+  - `./references/source-traceability.md`
+- Templates:
+  - `./templates/epic-template.md`
+  - `./templates/user-story-template.md`
+  - `./templates/technical-task-template.md`
+  - `./templates/spike-template.md`
+  - `./templates/bug-template.md`
+  - `./templates/ai-rag-story-template.md`
+  - `./templates/ai-agent-story-template.md`
+  - `./templates/review-queue-story-template.md`
+  - `./templates/jira-csv-import-template.csv`
+  - `./templates/sprint-readiness-report.md`
+  - `./templates/backlog-quality-report.md`
+  - `./templates/dependency-register.md`
+  - `./templates/mvp-backlog-template.md`
+- Scripts:
+  - `./scripts/generate_jira_csv.py`
+  - `./scripts/validate_jira_backlog.py`
+  - `./scripts/split_large_stories.py`
+  - `./scripts/create_dependency_register.py`
+  - `./scripts/convert_markdown_to_jira_csv.py`
+  - `./scripts/generate_jql_filters.py`
+- Evals:
+  - `./evals/README.md`
+  - `./evals/eval-cases.md`
+
+## Required Output Options
+
+Depending on the request, produce one or more of:
+
+- backlog hierarchy (initiative, epic, story, task, spike, bug, subtask)
+- acceptance criteria and definition of done snippets
+- dependency register and blockers
+- source traceability matrix
+- sprint grouping with dependency-aware sequencing
+- Jira CSV import package
+- backlog quality findings and remediation
+- JQL filters for execution and reporting
+
+## Core Workflow
+
+Follow this order unless the user requests a narrow subset:
+
+1. Clarify objective and output mode.
+2. Identify and classify source artifacts.
+3. Extract capabilities, requirements, constraints, dependencies, and unknowns.
+4. Build issue hierarchy using issue-type rules.
+5. Draft issue content using templates and testable acceptance criteria.
+6. Add AI-specific controls when scope includes AI, RAG, or agentic behavior.
+7. Add labels, priorities, estimates, dependencies, and traceability tags.
+8. Run backlog quality review and split oversized stories if needed.
+9. Prepare CSV import output only after markdown review, unless user asks for direct CSV.
+10. Produce sprint sequencing and JQL/report artifacts as requested.
+
+## Intake Checklist
+
+Before drafting tickets, establish as much as possible:
+
+- delivery outcome and MVP boundary
+- target Jira project and issue type model
+- source artifacts and trust level (source-backed versus user-inferred)
+- architecture, integration, and security constraints
+- dependency owners and needed-by windows
+- acceptance testing expectations
+- definition of ready and definition of done expectations
+
+If key ambiguity remains, ask the smallest set of clarifying questions needed to avoid inventing facts.
+
+## Issue Type Rules
+
+Use the rules in `./references/jira-issue-types.md`:
+
+- Epic: major capability or business outcome area
+- Story: user-visible or user-testable behavior
+- Task: technical implementation work not best shaped as a story
+- Spike: timeboxed research for uncertainty reduction
+- Bug: broken behavior or defect
+- Subtask: execution step under a parent issue
+
+Do not force all technical work into user-story format.
+
+## Writing Rules
+
+For every issue:
+
+- include clear summary and expected outcome
+- keep acceptance criteria testable
+- include dependency and source traceability fields
+- include explicit out-of-scope statements for boundary control
+- avoid hidden architectural decisions in implementation notes
+
+## AI-Specific Rules
+
+When AI, RAG, or agent flows are in scope, include criteria for:
+
+- citation behavior and source grounding
+- permission filtering and secure retrieval
+- no-answer behavior
+- model and prompt version traceability
+- observability and runtime logging
+- evaluation dataset coverage
+- human review or override behavior where applicable
+
+Use patterns in `./references/ai-ticket-patterns.md` and templates in `./templates/ai-rag-story-template.md` and `./templates/ai-agent-story-template.md`.
+
+## Quality Gates
+
+A backlog is ready when:
+
+- issue hierarchy is coherent
+- each issue is sized and independently testable
+- dependencies are explicit and assigned
+- source traceability is preserved or marked as inferred
+- security, data, and observability requirements are not omitted
+- sprint candidates satisfy definition of ready
+
+Use `./scripts/validate_jira_backlog.py` for machine-assisted checks when a CSV backlog exists.
+
+## CSV Import Rules
+
+- Prefer reviewable markdown first, then CSV.
+- Include core Jira columns from `./references/csv-import-guide.md`.
+- Preserve stable external IDs and source references.
+- Use `./scripts/generate_jira_csv.py` or `./scripts/convert_markdown_to_jira_csv.py` for conversion.
+
+## Reporting And Tracking
+
+When asked for tracking/reporting support:
+
+- generate JQL filters with `./scripts/generate_jql_filters.py`
+- create sprint readiness and blocked-work reports using template files
+- provide a dependency register and risk summary for client governance
+
+## Output Quality Rules
+
+- separate confirmed facts from assumptions
+- never invent source references
+- mark uncertain lineage as "derived from user instruction"
+- keep language execution-ready and testable
+- prioritize delivery clarity over narrative verbosity

package/.jumpstart/skills/jira-delivery-builder/evals/README.md

@@ -0,0 +1,27 @@
+# Jira Delivery Builder Evals
+
+Use these evals to verify that the skill consistently produces delivery-ready, traceable Jira artifacts.
+
+## Evaluation Areas
+
+- decomposition quality
+- issue type classification quality
+- acceptance criteria testability
+- dependency and source traceability completeness
+- AI-control completeness for RAG and agentic scopes
+- CSV import readiness
+
+## Basic Evaluation Method
+
+1. Pick an eval input from `eval-cases.md`.
+2. Run the skill prompt with no extra hidden assumptions.
+3. Score output against pass/fail checks per case.
+4. Capture recurring failure patterns and update templates or references.
+
+## Pass Criteria
+
+- no invented source references
+- stories contain testable acceptance criteria
+- technical work is not forced into stories
+- key dependencies are explicit and assigned or marked TBD
+- AI stories include traceability and guardrail criteria when relevant

package/.jumpstart/skills/jira-delivery-builder/evals/eval-cases.md

@@ -0,0 +1,65 @@
+# Eval Cases
+
+## Case 1: Discovery Notes To Backlog
+
+### Case 1 Input
+
+Workshop notes describing RFQ intake automation, source system constraints, and data-quality issues.
+
+### Case 1 Expected
+
+- 1 to 2 epics
+- 6 to 12 mixed issue types (story/task/spike)
+- explicit client dependencies
+- no fabricated requirement IDs
+
+## Case 2: PRD To Sprint-Ready Stories
+
+### Case 2 Input
+
+PRD with MVP scope and feature list.
+
+### Case 2 Expected
+
+- clear story boundaries
+- acceptance criteria in Given-When-Then format
+- out-of-scope statements
+- definition-of-ready gaps flagged
+
+## Case 3: AI RAG Capability Build
+
+### Case 3 Input
+
+RAG architecture notes and transcript excerpt.
+
+### Case 3 Expected
+
+- separate tickets for ingestion, retrieval, answer generation, citation, and evaluation
+- security and permission filtering criteria included
+- trace/logging criteria included
+- no-answer behavior included
+
+## Case 4: Backlog Quality Review
+
+### Case 4 Input
+
+Existing CSV backlog with vague summaries and large stories.
+
+### Case 4 Expected
+
+- findings with severity
+- split suggestions for oversized stories
+- explicit remediation actions
+
+## Case 5: CSV Import Package
+
+### Case 5 Input
+
+Markdown issue drafts for one epic and multiple child issues.
+
+### Case 5 Expected
+
+- valid CSV columns
+- parent and epic links preserved
+- external IDs present
+- source references preserved

package/.jumpstart/skills/jira-delivery-builder/references/acceptance-criteria-guide.md

@@ -0,0 +1,32 @@
+# Acceptance Criteria Guide
+
+## Preferred Style
+
+Given [context], when [action], then [expected result].
+
+## Coverage Dimensions
+
+- Functional behavior
+- Error handling
+- Security and access control
+- Accessibility expectations
+- Observability events and logging
+- AI evaluation and human review where relevant
+
+## Minimum Set
+
+Each story should include:
+
+- happy path criterion
+- failure-path criterion
+- permission or data-access criterion when applicable
+- trace/log criterion for operational visibility
+
+## AI/RAG Additions
+
+Add criteria for:
+
+- grounded responses with citations
+- no-answer behavior when retrieval confidence is low
+- prompt and model version capture
+- secure retrieval with permission filtering

package/.jumpstart/skills/jira-delivery-builder/references/ai-ticket-patterns.md

@@ -0,0 +1,30 @@
+# AI Ticket Patterns
+
+Use these patterns for AI Innovation Pod delivery backlogs.
+
+## Common AI Workstreams
+
+- document ingestion and normalization
+- chunking and embedding pipeline
+- retrieval and reranking
+- grounded answer generation
+- citation rendering and source drill-through
+- human review queue and override flow
+- trace and telemetry capture
+- evaluation dataset and scorecards
+- prompt and model provider abstraction
+- guardrail and prompt injection testing
+
+## Required AI Controls In Tickets
+
+- Source traceability at answer level
+- Access control and permission filtering
+- Runtime observability and token logging
+- Evaluation criteria and regression checks
+- Human escalation path for low-confidence outputs
+
+## Example Spike Questions
+
+- How is source ACL metadata preserved across chunking and retrieval?
+- What no-answer threshold should trigger reviewer escalation?
+- Which trace fields are required for auditability?

package/.jumpstart/skills/jira-delivery-builder/references/backlog-decomposition.md

@@ -0,0 +1,30 @@
+# Backlog Decomposition
+
+## Objective
+
+Convert raw source material into a delivery hierarchy that is estimable, testable, and sequenceable.
+
+## Method
+
+1. Extract capabilities and outcomes from source material.
+2. Group capabilities into epics by business objective.
+3. Split each epic into user-facing stories and technical tasks.
+4. Create spikes for unknowns that block reliable estimates.
+5. Add subtasks only when parent work is too broad for assignment tracking.
+6. Add dependency and traceability metadata.
+
+## Sizing Heuristic
+
+- Story target: 1 to 5 days of implementation effort.
+- Task target: 0.5 to 3 days.
+- Spike target: 1 to 2 days, timeboxed with exit criteria.
+
+## Split Signals
+
+Split an issue when it has two or more of the following:
+
+- multiple independent outcomes
+- multiple integrations or security boundaries
+- cannot be tested in a single scenario
+- estimate uncertainty above one sprint
+- implementation spans too many teams

package/.jumpstart/skills/jira-delivery-builder/references/csv-import-guide.md

@@ -0,0 +1,36 @@
+# Jira CSV Import Guide
+
+## Recommended Columns
+
+- Issue Type
+- Summary
+- Description
+- Priority
+- Epic Name
+- Epic Link
+- Parent
+- Labels
+- Components
+- Story Points
+- Sprint
+- Assignee
+- Reporter
+- Acceptance Criteria
+- Dependencies
+- External ID
+- Source Reference
+
+## Rules
+
+- Draft and review markdown issue content before CSV export.
+- Keep stable External ID values for repeat imports.
+- Preserve source references for auditability.
+- Avoid embedding large markdown tables in CSV cells when possible.
+
+## Validation Checklist
+
+- required columns exist
+- issue types are valid for target project
+- parent and epic links resolve
+- labels follow naming standard
+- acceptance criteria are not empty for stories

package/.jumpstart/skills/jira-delivery-builder/references/definition-of-done.md

@@ -0,0 +1,20 @@
+# Definition Of Done
+
+A ticket is done when:
+
+- acceptance criteria pass
+- tests are added or updated where appropriate
+- failure handling is implemented
+- security requirements are satisfied
+- observability is implemented for critical behavior
+- documentation is updated
+- demo path is validated
+- product owner acceptance is captured
+
+For AI work also require:
+
+- prompt template version recorded
+- model/provider runtime metadata captured
+- retrieved source IDs available for review
+- evaluation cases updated
+- human override path tested where applicable

package/.jumpstart/skills/jira-delivery-builder/references/definition-of-ready.md

@@ -0,0 +1,12 @@
+# Definition Of Ready
+
+A ticket is ready when:
+
+- business outcome is clear
+- actor and scope boundary are clear
+- acceptance criteria are testable
+- required systems and data are identified
+- dependencies are listed and owned
+- security and permission needs are documented
+- design expectations are explicit for user-facing work
+- estimate and priority are assigned

package/.jumpstart/skills/jira-delivery-builder/references/dependency-mapping.md

@@ -0,0 +1,27 @@
+# Dependency Mapping
+
+## Dependency Types
+
+- Identity and access setup
+- API credentials and platform onboarding
+- Network and firewall prerequisites
+- Source system data exports
+- Environment and infrastructure readiness
+- Security and compliance approvals
+- Product owner and user validation windows
+
+## Register Fields
+
+- Dependency
+- Blocking Ticket
+- Owner
+- Needed By
+- Risk If Late
+- Mitigation
+
+## Rules
+
+- Link dependencies to a specific blocking ticket.
+- Assign a named owner, not a generic team where possible.
+- Include a needed-by sprint or date.
+- State impact in delivery terms.

package/.jumpstart/skills/jira-delivery-builder/references/jira-issue-types.md

@@ -0,0 +1,29 @@
+# Jira Issue Type Guidance
+
+Use these defaults unless the target Jira project has custom issue types.
+
+## Hierarchy
+
+Initiative
+Epic
+Story
+Subtask
+Task
+Spike
+Bug
+
+## Decision Rules
+
+- Epic: Major capability, business process, or workstream.
+- Story: User-visible behavior that can be validated end to end.
+- Task: Technical work not naturally framed as user behavior.
+- Spike: Timeboxed investigation with explicit questions and deliverable.
+- Bug: Defect that breaks expected behavior.
+- Subtask: Execution step under a parent story or task.
+
+## Anti-Patterns
+
+- Converting every technical item into a story.
+- Creating giant stories that hide five or more capabilities.
+- Using spikes as implementation placeholders.
+- Mixing bug-fix and feature scope in one issue.

package/.jumpstart/skills/jira-delivery-builder/references/jira-reporting.md

@@ -0,0 +1,28 @@
+# Jira Reporting Guidance
+
+## Useful Reports
+
+- sprint readiness report
+- blocked work report
+- dependency report
+- risk and assumption report
+- story quality report
+- AI workstream report
+- integration readiness report
+- epic progress report
+- definition-of-ready compliance report
+
+## Report Structure
+
+- Summary metrics
+- Highest risk issues
+- Ready versus not-ready breakdown
+- Dependency bottlenecks
+- Recommended next actions
+
+## AI Workstream Additions
+
+- citation coverage status
+- permission-filtering readiness
+- eval dataset coverage
+- traceability and observability readiness

package/.jumpstart/skills/jira-delivery-builder/references/jql-cheatsheet.md

@@ -0,0 +1,25 @@
+# JQL Cheatsheet
+
+## Core Filters
+
+project = AIPOD ORDER BY priority DESC
+
+project = AIPOD AND issuetype = Spike AND status != Done
+
+project = AIPOD AND labels = client-dependency AND status != Done
+
+project = AIPOD AND labels in (security, integration, rag) AND status != Done
+
+project = AIPOD AND sprint in openSprints() ORDER BY Rank ASC
+
+## Backlog Quality
+
+project = AIPOD AND issuetype = Story AND description ~ "Acceptance Criteria" = false
+
+project = AIPOD AND status != Done AND assignee is EMPTY
+
+## Dependency Tracking
+
+project = AIPOD AND labels = blocked AND status != Done
+
+project = AIPOD AND labels = client-dependency ORDER BY priority DESC

package/.jumpstart/skills/jira-delivery-builder/references/source-traceability.md

@@ -0,0 +1,27 @@
+# Source Traceability
+
+## Objective
+
+Maintain a clear line from source evidence to Jira work so scope can be defended and audited.
+
+## Source Types
+
+- workshop notes
+- transcript sections
+- PRD and BRD requirement IDs
+- SOW sections
+- architecture decisions
+- client quotes
+
+## Traceability Fields
+
+- Source Reference
+- Requirement ID
+- Derived From
+- Confidence (source-backed or inferred)
+
+## Rules
+
+- Never invent source IDs or document references.
+- If missing, set Source Reference to "derived from user instruction".
+- Link traceability at epic level and at story/task level for high-risk items.

package/.jumpstart/skills/jira-delivery-builder/references/story-writing-standards.md

@@ -0,0 +1,30 @@
+# Story Writing Standards
+
+## Story Structure
+
+- User Story
+- Background
+- Acceptance Criteria
+- Implementation Notes
+- Dependencies
+- Out of Scope
+- Source Traceability
+
+## User Story Pattern
+
+As a [role], I want [capability], so that [business outcome].
+
+## Writing Rules
+
+- Use one primary outcome per story.
+- Keep language testable and implementation-neutral.
+- Include edge-case or failure behavior in criteria.
+- Keep out-of-scope explicit to protect sprint boundaries.
+
+## Completion Checks
+
+- business value is clear
+- actor is identified
+- acceptance criteria are testable
+- dependencies are listed
+- source traceability is present