# How the capture-tasks-from-meeting-notes Skill Extracts Actionable Items from Unstructured Meeting Text

> Learn how the capture-tasks-from-meeting-notes skill converts unstructured meeting notes into structured Jira tickets using a seven-step workflow and regex patterns to identify assignees and tasks.

- Repository: [OpenAI/plugins](https://github.com/openai/plugins)
- Tags: how-to-guide
- Published: 2026-06-11

---

**The capture-tasks-from-meeting-notes skill uses a deterministic seven-step workflow that applies five regex-style patterns to identify assignees and task descriptions, converting free-form meeting notes into structured Jira tickets.**

The openai/plugins repository hosts an Atlassian Rovo skill that automates the extraction of actionable tasks from chaotic meeting notes. This skill, defined in [`plugins/atlassian-rovo/skills/capture-tasks-from-meeting-notes/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/atlassian-rovo/skills/capture-tasks-from-meeting-notes/SKILL.md), demonstrates how to extract actionable items from unstructured meeting text using pattern matching and structured parsing pipelines.

## The Seven-Step Extraction Workflow

The skill operates through a deterministic pipeline documented in the source specification. Each step transforms the input data until it produces concrete Jira issues.

### Step 1: Ingest Meeting Notes

The workflow begins by accepting input via two pathways. Users can provide a Confluence page URL processed through `getConfluencePage`, or paste raw text directly into the chat interface. This flexibility allows the skill to process both archived documents and ad-hoc meeting minutes.

### Step 2: Parse Action Items (Core Extraction)

This is the critical phase where the skill extracts actionable items from unstructured meeting text. According to lines 56-100 of SKILL.md, the parser scans input line-by-line, applying five canonical patterns in priority order to identify assignees and task descriptions. It captures the assignee name and strips markers like `@`, `Action:`, and `TODO:` while preserving the task context.

### Step 3: Collect Project Metadata

The skill prompts the user to specify a Jira project key (e.g., `PROJ`) to ensure tasks are created in the correct repository.

### Step 4: Resolve Account IDs

Using `lookupJiraAccountId`, the system maps each extracted assignee name to a valid Jira account ID. The implementation handles zero matches, single matches, and multiple ambiguous matches through interactive user prompts.

### Step 5: Present for Review

Before any mutations occur, the skill displays the parsed action items—showing assignee, description, and context—allowing users to verify or abort the operation.

### Step 6: Create Jira Issues

The skill invokes `createJiraIssue` with the validated data, creating Tasks, Stories, or Bugs based on user selection.

### Step 7: Generate Summary

Finally, the skill returns a concise report containing links to all newly created Jira tickets and references back to the source meeting notes.

## Pattern-Based Text Parsing

The extraction logic relies on five regex-style patterns that run sequentially until a match is found. This priority-based approach maximizes precision when processing varied meeting note formats.

### Pattern 1: @-Mentions

The parser first searches for lines containing `@username` followed by action verbs like *to*, *will*, or *should*. For example, in `@Sarah to create user stories for chat feature`, the skill extracts **Sarah** as the assignee and **create user stories for chat feature** as the task.

### Pattern 2: Name + Verb

When no @-mention exists, the skill looks for a name followed by commitment verbs such as *will*, *to*, or *needs to*. In `Mike will update architecture doc`, **Mike** becomes the assignee and **update architecture doc** the task description.

### Pattern 3: Action: Format

Structured lines beginning with `Action:` follow a strict delimiter pattern. The parser extracts text between `Action:` and the hyphen as the assignee, and everything after the hyphen as the task.

### Pattern 4: TODO with Assignee

For lines formatted as `TODO: Task description (Name)`, the skill uses the content within parentheses as the assignee and the preceding text as the task description.

### Pattern 5: Bullet List

Markdown-style bullets using `-` or `*` followed by a name and colon trigger the final pattern. The text before the colon becomes the assignee, while the remainder forms the task description.

## Edge Case Handling

The SKILL.md specification documents robust handling for extraction failures. When no items are found, the skill prompts users to check for TODOs without explicit assignees or to manually specify tasks. Duplicate detection algorithms ask whether to collapse, keep, or skip identical entries. For lengthy descriptions exceeding Jira summary limits, the skill offers truncation options while preserving full text in the description field.

## Implementation Examples

### Processing Raw Meeting Notes

```json
{
  "plugin": "atlassian-rovo",
  "skill": "capture-tasks-from-meeting-notes",
  "input": {
    "meetingNotes": "# Product Planning – Dec 3\n\nAction Items:\n- @Sarah to create user stories for chat feature\n- Mike will update the architecture doc\n- Lisa: review and approve design mockups"

  }
}

```

### Fetching from Confluence

```json
{
  "plugin": "atlassian-rovo",
  "skill": "capture-tasks-from-meeting-notes",
  "input": {
    "confluenceUrl": "https://mycompany.atlassian.net/wiki/spaces/ENG/pages/123456789/Product+Planning+Dec+3"
  }
}

```

### Extraction Logic

```python
def parse_action_items(text):
    patterns = [
        r'@(?P<assignee>\w+)\s+(?:to|will|should)\s+(?P<task>.+)',          # @mention

        r'(?P<assignee>\w+)\s+(?:to|will|should|needs?\s+to)\s+(?P<task>.+)', # Name + verb

        r'Action:\s*(?P<assignee>\w+)\s*-\s*(?P<task>.+)',                 # Action: Name - Task

        r'TODO:\s*(?P<task>.+?)\s*\((?P<assignee>\w+)\)',                  # TODO (Name)

        r'[-*]\s*(?P<assignee>\w+)\s*[:\-]\s*(?P<task>.+)'                 # Bullet list

    ]
    items = []
    for line in text.splitlines():
        for pat in patterns:
            m = re.search(pat, line, flags=re.IGNORECASE)
            if m:
                items.append({
                    "assignee": m.group('assignee').strip(),
                    "task": m.group('task').strip(),
                    "context": extract_context(text)
                })
                break
    return items

```

## Summary

- The skill follows a deterministic seven-step workflow defined in [`plugins/atlassian-rovo/skills/capture-tasks-from-meeting-notes/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/atlassian-rovo/skills/capture-tasks-from-meeting-notes/SKILL.md)
- **Step 2: Parse Action Items** applies five regex-style patterns in priority order to extract assignees and tasks from unstructured text
- Supported patterns include @-mentions, name+verb combinations, `Action:` prefixes, `TODO:` markers, and bullet-list formats
- The system uses `lookupJiraAccountId` to resolve names to Jira IDs and `createJiraIssue` to generate tickets
- Built-in edge case handling manages missing assignees, duplicates, and long descriptions through interactive prompts

## Frequently Asked Questions

### What file contains the extraction logic for the capture-tasks-from-meeting-notes skill?

The complete specification resides in [`plugins/atlassian-rovo/skills/capture-tasks-from-meeting-notes/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/atlassian-rovo/skills/capture-tasks-from-meeting-notes/SKILL.md) within the openai/plugins repository. This document defines the seven-step workflow, five parsing patterns, and user interaction flows for converting meeting text into Jira tasks.

### Which pattern takes priority when parsing meeting notes?

The @-mention pattern takes precedence over other formats. The skill evaluates patterns in strict priority order: @-mentions first, followed by name+verb, Action: format, TODO with assignee, and finally bullet list syntax. This ordering ensures that explicit mentions receive highest confidence matching.

### How does the skill handle ambiguous or missing assignees?

When `lookupJiraAccountId` returns zero matches for an extracted name, the skill prompts the user to select the correct assignee from a list or enter a new name. If no assignee is found in the text, the skill asks whether to search for TODOs without explicit owners or to manually specify the task details.

### Can the skill process meeting notes stored in Confluence?

Yes. The skill accepts a `confluenceUrl` parameter and internally calls `getConfluencePage(cloudId, pageId, "markdown")` to fetch content before applying the same pattern-based extraction logic used for raw text input. This integration allows teams to process archived meeting minutes without manual copy-paste operations.