diff --git a/plugins/pm-advanced/skills/ai-product-canvas/SKILL.md b/plugins/pm-advanced/skills/ai-product-canvas/SKILL.md
new file mode 100644
index 0000000..f0559f9
--- /dev/null
+++ b/plugins/pm-advanced/skills/ai-product-canvas/SKILL.md
@@ -0,0 +1,145 @@
+---
+name: ai-product-canvas
+description: Structures AI and ML product decisions including model selection, data requirements, evaluation frameworks, and responsible AI considerations. Use when building AI-powered features, evaluating LLM integrations, designing AI products, or assessing AI readiness. Triggers on "AI product", "LLM feature", "AI canvas", "build with AI", "AI integration", "AI-powered", "machine learning feature".
+---
+
+# AI Product Canvas Skill
+
+Define AI products with the same rigour as any product decision — but with additional layers for data, model, evaluation, and responsible AI. This canvas prevents the most common AI product failure: building a technically impressive feature that doesn't solve a real problem.
+
+## AI Product Anti-Patterns to Check First
+
+Before building, flag if any of these apply:
+- ❌ "We should add AI to [existing feature]" — with no user problem defined
+- ❌ Accuracy target undefined before build begins
+- ❌ No plan for what happens when the model is wrong
+- ❌ User-facing AI output with no human review or fallback
+- ❌ Training data not audited for bias or quality
+- ❌ No evaluation metric — "we'll know it when we see it"
+
+---
+
+## AI Product Canvas Output Format
+
+### AI Product Canvas — [Feature Name] — [Date]
+
+**PM Owner:** [Name]
+**ML/AI Lead:** [Name]
+**Status:** Discovery / Design / Build / Evaluation / Live
+
+---
+
+#### 1. Problem Definition
+**User problem being solved:**
+> [What specific situation is the user in? What job are they trying to get done?]
+
+**Why AI?**
+> [What makes this problem require AI vs a deterministic solution? If the answer is "because we can," stop here.]
+
+**Success for the user looks like:**
+> [What outcome does the user experience when the AI feature is working well?]
+
+---
+
+#### 2. AI Approach
+
+**Task type:**
+- [ ] Classification
+- [ ] Generation (text, image, code)
+- [ ] Summarisation / extraction
+- [ ] Recommendation
+- [ ] Search / retrieval
+- [ ] Prediction / forecasting
+- [ ] Conversation / agent
+
+**Model approach:**
+- [ ] LLM API (GPT-4, Claude, Gemini, etc.) — specify: [Model name + version]
+- [ ] Fine-tuned model on own data
+- [ ] Custom model trained from scratch
+- [ ] RAG (retrieval-augmented generation)
+- [ ] Embedding + vector search
+
+**Rationale for chosen approach:** [Why this, not alternatives]
+
+---
+
+#### 3. Data Requirements
+
+| Data Type | Source | Volume | Quality Status | Bias Risk |
+|---|---|---|---|---|
+| [Training data] | [Where it comes from] | [Volume] | [Audit status] | H/M/L |
+| [Evaluation data] | [Where it comes from] | [Volume] | [Audit status] | H/M/L |
+
+**Data gaps:** [What's missing and plan to get it]
+**Privacy considerations:** [Any PII in training or inference data]
+**Data ownership:** [Do we own this data? Can we use it for training?]
+
+---
+
+#### 4. Evaluation Framework
+
+**Primary metric:** [The number that defines success — accuracy, F1, BLEU, user rating, task completion rate]
+**Minimum acceptable threshold:** [Below X, the feature does not ship]
+**Human evaluation plan:** [How will humans review model outputs? Sampling rate? Review panel?]
+
+| Evaluation Type | Method | Cadence | Owner |
+|---|---|---|---|
+| Offline (pre-launch) | [Test set, benchmark] | Pre-launch | ML Lead |
+| Online (post-launch) | [A/B test, user feedback] | Weekly | PM + ML |
+| Adversarial | [Red-team, edge cases] | Pre-launch | Safety reviewer |
+
+---
+
+#### 5. User Experience Design
+
+**How is AI output presented?**
+- [ ] Direct output shown to user (high trust required)
+- [ ] AI-assisted with user confirmation
+- [ ] Suggestion user can accept/reject
+- [ ] Background action with audit log
+
+**Confidence and uncertainty handling:**
+- What happens when confidence is low? [Show alternative, ask for clarification, fallback to manual]
+- How is uncertainty communicated to the user? [UI pattern]
+
+**Fallback plan:**
+- If the model fails or returns an error: [Specific fallback behaviour]
+- If accuracy degrades below threshold: [Kill switch or graceful degradation plan]
+
+---
+
+#### 6. Responsible AI Checklist
+
+- [ ] Bias audit completed on training data
+- [ ] Demographic fairness evaluated (does performance differ by user group?)
+- [ ] Hallucination / confabulation risk assessed and mitigated
+- [ ] User can see and correct AI output
+- [ ] Opt-out mechanism exists (can user disable the AI feature?)
+- [ ] Output provenance visible when relevant (does user know AI generated this?)
+- [ ] PII not used in ways user didn't consent to
+- [ ] Regulatory review completed (GDPR, AI Act, sector-specific)
+- [ ] Model cards / documentation completed
+
+---
+
+#### 7. Launch & Monitoring Plan
+
+**Rollout:** [% of users, with staged expansion criteria]
+**Monitoring metrics:**
+- Model performance: [Metric + alert threshold]
+- User engagement with AI output: [Acceptance rate, override rate, feedback score]
+- Error rate: [% of failed inferences]
+- Latency: [P95 target]
+
+**Model refresh cadence:** [How often is the model retrained or updated?]
+**Drift detection:** [How will you know when model performance degrades in production?]
+
+---
+
+## Guidelines
+
+- Never skip the "Why AI?" section — it's the most important question in AI product development
+- The fallback UX is not optional — what happens when AI fails defines your product's trustworthiness
+- Responsible AI checklist must be completed before launch, not after
+- Include latency in success metrics — a 5-second AI response is often worse than no AI at all
+- Recommend starting with a human-in-the-loop design and automating only when accuracy is proven
diff --git a/plugins/pm-advanced/skills/design-handoff-brief/SKILL.md b/plugins/pm-advanced/skills/design-handoff-brief/SKILL.md
new file mode 100644
index 0000000..b864f44
--- /dev/null
+++ b/plugins/pm-advanced/skills/design-handoff-brief/SKILL.md
@@ -0,0 +1,59 @@
+---
+name: design-handoff-brief
+description: Transform feature briefs into structured design briefs that give designers the context they need
+tool_integration: Figma, Notion
+---
+# Design Handoff Brief Skill
+
+## Purpose
+Produce a design brief that sets designers up for success — grounding them in user context and constraints before they open Figma, not after they've gone in the wrong direction.
+
+## What Designers Actually Need (and PMs Often Skip)
+- The user's goal, not the feature name
+- The emotional state of the user at this moment in the journey
+- What success looks like — how will we know the design worked?
+- Constraints: technical, legal, brand, accessibility
+- Edge cases that must be handled
+- What we're explicitly NOT solving for
+
+## Process
+1. Read the feature brief or PRD provided
+2. Extract user goal (reframe from feature language to user outcome language)
+3. Identify constraints — technical limitations, brand guidelines, accessibility requirements
+4. List edge cases the design must handle
+5. Define success criteria the design should be evaluated against
+6. Write a "not in scope" section to prevent scope creep in design
+
+## Output Format
+
+### Design Brief: [Feature Name]
+
+**User Goal:** (in the user's words, not ours)
+"When I [situation], I want to [motivation] so that I can [outcome]."
+
+**Context & Emotional State:**
+[Where is the user in their journey? What are they feeling? What just happened?]
+
+**Design Success Criteria:**
+- [Criterion 1 — measurable where possible]
+- [Criterion 2]
+- [Criterion 3]
+
+**Constraints:**
+- Technical: [limitations engineering has flagged]
+- Brand: [relevant brand guidelines]
+- Accessibility: [WCAG level required, any specific requirements]
+- Legal/Compliance: [if applicable]
+
+**Edge Cases to Design For:**
+- [Edge case 1]
+- [Edge case 2]
+- [Edge case 3]
+
+**Explicitly Out of Scope:**
+- [What we are NOT solving in this design iteration]
+
+**Reference Material:**
+- User research: [link]
+- Existing patterns: [Figma component library link]
+- Competitor examples: [links if relevant]
diff --git a/plugins/pm-advanced/skills/experiment-designer/SKILL.md b/plugins/pm-advanced/skills/experiment-designer/SKILL.md
new file mode 100644
index 0000000..122e7d5
--- /dev/null
+++ b/plugins/pm-advanced/skills/experiment-designer/SKILL.md
@@ -0,0 +1,55 @@
+---
+name: experiment-designer
+description: Designs A/B tests from hypotheses and interprets experiment results 
+with statistical rigour. Use when user says "run an experiment", "design an A/B 
+test", "test this feature", "interpret these results", "was this experiment 
+successful", or "what sample size do I need".
+metadata:
+  author: Mohit Aggarwal
+  version: 1.0.0
+  category: data-and-metrics
+  tags: [experimentation, data, analytics, ab-testing]
+  documentation: https://github.com/mohitagw15856/pm-claude-skills
+---
+# Experiment Designer Skill
+
+## Purpose
+Produce rigorous experiment designs from product hypotheses, and interpret 
+results with statistical and practical significance — so you can defend every 
+decision to a sceptical engineering lead or data scientist.
+
+## Two-Phase Process
+
+### Phase 1: Experiment Design
+**Required inputs:** hypothesis, primary metric, current baseline, minimum 
+detectable effect (MDE), available sample size per day.
+
+**Output:**
+- Hypothesis restated as: "If we [change], we expect [metric] to [move by X%] 
+  because [reason]"
+- Control and variant definitions
+- Primary metric (one only)
+- Secondary guardrail metrics (2-3 max)
+- Required sample size (calculated from MDE and baseline)
+- Estimated run time in days
+- Pre-defined success criteria (before the test runs — no moving goalposts)
+- Design risk flags: novelty effects, seasonal confounds, multiple testing issues,
+  network effects, sample ratio mismatch risks
+
+### Phase 2: Results Interpretation
+**Required inputs:** control results, variant results, p-value or raw numbers, 
+run duration, any anomalies observed.
+
+**Output:**
+- Statistical significance assessment (p < 0.05 threshold)
+- Practical significance: was the lift meaningful for the business, not just real?
+- Confidence interval interpretation
+- Confounding factors to investigate
+- Recommendation: Ship / Iterate / Kill / Run follow-up test
+- If "Iterate": specific hypotheses to test next
+
+## Quality Checks
+- Never interpret results from an underpowered test without flagging it
+- Always distinguish statistical from practical significance
+- Flag if test was stopped early (peeking problem)
+- Note if sample ratio mismatch occurred
diff --git a/plugins/pm-advanced/skills/multi-source-signal-synthesiser/SKILL.md b/plugins/pm-advanced/skills/multi-source-signal-synthesiser/SKILL.md
new file mode 100644
index 0000000..105676b
--- /dev/null
+++ b/plugins/pm-advanced/skills/multi-source-signal-synthesiser/SKILL.md
@@ -0,0 +1,62 @@
+---
+name: multi-source-signal-synthesiser
+description: Synthesises user signals from multiple research sources into a 
+unified insight brief, reconciling conflicting feedback. Use when user has data 
+from multiple sources, needs to "make sense of all this user data", "what are 
+users really telling us", "synthesise our research", or has conflicting feedback 
+from different channels.
+metadata:
+  author: Mohit Aggarwal
+  version: 1.0.0
+  category: discovery
+  tags: [user-research, synthesis, discovery, insights]
+  documentation: https://github.com/mohitagw15856/pm-claude-skills
+---
+# Multi-Source Signal Synthesiser Skill
+
+## Purpose
+Reconcile user signals from multiple sources — interviews, support tickets, NPS, 
+app reviews, sales calls — into a unified, weighted insight brief that surfaces 
+the underlying need rather than the surface-level request.
+
+## Source Weighting (default — adapt to your context)
+- Direct research (interviews, usability tests): weight 5
+- Support tickets (unprompted pain signals): weight 4
+- NPS verbatims: weight 3
+- App store reviews: weight 2
+- Sales call summaries (filtered through sales lens): weight 2
+- Anecdote or single report: weight 1
+
+## Process
+1. Accept inputs from any combination of the source types above
+2. Tag each signal by source and apply weight
+3. Look for CONVERGENCE: same underlying need appearing across 3+ sources
+4. Look for DIVERGENCE: contradictory signals suggesting user segmentation
+5. Distinguish surface request from underlying need
+   (e.g. "faster export" may mean "I don't trust the data will be there when 
+   I need it")
+6. Produce ranked insights by weighted frequency
+
+## Output Format
+
+### User Signal Synthesis — [Date / Period]
+**Sources included:** [list]
+**Total signals processed:** [n]
+
+#### Insight 1: [Underlying need, not feature request]
+- **Confidence:** High / Medium / Low (based on source diversity and weight)
+- **Evidence:** [Signals from each source supporting this]
+- **Conflicting signals:** [Any contradicting evidence and how to interpret it]
+- **Product implication:** [Specific, not generic]
+
+[Repeat for top 3-5 insights]
+
+#### Divergent Signals (Possible Segmentation)
+[Where user groups appear to have genuinely different needs]
+
+#### What the Data Does NOT Tell Us
+[Gaps that require further research before acting]
+
+## OpenClaw Configuration
+Connect to: Notion (research docs), support inbox, NPS tool, app review feed.
+Schedule: weekly synthesis run, diff output showing new signals only.
diff --git a/plugins/pm-analytics/skills/data-analysis-standard/SKILL.md b/plugins/pm-analytics/skills/data-analysis-standard/SKILL.md
new file mode 100644
index 0000000..dd1b96a
--- /dev/null
+++ b/plugins/pm-analytics/skills/data-analysis-standard/SKILL.md
@@ -0,0 +1,109 @@
+---
+name: data-analysis-standard
+description: Structures product data analysis, metric deep-dives, funnel analysis, and cohort studies. Use when asked to analyse product metrics, investigate a drop in conversion, build a dashboard spec, or explain data to stakeholders. Triggers on "analyse metrics", "funnel analysis", "cohort analysis", "data deep dive", "why did X drop".
+---
+
+# Data Analysis Standard Skill
+
+Turn raw numbers into product decisions. Structure every analysis with a clear question, methodology, finding, and recommended action.
+
+## Analysis Framework: The 4-Question Method
+
+Every analysis starts here:
+1. **What changed?** (describe the metric and its movement)
+2. **Why did it change?** (root cause — segment, funnel step, cohort, channel)
+3. **So what?** (business or product impact)
+4. **Now what?** (recommended action with confidence level)
+
+Never deliver data without answering all four. A chart with no narrative is not an analysis.
+
+---
+
+## Metric Triage Template
+
+Use when a metric has moved unexpectedly:
+
+```
+METRIC: [Name]
+MOVEMENT: [X% change over Y period]
+BASELINE: [What was normal]
+
+SEGMENTATION CHECK:
+- By platform (iOS / Android / Web)?
+- By user cohort (new / returning / power users)?
+- By acquisition channel?
+- By geography?
+- By plan/tier?
+
+ROOT CAUSE HYPOTHESIS:
+1. [Most likely explanation] — Evidence: [data point]
+2. [Alternative explanation] — Evidence: [data point]
+3. [Ruling out] — Eliminated because: [reason]
+
+CONCLUSION: [Single sentence answer to "why did this change?"]
+CONFIDENCE: [High / Medium / Low] — based on [data available]
+```
+
+---
+
+## Funnel Analysis Structure
+
+| Stage | Metric | Current | Benchmark/Target | Drop-off % | Notes |
+|---|---|---|---|---|---|
+| [Top of funnel] | [Users] | [N] | [N] | — | |
+| [Step 2] | [Users] | [N] | [N] | [X%] | |
+| [Step 3] | [Users] | [N] | [N] | [X%] | |
+| [Conversion] | [Users] | [N] | [N] | [X%] | |
+
+**Biggest drop-off:** [Step X → Step Y] — Hypothesis: [reason]
+**Recommended investigation:** [specific query or test]
+
+---
+
+## Cohort Analysis Guidelines
+
+Always define:
+- **Cohort definition:** [What groups users — signup week, first action, plan type]
+- **Retention metric:** [What counts as retained — login, core action, revenue]
+- **Retention window:** [D1, D7, D30, W4, M3, etc.]
+
+Output a cohort retention table and annotate:
+- Baseline retention for each cohort
+- Cohorts that over/underperform and why (feature launch? campaign? seasonal?)
+- Trend direction across cohorts (improving / declining / stable)
+
+---
+
+## Stakeholder Analysis Output Format
+
+### [Analysis Title] — [Date]
+
+**Question being answered:** [Specific question in plain English]
+**Time period:** [Date range]
+**Data source:** [Where data comes from]
+
+**Finding:**
+> [1–2 sentence plain-English summary of what the data shows]
+
+**Key chart / table:** [Include or describe]
+
+**Root cause:** [Best explanation with evidence]
+
+**Confidence level:** [High / Medium / Low] — [reason]
+
+**Recommended action:**
+1. [Immediate action — owner, timeline]
+2. [Investigation needed — what to check next]
+3. [Monitoring — what metric to watch and at what cadence]
+
+**What this analysis does NOT tell us:** [Important caveat — what data is missing or what can't be concluded]
+
+---
+
+## Guidelines
+
+- Always state what the data *cannot* tell you — never oversell confidence
+- Correlations are not causation — flag this every time
+- If the user has no baseline, recommend establishing one before drawing conclusions
+- Recommend the simplest chart for each finding: bar for comparison, line for trends, scatter for correlation, table for detailed breakdowns
+- Always specify the time window — "conversion dropped" is meaningless without "from X to Y over Z period"
diff --git a/plugins/pm-analytics/skills/product-health-analysis/SKILL.md b/plugins/pm-analytics/skills/product-health-analysis/SKILL.md
new file mode 100644
index 0000000..4b83442
--- /dev/null
+++ b/plugins/pm-analytics/skills/product-health-analysis/SKILL.md
@@ -0,0 +1,43 @@
+---
+name: product-health-analysis
+description: Interpret product metrics against goals and surface actionable signals
+tool_integration: Google Analytics, Mixpanel
+---
+# Product Health Dashboard Skill
+
+## Purpose
+Transform raw metrics data into a clear health narrative — what's working, what's not, and what needs immediate attention.
+
+## Metrics Framework
+Analyse across four layers:
+1. **Acquisition** — new users, source quality, CAC trends
+2. **Activation** — time to first value, onboarding completion rates
+3. **Engagement** — DAU/MAU, feature adoption, session depth
+4. **Retention** — D1/D7/D30 retention, churn rate, resurrection rate
+
+## Process
+1. For each metric, compare: current period vs. previous period, current vs. target
+2. Flag anything more than 10% off target as requiring investigation
+3. Look for correlations — does a drop in activation explain a retention dip 2 weeks later?
+4. Write a plain-English health summary (no jargon) suitable for sharing with non-data stakeholders
+5. Recommend top 3 areas for immediate investigation with suggested diagnostic steps
+
+## Output Format
+
+### Product Health Report — [Period]
+**Overall Health:** 🟢 On Track / 🟡 Watch / 🔴 Action Required
+
+| Metric | Current | Target | vs. Last Period | Status |
+|--------|---------|--------|-----------------|--------|
+| [metric] | [value] | [target] | [+/-%] | [🟢/🟡/🔴] |
+
+**Key Observations:**
+[3-5 bullet observations written in plain English]
+
+**Areas Requiring Investigation:**
+1. [Metric + hypothesis + suggested diagnostic]
+2. [Metric + hypothesis + suggested diagnostic]
+3. [Metric + hypothesis + suggested diagnostic]
+
+**Recommended Actions:**
+[Specific next steps with owners and timelines]
diff --git a/plugins/pm-analytics/skills/retention-analysis/SKILL.md b/plugins/pm-analytics/skills/retention-analysis/SKILL.md
new file mode 100644
index 0000000..46254fe
--- /dev/null
+++ b/plugins/pm-analytics/skills/retention-analysis/SKILL.md
@@ -0,0 +1,116 @@
+---
+name: retention-analysis
+description: Structures retention analysis, churn investigations, and engagement deep-dives for product teams. Use when asked to analyse user retention, investigate churn, measure DAU/MAU, or build a retention improvement plan. Triggers on "retention analysis", "churn", "DAU/MAU", "user retention", "why are users leaving".
+---
+
+# Retention Analysis Skill
+
+Diagnose why users leave, identify what keeps them, and recommend specific, testable interventions — not vague "improve onboarding" suggestions.
+
+## Retention Fundamentals
+
+**The retention curve has two components:**
+1. **Steepness of initial drop** (D1–D7) — onboarding problem
+2. **Long-term floor level** — product-market fit indicator
+
+A product with PMF has a retention curve that flattens. If it trends to zero, you have a PMF problem, not an onboarding problem. Name this distinction explicitly.
+
+---
+
+## Retention Metrics Definitions
+
+| Metric | Formula | What It Tells You |
+|---|---|---|
+| D1 Retention | Users who return on day 2 ÷ new users day 1 | Quality of first experience |
+| D7 Retention | Users active on day 8 ÷ users who joined 7 days ago | Early habit formation |
+| D30 Retention | Users active on day 31 ÷ users who joined 30 days ago | Product-market fit signal |
+| DAU/MAU Ratio | Daily active users ÷ monthly active users | Stickiness (>20% good, >50% excellent) |
+| Churn Rate | Users lost in period ÷ users at start of period | Monthly or annual |
+| Net Revenue Retention | MRR at end of period ÷ MRR at start (same cohort) | Revenue health including expansion |
+
+---
+
+## Retention Investigation Framework
+
+### Step 1: Segment the problem
+Don't analyse "retention" — analyse retention for specific cohorts:
+- New vs returning users
+- Paid vs free
+- Acquisition channel (organic vs paid vs referral)
+- Onboarding path completed vs not
+- Feature usage (power users vs lurkers)
+
+### Step 2: Find the inflection points
+Where does the drop happen? D1? D7? Month 3?
+- D1 drop → First session experience
+- D7 drop → Habit loop not formed
+- D30 drop → Value not delivered at depth
+- Month 3+ drop → Boredom, competition, or lifecycle event
+
+### Step 3: Identify the "aha moment" correlation
+Which early behaviour predicts long-term retention?
+- Run correlation: users who did [X] in first 7 days vs 30-day retention
+- Common patterns: connected an integration, invited a teammate, completed a core action N times
+
+### Step 4: Qualify the churn
+Interview churned users — never skip this. Survey data alone is insufficient.
+- "What was the trigger that led you to cancel/stop?"
+- "What were you trying to accomplish that you couldn't?"
+- "What would need to change for you to come back?"
+
+---
+
+## Output Format
+
+### Retention Analysis — [Product/Segment] — [Date]
+
+**Question:** [Specific retention question being answered]
+**Period Analysed:** [Date range]
+**Segment:** [Which users]
+
+---
+
+**Current Retention Snapshot:**
+
+| Metric | Current | Industry Benchmark | Status |
+|---|---|---|---|
+| D1 Retention | [X%] | 25–40% | 🔴/🟡/🟢 |
+| D7 Retention | [X%] | 10–25% | 🔴/🟡/🟢 |
+| D30 Retention | [X%] | 5–15% | 🔴/🟡/🟢 |
+| DAU/MAU | [X%] | 10–20% typical | 🔴/🟡/🟢 |
+
+**Retention Curve Shape:** [Flattening / Still declining / Trending to zero]
+**PMF Signal:** [Strong / Weak / Absent — based on curve shape]
+
+---
+
+**Root Cause Hypotheses:**
+
+| Hypothesis | Evidence | Confidence | Test |
+|---|---|---|---|
+| [Cause] | [Data point] | H/M/L | [How to validate] |
+
+**"Aha Moment" Correlation:**
+Users who [specific action] in first [N] days retain at [X%] vs [Y%] for those who don't.
+
+---
+
+**Recommended Interventions:**
+
+| Intervention | Target Drop | Expected Lift | Effort | Priority |
+|---|---|---|---|---|
+| [Specific change] | D1 / D7 / D30 | [X%] | S/M/L | 1/2/3 |
+
+**Monitoring Plan:**
+- Metric to track: [X]
+- Review cadence: [Weekly / Monthly]
+- Alert threshold: [If X drops below Y, investigate immediately]
+
+---
+
+## Guidelines
+
+- Never recommend "improve onboarding" without specifying *what* to change and *why*
+- Benchmark against industry — consumer apps, SaaS, and marketplaces have very different retention norms
+- If DAU/MAU is below 5%, that's a PMF conversation, not a retention tactics conversation
+- Always recommend talking to churned users — no amount of data replaces understanding the *reason*
diff --git a/plugins/pm-delivery/skills/ab-test-planner/SKILL.md b/plugins/pm-delivery/skills/ab-test-planner/SKILL.md
new file mode 100644
index 0000000..3d3aef5
--- /dev/null
+++ b/plugins/pm-delivery/skills/ab-test-planner/SKILL.md
@@ -0,0 +1,95 @@
+---
+name: ab-test-planner
+description: Designs statistically rigorous A/B tests for product features, UI changes, onboarding flows, and pricing experiments. Use when asked to set up an experiment, run an A/B test, calculate sample size, or interpret test results. Triggers on "A/B test", "experiment", "split test", "statistical significance", "sample size".
+---
+
+# A/B Test Planner Skill
+
+Design experiments that produce trustworthy results — not just directional signals. Every test output includes hypothesis, success metrics, sample size, duration, and a results interpretation guide.
+
+## Experiment Design Checklist
+
+Before running any test, confirm:
+- [ ] Clear hypothesis with predicted direction
+- [ ] Single primary metric (plus up to 2 guardrail metrics)
+- [ ] Minimum detectable effect (MDE) defined
+- [ ] Sample size calculated
+- [ ] Test duration estimated
+- [ ] Segment isolated (no overlap with other running tests)
+- [ ] Rollback plan defined
+
+## Hypothesis Template
+
+> "We believe that [change] will cause [primary metric] to [increase/decrease] by [X%] for [user segment], because [rationale based on data or insight]."
+
+Never run a test without a directional hypothesis. "Let's just see what happens" is not a hypothesis.
+
+## Sample Size Calculator Logic
+
+Use this formula (provide the output, not the formula, to the user):
+
+- **Baseline conversion rate:** Current rate of primary metric
+- **MDE:** Smallest change worth detecting (recommend 10–20% relative lift for most features)
+- **Statistical power:** 80% (standard)
+- **Significance level:** 95% (p < 0.05)
+
+For common scenarios, provide pre-calculated estimates:
+
+| Baseline Rate | MDE (Relative) | Required Sample per Variant |
+|---|---|---|
+| 5% | 20% | ~19,000 |
+| 10% | 15% | ~14,000 |
+| 20% | 10% | ~15,000 |
+| 40% | 10% | ~9,500 |
+| 60% | 5% | ~42,000 |
+
+Always warn: "These are estimates. Use a tool like Evan Miller's calculator or Statsig for precision."
+
+## Test Duration Guidance
+
+Minimum: 2 full weeks (to capture weekly seasonality)
+Maximum: 4 weeks (novelty effect distorts results beyond this)
+
+`Duration = Required sample ÷ (Daily traffic × % exposed)`
+
+Flag if traffic is too low to reach significance in under 8 weeks — recommend a different approach (e.g., holdout test, qualitative research).
+
+## Output Format
+
+### A/B Test Plan — [Test Name] — [Date]
+
+**Hypothesis:**
+> [Filled hypothesis template]
+
+**Variants:**
+- Control (A): [Current experience]
+- Treatment (B): [Changed experience — be specific]
+
+**Primary Metric:** [Metric name + how measured]
+**Guardrail Metrics:** [Metrics that must not degrade]
+
+**Target Segment:** [Who sees the test — % of traffic, user type]
+**Traffic Split:** [50/50 recommended unless ramp-up needed]
+
+**Sample Size Required:** ~[N] users per variant
+**Estimated Duration:** [X] weeks (based on [Y] daily eligible users)
+**Significance Threshold:** 95% confidence, 80% power
+
+**Exclusions:** [Any user segments to exclude and why]
+
+**Rollback Trigger:** If [guardrail metric] degrades by [X%], stop the test immediately.
+
+**Results Interpretation Guide:**
+- ✅ Ship if: Treatment shows [X%]+ lift on primary metric at 95% confidence AND guardrail metrics are stable
+- 🔄 Iterate if: Direction is positive but not significant — consider extending or redesigning
+- ❌ Reject if: No lift or negative direction at significance
+- ⚠️ Inconclusive: Do not ship. Do not call it a win.
+
+---
+
+## Guidelines
+
+- Always recommend against peeking at results before the test reaches planned sample size — explain p-hacking risk
+- If user wants to test multiple variants, explain the multiple comparisons problem and recommend a Bonferroni correction or a Bayesian approach
+- If traffic is very low (<1,000 users/day), recommend qualitative alternatives: moderated testing, 5-second tests, or user interviews
+- Never approve a test with no guardrail metrics — always protect revenue, retention, or core engagement
diff --git a/plugins/pm-delivery/skills/go-to-market-planner/SKILL.md b/plugins/pm-delivery/skills/go-to-market-planner/SKILL.md
new file mode 100644
index 0000000..71a45f8
--- /dev/null
+++ b/plugins/pm-delivery/skills/go-to-market-planner/SKILL.md
@@ -0,0 +1,114 @@
+---
+name: go-to-market-planner
+description: Builds go-to-market (GTM) plans for product launches, feature releases, and new market entries. Use when planning a product launch, writing a GTM strategy, defining launch tiers, or coordinating cross-functional launch activities. Triggers on "go-to-market", "GTM plan", "product launch plan", "launch strategy", "release plan".
+---
+
+# Go-to-Market Planner Skill
+
+Produce a complete, cross-functional GTM plan that aligns product, marketing, sales, and support around a single launch — with clear owners, timelines, and success metrics.
+
+## Launch Tier Framework
+
+Before planning, classify the launch:
+
+| Tier | Scope | Typical Effort | Examples |
+|---|---|---|---|
+| **Tier 1 — Major Launch** | New product / significant platform change | 8–12 weeks | New pricing model, platform rebrand, new product line |
+| **Tier 2 — Feature Launch** | Significant new capability | 4–6 weeks | Major feature, API release, new integration |
+| **Tier 3 — Incremental Release** | Improvement, bug fix, minor feature | 1–2 weeks | UI tweak, performance improvement, small enhancement |
+
+Always confirm tier with the user before proceeding.
+
+---
+
+## GTM Plan Output Format
+
+### GTM Plan — [Product/Feature Name] — [Launch Date]
+
+**Launch Tier:** [1 / 2 / 3]
+**Launch Owner (PM):** [Name]
+**Target Launch Date:** [Date]
+**Soft Launch Date (Beta/Limited):** [Date, if applicable]
+
+---
+
+### 1. What We're Launching
+**One-line description:** [What it is, for whom, and why now]
+**Key customer problem solved:** [Specific pain point]
+**Key differentiator:** [Why ours, why now]
+
+---
+
+### 2. Target Audience
+**Primary segment:** [Who benefits most — be specific]
+**Secondary segment:** [Who else benefits]
+**Not for:** [Who this is NOT for — helps sales and support]
+
+---
+
+### 3. Messaging
+
+**Headline:** [Customer-facing headline — lead with outcome, not feature]
+**Sub-headline:** [Supporting context — how it works or why it matters]
+**3 key messages:**
+1. [Problem solved]
+2. [How it works / what's new]
+3. [Proof / social proof / data]
+
+**Elevator pitch (30 seconds):**
+> [For [target user] who [has this problem], [product/feature] is a [category] that [key benefit]. Unlike [alternative], we [differentiator].]
+
+---
+
+### 4. Launch Activities by Function
+
+| Function | Activity | Owner | Due Date | Status |
+|---|---|---|---|---|
+| Product | Feature flagging / rollout plan | PM | [date] | |
+| Marketing | Blog post / landing page | Marketing | [date] | |
+| Marketing | Email campaign to existing users | Marketing | [date] | |
+| Marketing | Social media content | Marketing | [date] | |
+| Sales | Sales enablement deck | PM + Sales | [date] | |
+| Sales | FAQ for sales team | PM | [date] | |
+| Support | Help centre articles | Support | [date] | |
+| Support | Support team training | Support | [date] | |
+| Engineering | Monitoring/alerting in place | Eng | [date] | |
+
+---
+
+### 5. Success Metrics
+
+| Metric | Baseline | Target | Measurement Window |
+|---|---|---|---|
+| [Adoption metric] | [X] | [Y] | 30 days post-launch |
+| [Engagement metric] | [X] | [Y] | 60 days post-launch |
+| [Business metric] | [X] | [Y] | 90 days post-launch |
+
+---
+
+### 6. Risks & Contingencies
+
+| Risk | Likelihood | Impact | Mitigation |
+|---|---|---|---|
+| [Risk] | H/M/L | H/M/L | [Action if it happens] |
+
+---
+
+### 7. Launch Day Checklist
+- [ ] Feature live for [X%] of users
+- [ ] Monitoring dashboard active
+- [ ] Support team briefed
+- [ ] Blog post published
+- [ ] Email sent / scheduled
+- [ ] Sales team notified
+- [ ] Executive announcement sent (if Tier 1)
+- [ ] Rollback procedure confirmed
+
+---
+
+## Guidelines
+
+- Never plan a Tier 1 launch without at least 8 weeks of lead time
+- Always include a "Not for" section — it prevents misdirected sales and support tickets
+- Recommend a soft launch to 5–10% of users before full rollout for any Tier 1 or 2 launch
+- Post-launch retrospective should be scheduled at launch planning time — don't leave it to chance
diff --git a/plugins/pm-delivery/skills/product-launch-checklist/SKILL.md b/plugins/pm-delivery/skills/product-launch-checklist/SKILL.md
new file mode 100644
index 0000000..e28b4e3
--- /dev/null
+++ b/plugins/pm-delivery/skills/product-launch-checklist/SKILL.md
@@ -0,0 +1,117 @@
+---
+name: product-launch-checklist
+description: Generates comprehensive pre-launch, launch day, and post-launch checklists for product releases. Use when preparing for a product launch, feature release, or major update. Triggers on "launch checklist", "pre-launch", "launch day", "release checklist", "ship checklist", "go-live checklist".
+---
+
+# Product Launch Checklist Skill
+
+Never launch without checking everything. Generate a complete, role-assigned checklist covering pre-launch readiness, launch day execution, and post-launch monitoring.
+
+## How to Use This Skill
+
+Provide:
+- Launch name and date
+- Launch tier (1 = major, 2 = feature, 3 = incremental)
+- Team members and their roles
+
+The skill generates a tiered checklist. Tier 3 launches use only the Essentials section. Tier 2 adds Marketing & Comms. Tier 1 uses all sections.
+
+---
+
+## Output Format
+
+### Launch Checklist — [Feature/Product Name] — Target Date: [Date]
+
+**Launch Tier:** [1 / 2 / 3]
+**Launch Owner:** [PM Name]
+**Engineering Lead:** [Name]
+**Go/No-Go Decision By:** [Date and time — typically 24 hours before launch]
+
+---
+
+### 🔧 PRE-LAUNCH — Engineering & Product (T-2 weeks)
+- [ ] Feature flag created and tested in staging
+- [ ] All acceptance criteria signed off by PM
+- [ ] Code reviewed and merged to main
+- [ ] QA sign-off completed (regression + new feature)
+- [ ] Performance testing completed (load, latency)
+- [ ] Security review completed (if data or auth changes)
+- [ ] Rollback procedure documented and tested
+- [ ] Monitoring and alerting configured
+- [ ] Error logging in place with correct severity levels
+- [ ] Database migrations tested on staging with production data volume
+
+### 📢 PRE-LAUNCH — Marketing & Comms (T-1 week)
+- [ ] Blog post written, reviewed, and scheduled
+- [ ] In-app announcement or tooltip configured
+- [ ] Email campaign drafted and QA'd
+- [ ] Social media posts drafted and scheduled
+- [ ] Landing page or feature page live in staging
+- [ ] Press outreach sent (Tier 1 only)
+- [ ] Product Hunt / community posts prepared (Tier 1 only)
+
+### 🎓 PRE-LAUNCH — Sales & Support (T-1 week)
+- [ ] Sales enablement one-pager completed
+- [ ] FAQ document shared with sales and support teams
+- [ ] Help centre articles written and published
+- [ ] Support team demo / training completed
+- [ ] Customer success team briefed on top accounts
+- [ ] Pricing updated (if applicable)
+- [ ] Contracts / ToS updated (if applicable)
+
+### 📊 PRE-LAUNCH — Analytics (T-1 week)
+- [ ] Analytics events firing correctly in staging
+- [ ] Dashboard configured for launch metrics
+- [ ] Baseline metrics documented
+- [ ] Success criteria documented and shared with team
+- [ ] A/B test configured (if applicable)
+
+---
+
+### ✅ GO / NO-GO DECISION — T-24 hours
+
+| Criteria | Status | Owner |
+|---|---|---|
+| All critical bugs resolved | 🟢 / 🔴 | Eng Lead |
+| QA sign-off complete | 🟢 / 🔴 | QA |
+| Rollback tested | 🟢 / 🔴 | Eng Lead |
+| Help centre articles live | 🟢 / 🔴 | Support |
+| Monitoring active | 🟢 / 🔴 | Eng Lead |
+| PM sign-off | 🟢 / 🔴 | PM |
+
+**Go / No-Go Decision:** [GO / NO-GO]
+**Decision Owner:** [PM + Eng Lead jointly]
+
+---
+
+### 🚀 LAUNCH DAY
+- [ ] Feature flag enabled for [X%] of users (start low — 5–10%)
+- [ ] Launch confirmed in team Slack/channel
+- [ ] Metrics dashboard open and being monitored
+- [ ] Error rate checked at T+15 min, T+1 hr, T+4 hr
+- [ ] Blog post published / email sent
+- [ ] Social posts live
+- [ ] Support team on standby for first 4 hours
+- [ ] PM available and reachable all day
+- [ ] Feature flag expanded to 50% if T+2hr checks pass
+- [ ] Feature flag expanded to 100% if T+4hr checks pass
+
+---
+
+### 📈 POST-LAUNCH (D+7, D+30)
+- [ ] D+7 metrics review: adoption, errors, support tickets
+- [ ] D+7 customer feedback synthesised
+- [ ] Retrospective scheduled
+- [ ] Learnings documented
+- [ ] D+30 success metrics reviewed against targets
+- [ ] Feature flag removed from codebase (clean up)
+- [ ] Follow-up features added to backlog based on feedback
+
+---
+
+## Guidelines
+
+- The Go/No-Go decision must have a named owner — "the team" is not an owner
+- Never launch on a Friday unless you have weekend engineering coverage
+- Recommend starting all launches at <10% traffic — even for simple features
+- Document rollback time: "We can revert this in X minutes" should be known before launch
diff --git a/plugins/pm-delivery/skills/retro-analysis/SKILL.md b/plugins/pm-delivery/skills/retro-analysis/SKILL.md
new file mode 100644
index 0000000..d694735
--- /dev/null
+++ b/plugins/pm-delivery/skills/retro-analysis/SKILL.md
@@ -0,0 +1,43 @@
+---
+name: retro-analysis
+description: Analyse sprint delivery data and produce a structured retrospective brief
+tool_integration: Jira, Miro
+---
+# Retrospective Analysis Skill
+
+## Purpose
+Generate a data-grounded retrospective brief that separates facts from feelings, so the team spends retro time on solutions rather than debating what happened.
+
+## Required Inputs
+- Sprint tickets: planned vs. completed
+- Carry-over tickets and reasons
+- Tickets reopened after closing
+- Any incidents or unplanned work
+- Sprint velocity vs. historical average
+
+## Process
+1. Calculate: completion rate, carry-over rate, unplanned work percentage
+2. Identify patterns: which ticket types were most likely to carry over? Which caused blockers?
+3. Note any process or communication breakdowns visible in the data
+4. Prepare 3 "Start / Stop / Continue" prompts based on the data — not generic, specific to this sprint
+5. Suggest 1 concrete experiment for the next sprint based on the biggest friction point
+
+## Output Format
+
+### Sprint [Number] Retrospective Brief
+
+**By the Numbers:**
+- Planned: [n] tickets | Completed: [n] | Carry-over: [n] | Completion rate: [%]
+- Unplanned work: [n] tickets ([%] of capacity)
+- Velocity: [points] vs. [average] average
+
+**What the Data Suggests:**
+[2-3 observations grounded in the numbers above]
+
+**Discussion Prompts:**
+- Start: [specific prompt]
+- Stop: [specific prompt]
+- Continue: [specific prompt]
+
+**Suggested Experiment for Next Sprint:**
+[One concrete, testable process change]
diff --git a/plugins/pm-delivery/skills/sprint-brief/SKILL.md b/plugins/pm-delivery/skills/sprint-brief/SKILL.md
new file mode 100644
index 0000000..7f156a2
--- /dev/null
+++ b/plugins/pm-delivery/skills/sprint-brief/SKILL.md
@@ -0,0 +1,43 @@
+---
+name: sprint-brief
+description: Generate a structured sprint brief from Jira sprint data and goals
+tool_integration: Jira, Slack
+---
+# Sprint Brief Skill
+
+## Purpose
+Produce a clear, scannable sprint brief that every team member — engineer, designer, PM — can read in under three minutes and understand exactly what we're doing and why.
+
+## Required Inputs
+- Sprint name and number
+- Sprint goal (1-2 sentences)
+- Ticket list with owners
+- Known dependencies or blockers
+- Carry-over items from previous sprint
+
+## Process
+1. Read sprint goal and check it's specific and measurable — flag if it's too vague
+2. Group tickets by theme or feature area
+3. Identify the critical path — which tickets must complete for the sprint goal to be met?
+4. Flag risks: tickets with unclear acceptance criteria, missing designs, unresolved dependencies
+5. Note carry-over items and whether they affect this sprint's goal
+
+## Output Format
+
+### Sprint [Number] Brief — [Dates]
+**Sprint Goal:** [1-2 sentences]
+**Why This Sprint Matters:** [Connect to quarterly OKR in 2-3 sentences]
+
+**What We're Building:**
+- [Theme 1]: [tickets and owners]
+- [Theme 2]: [tickets and owners]
+
+**Critical Path:** [The 2-3 tickets everything else depends on]
+
+**Risks to Flag:**
+- [Risk 1 + mitigation]
+- [Risk 2 + mitigation]
+
+**Carry-over from Last Sprint:** [List + impact on current goal]
+
+**Definition of Done:** [Specific, agreed criteria for sprint success]
diff --git a/plugins/pm-delivery/skills/sprint-planning/SKILL.md b/plugins/pm-delivery/skills/sprint-planning/SKILL.md
new file mode 100644
index 0000000..1a24dde
--- /dev/null
+++ b/plugins/pm-delivery/skills/sprint-planning/SKILL.md
@@ -0,0 +1,89 @@
+---
+name: sprint-planning
+description: Structures and facilitates sprint planning sessions. Use when asked to plan a sprint, organise backlog items, assign story points, create sprint goals, or prepare sprint planning meeting agendas. Triggers on phrases like "plan sprint", "sprint planning", "sprint goal", "sprint backlog".
+---
+
+# Sprint Planning Skill
+
+Transform raw backlog items into a structured, achievable sprint with clear goals, velocity-calibrated scope, and team-ready output.
+
+## What This Skill Produces
+
+- **Sprint Goal** — single, outcome-focused sentence the whole team can rally around
+- **Sprint Backlog** — prioritised list of user stories with story point estimates and acceptance criteria
+- **Capacity Plan** — team availability breakdown accounting for holidays, meetings, and focus time
+- **Sprint Planning Agenda** — structured 2-hour meeting agenda with timings
+- **Risk Flags** — blockers or dependencies that could derail the sprint
+
+## Inputs to Request From User
+
+Ask for (if not already provided):
+- Sprint duration (1 or 2 weeks)
+- Team size and velocity (average story points per sprint)
+- Top 3–5 backlog items or epics to pull from
+- Any known absences, holidays, or team events
+- Previous sprint's incomplete items (carry-overs)
+
+## Sprint Goal Formula
+
+Use this structure:
+> "This sprint we will [deliver X outcome] so that [user/business benefit], measured by [success indicator]."
+
+Never write sprint goals as task lists. Always outcome-first.
+
+## Story Point Calibration
+
+| Complexity | Points | Description |
+|---|---|---|
+| Trivial | 1 | Clearly understood, no unknowns |
+| Small | 2 | Straightforward, minor effort |
+| Medium | 3 | Some complexity, clear path |
+| Large | 5 | Complex, needs design or research |
+| Very Large | 8 | High uncertainty, may need splitting |
+| Epic | 13+ | Too large — must be split before sprint |
+
+Flag any item estimated at 8+ and recommend splitting.
+
+## Capacity Formula
+
+```
+Available capacity = (Team size × Sprint days × Focus hours/day) × Availability factor
+Focus hours/day: 6 (accounting for meetings, Slack, admin)
+Availability factor: 0.7–0.85 depending on holidays/events
+Story points to commit = Historical velocity × Availability factor
+```
+
+## Output Format
+
+### Sprint [N] — [Start Date] to [End Date]
+
+**Sprint Goal:**
+> [Goal statement]
+
+**Team Capacity:** [X] story points available (based on [Y] team members, [Z]% availability)
+
+**Sprint Backlog:**
+
+| Priority | Story | Points | Owner | Acceptance Criteria |
+|---|---|---|---|---|
+| 1 | [Story title] | [N] | [Team member] | [When X then Y] |
+
+**Carry-Overs from Previous Sprint:**
+- [Item] — Reason for carry-over: [brief explanation]
+
+**Risks & Dependencies:**
+- [Risk description] → Mitigation: [action]
+
+**Sprint Planning Agenda:**
+- 00:00–00:10 — Review sprint goal and team capacity
+- 00:10–00:40 — Walk through backlog items, confirm estimates
+- 00:40–01:20 — Assign stories, identify dependencies
+- 01:20–01:50 — Review acceptance criteria per story
+- 01:50–02:00 — Confirm sprint commitment and close
+
+## Guidelines
+
+- Always challenge stories missing acceptance criteria — flag them explicitly
+- Recommend the team commits to 80% of available capacity, not 100%
+- If no velocity data is provided, assume 20–30 points for a 5-person team as a starting point
+- Highlight any story with unclear ownership as a blocker
diff --git a/plugins/pm-delivery/skills/technical-spec-template/SKILL.md b/plugins/pm-delivery/skills/technical-spec-template/SKILL.md
new file mode 100644
index 0000000..2518073
--- /dev/null
+++ b/plugins/pm-delivery/skills/technical-spec-template/SKILL.md
@@ -0,0 +1,133 @@
+---
+name: technical-spec-template
+description: Creates structured technical specification documents that bridge product requirements and engineering implementation. Use when writing a tech spec, engineering spec, system design doc, or API specification. Triggers on "technical spec", "tech spec", "engineering spec", "system design doc", "API spec", "implementation spec".
+---
+
+# Technical Spec Template Skill
+
+Write technical specifications that engineers actually read — clear problem framing, unambiguous requirements, explicit decisions, and documented trade-offs.
+
+## When to Write a Tech Spec
+
+Write a tech spec when:
+- The feature requires changes to 2+ systems
+- There are significant architectural decisions to make
+- More than one engineer will work on the implementation
+- The feature has security, privacy, or compliance implications
+- Estimated effort is >5 story points
+
+Skip the spec for trivial bug fixes or 1-2 hour changes.
+
+---
+
+## Technical Spec Output Format
+
+### Technical Specification — [Feature Name]
+
+**Author:** [Name]
+**Status:** Draft | In Review | Approved | Implemented
+**Created:** [Date] | **Last Updated:** [Date]
+**Reviewers:** [Eng Lead, Architect, PM, Security if needed]
+**Related PRD:** [Link] | **Jira Epic:** [Link]
+
+---
+
+#### 1. Problem Statement
+> [2–3 sentences. What problem are we solving and why now? No solution language here.]
+
+#### 2. Goals & Non-Goals
+
+**Goals (in scope):**
+- [Specific, measurable outcome]
+- [Specific, measurable outcome]
+
+**Non-Goals (explicitly out of scope):**
+- [What this spec does NOT cover]
+- [Common assumption to shut down early]
+
+#### 3. Background & Context
+[Any prior art, related systems, or context engineers need to understand the decision space. Link to previous specs, ADRs, or research.]
+
+#### 4. Proposed Solution
+
+**High-Level Approach:**
+[2–4 sentences describing the chosen solution. Why this approach vs alternatives?]
+
+**System Architecture Diagram:**
+[Describe or embed: which services are involved, how data flows, what APIs are called]
+
+**Data Model Changes:**
+```sql
+-- New tables or schema changes
+[Include DDL or schema definition]
+```
+
+**API Design:**
+```
+[Endpoint] [Method]
+Request: { [fields and types] }
+Response: { [fields and types] }
+Error codes: [list]
+```
+
+**Key Implementation Details:**
+- [Important technical constraint or approach]
+- [Edge case handling]
+- [Third-party dependency and version]
+
+#### 5. Alternative Approaches Considered
+
+| Option | Pros | Cons | Why Rejected |
+|---|---|---|---|
+| [Alt 1] | [Benefits] | [Drawbacks] | [Reason not chosen] |
+| [Alt 2] | [Benefits] | [Drawbacks] | [Reason not chosen] |
+
+#### 6. Security & Privacy Considerations
+- Data stored: [What PII or sensitive data is involved]
+- Authentication: [How is access controlled]
+- Authorisation: [What permissions are required]
+- Encryption: [At rest / in transit requirements]
+- Compliance implications: [GDPR, SOC2, etc. if relevant]
+
+#### 7. Performance & Scalability
+- Expected load: [Requests/second, data volume]
+- Latency requirements: [P50 / P95 targets]
+- Caching strategy: [If applicable]
+- Database indexing: [New indexes required]
+- Known bottlenecks: [Where to watch]
+
+#### 8. Testing Plan
+- Unit tests: [Key scenarios to cover]
+- Integration tests: [System boundaries to test]
+- Load tests: [If performance-critical]
+- Edge cases: [Known tricky scenarios]
+- Rollback plan: [How to revert if something goes wrong]
+
+#### 9. Rollout Plan
+- Feature flag: [Yes / No — name of flag]
+- Rollout stages: [% of users at each stage]
+- Monitoring: [Metrics and alerts to set up]
+- Success criteria to progress rollout: [What needs to be true]
+- Rollback trigger: [What would cause immediate rollback]
+
+#### 10. Open Questions
+| Question | Owner | Due Date | Resolution |
+|---|---|---|---|
+| [Unresolved question] | [Name] | [Date] | [Pending] |
+
+#### 11. Implementation Timeline (Rough)
+| Phase | Work | Estimated Effort |
+|---|---|---|
+| [Phase 1] | [What gets built] | [X days/points] |
+| [Phase 2] | [What gets built] | [X days/points] |
+| Total | | [X story points] |
+
+---
+
+## Guidelines
+
+- The spec is a decision record, not a task list — document *why* decisions were made
+- All open questions must have an owner and due date
+- Security and privacy sections are never optional for features that touch user data
+- Recommend async review: engineers read first, then a 30-minute sync to resolve questions
+- Keep the spec updated as implementation progresses — stale specs are worse than no specs
diff --git a/plugins/pm-discovery/skills/assumption-mapper/SKILL.md b/plugins/pm-discovery/skills/assumption-mapper/SKILL.md
new file mode 100644
index 0000000..654d735
--- /dev/null
+++ b/plugins/pm-discovery/skills/assumption-mapper/SKILL.md
@@ -0,0 +1,36 @@
+---
+name: assumption-mapper
+description: Extract and risk-rate all hidden assumptions in a product brief or PRD
+tool_integration: Miro
+---
+# Assumption Mapping Skill
+
+## Purpose
+Surface and prioritize the untested assumptions embedded in any product plan before development begins.
+
+## Process
+1. Read the provided brief, PRD, or concept description
+2. Extract all assumptions across four categories:
+   - **Desirability** (do users want this?)
+   - **Feasibility** (can we build it?)
+   - **Viability** (will it sustain the business?)
+   - **Usability** (can users actually use it?)
+3. For each assumption, score:
+   - Confidence (1-5): How sure are we this is true?
+   - Impact (1-5): How badly does the plan fail if this assumption is wrong?
+   - Priority = Impact minus Confidence (higher score = test this first)
+4. Output a ranked list with recommended validation methods
+
+## Output Format
+
+### Assumption Map: [Feature/Product Name]
+| Assumption | Category | Confidence | Impact | Priority Score | Recommended Validation |
+|------------|----------|------------|--------|----------------|----------------------|
+| [assumption] | [type] | [1-5] | [1-5] | [score] | [method] |
+
+#### Top 3 Assumptions to Validate First
+[Detailed recommendations for highest-priority items]
+
+## Notes
+- Flag any assumption that scores 4+ on Impact and 2 or below on Confidence as CRITICAL
+- Suggest specific research methods: usability test, survey, prototype test, data analysis
diff --git a/plugins/pm-discovery/skills/discovery-interview-guide/SKILL.md b/plugins/pm-discovery/skills/discovery-interview-guide/SKILL.md
new file mode 100644
index 0000000..0705c32
--- /dev/null
+++ b/plugins/pm-discovery/skills/discovery-interview-guide/SKILL.md
@@ -0,0 +1,90 @@
+---
+name: discovery-interview-guide
+description: Creates structured user discovery interview guides with screener questions, discussion guides, and synthesis frameworks. Use when planning user interviews, customer discovery sessions, Jobs-to-be-Done research, or problem validation. Triggers on "user interview", "discovery interview", "customer research", "JTBD", "problem validation".
+---
+
+# Discovery Interview Guide Skill
+
+Design interviews that surface genuine insight — not validation of what you already believe. Every guide follows a story-based, past-behaviour-focused structure.
+
+## Core Principles
+
+1. **Never ask about the future.** "Would you use X?" tells you nothing. "Tell me about the last time you did X" tells you everything.
+2. **Interview for behaviour, not opinion.** Opinions are cheap. Behaviour is evidence.
+3. **The 5 Whys.** Every surface answer is a door. Keep opening doors.
+4. **Confirm the problem before exploring the solution.** Never show a prototype until you've confirmed the pain exists unprompted.
+
+## Interview Structure (60 minutes standard)
+
+### 1. Warm-Up (5 min)
+Build rapport. Get them talking. Don't discuss the topic yet.
+- "Tell me a bit about your role and what a typical week looks like for you."
+- "What tools do you rely on most day-to-day?"
+
+### 2. Context Setting (10 min)
+Understand their world before diving into the problem space.
+- "Walk me through how you currently [handle the domain area]."
+- "What does that process look like from start to finish?"
+- "Who else is involved when you do this?"
+
+### 3. Problem Exploration (25 min) — THE CORE
+Surface pain without leading.
+- "Tell me about the last time you had to [relevant task]. What happened?"
+- "What was the hardest part of that?"
+- "How did you handle it?"
+- "What did you try before settling on that approach?"
+- "What does it cost you when this goes wrong?" (time, money, stress, reputation)
+- "If you could wave a magic wand and change one thing about this process, what would it be?"
+
+⚠️ **Do not mention your product or feature during this phase.**
+
+### 4. Current Solutions (10 min)
+Understand the competitive landscape from their perspective.
+- "What tools or workarounds do you use today for this?"
+- "What do you like about [current solution]? What frustrates you?"
+- "Have you tried other approaches? What happened?"
+
+### 5. Wrap-Up (10 min)
+- "Is there anything about this topic we haven't covered that you think I should know?"
+- "Is there anyone else you'd recommend I speak to?"
+- "Would you be open to a follow-up if I have more questions?"
+
+---
+
+## Output Format
+
+### Discovery Interview Guide — [Topic] — [Date]
+
+**Research Goal:** [One sentence: what decision will this research inform?]
+**Target Participant Profile:** [Role, company size, behaviour qualifier]
+
+**Screener Questions** (for recruiting):
+1. [Question] → Must answer: [Y/N or specific]
+2. [Question] → Must answer: [Y/N or specific]
+3. [Disqualifier question] → Disqualify if: [answer]
+
+**Interview Guide:**
+
+[Full structured guide using the format above, customised to the specific research topic]
+
+**Synthesis Template** (fill after each interview):
+- Key quote: "[verbatim]"
+- Core pain: [1 sentence]
+- Current workaround: [what they're doing today]
+- Intensity (1–5): [how painful is this?]
+- Surprise/unexpected finding: [anything that challenged your assumptions]
+
+**Pattern Detection** (after 5+ interviews):
+- Pain mentioned by [X/N] participants: [theme]
+- Workaround used by [X/N] participants: [theme]
+- Most emotionally charged moment in interviews: [observation]
+
+---
+
+## Guidelines
+
+- Recommend 5–8 interviews to reach thematic saturation for most discovery questions
+- Always record with permission — transcripts beat notes
+- If user is new to interviewing: remind them to stay silent after asking a question (aim for 80/20 participant-to-interviewer talking ratio)
+- Never synthesise during the interview — do it after, when you can look across sessions
+- Flag confirmation bias: if user writes questions that lead toward a predetermined answer, rewrite them as open-ended alternatives
diff --git a/plugins/pm-discovery/skills/job-story-mapper/SKILL.md b/plugins/pm-discovery/skills/job-story-mapper/SKILL.md
new file mode 100644
index 0000000..40a4813
--- /dev/null
+++ b/plugins/pm-discovery/skills/job-story-mapper/SKILL.md
@@ -0,0 +1,113 @@
+---
+name: job-story-mapper
+description: Writes Jobs-to-be-Done (JTBD) job stories and maps customer jobs across functional, social, and emotional dimensions. Use when defining user needs, writing job stories, conducting JTBD research, or reframing features around customer outcomes. Triggers on "job story", "JTBD", "jobs to be done", "when I want to", "user need", "hire a product".
+---
+
+# Job Story Mapper Skill
+
+Stop writing features. Start understanding jobs. This skill translates product requirements and user interviews into precise job stories that keep the team focused on outcomes — not outputs.
+
+## Jobs-to-be-Done Fundamentals
+
+A "job" is the progress a customer is trying to make in a given situation. People don't buy products — they hire them to get a job done.
+
+Three dimensions of every job:
+- **Functional job:** The practical task ("get from A to B")
+- **Emotional job:** How they want to feel ("feel confident I made the right choice")
+- **Social job:** How they want to be perceived ("look like a competent professional to my team")
+
+Great products address all three. Most roadmaps only address the functional one.
+
+---
+
+## Job Story Format
+
+**Template:**
+> When [situation/trigger], I want to [motivation/goal], so I can [expected outcome].
+
+**Not a user story:**
+User stories focus on roles and features: "As a [role] I want [feature] so that [benefit]."
+Job stories focus on situations and motivations: "When [I'm in this specific situation] I want [this capability] so I can [achieve this outcome]."
+
+**The situation is the most important part.** "When I'm in the middle of a sprint and my PM asks for an update" is a much richer trigger than "As a developer."
+
+---
+
+## Mapping Process
+
+### Step 1: Identify the main job
+One sentence: What is the core job your product is hired for?
+> "Help [user type] [accomplish outcome] when [context]."
+
+### Step 2: Break into job steps
+What are all the sub-tasks within the main job?
+(Use a job map: Define → Locate → Prepare → Confirm → Execute → Monitor → Modify → Conclude)
+
+### Step 3: Identify pain points per step
+Where does the job fall down today? Where do customers use workarounds?
+
+### Step 4: Write job stories for each pain point
+One job story per distinct situation-motivation pair.
+
+### Step 5: Map to product opportunities
+Which job stories are underserved? Which have existing solutions? Where is your differentiation?
+
+---
+
+## Output Format
+
+### Job Story Map — [Product/Feature Area] — [Date]
+
+**Core Job Statement:**
+> When [context], [user type] wants to [main job outcome], so they can [ultimate goal].
+
+---
+
+**Job Map:**
+
+| Step | Sub-Job | Current Solution | Pain Points | Underserved? |
+|---|---|---|---|---|
+| Define | [What user does] | [Tool/method used] | [Frustration] | H/M/L |
+| Locate | | | | |
+| Prepare | | | | |
+| Confirm | | | | |
+| Execute | | | | |
+| Monitor | | | | |
+| Modify | | | | |
+| Conclude | | | | |
+
+---
+
+**Job Stories (prioritised by underservice):**
+
+**Job Story 1 — [Situation label]**
+> When [specific situation], I want to [motivation], so I can [outcome].
+
+Functional dimension: [What they need to get done]
+Emotional dimension: [How they want to feel]
+Social dimension: [How they want to be perceived]
+
+Current workaround: [What they do today]
+Pain intensity: [High / Medium / Low]
+Frequency: [How often this situation occurs]
+Product opportunity: [What we could build to address this]
+
+---
+
+Repeat for each major job story.
+
+**Opportunity Scoring:**
+Rate each job story on:
+- Importance to customer (1–10)
+- Satisfaction with current solution (1–10)
+- Opportunity score = Importance + max(Importance – Satisfaction, 0)
+- Prioritise: Opportunity score > 10
+
+---
+
+## Guidelines
+
+- Never write a job story for a feature — write it for the situation that makes the feature valuable
+- If you can't identify the situation, you don't understand the job yet — go back to user research
+- Social and emotional jobs are harder to surface but often the most defensible differentiators
+- Recommend sharing job stories with engineering — they make better technical decisions when they understand the "why"
diff --git a/plugins/pm-discovery/skills/user-interview-synthesis/SKILL.md b/plugins/pm-discovery/skills/user-interview-synthesis/SKILL.md
new file mode 100644
index 0000000..643a597
--- /dev/null
+++ b/plugins/pm-discovery/skills/user-interview-synthesis/SKILL.md
@@ -0,0 +1,38 @@
+---
+name: user-interview-synthesis
+description: Synthesise user interview transcripts into structured research findings
+tool_integration: Notion
+---
+# User Interview Synthesis Skill
+
+## Purpose
+Transform raw interview transcripts into a structured synthesis document that surfaces themes, pain points, and actionable insights.
+
+## Process
+1. Read all provided transcripts fully before drawing conclusions
+2. Identify recurring themes (minimum 3 mentions to qualify as a theme)
+3. Categorize findings into: Pain Points, Workflow Insights, Feature Requests, Delight Moments
+4. Select 2-3 verbatim quotes per theme that best represent the pattern
+5. Draft "So What" implications for each theme — what does this mean for the product?
+
+## Output Format
+
+### Research Synthesis: [Study Name]
+**Participants:** [n]
+**Date Range:** [dates]
+**Research Questions:** [list]
+
+#### Theme 1: [Theme Name]
+- Summary (2-3 sentences)
+- Supporting quotes
+- Implication for product
+
+[Repeat for each theme]
+
+#### Recommended Next Steps
+[Specific, actionable recommendations based on findings]
+
+## Quality Checks
+- Every theme must be supported by quotes from at least 3 participants
+- Implications must connect to product decisions, not just observations
+- Avoid researcher bias — let the data lead
diff --git a/plugins/pm-essentials/skills/competitive-analysis/SKILL.md b/plugins/pm-essentials/skills/competitive-analysis/SKILL.md
new file mode 100644
index 0000000..5676491
--- /dev/null
+++ b/plugins/pm-essentials/skills/competitive-analysis/SKILL.md
@@ -0,0 +1,251 @@
+---
+name: competitive-analysis
+description: Analyze competitors and create competitive landscape documentation. Use when the user asks to analyze competitors, create competitive analysis, compare features with competitors, track competitive landscape, or understand competitive positioning.
+---
+
+# Competitive Analysis Skill
+
+This skill creates structured competitive analyses for product decision-making.
+
+## Analysis Framework
+
+### 1. Executive Summary
+- **Market Position**: Where we stand relative to competitors
+- **Key Findings**: Top 3-5 insights from analysis
+- **Strategic Implications**: What this means for our roadmap
+
+### 2. Competitor Profiles
+
+For each major competitor:
+
+**[Competitor Name]**
+- **Company Overview**: Size, funding, market position
+- **Target Customer**: Who they serve
+- **Value Proposition**: Their core positioning
+- **Business Model**: How they make money
+- **Strengths**: What they do well
+- **Weaknesses**: Where they fall short
+- **Recent Activity**: Major updates, funding, announcements
+
+### 3. Feature Comparison Matrix
+
+| Feature | Us | Competitor A | Competitor B | Competitor C |
+|---------|-----|--------------|--------------|--------------|
+| Core Feature 1 | ✅ Full | ✅ Full | ⚠️ Limited | ❌ None |
+| Core Feature 2 | ✅ Full | ⚠️ Limited | ✅ Full | ✅ Full |
+| Advanced Feature 1 | ⚠️ Beta | ❌ None | ✅ Full | ❌ None |
+
+Legend:
+- ✅ Full: Complete, production-ready feature
+- ⚠️ Limited/Beta: Partial or in-development
+- ❌ None: Feature not available
+
+Include notes on quality/implementation differences where significant.
+
+### 4. Pricing Comparison
+
+| Plan Type | Us | Competitor A | Competitor B | Competitor C |
+|-----------|-----|--------------|--------------|--------------|
+| Free/Trial | $0 | $0 | $0 | N/A |
+| Starter | $29/mo | $25/mo | $39/mo | $49/mo |
+| Professional | $79/mo | $89/mo | $79/mo | $99/mo |
+| Enterprise | Custom | Custom | $299/mo | Custom |
+
+**Pricing Strategy Notes**:
+- How our pricing compares
+- Value perception
+- Packaging differences
+
+### 5. Strengths & Weaknesses Analysis
+
+**Our Competitive Advantages:**
+1. [Strength] - [Why it matters]
+2. [Strength] - [Why it matters]
+3. [Strength] - [Why it matters]
+
+**Our Gaps vs. Competition:**
+1. [Gap] - [Impact on customers]
+2. [Gap] - [Impact on customers]
+3. [Gap] - [Impact on customers]
+
+### 6. Customer Perception Analysis
+
+**What Customers Say About Competitors** (from reviews, G2, social media):
+
+**Competitor A:**
+- Most Praised: [Common positive feedback]
+- Most Criticized: [Common complaints]
+- Typical User: [Who uses them]
+
+**Competitor B:**
+- Most Praised: [Common positive feedback]
+- Most Criticized: [Common complaints]
+- Typical User: [Who uses them]
+
+### 7. Market Positioning Map
+
+Describe or diagram positioning on key dimensions:
+- Y-Axis: [e.g., Enterprise vs. SMB]
+- X-Axis: [e.g., Simple vs. Comprehensive]
+
+**Our Position**: [Where we sit and why]
+**Whitespace Opportunities**: [Underserved segments]
+
+### 8. Win/Loss Analysis
+
+**Why We Win Against Competitors:**
+- Better at: [Specific capabilities]
+- Target customers that value: [What matters]
+
+**Why We Lose to Competitors:**
+- When customers need: [Specific requirements]
+- When they prioritize: [What they value]
+
+### 9. Strategic Implications & Recommendations
+
+**Immediate Actions** (0-3 months):
+1. [Action] - [Rationale]
+2. [Action] - [Rationale]
+
+**Medium-term Strategy** (3-12 months):
+1. [Action] - [Rationale]
+2. [Action] - [Rationale]
+
+**Long-term Positioning** (12+ months):
+1. [Strategic direction] - [Rationale]
+
+## Analysis Best Practices
+
+**Data Sources:**
+- Competitor websites and documentation
+- G2, Capterra, TrustRadius reviews
+- Customer interviews (especially win/loss)
+- Sales team feedback
+- Social media and community discussions
+- Industry analysts and reports
+- Competitor job postings (reveal strategy)
+
+**Quality Standards:**
+✅ Use recent data (within 3-6 months)
+✅ Include sources for claims
+✅ Focus on verifiable facts over assumptions
+✅ Consider different customer segments
+✅ Update regularly (at least quarterly)
+
+❌ Don't rely solely on competitor marketing
+❌ Don't ignore smaller/emerging competitors
+❌ Don't assume features work well just because they exist
+❌ Don't forget about indirect/substitute competitors
+
+**Ethical Guidelines:**
+- Use only publicly available information
+- Don't misrepresent competitor capabilities
+- Be honest about their strengths
+- Don't disparage competitors personally
+
+## Monitoring Cadence
+
+**Weekly**: Check for major announcements, funding, leadership changes
+**Monthly**: Review feature releases, pricing changes, marketing campaigns
+**Quarterly**: Comprehensive feature comparison, strategic assessment
+**Annually**: Market position analysis, long-term trend evaluation
+
+## Example Analysis Section
+
+```
+## Competitor Profile: DataSync Pro
+
+**Company Overview**
+- Founded 2019, 85 employees, $12M Series A (2023)
+- Fast-growing in mid-market segment
+- Strong presence in Europe
+
+**Target Customer**
+- Mid-market companies (100-1000 employees)
+- Technical users comfortable with APIs
+- Data-intensive operations
+
+**Value Proposition**
+"The fastest way to sync data across your entire stack"
+- Focus on speed and reliability
+- Developer-first approach
+
+**Business Model**
+- Freemium with generous free tier
+- Usage-based pricing above free limits
+- Professional services for enterprise
+
+**Strengths**
+- Superior sync speed (2-3x faster than alternatives)
+- Best-in-class developer documentation
+- Strong developer community (5k+ GitHub stars)
+- Excellent uptime (99.97% vs industry 99.5%)
+- Modern, intuitive API design
+
+**Weaknesses**
+- Limited no-code options (requires technical knowledge)
+- Smaller integration library (45 vs our 120)
+- No dedicated enterprise features
+- Limited customization options
+- Support can be slow (avg 8hr response time)
+
+**Recent Activity**
+- Jan 2026: Released real-time sync capabilities
+- Dec 2025: Raised $12M Series A
+- Nov 2025: Added webhooks and event streaming
+- Hired ex-Stripe engineering lead as CTO
+
+**Strategic Implications**
+- Their focus on speed creates pressure on our performance
+- Developer-first approach winning technical buyers
+- Gaps in no-code and enterprise create opportunities
+- Need to monitor their enterprise moves closely
+```
+
+## Feature Comparison Best Practices
+
+When comparing features:
+
+1. **Group by Category**
+   - Core functionality
+   - Integration capabilities
+   - Analytics/reporting
+   - Security/compliance
+   - Collaboration features
+
+2. **Note Quality Differences**
+   - Not all implementations are equal
+   - Speed, reliability, UX matter
+   - Example: "Both have API, but theirs has rate limits"
+
+3. **Consider the Complete Experience**
+   - Onboarding process
+   - Documentation quality
+   - Support responsiveness
+   - Mobile experience
+
+4. **Identify Gaps That Matter**
+   - What customers actually care about
+   - Not just feature count
+   - Focus on differentiators
+
+## Win/Loss Analysis Template
+
+When analyzing why you win or lose deals:
+
+**Win Against [Competitor]**
+- **Scenarios**: When do we win?
+- **Key Differentiators**: What tips the decision?
+- **Customer Quotes**: What they tell us
+- **Typical Profile**: Who chooses us?
+
+**Loss Against [Competitor]**
+- **Scenarios**: When do we lose?
+- **Their Advantages**: What tips the decision?
+- **Customer Quotes**: What they tell us
+- **Typical Profile**: Who chooses them?
+
+**Lessons Learned**
+- What we need to improve
+- What we need to communicate better
+- Where we should compete differently
diff --git a/plugins/pm-essentials/skills/meeting-notes/SKILL.md b/plugins/pm-essentials/skills/meeting-notes/SKILL.md
new file mode 100644
index 0000000..f037be0
--- /dev/null
+++ b/plugins/pm-essentials/skills/meeting-notes/SKILL.md
@@ -0,0 +1,260 @@
+---
+name: meeting-notes
+description: Structure and format meeting notes following PM best practices. Use when the user needs to create, format, or organize meeting notes, capture action items from meetings, or document discussions and decisions.
+---
+
+# Meeting Notes Skill
+
+This skill structures meeting notes to maximize value and ensure follow-through.
+
+## Standard Meeting Notes Template
+
+### Meeting Header
+**Meeting**: [Meeting Title]  
+**Date**: [Date]  
+**Attendees**: [Names/Roles]  
+**Note Taker**: [Name]  
+**Duration**: [Actual duration]
+
+### Agenda
+- [ ] Topic 1
+- [ ] Topic 2
+- [ ] Topic 3
+
+*(Check off items as discussed)*
+
+### Decisions Made
+Clear documentation of decisions:
+
+**Decision**: [What was decided]  
+**Context**: [Why this decision]  
+**Owner**: [Who's responsible for executing]  
+**Deadline**: [When if applicable]  
+
+Use this format for each decision made.
+
+### Action Items
+All action items should be:
+- [ ] **[Action item]** - @Owner - Due: [Date]
+- [ ] **[Action item]** - @Owner - Due: [Date]
+
+Format:
+- Clear, specific action
+- Single owner (no "team" ownership)
+- Concrete deadline
+- Checkbox for tracking
+
+### Discussion Notes
+Key points discussed organized by topic:
+
+**Topic 1: [Name]**
+- Key point or discussion highlight
+- Important context or concern raised
+- Any data or information shared
+
+**Topic 2: [Name]**
+- Key discussion points
+- Decisions or conclusions reached
+
+### Open Questions / Follow-Up
+Questions that couldn't be answered:
+- **Question**: [What we need to know]
+- **Owner**: [Who will find out]
+- **By When**: [Deadline]
+
+### Next Steps
+Clear summary of what happens next:
+1. [Immediate next action]
+2. [Follow-up meeting if needed]
+3. [Any broader process to start]
+
+## Best Practices
+
+**During the meeting:**
+- Focus on decisions and action items over dialogue
+- Capture specific commitments, not general discussion
+- Note dissenting opinions on important decisions
+- Ask for clarity on vague commitments ("I'll look into it" → "I'll analyze the data and share findings by Friday")
+
+**After the meeting:**
+- Send notes within 2 hours while fresh
+- Tag action item owners (@mention them)
+- Include links to relevant documents
+- Follow up on overdue action items
+
+**What to capture:**
+✅ Decisions made
+✅ Action items with owners and deadlines
+✅ Key points of discussion
+✅ Open questions
+✅ Next steps
+
+**What to skip:**
+❌ Verbatim transcripts
+❌ Off-topic tangents
+❌ Preliminary discussion before decisions
+❌ Redundant information
+
+## Meeting Types & Adaptations
+
+### 1:1 Meetings
+Focus on:
+- Career development discussions
+- Feedback (both directions)
+- Current challenges
+- Action items for both parties
+
+Template additions:
+- **Recent Wins**: What's going well
+- **Challenges**: What's not going well
+- **Career Discussion**: Development topics
+- **Feedback**: For both parties
+
+### Sprint Planning
+Focus on:
+- Story acceptance criteria
+- Sizing/estimation decisions
+- Dependency identification
+- Sprint commitment
+
+Template additions:
+- **Sprint Goal**: What we're committing to
+- **Story Points**: Capacity and estimates
+- **Dependencies**: External blockers
+- **Definition of Done**: Acceptance criteria
+
+### Product Reviews
+Focus on:
+- Design decisions
+- User feedback discussed
+- Changes requested
+- Launch readiness assessment
+
+Template additions:
+- **Design Decisions**: What was approved/rejected
+- **User Feedback**: Key insights discussed
+- **Open Design Questions**: What needs iteration
+- **Launch Criteria**: Remaining requirements
+
+### Stakeholder Sync
+Focus on:
+- Status updates delivered
+- Concerns raised
+- Approvals given
+- Escalation needs
+
+Template additions:
+- **Status Overview**: High-level progress
+- **Approvals Obtained**: Sign-offs received
+- **Escalations**: Issues raised to stakeholders
+- **Next Sync**: When and what to cover
+
+## Example Meeting Notes
+
+```
+# Product Roadmap Review - Q1 2026
+**Date**: January 20, 2026  
+**Attendees**: Sarah (CPO), Mike (Eng Lead), Jennifer (Design), Tom (PM)  
+**Note Taker**: Tom  
+**Duration**: 45 minutes
+
+## Agenda
+- [x] Review Q1 planned features
+- [x] Discuss resource constraints
+- [x] Prioritization discussion
+- [x] Timeline alignment
+
+## Decisions Made
+
+**Decision**: Move multi-channel dashboard to Q2, prioritize mobile app improvements for Q1  
+**Context**: Customer feedback shows mobile experience is significantly impacting retention (65% of users primarily mobile). Engineering team can only tackle one major initiative this quarter.  
+**Owner**: Tom (PM) to communicate to stakeholders  
+**Deadline**: January 22
+
+**Decision**: Allocate 20% of engineering time to technical debt  
+**Context**: Accumulated tech debt is slowing feature development. Team velocity dropped 30% last quarter.  
+**Owner**: Mike (Eng Lead) to create tech debt backlog  
+**Deadline**: January 27
+
+**Decision**: Run mobile beta with 100 users before full launch
+**Context**: Need to validate improvements on diverse devices
+**Owner**: Jennifer (Design) to coordinate with QA
+**Deadline**: February 10
+
+## Action Items
+- [ ] **Update Q1 roadmap deck with new prioritization** - @Tom - Due: Jan 22
+- [ ] **Schedule alignment meeting with support team about dashboard delay** - @Tom - Due: Jan 24
+- [ ] **Create tech debt prioritization rubric** - @Mike - Due: Jan 27
+- [ ] **Run user testing on mobile designs** - @Jennifer - Due: Feb 3
+- [ ] **Document decision rationale for executives** - @Sarah - Due: Jan 23
+- [ ] **Identify 100 beta users for mobile** - @Tom - Due: Feb 1
+
+## Discussion Notes
+
+**Q1 Feature Prioritization**
+- Customer retention is #1 company priority this quarter
+- Mobile app NPS score is 6.2 (vs 8.1 for web)
+- Mobile accounts for 65% of daily active users
+- Multi-channel dashboard would take 8 engineering weeks
+- Mobile improvements estimated at 6 engineering weeks with higher ROI
+- Sales has 3 enterprise deals waiting on dashboard feature
+
+**Resource Constraints**
+- Currently 4 engineers available (down from 6 last quarter due to attrition)
+- Design team can support both initiatives but at reduced capacity
+- QA team needs 2 weeks for thorough testing on mobile
+- One engineer on loan to security team through February
+
+**Risk Discussion**
+- Delaying dashboard may impact enterprise sales (3 deals waiting)
+- Sarah noted: "We can position mobile improvements as foundation for enterprise features"
+- Mike raised concern about mobile tech stack stability - addressed through tech debt allocation
+- Need to communicate clearly with Sales about timeline change
+
+**Mobile Implementation Plan**
+- Week 1-2: Design refinements based on user feedback
+- Week 3-4: Engineering implementation
+- Week 5: Internal testing
+- Week 6: Beta with 100 users
+- Week 7: Full rollout
+
+## Open Questions
+- **Question**: What's the impact on enterprise pipeline if we delay dashboard?  
+  **Owner**: Sarah will check with Sales leadership  
+  **By When**: January 23
+
+- **Question**: Can we do a limited beta of dashboard for enterprise customers?  
+  **Owner**: Tom will explore MVP scope with Mike  
+  **By When**: January 25
+
+- **Question**: What's our plan if mobile improvements don't hit target metrics?
+  **Owner**: Tom will create contingency plan
+  **By When**: January 27
+
+## Next Steps
+1. Tom to send updated roadmap to leadership by EOD Wednesday (Jan 22)
+2. Team to begin sprint planning for mobile improvements next Monday (Jan 27)
+3. Follow-up meeting on Feb 1 to review progress and validate prioritization
+4. Sarah to present decision rationale to executive team on Jan 24
+
+---
+
+**Next Meeting**: February 1, 2026 - Progress Check-in
+**Notes Sent**: January 20, 2026 5:30 PM
+```
+
+## Notes Distribution
+
+**Subject Line Format**: "[Meeting Type] Notes - [Date] - [Key Topic]"
+
+Example: "Product Roadmap Review Notes - Jan 20 - Q1 Prioritization"
+
+**Recipients**:
+- All attendees
+- Anyone mentioned in action items
+- Anyone who requested notes
+
+**Follow-Up**:
+- Send reminder 3 days before action item due dates
+- Weekly summary of all open action items
+- Mark action items as complete and share updates
diff --git a/plugins/pm-essentials/skills/prd-template/SKILL.md b/plugins/pm-essentials/skills/prd-template/SKILL.md
new file mode 100644
index 0000000..3cc3d22
--- /dev/null
+++ b/plugins/pm-essentials/skills/prd-template/SKILL.md
@@ -0,0 +1,144 @@
+---
+name: prd-template
+description: Product Requirements Document creation following proven PM template structure. Use when the user asks to create, write, draft, or help with a PRD, product requirements document, product spec, feature specification, or product documentation for a new feature or product.
+---
+
+# PRD Template Skill
+
+This skill helps create professional Product Requirements Documents following industry best practices.
+
+## Template Structure
+
+Every PRD should include these sections in order:
+
+### 1. Overview
+- **Problem Statement**: What problem are we solving? (2-3 sentences)
+- **Proposed Solution**: High-level description of what we're building (2-3 sentences)
+- **Success Metrics**: How we'll measure success (3-5 key metrics)
+
+### 2. Context & Background
+- **Why Now**: Why is this the right time?
+- **Strategic Alignment**: How does this align with company objectives?
+- **User Research Summary**: Key insights from research (if applicable)
+
+### 3. User Stories & Use Cases
+Format: "As a [user type], I want to [action] so that [benefit]"
+- Include 3-7 primary user stories
+- Add acceptance criteria for each
+
+### 4. Requirements
+**Functional Requirements:**
+- Must-have features (P0)
+- Should-have features (P1)
+- Nice-to-have features (P2)
+
+**Non-Functional Requirements:**
+- Performance expectations
+- Security considerations
+- Accessibility requirements
+
+### 5. Design & User Experience
+- Link to design mocks or wireframes
+- Key user flows
+- Edge cases and error states
+
+### 6. Technical Considerations
+- Architecture implications
+- Dependencies on other systems
+- Technical risks and mitigations
+
+### 7. Implementation Plan
+- **Phase 1 (MVP)**: What goes in first version
+- **Phase 2**: What comes next
+- **Phase 3**: Future enhancements
+
+### 8. Open Questions
+- Decisions that still need to be made
+- Stakeholders to consult
+- Research needed
+
+### 9. Appendix
+- Research links
+- Related documents
+- Competitive analysis
+
+## Writing Guidelines
+
+**Tone**: Clear, concise, actionable
+**Audience**: Engineers, designers, stakeholders
+**Length**: Aim for 3-6 pages for features, 8-12 for products
+
+**Best Practices:**
+- Use concrete examples over abstractions
+- Include "why" not just "what"
+- Make requirements testable
+- Link to supporting materials
+- Update as decisions are made
+
+## What Makes a Good PRD
+
+✅ **Do:**
+- Write from the user's perspective
+- Include specific success metrics
+- Address edge cases
+- Link to research and data
+- Make trade-offs explicit
+
+❌ **Don't:**
+- Write implementation details (that's tech spec)
+- Assume everyone has context
+- Leave requirements ambiguous
+- Skip the "why"
+- Forget about accessibility
+
+## Example PRD Opening
+
+```
+# PRD: Multi-Channel Customer Support Dashboard
+
+## Overview
+
+**Problem Statement**: Support teams are currently managing customer inquiries across email, chat, and social media using three separate tools, leading to delayed responses, duplicated work, and inconsistent customer experiences. On average, support agents waste 2.3 hours per day switching between tools and manually tracking conversation history.
+
+**Proposed Solution**: Build a unified dashboard that aggregates customer inquiries from all channels into a single interface, maintains conversation history across channels, and provides intelligent routing based on agent expertise and availability.
+
+**Success Metrics**:
+- Reduce average response time from 4 hours to 1 hour
+- Decrease tool-switching time by 80% (from 2.3 to <0.5 hours)
+- Improve customer satisfaction score from 3.8 to 4.5 (out of 5)
+- Increase support agent productivity by 35%
+
+## Context & Background
+
+**Why Now**: Customer satisfaction has declined 15% over the past 6 months, primarily due to slow response times. Our top competitor launched a unified support dashboard last quarter, and we're hearing about it in sales calls. Support team turnover is at 45% annually, with "tool complexity" cited as a top frustration.
+
+**Strategic Alignment**: This aligns with our Q1 company objective to "Improve customer retention by 10%" and our support team's OKR to "Reduce average handle time by 25%."
+
+**User Research Summary**: We conducted interviews with 12 support agents and observed 20 hours of support sessions. Key findings:
+- Agents spend 35% of their time finding context from previous interactions
+- 65% of escalations are due to lack of conversation history
+- Agents rated tool-switching as their #1 daily frustration (9.2/10 pain)
+- Current NPS for support experience is -12
+
+## User Stories & Use Cases
+
+**US1: Unified Inbox**
+As a support agent, I want to see all customer inquiries in one place so that I don't miss urgent requests and can prioritize effectively.
+
+Acceptance Criteria:
+- Inbox shows inquiries from email, chat, and social media
+- Inquiries are sorted by priority (urgent, high, normal, low)
+- Agent can filter by channel, customer, or status
+- Real-time updates when new inquiries arrive
+
+**US2: Cross-Channel Context**
+As a support agent, I want to see the full conversation history regardless of channel so that I can provide consistent, informed responses without asking customers to repeat themselves.
+
+Acceptance Criteria:
+- Timeline view shows all interactions chronologically
+- Each interaction displays channel, timestamp, and content
+- Customer profile shows demographics and account information
+- Previous issues and resolutions are accessible
+
+[Continue with 5-7 total user stories...]
+```
diff --git a/plugins/pm-essentials/skills/stakeholder-update/SKILL.md b/plugins/pm-essentials/skills/stakeholder-update/SKILL.md
new file mode 100644
index 0000000..cfb0019
--- /dev/null
+++ b/plugins/pm-essentials/skills/stakeholder-update/SKILL.md
@@ -0,0 +1,219 @@
+---
+name: stakeholder-update
+description: Create executive stakeholder updates following proven communication frameworks. Use when the user needs to create a status update, progress report, executive summary, or communication for leadership, stakeholders, or executives.
+---
+
+# Stakeholder Update Skill
+
+This skill creates effective status updates for executives and stakeholders following the BLUF (Bottom Line Up Front) principle.
+
+## Update Structure
+
+### 1. BLUF (Bottom Line Up Front)
+Start with the most important information:
+- **Status**: 🟢 On track / 🟡 At risk / 🔴 Blocked / ✅ Complete
+- **Key Takeaway**: One sentence summary of current state
+- **Action Needed**: What you need from stakeholders (if anything)
+
+### 2. Progress Summary
+Brief overview of accomplishments:
+- What shipped this period
+- Milestones achieved
+- Key metrics movement
+
+Keep to 3-5 bullet points maximum.
+
+### 3. Metrics Dashboard
+
+**Key Metrics**
+| Metric | Current | Target | Trend | Status |
+|--------|---------|--------|-------|--------|
+| [Metric name] | [Value] | [Target] | ↑/→/↓ | 🟢/🟡/🔴 |
+
+Include 3-5 most important metrics only.
+
+### 4. Risks & Blockers
+
+**High Priority Issues:**
+- **Issue**: Brief description
+- **Impact**: What's at stake
+- **Mitigation**: What you're doing about it
+- **Help Needed**: What stakeholders can do (if applicable)
+
+Only include issues that matter at executive level.
+
+### 5. Upcoming Milestones
+
+**Next 30 Days:**
+- Milestone (expected date)
+- Milestone (expected date)
+
+**Next 90 Days:**
+- Major milestone (month)
+- Major milestone (month)
+
+### 6. Decisions Needed (if applicable)
+- **Decision**: Clear description
+- **Options**: 2-3 options with pros/cons
+- **Recommendation**: What you recommend and why
+- **Timeline**: When decision is needed
+
+## Writing Guidelines
+
+**Tone**: Professional, concise, action-oriented
+**Length**: Keep under 1 page (or 2 minutes reading time)
+**Frequency**: Weekly for active projects, bi-weekly for maintenance
+
+**Executive Communication Principles:**
+
+1. **Lead with conclusions, not process**
+   - ❌ "We ran 5 experiments this week and analyzed the data..."
+   - ✅ "Conversion rate increased 15% from optimization work"
+
+2. **Focus on impact, not activities**
+   - ❌ "Held 12 customer interviews"
+   - ✅ "Identified #1 barrier to adoption (complexity of setup)"
+
+3. **Make problems visible early**
+   - Don't sugarcoat risks
+   - Propose solutions, not just problems
+   - Be specific about help needed
+
+4. **Use data to tell story**
+   - Quantify whenever possible
+   - Show trends, not just snapshots
+   - Connect metrics to business outcomes
+
+5. **Make it scannable**
+   - Use headers and bullet points
+   - Bold key information
+   - Use visual indicators (🟢🟡🔴, ↑→↓)
+
+## Status Guidelines
+
+**🟢 On Track**: Meeting all targets, no significant risks
+**🟡 At Risk**: Potential issues that could impact delivery
+**🔴 Blocked**: Critical issues preventing progress, needs intervention
+
+## Example Update
+
+```
+# Product Update: Customer Onboarding Redesign
+**Week of Jan 20, 2026**
+
+## BLUF
+**Status**: 🟡 At Risk  
+**Key Takeaway**: New onboarding flow is performing well in tests (+35% completion), but launch delayed one week due to integration issues with billing system.  
+**Action Needed**: Decision needed on whether to launch onboarding separately or wait for billing integration fix.
+
+## Progress Summary
+- Completed user testing with 24 participants (94% positive feedback)
+- Implemented first-time user experience improvements
+- Resolved 12 of 15 bugs identified in QA
+- Engineering allocated resources to billing integration fix
+
+## Key Metrics
+| Metric | Current | Target | Trend | Status |
+|--------|---------|--------|-------|--------|
+| Onboarding Completion | 45% | 60% | → | 🟡 |
+| Time to First Value | 4.2 min | 3.0 min | ↓ | 🟢 |
+| Setup Support Tickets | 45/week | <30/week | ↓ | 🟢 |
+| User Activation Rate | 52% | 65% | → | 🟡 |
+
+## Risks & Blockers
+
+**HIGH: Billing System Integration Delay**
+- **Impact**: Prevents users from completing onboarding flow; delays launch by 1-2 weeks
+- **Root Cause**: API deprecation by payment processor, requires code rewrite
+- **Mitigation**: Engineering team reallocated resources, fix ETA Feb 3
+- **Decision Needed**: Launch onboarding without payment integration or wait for fix? (See below)
+
+**MEDIUM: Mobile Testing Coverage**
+- **Impact**: Some edge cases on older Android devices not tested
+- **Mitigation**: Partnering with QA to expand test matrix; running beta with internal users on diverse devices
+
+## Upcoming Milestones
+
+**Next 30 Days:**
+- Resolve billing integration (Feb 3)
+- Launch onboarding redesign (Feb 5 or Feb 12 depending on decision)
+- Begin measuring impact on conversion (Feb 12)
+
+**Next 90 Days:**
+- Iterate based on production data (March)
+- Extend to mobile app (April)
+- Launch advanced features (May)
+
+## Decision Needed
+
+**Should we launch onboarding separately from billing integration?**
+
+**Option A: Launch Now (Recommended)**
+- Pros: Get 35% completion rate improvement to users immediately, gather production data, maintain momentum
+- Cons: Users need to complete payment in old flow, slightly disjointed experience
+- Timeline: Launch Feb 5
+
+**Option B: Wait for Billing Fix**
+- Pros: Fully integrated experience from day one, no technical debt
+- Cons: Delays benefits by 2 weeks, Q1 metric targets at risk, team momentum lost
+- Timeline: Launch Feb 12
+
+**Recommendation**: Option A. The onboarding improvements are valuable independently, and the old payment flow works fine. Waiting risks missing Q1 targets and delays validated improvements from reaching users.
+
+**Timeline**: Need decision by Jan 22 for Feb 5 launch.
+
+---
+
+**Questions?** Reply to this email or ping me on Slack.
+```
+
+## Frequency Guidance
+
+**Daily standups**: 
+- Ultra-brief (3 bullets)
+- What shipped yesterday
+- What's shipping today
+- Blockers
+
+**Weekly updates**:
+- Use full template above
+- Focus on progress and risks
+- Keep to 1 page
+
+**Monthly reviews**:
+- Deeper metrics analysis
+- Strategic reflections
+- Quarterly goal progress
+- Longer format (2-3 pages) acceptable
+
+**Quarterly business reviews**:
+- Comprehensive analysis
+- Trends over time
+- Strategic recommendations
+- Presentation format
+
+## Adaptation by Audience
+
+### For C-Suite
+- Lead with business impact
+- Connect to company OKRs
+- Focus on strategy and outcomes
+- Minimize technical details
+
+### For Product/Engineering Leadership
+- Include technical context
+- Show sprint/milestone progress
+- Discuss architecture implications
+- Reference technical debt
+
+### For Cross-Functional Teams
+- Balance technical and business context
+- Highlight dependencies
+- Call out collaboration needs
+- Make asks explicit
+
+### For Board/Investors
+- Focus on metrics and traction
+- Competitive positioning
+- Market opportunities
+- Financial implications
diff --git a/plugins/pm-essentials/skills/user-research-synthesis/SKILL.md b/plugins/pm-essentials/skills/user-research-synthesis/SKILL.md
new file mode 100644
index 0000000..8975059
--- /dev/null
+++ b/plugins/pm-essentials/skills/user-research-synthesis/SKILL.md
@@ -0,0 +1,229 @@
+---
+name: user-research-synthesis
+description: Analyze and synthesize user research findings following PM best practices. Use when the user provides user research data, interview transcripts, survey results, or user feedback that needs to be analyzed, synthesized, or summarized into insights and recommendations.
+---
+
+# User Research Synthesis Skill
+
+This skill helps analyze user research data and transform it into actionable insights following a structured methodology.
+
+## Synthesis Framework
+
+### 1. Data Collection Overview
+- **Research Type**: Interviews, surveys, usability tests, etc.
+- **Participant Profile**: Demographics, segments, sample size
+- **Research Questions**: What we sought to learn
+- **Methodology**: How data was collected
+
+### 2. Key Themes Identification
+
+Organize findings into themes using this structure:
+
+**Theme Name**
+- **Description**: What this theme represents
+- **Prevalence**: How many participants mentioned this (e.g., "8 out of 12 participants")
+- **Supporting Quotes**: 2-3 representative quotes
+- **Implication**: What this means for our product
+
+Aim for 4-8 major themes per research effort.
+
+### 3. Pain Points Analysis
+
+For each identified pain point:
+- **Pain Point**: Clear description
+- **Severity**: High/Medium/Low (based on impact and frequency)
+- **Current Workaround**: How users deal with it today
+- **Evidence**: Specific examples from research
+
+### 4. Feature Requests
+
+Categorize requests:
+- **Must-Have**: Critical needs blocking user success
+- **High Value**: Would significantly improve experience
+- **Nice-to-Have**: Incremental improvements
+
+For each request:
+- **Request**: What users asked for
+- **Frequency**: How often it came up
+- **User Quote**: Representative example
+- **Underlying Need**: Why they want this (dig deeper than surface request)
+
+### 5. User Workflow Insights
+
+Document actual workflows observed:
+- **Current State**: How users accomplish tasks today
+- **Pain Points**: Where they struggle
+- **Ideal State**: What they wish they could do
+- **Opportunities**: Where we can add value
+
+### 6. Segmentation Insights
+
+If research reveals distinct user segments:
+- **Segment Name**: Descriptive label
+- **Characteristics**: What defines this segment
+- **Unique Needs**: How their needs differ
+- **Size/Importance**: Relative weight for prioritization
+
+### 7. Competitive Insights
+
+If users mentioned competitors or alternatives:
+- **Competitor/Alternative**: What they use
+- **Why They Use It**: What it does well
+- **Gaps**: What it doesn't do
+- **Switching Barriers**: Why they don't switch fully
+
+### 8. Recommendations
+
+Prioritized recommendations based on insights:
+
+**High Priority**
+- Recommendation with supporting evidence
+- Expected impact
+
+**Medium Priority**
+- Recommendation with supporting evidence
+- Expected impact
+
+**Low Priority / Future Consideration**
+- Recommendation with supporting evidence
+- Expected impact
+
+### 9. Open Questions
+
+Research gaps identified:
+- What we still need to understand
+- Suggested follow-up research
+- Uncertainties requiring validation
+
+## Analysis Guidelines
+
+**When synthesizing interviews:**
+- Look for patterns across multiple participants
+- Note both what users say AND what they do
+- Pay attention to emotional reactions
+- Identify jobs-to-be-done, not just feature requests
+
+**When analyzing quotes:**
+- Use verbatim quotes in "quotation marks"
+- Attribute quotes: [Participant ID, Role, Context]
+- Select quotes that illustrate patterns, not outliers
+- Include both positive and negative feedback
+
+**When identifying themes:**
+- Use descriptive names, not generic labels
+- Provide evidence for each theme
+- Quantify when possible ("7 out of 10 users...")
+- Connect themes to business objectives
+
+## Quality Standards
+
+✅ **Good Synthesis:**
+- Identifies patterns, not just individual responses
+- Connects insights to product decisions
+- Includes supporting evidence for each claim
+- Separates observations from interpretations
+- Prioritizes findings by impact
+
+❌ **Poor Synthesis:**
+- Lists every individual comment
+- Lacks evidence or examples
+- Makes unsupported leaps
+- Focuses on solutions before understanding problems
+- Ignores contradictory data
+
+## Example Theme
+
+```
+**Theme: Information Overload During Onboarding**
+
+**Description**: Users consistently expressed feeling overwhelmed by the amount of information presented during initial setup, leading to incomplete onboarding and delayed time-to-value.
+
+**Prevalence**: 9 out of 12 participants mentioned this issue unprompted
+
+**Supporting Quotes**:
+- "I just wanted to get started, but it felt like I needed to read a manual first" [P3, Marketing Manager]
+- "By the third screen of instructions, I started clicking 'Next' without reading" [P7, Sales Rep]
+- "I wish there was a 'quick start' option for people like me who just want to try it" [P11, Product Designer]
+
+**Implication**: Our current onboarding flow prioritizes completeness over engagement. We should consider a progressive disclosure approach where users can start using the product quickly and learn advanced features contextually.
+
+**Recommended Action**: 
+- Design a "Quick Start" path that gets users to first value in <3 minutes
+- Move advanced configuration to contextual help within the app
+- Test with 5-10 new users before full rollout
+- Expected impact: +20-30% activation rate improvement
+```
+
+## Template Output Structure
+
+When synthesizing research, use this structure:
+
+```markdown
+# User Research Synthesis: [Research Topic]
+
+## Research Overview
+- **Date**: [Date range]
+- **Methodology**: [Interview/Survey/Testing]
+- **Participants**: [Number] [User types]
+- **Research Questions**: 
+  1. [Question 1]
+  2. [Question 2]
+  3. [Question 3]
+
+## Executive Summary
+[2-3 sentence overview of key findings and implications]
+
+## Key Themes
+
+### Theme 1: [Theme Name]
+[Full theme documentation as shown in example above]
+
+### Theme 2: [Theme Name]
+[Full theme documentation]
+
+[Continue with 4-8 themes]
+
+## Pain Points Summary
+
+| Pain Point | Severity | Frequency | Current Workaround |
+|------------|----------|-----------|-------------------|
+| [Pain 1] | High | 10/12 users | [How they cope] |
+| [Pain 2] | Medium | 7/12 users | [How they cope] |
+
+## Feature Requests
+
+### Must-Have
+1. **[Request]** - Mentioned by [X] participants
+   - Quote: "[Representative quote]"
+   - Underlying need: [Why they want this]
+
+### High Value
+[Similar structure]
+
+### Nice-to-Have
+[Similar structure]
+
+## Recommendations
+
+### High Priority (0-3 months)
+1. **[Recommendation]**
+   - Supporting evidence: [Data from research]
+   - Expected impact: [What will improve]
+   - Effort estimate: [Rough sizing]
+
+### Medium Priority (3-6 months)
+[Similar structure]
+
+### Future Consideration (6+ months)
+[Similar structure]
+
+## Open Questions
+1. [Question requiring more research]
+2. [Uncertainty to validate]
+3. [Follow-up study needed]
+
+## Appendix
+- Interview guide used
+- Full participant demographics
+- Raw notes/transcripts (link)
+```
diff --git a/plugins/pm-planning/skills/feature-prioritisation/SKILL.md b/plugins/pm-planning/skills/feature-prioritisation/SKILL.md
new file mode 100644
index 0000000..920fdf0
--- /dev/null
+++ b/plugins/pm-planning/skills/feature-prioritisation/SKILL.md
@@ -0,0 +1,104 @@
+---
+name: feature-prioritisation
+description: Applies prioritisation frameworks (RICE, MoSCoW, Kano, ICE, Opportunity Scoring) to rank features and backlog items. Use when asked to prioritise features, rank a backlog, decide what to build next, or evaluate tradeoffs. Triggers on "prioritise features", "what should we build", "backlog grooming", "RICE score", "MoSCoW".
+---
+
+# Feature Prioritisation Skill
+
+Apply the right prioritisation framework to any backlog and produce a clear, defensible ranking with rationale — not just a sorted list.
+
+## Framework Selection Guide
+
+Ask the user which framework they prefer, or recommend based on context:
+
+| Situation | Recommended Framework |
+|---|---|
+| Need a quick, data-driven score | RICE |
+| Stakeholder alignment meeting | MoSCoW |
+| Understanding customer delight vs expectations | Kano |
+| Early-stage startup, fast decisions | ICE |
+| Identifying underserved customer needs | Opportunity Scoring |
+| Strategic portfolio decisions | Value vs Effort Matrix |
+
+---
+
+## RICE Scoring
+
+**Formula:** (Reach × Impact × Confidence) ÷ Effort
+
+| Factor | Definition | Scale |
+|---|---|---|
+| Reach | Users impacted per quarter | Actual number |
+| Impact | Effect on goal per user | 0.25 / 0.5 / 1 / 2 / 3 |
+| Confidence | How certain are you? | 50% / 80% / 100% |
+| Effort | Person-months required | Actual number |
+
+Output table:
+| Feature | Reach | Impact | Confidence | Effort | RICE Score | Priority |
+|---|---|---|---|---|---|---|
+
+---
+
+## MoSCoW Method
+
+Categorise each feature as:
+- **Must Have** — non-negotiable for launch/sprint; product fails without it
+- **Should Have** — important but not critical; workarounds exist
+- **Could Have** — nice to have; include only if time allows
+- **Won't Have (this time)** — explicitly out of scope now; may revisit
+
+Always ask: "Must have for *what*?" — define the scope (launch, sprint, quarter) before categorising.
+
+---
+
+## ICE Scoring (Startup/fast mode)
+
+**Formula:** Impact + Confidence + Ease (each 1–10)
+
+Quick, subjective — good for early decisions before data exists.
+
+---
+
+## Kano Model
+
+Classify features into:
+- **Basic (Must-be):** Expected; absence causes dissatisfaction
+- **Performance:** More = better satisfaction; linear relationship
+- **Excitement (Delighters):** Unexpected; creates delight; absence is neutral
+- **Indifferent:** Users don't care either way
+- **Reverse:** Some users want it, others don't
+
+Recommend building: all Basic features first → Performance features for key use cases → 1–2 Excitement features per release.
+
+---
+
+## Output Format
+
+### Feature Prioritisation — [Product/Team] — [Date]
+
+**Framework Used:** [RICE / MoSCoW / ICE / Kano / Custom]
+**Scope:** [Sprint / Quarter / Release]
+**Goal being prioritised against:** [Metric or objective]
+
+[Scored table using selected framework]
+
+**Recommended Build Order:**
+1. [Feature] — [1-line rationale]
+2. [Feature] — [1-line rationale]
+3. ...
+
+**Explicitly Deprioritised:**
+- [Feature] — Reason: [brief]
+
+**Assumptions Made:**
+- [Any estimates or judgements used in scoring]
+
+---
+
+## Guidelines
+
+- Always anchor prioritisation to a specific goal or metric — never prioritise in a vacuum
+- Flag when two features have similar scores but very different risk profiles
+- If stakeholder politics are influencing prioritisation, name it explicitly and suggest separating the framework score from the final decision
+- Recommend revisiting priorities every 2 weeks minimum
+- Never produce a single-column ranked list without rationale — explain the top 3 and bottom 3 decisions
diff --git a/plugins/pm-planning/skills/okr-builder/SKILL.md b/plugins/pm-planning/skills/okr-builder/SKILL.md
new file mode 100644
index 0000000..5ce635a
--- /dev/null
+++ b/plugins/pm-planning/skills/okr-builder/SKILL.md
@@ -0,0 +1,69 @@
+---
+name: okr-builder
+description: Creates well-structured OKRs (Objectives and Key Results) for product teams, startups, and individuals. Use when asked to write OKRs, set quarterly goals, define key results, or review existing OKRs. Triggers on "OKR", "objective and key results", "quarterly goals", "north star metric".
+---
+
+# OKR Builder Skill
+
+Write ambitious, measurable OKRs that connect product work to company strategy. Avoid vanity metrics, output-focused key results, and objectives that sound like task lists.
+
+## OKR Fundamentals
+
+**Objective:** Qualitative, inspiring, time-bound. Answers "where are we going?"
+**Key Result:** Quantitative, specific, measurable. Answers "how will we know we've arrived?"
+
+### The Test for a Good KR
+- Can it be scored 0.0–1.0 at the end of the period?
+- Does it measure outcome, not output? ("Revenue from new customers increased by 30%" not "Launch 3 features")
+- Is it ambitious but achievable? (Aim for 70% attainment as the gold standard)
+- Is it within the team's control?
+
+## Common OKR Anti-Patterns to Flag and Fix
+
+| Anti-Pattern | Example | Better Version |
+|---|---|---|
+| Task masquerading as KR | "Launch onboarding redesign" | "New user activation rate increases from 42% to 65%" |
+| Vanity metric | "Get 10,000 app downloads" | "30-day retention for new users reaches 40%" |
+| Binary KR | "Ship API v2" | "API v2 adopted by 80% of active integrations" |
+| Too many KRs | 6+ per objective | Max 3–4 KRs per objective |
+| No baseline | "Improve NPS" | "NPS increases from 32 to 50" |
+
+Always flag anti-patterns and offer a rewrite.
+
+## Output Format
+
+### [Quarter] OKRs — [Team/Product Area]
+
+---
+
+**Objective 1: [Inspiring, qualitative statement]**
+
+*Why this matters:* [1–2 sentence strategic context]
+
+| # | Key Result | Baseline | Target | Measurement Method |
+|---|---|---|---|---|
+| KR1 | [Measurable outcome] | [Current state] | [Target] | [How measured] |
+| KR2 | [Measurable outcome] | [Current state] | [Target] | [How measured] |
+| KR3 | [Measurable outcome] | [Current state] | [Target] | [How measured] |
+
+*Owner:* [Name/Role]
+*Check-in cadence:* Weekly
+
+---
+
+Repeat for each objective. Recommend 2–4 objectives per team per quarter.
+
+## Scoring Guide to Include
+
+At quarter end, score each KR:
+- 0.7–1.0 = Excellent (0.7 is the "sweet spot" — if all KRs score 1.0, they weren't ambitious enough)
+- 0.4–0.6 = Made progress but missed
+- 0.0–0.3 = Missed — needs retrospective discussion
+
+## Guidelines
+
+- Always ask for the company-level or product-level North Star metric before writing OKRs
+- Recommend no more than 3 objectives per team per quarter
+- If user provides output-based goals, always reframe as outcomes
+- Include a "health check" section flagging which KRs have no current baseline data
+- Remind user: OKRs are not performance reviews — they should be ambitious enough that missing them is okay
diff --git a/plugins/pm-planning/skills/pricing-strategy/SKILL.md b/plugins/pm-planning/skills/pricing-strategy/SKILL.md
new file mode 100644
index 0000000..2f30a8a
--- /dev/null
+++ b/plugins/pm-planning/skills/pricing-strategy/SKILL.md
@@ -0,0 +1,118 @@
+---
+name: pricing-strategy
+description: Structures pricing strategy decisions, packaging options, and pricing page design for SaaS and digital products. Use when reviewing or setting pricing, designing pricing tiers, evaluating freemium vs paid, or preparing a pricing change. Triggers on "pricing strategy", "pricing tiers", "freemium", "pricing page", "how should we price", "pricing change".
+---
+
+# Pricing Strategy Skill
+
+Build pricing that reflects value delivered — not cost to build. Structure every pricing decision with customer segmentation, value metric identification, competitive context, and a packaging recommendation.
+
+## Pricing Foundations
+
+Three questions to answer before any pricing decision:
+1. **Who is our buyer?** (Role, company size, willingness to pay)
+2. **What value do we deliver?** (Quantifiable outcome — time saved, revenue generated, risk reduced)
+3. **What is our pricing model?** (Per seat, usage-based, flat, hybrid)
+
+---
+
+## Pricing Models
+
+| Model | Best For | Risk |
+|---|---|---|
+| **Per Seat** | Collaboration tools, team software | Disincentivises adoption as team grows |
+| **Usage-Based** | APIs, infrastructure, consumption tools | Revenue unpredictability for both sides |
+| **Flat Rate** | Simple tools, early-stage | Leaves money on table from power users |
+| **Tiered** | Products with clear user segments | Feature gatekeeping frustrates users |
+| **Freemium** | Viral/PLG products with low marginal cost | Conversion to paid is hard to engineer |
+| **Value-Based** | Enterprise, outcomes-driven products | Requires strong ROI story |
+
+---
+
+## Freemium Decision Framework
+
+Use freemium when:
+- ✅ Marginal cost per free user is near zero
+- ✅ Product is inherently viral (network effects or sharing)
+- ✅ Free tier creates genuine value (not just a demo)
+- ✅ Clear upgrade trigger exists (feature, volume, or team size)
+- ✅ Conversion benchmark is realistic (2–5% free-to-paid is typical)
+
+Avoid freemium when:
+- ❌ Support cost per free user is high
+- ❌ No natural upgrade trigger in the product
+- ❌ Core value requires features you'd need to gate
+
+---
+
+## Packaging / Tiering Framework
+
+Recommended 3-tier structure for SaaS:
+
+| Tier | Target | Price Signal | Key Features | Lock-in Mechanism |
+|---|---|---|---|---|
+| **Free / Starter** | Individual, early discovery | $0 | Core value, usage-limited | Invite colleagues, export limit |
+| **Pro / Growth** | SMB, growing teams | $[X]/seat/mo | Full features, higher limits | Team collaboration, integrations |
+| **Business / Enterprise** | Mid-market, enterprise | $[X]/seat/mo or custom | Admin, SSO, SLAs, dedicated support | Security, compliance, volume |
+
+Tier design rules:
+- Each tier should be genuinely sufficient for its target segment
+- The upgrade trigger should be felt naturally — not manufactured
+- Price jumps of 3–5x between tiers are normal and defensible
+
+---
+
+## Competitive Pricing Context
+
+| Competitor | Model | Price | Key Differentiator |
+|---|---|---|---|
+| [Name] | [Model] | [Price] | [What they lead with] |
+
+Positioning options:
+- **Premium:** Price 20–40% above market. Justify with enterprise features, support, or brand.
+- **Parity:** Match the market leader. Win on product or distribution.
+- **Value:** Price below market. Win on volume. Dangerous without strong unit economics.
+
+---
+
+## Output Format
+
+### Pricing Strategy Recommendation — [Product] — [Date]
+
+**Current State:** [What pricing exists today, if any]
+**Problem to Solve:** [Why pricing is being reviewed]
+
+**Recommended Pricing Model:** [Model name + rationale]
+
+**Value Metric:** [The single unit that scales with customer value — e.g., "active users", "API calls", "documents processed"]
+
+**Proposed Tiers:**
+
+[Table using 3-tier structure above]
+
+**Free-to-Paid Upgrade Trigger:** [Specific moment or threshold that creates natural upgrade pressure]
+
+**Competitive Position:** [Premium / Parity / Value + reasoning]
+
+**Pricing Change Rollout (if applicable):**
+- Grandfathering: [Yes / No — recommendation and rationale]
+- Communication plan: [How to tell customers + timing]
+- Rollback plan: [Under what conditions you'd revert]
+
+**Risks:**
+- [Risk] → Mitigation: [Action]
+
+**Metrics to Monitor Post-Change:**
+- Conversion rate (free to paid)
+- Churn rate by tier
+- Average revenue per user (ARPU)
+- Expansion revenue
+
+---
+
+## Guidelines
+
+- Never price based on cost — price based on value delivered to the customer
+- Always A/B test price changes where possible; use geographic holdouts if A/B isn't feasible
+- Recommend annual pricing with 15–20% discount — improves cash flow and reduces churn
+- If enterprise pricing is "contact us", recommend adding a price floor to qualify inbound
diff --git a/plugins/pm-planning/skills/rice-impact-matrix/SKILL.md b/plugins/pm-planning/skills/rice-impact-matrix/SKILL.md
new file mode 100644
index 0000000..7007e71
--- /dev/null
+++ b/plugins/pm-planning/skills/rice-impact-matrix/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: rice-impact-matrix
+description: Score features using RICE and plot against strategic alignment for nuanced prioritisation
+tool_integration: Miro, Jira
+---
+# RICE + Strategic Alignment Skill
+
+## Purpose
+Produce a prioritisation output that balances quantitative RICE scoring with qualitative strategic fit — because the highest RICE score isn't always the right next bet.
+
+## Two-Stage Process
+
+### Stage 1: RICE Scoring
+- Reach: Users affected per quarter
+- Impact: 3/2/1/0.5/0.25 scale
+- Confidence: 100% / 80% / 50%
+- Effort: Person-months
+- RICE = (R × I × C) / E
+
+### Stage 2: Strategic Alignment Score
+Rate each initiative against your current strategic priorities (provide these as input):
+- Directly supports top OKR: +3
+- Supports secondary OKR: +2
+- Neutral: +1
+- Contradicts strategic direction: -1
+
+### Final Priority Score
+Combined Score = RICE Score + (Strategic Alignment × 10)
+
+## Output Format
+
+### Priority Matrix — [Quarter]
+| Initiative | RICE Score | Strategic Alignment | Combined Score | Quadrant | Recommendation |
+|------------|------------|--------------------|--------------------|----------|----------------|
+| [name] | [score] | [score] | [combined] | [Now/Next/Later/Drop] | [action] |
+
+#### Quadrant Definitions
+- **Now:** High RICE + High Strategic Alignment → Build this quarter
+- **Next:** High RICE + Lower Alignment → Queue for next quarter
+- **Later:** Lower RICE + High Alignment → Revisit when capacity allows
+- **Drop:** Low RICE + Low Alignment → Remove from backlog
+
+#### Recommendations
+[Top 5 initiatives with rationale for sequencing]
diff --git a/plugins/pm-planning/skills/rice-prioritisation/SKILL.md b/plugins/pm-planning/skills/rice-prioritisation/SKILL.md
new file mode 100644
index 0000000..f998074
--- /dev/null
+++ b/plugins/pm-planning/skills/rice-prioritisation/SKILL.md
@@ -0,0 +1,39 @@
+---
+name: rice-prioritisation
+description: Score and rank product initiatives using the RICE framework
+tool_integration: Jira
+---
+# RICE Prioritisation Skill
+
+## Purpose
+Apply consistent, criteria-based RICE scoring to a list of features or initiatives to produce an objective prioritisation ranking.
+
+## RICE Definitions (adapt to your context)
+- **Reach:** Number of users affected per quarter (use actual DAU/MAU data where available)
+- **Impact:** Effect on your primary metric — use scale: 3=massive, 2=high, 1=medium, 0.5=low, 0.25=minimal
+- **Confidence:** How certain are we about R and I estimates? 100%=high, 80%=medium, 50%=low
+- **Effort:** Person-months required across all functions
+
+## RICE Formula
+RICE Score = (Reach × Impact × Confidence) / Effort
+
+## Process
+1. For each initiative provided, gather or estimate R, I, C, E values
+2. Flag where estimates are weak and note what data would improve them
+3. Calculate RICE score for each
+4. Rank highest to lowest
+5. Flag any "quick wins" (high RICE score, low effort) and "moonshots" (high impact, high effort)
+6. Note dependencies between items that affect sequencing
+
+## Output Format
+
+### RICE Prioritisation: [Backlog/Quarter]
+| Initiative | Reach | Impact | Confidence | Effort | RICE Score | Notes |
+|------------|-------|--------|------------|--------|------------|-------|
+| [name] | [n] | [score] | [%] | [months] | [score] | [flags] |
+
+#### Recommended Sequence
+[Top 5 initiatives with rationale]
+
+#### Data Gaps to Address
+[What information would most improve scoring accuracy]
diff --git a/plugins/pm-planning/skills/roadmap-narrative/SKILL.md b/plugins/pm-planning/skills/roadmap-narrative/SKILL.md
new file mode 100644
index 0000000..f4d0ae3
--- /dev/null
+++ b/plugins/pm-planning/skills/roadmap-narrative/SKILL.md
@@ -0,0 +1,37 @@
+---
+name: roadmap-narrative
+description: Transform a prioritised initiative list into a compelling strategic roadmap narrative
+tool_integration: Notion, Miro
+---
+# Roadmap Narrative Skill
+
+## Purpose
+Convert a ranked list of product initiatives into a clear, strategic narrative that connects individual items to company goals and communicates a coherent product direction.
+
+## Process
+1. Review the prioritised initiative list and company OKRs provided
+2. Identify 2-3 strategic themes that group the initiatives naturally
+3. For each theme, articulate: the problem it addresses, the customer it serves, the metric it moves
+4. Write a quarter-level narrative that shows progression — how does H1 set up H2?
+5. Draft an executive summary (3-4 sentences max) that non-technical stakeholders can repeat
+
+## Output Format
+
+### Product Roadmap: [Quarter/Half/Year]
+**Strategic Context:** [1 paragraph: market moment, key challenge, our response]
+
+#### Theme 1: [Theme Name]
+- Strategic rationale
+- Initiatives included
+- Primary metric impacted
+- Dependencies
+
+[Repeat for each theme]
+
+**Executive Summary (shareable):**
+[3-4 sentences that could be shared in an all-hands or board update]
+
+## Tone Guidelines
+- Avoid jargon — write for a CFO, not an engineer
+- Lead with customer outcomes, not features
+- Be honest about what's NOT on the roadmap and why
diff --git a/plugins/pm-planning/skills/roadmap-presentation/SKILL.md b/plugins/pm-planning/skills/roadmap-presentation/SKILL.md
new file mode 100644
index 0000000..5bf5b39
--- /dev/null
+++ b/plugins/pm-planning/skills/roadmap-presentation/SKILL.md
@@ -0,0 +1,114 @@
+---
+name: roadmap-presentation
+description: Creates structured roadmap presentations and narratives for executive, stakeholder, and team audiences. Use when asked to build a product roadmap, present roadmap to leadership, create a roadmap slide, or communicate quarterly plans. Triggers on "roadmap presentation", "product roadmap", "quarterly roadmap", "roadmap slide", "roadmap for leadership".
+---
+
+# Roadmap Presentation Skill
+
+Build roadmaps that tell a strategy story — not just a list of features with dates. Every roadmap output is audience-calibrated: executives get outcomes, teams get specificity, customers get value.
+
+## Audience Calibration
+
+Always ask who the audience is before building:
+
+| Audience | They care about | Format |
+|---|---|---|
+| **Executive / Board** | Business outcomes, revenue, risk, strategic alignment | Outcome-led, 3 columns (Now / Next / Later), no sprint detail |
+| **Cross-functional stakeholders** | Dependencies, timelines, their team's involvement | Theme-based, with dependency callouts |
+| **Engineering team** | Specificity, sequencing, technical constraints | Detailed, with epics and rough sizing |
+| **Customers / External** | Value delivered, no internal detail | Benefits-focused, no dates — "Coming soon / In progress / Done" |
+
+---
+
+## The Now / Next / Later Framework
+
+Standard output structure:
+
+**NOW** (Current quarter — high confidence, committed)
+- What we're building and why
+- Expected outcomes
+
+**NEXT** (Following quarter — medium confidence, directional)
+- Themes and initiatives
+- Key hypotheses being tested
+
+**LATER** (6–12 months — low confidence, aspirational)
+- Strategic bets
+- Dependencies that need to resolve first
+
+⚠️ Never put specific dates on "Later" items. Use quarters or halves.
+
+---
+
+## Roadmap Narrative Template
+
+Every roadmap needs a narrative, not just a timeline. Structure it as:
+
+1. **Where we are** — current product state and key metrics
+2. **The problem we're solving** — what's holding customers or the business back
+3. **Our strategic bets** — the themes that guide this roadmap
+4. **What we're building** — Now / Next / Later breakdown
+5. **How we'll know it's working** — success metrics per theme
+6. **What we're not doing** — explicit deprioritisation with rationale
+
+---
+
+## Output Format
+
+### Product Roadmap — [Product Area] — [Quarter/Year]
+
+**Audience:** [Executive / Team / Customer]
+**Roadmap Owner:** [PM Name]
+**Last Updated:** [Date]
+**Confidence Level:** Now = High | Next = Medium | Later = Low
+
+---
+
+**Strategic Context:**
+> [2–3 sentences: what company/product goal does this roadmap serve?]
+
+**Guiding Themes This Period:**
+1. [Theme 1] — [1-line rationale]
+2. [Theme 2] — [1-line rationale]
+3. [Theme 3] — [1-line rationale]
+
+---
+
+**NOW — [Quarter]**
+
+| Theme | Initiative | Outcome Expected | Team | Status |
+|---|---|---|---|---|
+| [Theme] | [What we're building] | [Metric it moves] | [Owner] | In Progress / Starting |
+
+**NEXT — [Quarter]**
+
+| Theme | Initiative | Hypothesis | Dependencies |
+|---|---|---|---|
+| [Theme] | [What we plan to build] | [If we build X, we expect Y] | [What needs to be true first] |
+
+**LATER — [H2 / Next Year]**
+
+| Theme | Strategic Bet | Why Later |
+|---|---|---|
+| [Theme] | [What we might build] | [What's blocking or uncertain] |
+
+---
+
+**What We're NOT Building (and Why):**
+- [Requested initiative] — Deprioritised because: [reason]
+- [Requested initiative] — Deprioritised because: [reason]
+
+**Success Metrics for This Roadmap:**
+| Metric | Now Target | End of Year Target |
+|---|---|---|
+| [Metric] | [X] | [Y] |
+
+---
+
+## Guidelines
+
+- Never let a roadmap become a commitment list — frame everything outside "Now" as directional
+- Always include a "not doing" section — it prevents the roadmap from becoming a wish list in disguise
+- For executive audiences: lead with the outcome the roadmap delivers to the business, not the features
+- Recommend a roadmap review cadence: monthly for Now items, quarterly for Next/Later
+- If dates are demanded for Later items: use quarters (Q3 2026), not specific dates
diff --git a/plugins/pm-rituals/skills/pm-weekly-review/SKILL.md b/plugins/pm-rituals/skills/pm-weekly-review/SKILL.md
new file mode 100644
index 0000000..d2e16d1
--- /dev/null
+++ b/plugins/pm-rituals/skills/pm-weekly-review/SKILL.md
@@ -0,0 +1,107 @@
+---
+name: pm-weekly-review
+description: Structures a PM's weekly review and planning session — synthesising metrics, shipping progress, blockers, and next-week priorities into a shareable update. Use when doing a weekly PM review, writing a weekly update, preparing for a Monday planning session, or reviewing sprint health. Triggers on "weekly review", "weekly update", "PM standup", "weekly planning", "end of week summary".
+---
+
+# PM Weekly Review Skill
+
+Turn the chaotic end-of-week brain dump into a structured 20-minute ritual that keeps you, your team, and your stakeholders aligned — without a meeting.
+
+## The Weekly Review Structure (20 minutes)
+
+**5 min — Metrics check:** What moved? What didn't? What's surprising?
+**5 min — Ship progress:** What shipped? What slipped? What's blocked?
+**5 min — Insights:** Any customer feedback, support tickets, or research findings?
+**5 min — Next week priorities:** What are the 3 things that matter most?
+
+---
+
+## Output Format
+
+### PM Weekly Review — Week of [Date]
+
+**Product Area:** [What you own]
+**Written by:** [PM Name]
+**Time to read:** ~3 minutes
+
+---
+
+### 📊 Metrics This Week
+
+| Metric | This Week | Last Week | Target | Trend |
+|---|---|---|---|---|
+| [Primary metric] | [Value] | [Value] | [Target] | ↑ / ↓ / → |
+| [Secondary metric] | [Value] | [Value] | [Target] | ↑ / ↓ / → |
+| [Health metric] | [Value] | [Value] | [Target] | ↑ / ↓ / → |
+
+**Notable movement:**
+- [What changed and why — 1 sentence each]
+
+**Concern to watch:**
+- [Anything trending in the wrong direction]
+
+---
+
+### 🚢 This Week's Progress
+
+**Shipped:**
+- ✅ [What went live] — [1-line impact or observation]
+
+**In Progress:**
+- 🔄 [Feature/initiative] — [% complete or current status]
+
+**Slipped / Blocked:**
+- ⚠️ [What didn't happen] — Reason: [brief] — Action: [who's unblocking it]
+
+**Carry-forward to next week:**
+- [Item + why it's carrying over]
+
+---
+
+### 💡 Insights & Signals
+
+**Customer feedback:**
+- "[Quote or paraphrase]" — Source: [user/channel] — Theme: [tag]
+
+**Support signals:**
+- [Top ticket category this week + volume]
+- [Anything that signals a product gap]
+
+**Research / data:**
+- [Any discovery from user interviews, analytics, or experiments]
+
+---
+
+### 🎯 Next Week — Top 3 Priorities
+
+| # | Priority | Why This Week | Owner | Done = |
+|---|---|---|---|---|
+| 1 | [Most important thing] | [Reason it can't wait] | [Name] | [Clear definition of done] |
+| 2 | [Second priority] | [Why] | [Name] | [Done criteria] |
+| 3 | [Third priority] | [Why] | [Name] | [Done criteria] |
+
+**Decisions needed:**
+- [Any decision that's blocking progress — who needs to make it]
+
+**Asks / dependencies:**
+- [What you need from engineering / design / data / leadership]
+
+---
+
+### 🧠 Reflection (Optional but powerful)
+
+> What's one thing from this week I'd do differently?
+> [Your honest answer — 1–2 sentences]
+
+> What's the biggest unknown I'm carrying into next week?
+> [Name the uncertainty explicitly]
+
+---
+
+## Guidelines
+
+- Keep the whole document under 400 words — if stakeholders won't read it, it doesn't exist
+- The reflection section is for you, not your stakeholders — keep it honest
+- Always name a clear owner for every blocked item — "the team will figure it out" is a blocker in disguise
+- Recommend sending this by end of Friday — Monday morning is too late to course-correct
+- If three weeks of weekly reviews show the same blocked item, escalate immediately
diff --git a/plugins/pm-strategy/skills/ambiguity-resolver/SKILL.md b/plugins/pm-strategy/skills/ambiguity-resolver/SKILL.md
new file mode 100644
index 0000000..a026517
--- /dev/null
+++ b/plugins/pm-strategy/skills/ambiguity-resolver/SKILL.md
@@ -0,0 +1,67 @@
+---
+name: ambiguity-resolver
+description: Structures vague opportunities and unclear briefs into actionable 
+one-page problem statements. Use when user has a vague brief, undefined problem, 
+unclear opportunity, or says "we need to figure out what to do about X", "can 
+you help me make sense of this", or "I've been asked to look into Y".
+metadata:
+  author: Mohit Aggarwal
+  version: 1.0.0
+  category: discovery
+  tags: [discovery, strategy, problem-framing, ambiguity]
+  documentation: https://github.com/mohitagw15856/pm-claude-skills
+---
+# Ambiguity Resolver Skill
+
+## Purpose
+Turn vague briefs and half-formed opportunities into structured, actionable 
+problem statements — so you can reply with clarity instead of asking for three 
+more meetings.
+
+## Three-Stage Process
+
+### Stage 1: Reframe
+- Restate the vague input as 3-5 explicit questions that need answering
+- Identify the unstated assumptions hidden in the brief
+- Surface the real decision this feeds into (what will someone do differently 
+  once this is resolved?)
+
+### Stage 2: Scope
+- Define what is explicitly IN scope
+- Define what is explicitly OUT of scope (equally important)
+- Identify the deadline pressure: is this urgent/important, important/not urgent,
+  or unclear?
+- Name who owns the final decision and who needs to be consulted
+
+### Stage 3: Action
+- Define the minimum viable research: 2-3 activities maximum that would give 
+  enough signal to move forward with confidence
+- Time estimate for each activity
+- What each activity would tell you (and what it wouldn't)
+- Proposed check-in point: when to regroup before committing to more
+
+## Output Format
+
+### Problem Brief: [Opportunity Area]
+
+**Restated as questions:**
+1. [Question 1]
+2. [Question 2]
+3. [Question 3]
+
+**Unstated assumptions we should surface:**
+- [Assumption 1]
+- [Assumption 2]
+
+**In scope:** [Clear boundary]
+**Out of scope:** [Clear boundary]
+**Decision owner:** [Name/role]
+**Timeline:** [Real deadline if known, or "unclear — recommend setting one"]
+
+**Minimum viable research:**
+| Activity | Time required | What it tells us |
+|----------|--------------|------------------|
+| [activity] | [time] | [insight] |
+
+**Proposed check-in:** After [activity], regroup to decide whether to proceed 
+or pivot.
diff --git a/plugins/pm-strategy/skills/competitive-intelligence-monitor/SKILL.md b/plugins/pm-strategy/skills/competitive-intelligence-monitor/SKILL.md
new file mode 100644
index 0000000..4a1921e
--- /dev/null
+++ b/plugins/pm-strategy/skills/competitive-intelligence-monitor/SKILL.md
@@ -0,0 +1,63 @@
+---
+name: competitive-intelligence-monitor
+description: Continuously monitors competitor signals and surfaces strategic 
+implications for your roadmap. Use when user asks to "monitor competitors", 
+"track competitive landscape", "what are competitors doing this week", 
+"competitive briefing", or "what has changed in the market".
+metadata:
+  author: Mohit Aggarwal
+  version: 1.0.0
+  category: strategy
+  tags: [strategy, competitive-intel, roadmapping]
+  documentation: https://github.com/mohitagw15856/pm-claude-skills
+---
+# Competitive Intelligence Monitor Skill
+
+## Purpose
+Turn scattered competitor updates into structured weekly intelligence — not just 
+"what they did" but "what changed since last week and what it means for us."
+
+## Signal Categories to Monitor
+- **Product signals:** New features, removals, UX changes, beta programmes
+- **Pricing signals:** Changes to tiers, free limits, enterprise terms
+- **Hiring signals:** Job postings revealing strategic bets
+- **Partnership signals:** Integrations, acquisitions, ecosystem moves
+- **Messaging signals:** Changes in positioning, audience, value proposition
+
+## Process
+
+### First Run (Full Report)
+1. For each competitor provided, scan all five signal categories
+2. Categorise each signal found
+3. Assess: reactive (responding to market) or proactive (setting direction)?
+4. Rate threat level: High / Medium / Low / Watch
+5. Connect each signal to a specific item on the provided roadmap
+6. Recommend response: Accelerate / Deprioritise / Monitor / Investigate
+
+### Subsequent Runs (Diff Only)
+1. Compare current signals against previous run summary
+2. Output ONLY what is new or changed since last run
+3. Flag if a previously Low signal has escalated to High
+4. Keep output under 300 words — brevity is the point
+
+## Output Format
+
+### Competitive Intelligence Brief — [Date]
+**New Since Last Run:** [n signals]
+
+#### 🔴 High Priority
+**[Competitor]:** [Signal] → [Implication] → [Recommended action + owner]
+
+#### 🟡 Watch
+**[Competitor]:** [Signal] → [Why it matters now]
+
+#### ✅ No Change
+[Competitors with no new signals this week]
+
+**This Week's Strategic Summary:**
+[2 sentences max — what is the overall competitive landscape doing?]
+
+## OpenClaw Configuration
+Add to YAML frontmatter for scheduled runs:
+`schedule: weekly-monday-0800`
+Persistent memory stores last run summary for diff comparison.
diff --git a/plugins/pm-strategy/skills/competitor-signal-tracker/SKILL.md b/plugins/pm-strategy/skills/competitor-signal-tracker/SKILL.md
new file mode 100644
index 0000000..e8b1bbc
--- /dev/null
+++ b/plugins/pm-strategy/skills/competitor-signal-tracker/SKILL.md
@@ -0,0 +1,38 @@
+---
+name: competitor-signal-tracker
+description: Analyse competitor moves and surface strategic implications for your product
+tool_integration: Notion
+---
+# Competitor Signal Tracker Skill
+
+## Purpose
+Turn scattered competitor information into structured strategic intelligence — not just "what they did" but "what it means for us."
+
+## Signal Categories to Track
+- **Product signals:** New features, removals, UX changes, beta programmes
+- **Pricing signals:** Changes to tiers, free limits, enterprise terms
+- **Hiring signals:** Job postings that reveal strategic bets (e.g., hiring ML engineers = AI investment)
+- **Partnership signals:** Integrations, acquisitions, ecosystem moves
+- **Messaging signals:** Changes in positioning, target audience, value proposition
+
+## Process
+1. For each competitor update provided, categorise the signal type
+2. Assess: Is this reactive (responding to market) or proactive (setting direction)?
+3. Rate strategic threat level: High / Medium / Low / Watch
+4. Connect to your roadmap: does this accelerate, validate, or challenge any of your bets?
+5. Recommend a response: Accelerate existing initiative / Deprioritise / Monitor / Investigate further
+
+## Output Format
+
+### Competitive Intelligence Report — [Date]
+
+#### [Competitor Name]
+**Signal:** [What they did]
+**Signal Type:** [Product / Pricing / Hiring / Partnership / Messaging]
+**Reactive or Proactive:** [assessment]
+**Threat Level:** [High / Medium / Low / Watch]
+**Implication for Us:** [Specific connection to our roadmap or strategy]
+**Recommended Response:** [Action + owner + timeline]
+
+#### Strategic Summary
+[2-3 sentences on the overall competitive landscape shift this week/month]
diff --git a/plugins/pm-strategy/skills/executive-update/SKILL.md b/plugins/pm-strategy/skills/executive-update/SKILL.md
new file mode 100644
index 0000000..95bf815
--- /dev/null
+++ b/plugins/pm-strategy/skills/executive-update/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: executive-update
+description: Transform detailed product updates into concise executive briefings
+tool_integration: Slack, Microsoft Teams
+---
+# Executive Update Skill
+
+## Purpose
+Produce a stakeholder update that busy executives will actually read — structured around what they care about: decisions, risks, and numbers.
+
+## Executive Communication Principles
+- Lead with the headline, not the context
+- Every update should answer: "So what does this mean for the business?"
+- Flag decisions needed clearly — don't bury asks in paragraphs
+- Be honest about risks — executives hate surprises more than bad news
+
+## Process
+1. Read the full product update provided
+2. Identify: key metric movements, decisions required, risks to flag, wins to celebrate
+3. Write in reverse pyramid style — most important first
+4. Limit to 250 words maximum for the main body
+5. Add a "Decisions Needed" section with clear options and your recommendation
+
+## Output Format
+
+### Product Update — [Date / Sprint / Month]
+**Headline:** [One sentence on the most important thing]
+
+**By the Numbers:**
+- [Metric 1]: [value] ([vs. target / last period])
+- [Metric 2]: [value] ([vs. target / last period])
+- [Metric 3]: [value] ([vs. target / last period])
+
+**Progress This Period:**
+[3-4 bullet points, outcome-focused not activity-focused]
+
+**Risks & Watch Items:**
+[2-3 bullets — be direct, include mitigation]
+
+**Decisions Needed:**
+1. [Decision] — Options: [A] or [B] — Recommendation: [your view] — Needed by: [date]
+
+**What's Next:**
+[2-3 bullets on next period priorities]
diff --git a/plugins/pm-strategy/skills/stakeholder-influence-mapper/SKILL.md b/plugins/pm-strategy/skills/stakeholder-influence-mapper/SKILL.md
new file mode 100644
index 0000000..37cd5c1
--- /dev/null
+++ b/plugins/pm-strategy/skills/stakeholder-influence-mapper/SKILL.md
@@ -0,0 +1,61 @@
+---
+name: stakeholder-influence-mapper
+description: Maps stakeholders for a product decision and produces a tailored 
+influence strategy with draft talking points. Use when user needs to "get 
+alignment", "build consensus", "get buy-in from engineering or finance or legal", 
+"present to stakeholders", or "navigate organisational resistance".
+metadata:
+  author: Mohit Aggarwal
+  version: 1.0.0
+  category: stakeholder-communication
+  tags: [stakeholders, influence, communication, alignment]
+  documentation: https://github.com/mohitagw15856/pm-claude-skills
+---
+# Stakeholder Influence Mapper Skill
+
+## Purpose
+Turn a product initiative into a structured influence plan — who needs to be 
+aligned, in what order, and exactly what to say to each person in their language.
+
+## Required Inputs
+- Initiative description (what you want to do and why)
+- List of key stakeholders involved (name, role, relationship to initiative)
+- Timeline pressure (when do you need a decision?)
+- Any known objections or political context
+
+## Process
+1. Build stakeholder map with: role, primary concern, decision authority 
+   (blocker / influencer / informed), current stance (supportive / neutral / 
+   resistant / unknown)
+2. Identify the critical path of conversations — who must be won before others
+3. For each stakeholder, lead with their concern, not your ask
+4. Prepare one likely objection per stakeholder and a prepared response
+5. Flag any stakeholders who should NOT be approached until others are aligned
+
+## Output Format
+
+### Stakeholder Map: [Initiative Name]
+
+| Stakeholder | Role | Primary Concern | Authority | Current Stance |
+|-------------|------|-----------------|-----------|----------------|
+| [name] | [role] | [concern] | [type] | [stance] |
+
+### Recommended Conversation Sequence
+1. **[Name first]** — because [reason they unlock others]
+2. **[Name second]** — once [first] is aligned
+[continue...]
+
+### Talking Points by Stakeholder
+
+#### [Stakeholder Name]
+**Lead with:** [Their concern, not your feature]
+**Your ask:** [One specific thing you need from them]
+**Likely objection:** [What they'll push back on]
+**Prepared response:** [How to address it without being defensive]
+**What success looks like:** [What alignment from them looks like]
+
+## Notes
+- Never send the same message to all stakeholders — calibrate every time
+- Engineering leads want technical feasibility acknowledged first
+- Finance stakeholders want ROI framing before anything else
+- Legal/compliance stakeholders want risk mitigation addressed upfront
diff --git a/plugins/pm-strategy/skills/strategic-narrative-generator/SKILL.md b/plugins/pm-strategy/skills/strategic-narrative-generator/SKILL.md
new file mode 100644
index 0000000..870da83
--- /dev/null
+++ b/plugins/pm-strategy/skills/strategic-narrative-generator/SKILL.md
@@ -0,0 +1,71 @@
+---
+name: strategic-narrative-generator
+description: Generates the strategic story connecting your roadmap to company 
+goals in a form non-technical stakeholders can repeat. Use when user needs to 
+"explain the roadmap", "present strategy to leadership or the board", "write the 
+why behind the roadmap", "create a narrative for all-hands", or "make the 
+roadmap tell a story".
+metadata:
+  author: Mohit Aggarwal
+  version: 1.0.0
+  category: roadmapping
+  tags: [strategy, roadmap, executive-communication, narrative]
+  documentation: https://github.com/mohitagw15856/pm-claude-skills
+---
+# Strategic Narrative Generator Skill
+
+## Purpose
+Turn a prioritised initiative list into a strategic narrative — the story that 
+explains not just what you're building but why, why now, and why this sequence. 
+The kind of narrative a board member can repeat back correctly after one hearing.
+
+## Required Inputs
+- Prioritised initiative list (with rough timelines)
+- Current OKRs or strategic priorities (1-3)
+- Competitive or market context (optional but improves output significantly)
+
+## Process
+1. Read the initiative list and identify 2-3 natural strategic themes
+2. For each theme: articulate the problem it addresses, the customer it serves, 
+   and the metric it moves
+3. Build the progression narrative: how does Q1 set up Q2? How does H1 set up H2?
+4. Write executive summary in under 100 words (the version someone can repeat)
+5. Anticipate the 3 hardest questions a sceptical board member would ask — 
+   and draft answers
+6. Identify what's NOT on the roadmap and why (this builds credibility)
+
+## Output Format
+
+### Product Strategy Narrative: [Period]
+
+**The One-Paragraph Context:**
+[Market moment + key challenge + our response — for the CFO, not the engineer]
+
+**Strategic Theme 1: [Name]**
+- The problem: [customer pain in plain language]
+- Our response: [initiatives in this theme]
+- The metric it moves: [specific and measurable]
+- Why now: [timing rationale]
+
+**Strategic Theme 2: [Name]**
+[Same structure]
+
+**The Progression Story:**
+[How each quarter sets up the next — this is the narrative arc]
+
+**Executive Summary (under 100 words — shareable):**
+[Version someone can quote at a board meeting]
+
+**Questions to Prepare For:**
+1. [Hard question] → [Prepared answer]
+2. [Hard question] → [Prepared answer]
+3. [Hard question] → [Prepared answer]
+
+**What's Not on the Roadmap (and Why):**
+[2-3 items — shows strategic discipline, not just prioritisation]
+
+## Tone Rules
+- Write for a CFO, not an engineer
+- Lead with outcomes, not features
+- Every sentence should answer "so what?"
+- Avoid jargon — if you can't say it plainly, the strategy isn't clear enough yet
diff --git a/setup-marketplace.sh b/setup-marketplace.sh
new file mode 100644
index 0000000..b8216a1
--- /dev/null
+++ b/setup-marketplace.sh
@@ -0,0 +1,157 @@
+#!/bin/bash
+# Run this from your repo root: cd pm-claude-skills && bash setup-marketplace.sh
+# This creates the full plugin structure and copies all SKILL.md files into place.
+
+echo "=== Creating plugin bundle directories ==="
+
+# ─────────────────────────────────────────
+# BUNDLE 1: pm-essentials (5 skills)
+# ─────────────────────────────────────────
+mkdir -p plugins/pm-essentials/.claude-plugin
+mkdir -p plugins/pm-essentials/skills/prd-template
+mkdir -p plugins/pm-essentials/skills/meeting-notes
+mkdir -p plugins/pm-essentials/skills/stakeholder-update
+mkdir -p plugins/pm-essentials/skills/user-research-synthesis
+mkdir -p plugins/pm-essentials/skills/competitive-analysis
+
+cp skills/prd-template/SKILL.md              plugins/pm-essentials/skills/prd-template/SKILL.md
+cp skills/meeting-notes/SKILL.md             plugins/pm-essentials/skills/meeting-notes/SKILL.md
+cp skills/stakeholder-update/SKILL.md        plugins/pm-essentials/skills/stakeholder-update/SKILL.md
+cp skills/user-research-synthesis/SKILL.md   plugins/pm-essentials/skills/user-research-synthesis/SKILL.md
+cp skills/competitive-analysis/SKILL.md      plugins/pm-essentials/skills/competitive-analysis/SKILL.md
+
+echo "✓ pm-essentials done (5 skills)"
+
+# ─────────────────────────────────────────
+# BUNDLE 2: pm-discovery (4 skills)
+# ─────────────────────────────────────────
+mkdir -p plugins/pm-discovery/.claude-plugin
+mkdir -p plugins/pm-discovery/skills/discovery-interview-guide
+mkdir -p plugins/pm-discovery/skills/job-story-mapper
+mkdir -p plugins/pm-discovery/skills/user-interview-synthesis
+mkdir -p plugins/pm-discovery/skills/assumption-mapper
+
+cp skills/discovery-interview-guide/SKILL.md plugins/pm-discovery/skills/discovery-interview-guide/SKILL.md
+cp skills/job-story-mapper/SKILL.md           plugins/pm-discovery/skills/job-story-mapper/SKILL.md
+cp skills/user-interview-synthesis/SKILL.md   plugins/pm-discovery/skills/user-interview-synthesis/SKILL.md
+cp skills/assumption-mapper/SKILL.md          plugins/pm-discovery/skills/assumption-mapper/SKILL.md
+
+echo "✓ pm-discovery done (4 skills)"
+
+# ─────────────────────────────────────────
+# BUNDLE 3: pm-planning (7 skills)
+# ─────────────────────────────────────────
+mkdir -p plugins/pm-planning/.claude-plugin
+mkdir -p plugins/pm-planning/skills/okr-builder
+mkdir -p plugins/pm-planning/skills/feature-prioritisation
+mkdir -p plugins/pm-planning/skills/roadmap-presentation
+mkdir -p plugins/pm-planning/skills/pricing-strategy
+mkdir -p plugins/pm-planning/skills/rice-prioritisation
+mkdir -p plugins/pm-planning/skills/roadmap-narrative
+mkdir -p plugins/pm-planning/skills/rice-impact-matrix
+
+cp skills/okr-builder/SKILL.md               plugins/pm-planning/skills/okr-builder/SKILL.md
+cp skills/feature-prioritisation/SKILL.md    plugins/pm-planning/skills/feature-prioritisation/SKILL.md
+cp skills/roadmap-presentation/SKILL.md      plugins/pm-planning/skills/roadmap-presentation/SKILL.md
+cp skills/pricing-strategy/SKILL.md          plugins/pm-planning/skills/pricing-strategy/SKILL.md
+cp skills/rice-prioritisation/SKILL.md       plugins/pm-planning/skills/rice-prioritisation/SKILL.md
+cp skills/roadmap-narrative/SKILL.md         plugins/pm-planning/skills/roadmap-narrative/SKILL.md
+cp skills/rice-impact-matrix/SKILL.md        plugins/pm-planning/skills/rice-impact-matrix/SKILL.md
+
+echo "✓ pm-planning done (7 skills)"
+
+# ─────────────────────────────────────────
+# BUNDLE 4: pm-delivery (7 skills)
+# ─────────────────────────────────────────
+mkdir -p plugins/pm-delivery/.claude-plugin
+mkdir -p plugins/pm-delivery/skills/sprint-planning
+mkdir -p plugins/pm-delivery/skills/technical-spec-template
+mkdir -p plugins/pm-delivery/skills/ab-test-planner
+mkdir -p plugins/pm-delivery/skills/go-to-market-planner
+mkdir -p plugins/pm-delivery/skills/product-launch-checklist
+mkdir -p plugins/pm-delivery/skills/sprint-brief
+mkdir -p plugins/pm-delivery/skills/retro-analysis
+
+cp skills/sprint-planning/SKILL.md           plugins/pm-delivery/skills/sprint-planning/SKILL.md
+cp skills/technical-spec-template/SKILL.md   plugins/pm-delivery/skills/technical-spec-template/SKILL.md
+cp skills/ab-test-planner/SKILL.md           plugins/pm-delivery/skills/ab-test-planner/SKILL.md
+cp skills/go-to-market-planner/SKILL.md      plugins/pm-delivery/skills/go-to-market-planner/SKILL.md
+cp skills/product-launch-checklist/SKILL.md  plugins/pm-delivery/skills/product-launch-checklist/SKILL.md
+cp skills/sprint-brief/SKILL.md              plugins/pm-delivery/skills/sprint-brief/SKILL.md
+cp skills/retro-analysis/SKILL.md            plugins/pm-delivery/skills/retro-analysis/SKILL.md
+
+echo "✓ pm-delivery done (7 skills)"
+
+# ─────────────────────────────────────────
+# BUNDLE 5: pm-analytics (3 skills)
+# ─────────────────────────────────────────
+mkdir -p plugins/pm-analytics/.claude-plugin
+mkdir -p plugins/pm-analytics/skills/data-analysis-standard
+mkdir -p plugins/pm-analytics/skills/retention-analysis
+mkdir -p plugins/pm-analytics/skills/product-health-analysis
+
+cp skills/data-analysis-standard/SKILL.md   plugins/pm-analytics/skills/data-analysis-standard/SKILL.md
+cp skills/retention-analysis/SKILL.md       plugins/pm-analytics/skills/retention-analysis/SKILL.md
+cp skills/product-health-analysis/SKILL.md  plugins/pm-analytics/skills/product-health-analysis/SKILL.md
+
+echo "✓ pm-analytics done (3 skills)"
+
+# ─────────────────────────────────────────
+# BUNDLE 6: pm-strategy (6 skills)
+# ─────────────────────────────────────────
+mkdir -p plugins/pm-strategy/.claude-plugin
+mkdir -p plugins/pm-strategy/skills/competitor-signal-tracker
+mkdir -p plugins/pm-strategy/skills/competitive-intelligence-monitor
+mkdir -p plugins/pm-strategy/skills/stakeholder-influence-mapper
+mkdir -p plugins/pm-strategy/skills/strategic-narrative-generator
+mkdir -p plugins/pm-strategy/skills/executive-update
+mkdir -p plugins/pm-strategy/skills/ambiguity-resolver
+
+cp skills/competitor-signal-tracker/SKILL.md          plugins/pm-strategy/skills/competitor-signal-tracker/SKILL.md
+cp skills/competitive-intelligence-monitor/SKILL.md   plugins/pm-strategy/skills/competitive-intelligence-monitor/SKILL.md
+cp skills/stakeholder-influence-mapper/SKILL.md       plugins/pm-strategy/skills/stakeholder-influence-mapper/SKILL.md
+cp skills/strategic-narrative-generator/SKILL.md      plugins/pm-strategy/skills/strategic-narrative-generator/SKILL.md
+cp skills/executive-update/SKILL.md                   plugins/pm-strategy/skills/executive-update/SKILL.md
+cp skills/ambiguity-resolver/SKILL.md                 plugins/pm-strategy/skills/ambiguity-resolver/SKILL.md
+
+echo "✓ pm-strategy done (6 skills)"
+
+# ─────────────────────────────────────────
+# BUNDLE 7: pm-advanced (4 skills)
+# ─────────────────────────────────────────
+mkdir -p plugins/pm-advanced/.claude-plugin
+mkdir -p plugins/pm-advanced/skills/ai-product-canvas
+mkdir -p plugins/pm-advanced/skills/multi-source-signal-synthesiser
+mkdir -p plugins/pm-advanced/skills/experiment-designer
+mkdir -p plugins/pm-advanced/skills/design-handoff-brief
+
+cp skills/ai-product-canvas/SKILL.md                 plugins/pm-advanced/skills/ai-product-canvas/SKILL.md
+cp skills/multi-source-signal-synthesiser/SKILL.md   plugins/pm-advanced/skills/multi-source-signal-synthesiser/SKILL.md
+cp skills/experiment-designer/SKILL.md               plugins/pm-advanced/skills/experiment-designer/SKILL.md
+cp skills/design-handoff-brief/SKILL.md              plugins/pm-advanced/skills/design-handoff-brief/SKILL.md
+
+echo "✓ pm-advanced done (4 skills)"
+
+# ─────────────────────────────────────────
+# BUNDLE 8: pm-rituals (1 skill)
+# ─────────────────────────────────────────
+mkdir -p plugins/pm-rituals/.claude-plugin
+mkdir -p plugins/pm-rituals/skills/pm-weekly-review
+
+cp skills/pm-weekly-review/SKILL.md  plugins/pm-rituals/skills/pm-weekly-review/SKILL.md
+
+echo "✓ pm-rituals done (1 skill)"
+
+# ─────────────────────────────────────────
+# SUMMARY
+# ─────────────────────────────────────────
+echo ""
+echo "=== All done! 33 skills across 8 plugin bundles ==="
+echo ""
+echo "Next steps:"
+echo "  1. Copy marketplace.json   → .claude-plugin/marketplace.json"
+echo "  2. Copy plugin.json        → plugins/<bundle>/.claude-plugin/plugin.json  (for each bundle)"
+echo "  3. git add . && git commit -m 'add marketplace plugin structure' && git push"
+echo "  4. Test in Claude Code:"
+echo "     /plugin marketplace add mohitagw15856/pm-claude-skills"
+echo "     /plugin install pm-essentials@pm-claude-skills"