Fetches extract-my-action-items from casper-studios/casper-marketplace and configures it for Cursor.
3
Select Cursor when prompted
The CLI shows a list of agents. Use arrow keys and space to select Cursor:
◆ Which agents do you want to install to?
│
│ ── Universal (.agents/skills) ────────────────
│ · Cline · Codex · Goose · Windsurf
│ ●Cursor(selected)
│ · Cursor · Aider · Continue
4
Verify installation
Confirm successful installation by checking the skill directory location:
.cursor/skills/extract-my-action-items
Restart Cursor to activate extract-my-action-items. Access via /extract-my-action-items in your agent's command palette.
⚠
Security Notice
We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.
Skills execute code in your environment. Always review source, verify the publisher, and test in isolation before production.
Extract action items from a Fireflies transcript using parallel subagents. Catches items automated summaries miss.
Two modes:
All attendees (default): No target specified — extract action items for every participant
Single person: Target specified — extract action items for that person only
Phase 1: Determine Mode
Parse the user's invocation:
If a target person is specified → single-person mode
Otherwise → all-attendees mode
Extract the search criteria (date, keyword, or transcript ID) from the invocation.
Phase 2: Fetch & Preprocess (Subagent)
The transcript API returns a JSON array (or an MCP wrapper containing one). Extract to plain text before chunking.
You should inspect the user's local hooks config and avoid running commands that are blocked by the hooks.
MCP based extraction
mkdir-p .claude/scratchpad
node-e"
const fs = require('fs');
let data = JSON.parse(fs.readFileSync(process.argv[1], 'utf8'));
// Handle MCP wrapper: if top-level array has a .text field containing the real transcript, parse that
if (data.length === 1 && typeof data[0]?.text === 'string') {
// Extract speaker lines from the text content
const lines = data[0].text.split('\n').filter(l => l.match(/^[A-Za-z].*?:/));
fs.writeFileSync('.claude/scratchpad/transcript.txt', lines.join('\n'));
const speakers = [...new Set(lines.map(l => l.split(':')[0].trim()))].sort();
console.log('Speakers:', JSON.stringify(speakers));
console.log('Total lines:', lines.length);
} else {
// Standard array of {speaker_name, text} objects
const lines = data.map(e => (e.speaker_name || 'Unknown') + ': ' + (e.text || ''));
fs.writeFileSync('.claude/scratchpad/transcript.txt', lines.join('\n'));
const speakers = [...new Set(data.map(e => e.speaker_name).filter(Boolean))].sort();
console.log('Speakers:', JSON.stringify(speakers));
console.log('Total lines:', lines.length);
}
"[TRANSCRIPT_JSON_FILE]
If the transcript JSON was saved to a tool-results file by the MCP client, pass that file path as the argument.
API based extraction
CRITICAL: The orchestrator MUST NOT call any Fireflies MCP tools directly. ALL Fireflies interaction happens inside this subagent.
Launch a single general-purpose subagent with this prompt:
Search Fireflies for a transcript matching: [SEARCH_CRITERIA]
1. Call `mcp__fireflies__fireflies_get_transcripts` to find the transcript (by date, keyword, or ID).
2. Call `mcp__fireflies__fireflies_get_summary` and `mcp__fireflies__fireflies_get_transcript` in parallel for the matched transcript.
3. The transcript API returns a JSON array. Extract to plain text:
- With jq: jq -r '.[].text' < raw_transcript.json > .claude/scratchpad/transcript.txt
- Fallback: python3 -c "import json,sys; print('\n'.join(e['text'] for e in json.load(sys.stdin)))" < raw_transcript.json > .claude/scratchpad/transcript.txt
4. Count lines: wc -l < .claude/scratchpad/transcript.txt
5. Extract the distinct speaker list from the transcript JSON:
python3 -c "import json,sys; data=json.load(sys.stdin); print('\n'.join(sorted(set(e.get('speaker_name','') for e in data if e.get('speaker_name')))))" < raw_transcript.json
Return EXACTLY this (no other text):
- meeting_title: <title>
- meeting_date: <date>
- transcript_id: <id>
- transcript_path: .claude/scratchpad/transcript.txt
- line_count: <number>
- speakers: <comma-separated list>
- summary: <the Fireflies summary text>
Wait for the subagent to finish. Parse its returned values — these are the inputs for the remaining phases.
Phase 3: Parallel Subagent Extraction
Chunk sizing:ceil(total_lines / 5) lines per chunk, minimum 200. Adjust chunk count so no chunk is under 200 lines.
Launch one general-purpose subagent per chunk.
Single-Person Prompt
Read lines [START] to [END] of [FILE_PATH].
Find ALL action items for [TARGET_PERSON]. Return each as:
- **Item**: what they committed to
- **Quote**: exact words from transcript
- **Context**: who else involved, any deadline
- **Discussion depth**: If this item emerged from extended back-and-forth (design decisions, technical debates, multi-speaker deliberation), include: what was proposed, what alternatives were considered, what was decided and WHY, specific technical details (field names, schema choices, API behaviors), open questions or deferred items, and connections to other people's work
Beyond obvious commitments ("I'll do X"), catch these non-obvious patterns:
- Self-notes: "I'll make a note to...", "let me jot down..."
- Admissions implying catch-up: "I dropped the ball on X", "I still haven't read X"
- Conditional offers that became commitments: "If we have time, I'm happy to..."
- Volunteering: "I guess I'll volunteer to..."
- Exploration tasks: "Let me spend a few hours with it"
- Questions/topics for external parties: "I need to ask [person/firm] about X", "thing to discuss with [party]"
All-Attendees Prompt
Read lines [START] to [END] of [FILE_PATH].
The meeting attendees are: [SPEAKER_LIST]
Find ALL action items for EVERY attendee. Group by person. For each item return:
- **Person**: who owns the action item
- **Item**: what they committed to
- **Quote**: exact words from transcript
- **Context**: who else involved, any deadline
- **Discussion depth**: If this item emerged from extended back-and-forth (design decisions, technical debates, multi-speaker deliberation), include: what was proposed, what alternatives were considered, what was decided and WHY, specific technical details (field names, schema choices, API behaviors), open questions or deferred items, and connections to other people's work
Beyond obvious commitments ("I'll do X"), catch these non-obvious patterns:
- Self-notes: "I'll make a note to...", "let me jot down..."
- Admissions implying catch-up: "I dropped the ball on X", "I still haven't read X"
- Conditional offers that became commitments: "If we have time, I'm happy to..."
- Volunteering: "I guess I'll volunteer to..."
- Exploration tasks: "Let me spend a few hours with it"
- Questions/topics for external parties: "I need to ask [person/firm] about X", "thing to discuss with [party]"
- Delegations: "[Person], can you handle X?", "I'll leave that to [person]"
Phase 4: Synthesize Notes
Merge subagent results, deduplicate, and categorize into a rich synthesized notes file. This is the master working document — all detail lives here. Linear proposals and the final action items checklist are derived from it.
Write to .claude/scratchpad/synthesized-notes-YYYY-MM-DD.md. Only include categories that have items.
Synthesis Depth
Preserve the full Discussion depth returned by subagents. Never flatten discussion-rich items into one-liners.
Checkbox title = the deliverable. Body = full context needed to execute it.
If a subagent returned multi-paragraph context for an item, keep it. Use bold sub-headers to organize (e.g., "Root cause:", "Agreed approach:", "Open items:").
Never collapse N distinct decisions into 1 bullet. List each.
Cross-link items that depend on each other (e.g., "dependency for Emerson's fiscal period table work").
Simple items (credential sharing, quick investigations) stay as one-liners.
Include exact quotes from the transcript for each item.
Derive Linear ticket creates and updates from the synthesized notes. The rich context and quotes from Phase 4 flow into Linear (as comments or ticket descriptions) so it becomes the source of truth. Uses a config file for team defaults and queries active cycle tickets for update candidates.
5a: Config Resolution
Look for team configuration in this order (first match wins):
references/config.json (bundled defaults, relative to this skill file)
Use the user config if found. Otherwise fall back to the bundled config.json.
If no user config exists AND the bundled config has an empty team field, stop and prompt the user:
No Linear config found. Create a user config at: ~/.agents/configs/extract-my-action-items/config.json
Copy the bundled references/config.json as a starting point and fill in your team, project, assignee, and labels.
If config resolves successfully, proceed.
5b–5c: Pull Active Tickets and Semantic Match (Single Subagent)
CRITICAL: Run 5b and 5c together inside a single general-purpose subagent. The cycle ticket data is large and should NOT flow through the main context window.
Launch a subagent with this prompt:
## Task: Pull active Linear tickets and match against synthesized meeting notes
### Step 1: Pull active tickets
Config: team=[TEAM], states=[STATES_LIST], attendees=[SPEAKER_LIST]
1. `mcp__linear__list_teams` with query=[TEAM] → get team ID
2. `mcp__linear__list_cycles` with type="current" → get current cycle ID
3. In parallel:
- `mcp__linear__list_issues` filtered by cycle + team (limit 250)
- `mcp__linear__list_issues` for each attendee (assignee filter, state="In Progress")
4. Deduplicate and build a lookup table: {identifier, title, assignee, status}
### Step 2: Semantic matching
Read the synthesized notes at [SYNTHESIZED_NOTES_PATH].
For each item, classify as:
- **UPDATE [TICKET-ID]** — maps to an existing ticket. Explain what new info to append.
- **NEW TICKET** — distinct deliverable not covered. Suggest title, assignee, priority.
- **IDEA** — process improvement, behavioral commitment, or exploratory thought.
Group output by classification. For UPDATE items include ticket ID. For NEW TICKET items include suggested title, assignee, and priority.
5d: Draft Proposals to Scratchpad
Write to .claude/scratchpad/linear-proposals-YYYY-MM-DD.md using the template from references/ticket-template.md.
Proposed Updates: For each UPDATE match, draft a comment body with the new feedback (dated section with context and quotes from the synthesized notes). Do NOT modify the issue description — updates are posted as comments.
Proposed New Tickets: Use send-to-linear description format (User Story, Requirements, Acceptance Criteria) with concrete examples and exact quotes from the synthesized notes.
Ideas / Needs More Thought: List with person, context, and exact quote. These are not skipped — they appear in the proposals file but do not become full tickets.
5e: User Review Gate
STOP. Tell the user the proposals file is ready at .claude/scratchpad/linear-proposals-YYYY-MM-DD.md and wait for explicit instruction.
Use AskUserQuestion: "Linear ticket proposals are ready. Review the file, then choose:"
"Create/update tickets in Linear" — proceed to execute
"Skip — just do Slack DMs" — skip to Phase 7
The user may edit the scratchpad file before approving. On approval:
Resolve team ID, label IDs, project ID, and current cycle via Linear MCP (same pattern as send-to-linear Phase 6):
mcp__linear__list_teams → team ID
mcp__linear__list_issue_labels → label IDs
mcp__linear__list_projects → project ID (if configured)
mcp__linear__list_cycles with type: "current" → current cycle
For updates:mcp__linear__create_comment with issueId and the drafted comment body. Do NOT use mcp__linear__save_issue to modify the description.
For new tickets:mcp__linear__save_issue with all fields from config + proposal (team, project, assignee, cycle, state, labels, title, description)
Ideas — no Linear action (they stay in the proposals file for reference only)
Report results with clickable links so the user can verify:
Updated tickets:https://linear.app/[WORKSPACE]/issue/[TICKET-ID] for each commented ticket
Created tickets:https://linear.app/[WORKSPACE]/issue/[TICKET-ID] for each new ticket (use the identifier returned by save_issue)
Derive [WORKSPACE] from the team's organization key, or from the config if available
Phase 6: Action Items Checklist
Generate a terse action items checklist derived from the synthesized notes. Linear is the source of truth for detail — the checklist is just a scannable index with links.
Where an item maps to a Linear ticket (updated or created in Phase 5), include the Linear link inline. Items not sent to Linear get a one-line description only.
Output
Single-person mode — Write to .claude/scratchpad/[name]-action-items-YYYY-MM-DD.md:
›Access to product documentation and roadmap tools (Jira, Notion, etc.)
›Understanding of product management frameworks (RICE, Jobs-to-be-Done, etc.)
›Stakeholder contact information and communication channels
Time Estimate
30-60 minutes to see productivity improvements
Steps
1Install product management skill
2Start with user story generation for known feature
3Progress to competitive analysis: research 2-3 competitors
4Use for roadmap prioritization: apply RICE/ICE scoring
5Draft stakeholder communications and refine based on feedback
6Build template library for recurring PM tasks
7Share effective prompts with product team
Common Pitfalls
⚠Not validating competitive research—verify facts before sharing
⚠Accepting user stories without involving engineering team
⚠Over-relying on frameworks without qualitative judgment
⚠Not customizing outputs to company culture and communication style
⚠Skipping stakeholder validation of generated requirements
Best Practices
✓ Do
+Validate research and competitive analysis with real data
+Collaborate with engineering when generating technical requirements
+Customize frameworks and templates to your company context
+Use skill for first drafts, refine with stakeholder input
+Document successful prompt patterns for PM tasks
+Combine AI efficiency with human judgment and intuition
✗ Don't
−Don't publish competitive analysis without fact-checking
−Don't finalize user stories without engineering review
−Don't make prioritization decisions solely on AI scoring
−Don't skip customer validation of generated requirements
−Don't ignore company-specific context and culture
💡 Pro Tips
★Provide context: company goals, constraints, customer feedback
★Ask for alternatives: 'Show 3 ways to prioritize this roadmap'
★Request stakeholder-specific formatting: 'Executive summary vs. engineering spec'
★Use skill for 70% generation + 30% customization to company needs
When to Use This
✓ Use when
Use for user story writing, competitive research, roadmap prioritization, stakeholder communication, and PRD drafting. Best for reducing repetitive documentation and research work.
✗ Avoid when
Avoid for strategic product vision (requires deep customer empathy), pricing decisions (needs market and financial expertise), or when face-to-face customer discovery is more valuable than speed.
Learning Path
1Basic: user stories, feature specs, status updates
