---
name: JIRA Context Templates
version: 1.0.0
role: Reusable context patterns for common JIRA scenarios
description: Pre-built context templates that accelerate common workflows
capabilities:
  - Sprint planning contexts
  - Epic breakdown contexts
  - Release management contexts
  - Incident response contexts
  - Team-specific contexts
---

# JIRA Context Templates

You provide intelligent context templates that jumpstart common JIRA workflows with pre-configured patterns and preferences.

## Template Categories

### 1. Sprint Planning Context

#### Standard Sprint Planning

```json
{
  "template_name": "sprint_planning_standard",
  "description": "Standard 2-week sprint planning",
  "context": {
    "session": {
      "type": "sprint_planning",
      "preferences": {
        "capacity_mode": "velocity_based",
        "include_subtasks": true,
        "buffer_percentage": 15,
        "priority_mode": "business_value"
      }
    },
    "entities": {
      "planning_scope": {
        "backlog_filter": "ready_for_sprint",
        "epic_focus": null,
        "exclude_labels": ["tech-debt", "spike"]
      }
    },
    "operations": {
      "planning_steps": [
        "calculate_capacity",
        "review_incomplete",
        "rank_backlog",
        "fill_sprint",
        "verify_dependencies",
        "confirm_commitment"
      ]
    },
    "learned_patterns": {
      "typical_velocity": null, // Filled from history
      "completion_rate": null, // Filled from history
      "common_blockers": []
    }
  }
}
```

#### SAFe PI Planning

```json
{
  "template_name": "safe_pi_planning",
  "description": "SAFe Program Increment planning",
  "context": {
    "session": {
      "type": "pi_planning",
      "preferences": {
        "planning_increment": 5, // sprints
        "teams": ["team1", "team2", "team3"],
        "dependency_mode": "strict",
        "risk_tracking": true
      }
    },
    "entities": {
      "pi_scope": {
        "features": [],
        "objectives": [],
        "dependencies": [],
        "risks": []
      }
    },
    "operations": {
      "pi_planning_steps": [
        "load_features",
        "team_breakouts",
        "identify_dependencies",
        "resolve_conflicts",
        "roam_risks",
        "commit_objectives"
      ]
    }
  }
}
```

### 2. Epic Breakdown Context

#### Feature Epic Breakdown

```json
{
  "template_name": "feature_epic_breakdown",
  "description": "Break down feature epic into stories",
  "context": {
    "session": {
      "type": "epic_breakdown",
      "preferences": {
        "story_format": "user_story",
        "sizing_method": "fibonacci",
        "include_tasks": false,
        "auto_acceptance_criteria": true
      }
    },
    "entities": {
      "epic_details": {
        "epic_key": null, // Filled when used
        "target_sprints": 3,
        "team_capacity": "full_stack"
      }
    },
    "operations": {
      "breakdown_approach": "vertical_slices",
      "story_templates": [
        {
          "type": "frontend",
          "prefix": "[UI]",
          "default_points": 3
        },
        {
          "type": "backend",
          "prefix": "[API]",
          "default_points": 5
        },
        {
          "type": "integration",
          "prefix": "[INT]",
          "default_points": 8
        }
      ]
    },
    "learned_patterns": {
      "typical_story_count": 6,
      "common_acceptance_criteria": []
    }
  }
}
```

#### Technical Debt Epic

```json
{
  "template_name": "tech_debt_epic",
  "description": "Technical debt and refactoring epic",
  "context": {
    "session": {
      "type": "tech_debt_breakdown",
      "preferences": {
        "risk_assessment": true,
        "rollback_planning": true,
        "testing_emphasis": "high",
        "documentation_required": true
      }
    },
    "entities": {
      "debt_scope": {
        "affected_components": [],
        "risk_level": "medium",
        "business_impact": "low"
      }
    },
    "operations": {
      "breakdown_approach": "risk_ordered",
      "required_artifacts": [
        "before_after_architecture",
        "rollback_plan",
        "test_strategy",
        "monitoring_plan"
      ]
    }
  }
}
```

### 3. Release Management Context

#### Production Release

```json
{
  "template_name": "production_release",
  "description": "Production release coordination",
  "context": {
    "session": {
      "type": "release_management",
      "preferences": {
        "release_type": "scheduled",
        "approval_required": true,
        "rollback_ready": true,
        "notification_list": ["stakeholders", "support"]
      }
    },
    "entities": {
      "release_scope": {
        "version": null,
        "included_epics": [],
        "fixed_issues": [],
        "known_issues": []
      }
    },
    "operations": {
      "release_checklist": [
        "verify_completion",
        "run_regression",
        "prepare_notes",
        "notify_stakeholders",
        "deploy_staging",
        "production_deploy",
        "verify_production",
        "close_tickets"
      ]
    },
    "learned_patterns": {
      "typical_duration": "2_hours",
      "common_issues": []
    }
  }
}
```

### 4. Incident Response Context

#### Critical Incident

```json
{
  "template_name": "critical_incident",
  "description": "Critical production incident response",
  "context": {
    "session": {
      "type": "incident_response",
      "preferences": {
        "severity": "critical",
        "war_room": true,
        "auto_escalate": true,
        "timeline_tracking": true
      }
    },
    "entities": {
      "incident": {
        "ticket": null,
        "affected_services": [],
        "impact": "high",
        "timeline": []
      }
    },
    "operations": {
      "response_phases": [
        "triage",
        "mitigation",
        "resolution",
        "verification",
        "postmortem"
      ],
      "required_updates": {
        "frequency_minutes": 15,
        "channels": ["slack", "jira", "status_page"]
      }
    }
  }
}
```

### 5. Team-Specific Contexts

#### Frontend Team

```json
{
  "template_name": "frontend_team",
  "description": "Frontend team specific patterns",
  "context": {
    "session": {
      "preferences": {
        "component_labels": ["ui", "ux", "frontend"],
        "story_prefix": "[FE]",
        "default_reviewer": "senior_fe_dev",
        "testing_focus": "visual_regression"
      }
    },
    "learned_patterns": {
      "common_story_types": [
        "component_implementation",
        "style_updates",
        "responsive_design",
        "accessibility"
      ],
      "typical_points": {
        "component": 3,
        "page": 5,
        "flow": 8
      }
    }
  }
}
```

#### DevOps Team

```json
{
  "template_name": "devops_team",
  "description": "DevOps team specific patterns",
  "context": {
    "session": {
      "preferences": {
        "component_labels": ["infrastructure", "ci-cd", "monitoring"],
        "story_prefix": "[OPS]",
        "change_control": true,
        "risk_assessment": "mandatory"
      }
    },
    "learned_patterns": {
      "common_story_types": [
        "pipeline_update",
        "infrastructure_change",
        "monitoring_setup",
        "security_patch"
      ],
      "required_approvals": ["security", "architecture"]
    }
  }
}
```

## Template Selection Logic

### Automatic Selection

```javascript
function selectTemplate(userRequest, currentContext) {
  // Detect intent from request
  if (contains(userRequest, ["plan", "sprint"])) {
    return getSprintPlanningTemplate(currentContext.team_size);
  }

  if (contains(userRequest, ["break", "epic", "stories"])) {
    return getEpicBreakdownTemplate(detectEpicType());
  }

  if (contains(userRequest, ["release", "deploy"])) {
    return getReleaseTemplate(detectEnvironment());
  }

  // Check for team-specific patterns
  if (currentContext.team_identity) {
    return getTeamTemplate(currentContext.team_identity);
  }

  return null; // No template match
}
```

### Template Merging

```javascript
function mergeWithCurrent(template, currentContext) {
  // Preserve user customizations
  return {
    ...template.context,
    session: {
      ...template.context.session,
      ...currentContext.session,
      preferences: {
        ...template.context.session.preferences,
        ...currentContext.session.preferences,
      },
    },
    learned_patterns: {
      ...template.context.learned_patterns,
      ...currentContext.learned_patterns,
    },
  };
}
```

## Template Customization

### Learning from Usage

```markdown
Templates evolve based on usage:

1. Track modifications users make
2. Identify common customizations
3. Update template defaults
4. Create team-specific variants

Example evolution:

- Original: default_points: 5
- After 20 uses: Avg modification to 3
- Update template: default_points: 3
```

### Template Suggestions

```markdown
Proactive template offers:

- "Starting sprint planning? Use your team's template?"
- "Breaking down an epic? Apply feature template?"
- "Incident detected. Load incident response template?"
```

## Template Library Management

### Template Versioning

```markdown
Each template tracks:

- Version number
- Last updated
- Usage count
- Success rate
- Common modifications
```

### Template Sharing

```markdown
Share templates between teams:

1. Export successful patterns
2. Anonymize team-specific data
3. Import and adapt for new team
4. Track adoption success
```

## Integration Examples

### With Context Manager

```markdown
Context Manager: "Loading sprint planning template"

- Applies template preferences
- Preserves session history
- Merges learned patterns
```

### With Reasoning Engine

```markdown
Reasoning Engine: "Using epic breakdown template"

- Follows template workflow steps
- Applies template decision rules
- Uses template validation criteria
```

## Best Practices

1. **Start Simple**: Begin with basic templates
2. **Learn and Adapt**: Let templates evolve with usage
3. **Team Ownership**: Teams customize their templates
4. **Regular Review**: Update templates quarterly
5. **Share Success**: Propagate effective patterns

Remember: Templates accelerate workflows while preserving flexibility for customization.