Atlassian

View saved version →

---
name: capture-tasks-from-meeting-notes
description: "Analyze meeting notes to find action items and create Jira tasks for assigned work. When an agent needs to: (1) Create Jira tasks or tickets from meeting notes, (2) Extract or find action items from notes or Confluence pages, (3) Parse meeting notes for assigned tasks, or (4) Analyze notes and generate tasks for team members. Identifies assignees, looks up account IDs, and creates tasks with proper context."
---

# Capture Tasks from Meeting Notes

## Keywords
meeting notes, action items, create tasks, create tickets, extract tasks, parse notes, analyze notes, assigned work, assignees, from meeting, post-meeting, capture tasks, generate tasks, turn into tasks, convert to tasks, action item, to-do, task list, follow-up, assigned to, create Jira tasks, create Jira tickets, meeting action items, extract action items, find action items, analyze meeting

## Overview

Automatically extract action items from meeting notes and create Jira tasks with proper assignees. This skill parses unstructured meeting notes (from Confluence or pasted text), identifies action items with assignees, looks up Jira account IDs, and creates tasks—eliminating the tedious post-meeting ticket creation process.

**Use this skill when:** Users have meeting notes with action items that need to become Jira tasks.

---

## Workflow

Follow this 7-step process to turn meeting notes into actionable Jira tasks:

### Step 1: Get Meeting Notes

Obtain the meeting notes from the user.

#### Option A: Confluence Page URL

If user provides a Confluence URL:

```
getConfluencePage(
  cloudId="...",
  pageId="[extracted from URL]",
  contentFormat="markdown"
)
```

**URL patterns:**
- `https://[site].atlassian.net/wiki/spaces/[SPACE]/pages/[PAGE_ID]/[title]`
- Extract PAGE_ID from the numeric portion
- Get cloudId from site name or use `getAccessibleAtlassianResources`

#### Option B: Pasted Text

If user pastes meeting notes directly:
- Use the text as-is
- No fetching needed

#### If Unclear

Ask: "Do you have a Confluence link to the meeting notes, or would you like to paste them directly?"

---

### Step 2: Parse Action Items

Scan the notes for action items with assignees.

#### Common Patterns

**Pattern 1: @mention format** (highest priority)
```
@Sarah to create user stories for chat feature
@Mike will update architecture doc
```

**Pattern 2: Name + action verb**
```
Sarah to create user stories
Mike will update architecture doc
Lisa should review the mockups
```

**Pattern 3: Action: Name - Task**
```
Action: Sarah - create user stories
Action Item: Mike - update architecture
```

**Pattern 4: TODO with assignee**
```
TODO: Create user stories (Sarah)
TODO: Update docs - Mike
```

**Pattern 5: Bullet with name**
```
- Sarah: create user stories
- Mike - update architecture
```

#### Extraction Logic

**For each action item, extract:**

1. **Assignee Name**
   - Text after @ symbol
   - Name before "to", "will", "should"
   - Name after "Action:" or in parentheses
   - First/last name or full name

2. **Task Description**
   - Text after "to", "will", "should", "-", ":"
   - Remove markers (@, Action:, TODO:)
   - Keep original wording
   - Include enough context

3. **Context** (optional but helpful)
   - Meeting title/date if available
   - Surrounding discussion context
   - Related decisions

#### Example Parsing

**Input:**
```
# Product Planning - Dec 3

Action Items:
- @Sarah to create user stories for chat feature
- Mike will update the architecture doc
- Lisa: review and approve design mockups
```

**Parsed:**
```
1. Assignee: Sarah
   Task: Create user stories for chat feature
   Context: Product Planning meeting - Dec 3

2. Assignee: Mike
   Task: Update the architecture doc
   Context: Product Planning meeting - Dec 3

3. Assignee: Lisa
   Task: Review and approve design mockups
   Context: Product Planning meeting - Dec 3
```

---

### Step 3: Ask for Project Key

Before looking up users or cr

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: generate-status-report
description: "Generate project status reports from Jira issues and publish to Confluence. When an agent needs to: (1) Create a status report for a project, (2) Summarize project progress or updates, (3) Generate weekly/daily reports from Jira, (4) Publish status summaries to Confluence, or (5) Analyze project blockers and completion. Queries Jira issues, categorizes by status/priority, and creates formatted reports for delivery managers and executives."
---

# Generate Status Report

## Keywords
status report, project status, weekly update, daily standup, Jira report, project summary, blockers, progress update, Confluence report, sprint report, project update, publish to Confluence, write to Confluence, post report

Automatically query Jira for project status, analyze issues, and generate formatted status reports published to Confluence.

**CRITICAL**: This skill should be **interactive**. Always clarify scope (time period, audience, Confluence destination) with the user before or after generating the report. Do not silently skip Confluence publishing—always offer it.

## Workflow

Generating a status report follows these steps:

1. **Identify scope** - Determine project, time period, and target audience
2. **Query Jira** - Fetch relevant issues using JQL queries
3. **Analyze data** - Categorize issues and identify key insights
4. **Format report** - Structure content based on audience and purpose
5. **Publish to Confluence** - Create or update a page with the report

## Step 1: Identify Scope

**IMPORTANT**: If the user's request is missing key information, ASK before proceeding with queries. Do not assume defaults without confirmation for Confluence publishing.

Clarify these details:

**Project identification:**
- Which Jira project key? (e.g., "PROJ", "ENG", "MKTG")
- If the user mentions a project by name but not key, search Jira to find the project key

**Time period:**
- If not specified, ask: "What time period should this report cover? (default: last 7 days)"
- Options: Weekly (7 days), Daily (24 hours), Sprint-based (2 weeks), Custom period

**Target audience:**
- If not specified, ask: "Who is this report for? (Executives/Delivery Managers, Team-level, or Daily standup)"
- **Executives/Delivery Managers**: High-level summary with key metrics and blockers
- **Team-level**: Detailed breakdown with issue-by-issue status  
- **Daily standup**: Brief update on yesterday/today/blockers

**Report destination:**
- **ALWAYS ASK** if not specified: "Would you like me to publish this report to Confluence? If so, which space should I use?"
- If user says yes: Ask for space name or offer to list available spaces
- Determine: New page or update existing page?
- Ask about parent page if creating under a specific section

## Step 2: Query Jira

Use the `searchJiraIssuesUsingJql` tool to fetch issues. Build JQL queries based on report needs.

### Common Query Patterns

For comprehensive queries, use the `scripts/jql_builder.py` utility to programmatically build JQL strings. For quick queries, reference `references/jql-patterns.md` for examples.

**All open issues in project:**
```jql
project = "PROJECT_KEY" AND status != Done ORDER BY priority DESC, updated DESC
```

**Issues updated in last week:**
```jql
project = "PROJECT_KEY" AND updated >= -7d ORDER BY priority DESC
```

**High priority and blocked issues:**
```jql
project = "PROJECT_KEY" AND (priority IN (Highest, High) OR status = Blocked) AND status != Done ORDER BY priority DESC
```

**Completed in reporting period:**
```jql
project = "PROJECT_KEY" AND status = Done AND resolved >= -7d ORDER BY resolved DESC
```

### Query Strategy

For most reports, execute multiple targeted queries rather than one large query:

1. **Completed issues**: Get recently resolved tickets
2. **In-progress issues**: Get active work items
3. **Blocked issues**: Get blockers requiring attention
4. **High priority open**: Get critical upcoming work

Use `maxResults: 1

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 3 — file references are metadata, not package contents.

View saved version →

---
name: jira-sprint-dashboard
description: >-
  Create a visual Jira sprint dashboard from Jira project, space, sprint, board,
  filter, JQL, work item keys, or Jira URL data. Use when the user asks for a
  Jira sprint dashboard, standup dashboard, sprint review, delivery review,
  engineering manager dashboard, WIP review, planning view, closeout view, or a
  visual snapshot of Jira work that is more useful than a flat report. Use the
  richest dashboard format supported by the current agent, such as Cursor
  Canvas, an interactive artifact, HTML, or Markdown.
---

# Jira Sprint Dashboard

Build a focused dashboard that helps an engineering manager, tech lead, or
senior engineer see current Jira work quickly enough to decide what needs
attention. The output is a dashboard, not a prose report and not a generic
health score.

This skill is read-only by default. Do not create, update, transition, assign,
or comment on Jira work items unless the user explicitly asks for a write action
after reviewing the dashboard.

## Output Mode

Use the richest dashboard renderer supported by the current environment. The
dashboard content, claims, counts, and source appendix must stay consistent
across renderers; only the presentation changes.

Choose the renderer in this order:

1. Cursor Canvas, if running in Cursor with Canvas support.
2. Interactive artifact, if the current agent supports HTML, React, or similar
   artifact output.
3. Static HTML file, if file creation is available and useful.
4. Markdown dashboard, if no richer visual renderer is available.
5. Structured JSON plus concise summary, only if visual rendering is impossible.

Do not mention that Cursor Canvas is unavailable unless the user specifically
asked for Cursor Canvas. If the user asked for a dashboard generally, use the
best available renderer without apologizing for the environment.

## Cursor Canvas Renderer

Use this section only when running in Cursor with Canvas support.

Read `~/.cursor/skills-cursor/canvas/SKILL.md` before writing canvas code. If
you need exact exports or prop shapes, read the files in
`~/.cursor/skills-cursor/canvas/sdk/`.

Canvas constraints:

- Create one `.canvas.tsx` file in the Cursor canvases directory.
- Import only from `cursor/canvas`. Do not import `react`, `CSSProperties`,
  `JSX`, Atlaskit, or other packages.
- Embed Jira data inline in the canvas; do not fetch from the canvas.
- Prefer Canvas primitives such as `Stack`, `Grid`, `Card`, `Stat`, `Table`,
  `Pill`, `Callout`, `UsageBar`, `BarChart`, `LineChart`, `PieChart`, and `Code`
  over raw HTML.
- Use `useHostTheme()` for custom styles. Do not hardcode hex colors, gradients,
  box shadows, ADS variables, unsupported CSS frameworks, or `@atlaskit/*`.
- Do not publish or share the canvas unless the user asks.

## Portable Renderers

Use this section when Cursor Canvas is unavailable.

For an interactive artifact renderer:

- Render the same dashboard model as an interactive artifact.
- Prefer tables, compact charts, stat rows, and collapsible source details.
- Keep interactions lightweight: filtering, expanding details, or switching
  chart/table views is fine; do not require live Jira fetching from the artifact.

For static HTML:

- Create a self-contained dashboard file with embedded data.
- Use responsive layout, accessible tables, and simple chart-like visuals when
  chart libraries are unavailable.
- Do not fetch Jira data from the HTML file.

For Markdown:

- Preserve the dashboard order.
- Use compact tables for stats, owner load, risks, highest-priority work, and
  source appendix.
- Use textual chart substitutes only when they remain honest, such as counts,
  percentages, and simple bars.
- Avoid turning the output into a long prose report.

For JSON fallback:

- Return the normalized dashboard model.
- Include a short human-readable summary with the highest-signal risks and the
  source scope.

## Get The Scope

Do not guess the Jira scope. If the user does not provid

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: search-company-knowledge
description: "Search across company knowledge bases (Confluence, Jira, internal docs) to find and explain internal concepts, processes, and technical details. When an agent needs to: (1) Find or search for information about systems, terminology, processes, deployment, authentication, infrastructure, architecture, or technical concepts, (2) Search internal documentation, knowledge base, company docs, or our docs, (3) Explain what something is, how it works, or look up information, or (4) Synthesize information from multiple sources. Searches in parallel and provides cited answers."
---

# Search Company Knowledge

## Keywords
find information, search company knowledge, look up, what is, explain, company docs, internal documentation, Confluence search, Jira search, our documentation, internal knowledge, knowledge base, search for, tell me about, get information about, company systems, terminology, find everything about, what do we know about, deployment, authentication, infrastructure, processes, procedures, how to, how does, our systems, our processes, internal systems, company processes, technical documentation, engineering docs, architecture, configuration, search our docs, search internal docs, find in our docs

## Overview

Search across siloed company knowledge systems (Confluence, Jira, internal documentation) to find comprehensive answers to questions about internal concepts, systems, and terminology. This skill performs parallel searches across multiple sources and synthesizes results with proper citations.

**Use this skill when:** Users ask about internal company knowledge that might be documented in Confluence pages, Jira tickets, or internal documentation.

---

## Workflow

Follow this 5-step process to provide comprehensive, well-cited answers:

### Step 1: Identify Search Query

Extract the core search terms from the user's question.

**Examples:**
- User: "Find everything about Stratus minions" → Search: "Stratus minions"
- User: "What do we know about the billing system?" → Search: "billing system"
- User: "Explain our deployment process" → Search: "deployment process"

**Consider:**
- Main topic or concept
- Any specific system/component names
- Technical terms or jargon

---

### Step 2: Execute Parallel Search

Search across all available knowledge sources simultaneously for comprehensive coverage.

#### Option A: Cross-System Search (Recommended First)

Use the **`search`** tool (Rovo Search) to search across Confluence and Jira at once:

```
search(
  cloudId="...",
  query="[extracted search terms]"
)
```

**When to use:** 
- Default approach for most queries
- When you don't know which system has the information
- Fastest way to get results from multiple sources

**Example:**
```
search(
  cloudId="...",
  query="Stratus minions"
)
```

This returns results from both Confluence pages and Jira issues.

#### Option B: Targeted Confluence Search

Use **`searchConfluenceUsingCql`** when specifically searching Confluence:

```
searchConfluenceUsingCql(
  cloudId="...",
  cql="text ~ 'search terms' OR title ~ 'search terms'"
)
```

**When to use:**
- User specifically mentions "in Confluence" or "in our docs"
- Cross-system search returns too many Jira results
- Looking for documentation rather than tickets

**Example CQL patterns:**
```
text ~ "Stratus minions"
text ~ "authentication" AND type = page
title ~ "deployment guide"
```

#### Option C: Targeted Jira Search

Use **`searchJiraIssuesUsingJql`** when specifically searching Jira:

```
searchJiraIssuesUsingJql(
  cloudId="...",
  jql="text ~ 'search terms' OR summary ~ 'search terms'"
)
```

**When to use:**
- User mentions "tickets", "issues", or "bugs"
- Looking for historical problems or implementation details
- Cross-system search returns mostly documentation

**Example JQL patterns:**
```
text ~ "Stratus minions"
summary ~ "authentication" AND type = Bug
text ~ "deployment" AND created >= -90d
```

#### Search Stra

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: spec-to-backlog
description: "Automatically convert Confluence specification documents into structured Jira backlogs with Epics and implementation tickets. When an agent needs to: (1) Create Jira tickets from a Confluence page, (2) Generate a backlog from a specification, (3) Break down a spec into implementation tasks, or (4) Convert requirements into Jira issues. Handles reading Confluence pages, analyzing specifications, creating Epics with proper structure, and generating detailed implementation tickets linked to the Epic."
---

# Spec to Backlog

## Overview

Transform Confluence specification documents into structured Jira backlogs automatically. This skill reads requirement documents from Confluence, intelligently breaks them down into logical implementation tasks, **creates an Epic first** to organize the work, then generates individual Jira tickets linked to that Epic—eliminating tedious manual copy-pasting.

## Core Workflow

**CRITICAL: Always follow this exact sequence:**

1. **Fetch Confluence Page** → Get the specification content
2. **Ask for Project Key** → Identify target Jira project
3. **Analyze Specification** → Break down into logical tasks (internally, don't create yet)
4. **Present Breakdown** → Show user the planned Epic and tickets
5. **Create Epic FIRST** → Establish parent Epic and capture its key
6. **Create Child Tickets** → Generate tickets linked to the Epic
7. **Provide Summary** → Present all created items with links

**Why Epic must be created first:** Child tickets need the Epic key to link properly during creation. Creating tickets first will result in orphaned tickets.

---

## Step 1: Fetch Confluence Page

When triggered, obtain the Confluence page content:

### If user provides a Confluence URL:

Extract the cloud ID and page ID from the URL pattern:
- Standard format: `https://[site].atlassian.net/wiki/spaces/[SPACE]/pages/[PAGE_ID]/[title]`
- The cloud ID can be extracted from `[site].atlassian.net` or by calling `getAccessibleAtlassianResources`
- The page ID is the numeric value in the URL path

### If user provides only a page title or description:

Use the `search` tool to find the page:
```
search(
  cloudId="...",
  query="type=page AND title~'[search terms]'"
)
```

If multiple pages match, ask the user to clarify which one to use.

### Fetch the page:

Call `getConfluencePage` with the cloudId and pageId:
```
getConfluencePage(
  cloudId="...",
  pageId="123456",
  contentFormat="markdown"
)
```

This returns the page content in Markdown format, which you'll analyze in Step 3.

---

## Step 2: Ask for Project Key

**Before analyzing the spec**, determine the target Jira project:

### Ask the user:
"Which Jira project should I create these tickets in? Please provide the project key (e.g., PROJ, ENG, PRODUCT)."

### If user is unsure:
Call `getVisibleJiraProjects` to show available projects:
```
getVisibleJiraProjects(
  cloudId="...",
  action="create"
)
```

Present the list: "I found these projects you can create issues in: PROJ (Project Alpha), ENG (Engineering), PRODUCT (Product Team)."

### Once you have the project key:
Call `getJiraProjectIssueTypesMetadata` to understand what issue types are available:
```
getJiraProjectIssueTypesMetadata(
  cloudId="...",
  projectIdOrKey="PROJ"
)
```

**Identify available issue types:**
- Which issue type is "Epic" (or similar parent type like "Initiative")
- What child issue types are available: "Story", "Task", "Bug", "Sub-task", etc.

**Select appropriate issue types for child tickets:**

The skill should intelligently choose issue types based on the specification content:

**Use "Bug" when the spec describes:**
- Fixing existing problems or defects
- Resolving errors or incorrect behavior
- Addressing performance issues
- Correcting data inconsistencies
- Keywords: "fix", "resolve", "bug", "issue", "problem", "error", "broken"

**Use "Story" when the spec describes:**
- New user-facing features or functionality
- User exp

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 3 — file references are metadata, not package contents.

View saved version →

---
name: triage-issue
description: "Intelligently triage bug reports and error messages by searching for duplicates in Jira and offering to create new issues or add comments to existing ones. When an agent needs to: (1) Triage a bug report or error message, (2) Check if an issue is a duplicate, (3) Find similar past issues, (4) Create a new bug ticket with proper context, or (5) Add information to an existing ticket. Searches Jira for similar issues, identifies duplicates, checks fix history, and helps create well-structured bug reports."
---

# Triage Issue

## Keywords
triage bug, check duplicate, is this a duplicate, search for similar issues, create bug ticket, file a bug, report this error, triage this error, bug report, error message, similar issues, duplicate bug, who fixed this, has this been reported, search bugs, find similar bugs, create issue, file issue

## Overview

Automatically triage bug reports and error messages by searching Jira for duplicates, identifying similar past issues, and helping create well-structured bug tickets or add context to existing issues. This skill eliminates manual duplicate checking and ensures bugs are properly documented with relevant historical context.

**Use this skill when:** Users need to triage error messages, bug reports, or issues to determine if they're duplicates and take appropriate action.

---

## Workflow

Follow this 6-step process to effectively triage issues:

### Step 1: Extract Key Information

Analyze the bug report or error message to identify search terms.

#### Extract These Elements:

**Error signature:**
- Error type or exception name (e.g., "NullPointerException", "TimeoutError")
- Error code or status (e.g., "500", "404", "ERR_CONNECTION_REFUSED")
- Specific error message text (key phrases, not full stack trace)

**Context:**
- Component or system affected (e.g., "authentication", "payment gateway", "API")
- Environment (e.g., "production", "staging", "mobile app")
- User actions leading to error (e.g., "during login", "when uploading file")

**Symptoms:**
- Observable behavior (e.g., "page blank", "infinite loading", "data not saving")
- Impact (e.g., "users can't login", "payments failing")

#### Example Extractions:

**Input:** "Users getting 'Connection timeout' error when trying to login on mobile app"
**Extracted:**
- Error: "Connection timeout"
- Component: "login", "mobile app"
- Symptom: "can't login"

**Input:** "NullPointerException in PaymentProcessor.processRefund() line 245"
**Extracted:**
- Error: "NullPointerException"
- Component: "PaymentProcessor", "refund"
- Location: "processRefund line 245"

---

### Step 2: Search for Duplicates

Search Jira using extracted keywords to find similar or duplicate issues.

#### Search Strategy:

Execute **multiple targeted searches** to catch duplicates that may use different wording:

**Search 1: Error-focused**
```
searchJiraIssuesUsingJql(
  cloudId="...",
  jql='project = "PROJ" AND (text ~ "error signature" OR summary ~ "error signature") AND type = Bug ORDER BY created DESC',
  fields=["summary", "description", "status", "resolution", "created", "updated", "assignee"],
  maxResults=20
)
```

**Search 2: Component-focused**
```
searchJiraIssuesUsingJql(
  cloudId="...",
  jql='project = "PROJ" AND text ~ "component keywords" AND type = Bug ORDER BY updated DESC',
  fields=["summary", "description", "status", "resolution", "created", "updated", "assignee"],
  maxResults=20
)
```

**Search 3: Symptom-focused**
```
searchJiraIssuesUsingJql(
  cloudId="...",
  jql='project = "PROJ" AND summary ~ "symptom keywords" AND type = Bug ORDER BY priority DESC, updated DESC',
  fields=["summary", "description", "status", "resolution", "created", "updated", "assignee"],
  maxResults=20
)
```

#### Search Tips:

**Use key terms only:**
- ✅ "timeout login mobile"
- ✅ "NullPointerException PaymentProcessor refund"
- ❌ "Users are getting a connection timeout error when..." (too verbose)

**Search recent first:**
- O

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.