leedab 0.5.3 → 0.6.1

package/context/skills/sales-skills.md

@@ -0,0 +1,827 @@
+# Sales Agent Skills
+
+> Sourced from alirezarezvani/claude-skills (MIT License)
+
+---
+
+---
+name: "sales-engineer"
+description: Analyzes RFP/RFI responses for coverage gaps, builds competitive feature comparison matrices, and plans proof-of-concept (POC) engagements for pre-sales engineering. Use when responding to RFPs, bids, or proposal requests; comparing product features against competitors; planning or scoring a customer POC or sales demo; preparing a technical proposal; or performing win/loss competitor analysis. Handles tasks described as 'RFP response', 'bid response', 'proposal response', 'competitor comparison', 'feature matrix', 'POC planning', 'sales demo prep', or 'pre-sales engineering'.
+---
+
+# Sales Engineer Skill
+
+## 5-Phase Workflow
+
+### Phase 1: Discovery & Research
+
+**Objective:** Understand customer requirements, technical environment, and business drivers.
+
+**Checklist:**
+- [ ] Conduct technical discovery calls with stakeholders
+- [ ] Map customer's current architecture and pain points
+- [ ] Identify integration requirements and constraints
+- [ ] Document security and compliance requirements
+- [ ] Assess competitive landscape for this opportunity
+
+**Tools:** Run `rfp_response_analyzer.py` to score initial requirement alignment.
+
+```bash
+python scripts/rfp_response_analyzer.py assets/sample_rfp_data.json --format json > phase1_rfp_results.json
+```
+
+**Output:** Technical discovery document, requirement map, initial coverage assessment.
+
+**Validation checkpoint:** Coverage score must be >50% and must-have gaps ≤3 before proceeding to Phase 2. Check with:
+```bash
+python scripts/rfp_response_analyzer.py assets/sample_rfp_data.json --format json | python -c "import sys,json; r=json.load(sys.stdin); print('PROCEED' if r['coverage_score']>50 and r['must_have_gaps']<=3 else 'REVIEW')"
+```
+
+---
+
+### Phase 2: Solution Design
+
+**Objective:** Design a solution architecture that addresses customer requirements.
+
+**Checklist:**
+- [ ] Map product capabilities to customer requirements
+- [ ] Design integration architecture
+- [ ] Identify customization needs and development effort
+- [ ] Build competitive differentiation strategy
+- [ ] Create solution architecture diagrams
+
+**Tools:** Run `competitive_matrix_builder.py` using Phase 1 data to identify differentiators and vulnerabilities.
+
+```bash
+python scripts/competitive_matrix_builder.py competitive_data.json --format json > phase2_competitive.json
+
+python -c "import json; d=json.load(open('phase2_competitive.json')); print('Differentiators:', d['differentiators']); print('Vulnerabilities:', d['vulnerabilities'])"
+```
+
+**Output:** Solution architecture, competitive positioning, technical differentiation strategy.
+
+**Validation checkpoint:** Confirm at least one strong differentiator exists per customer priority before proceeding to Phase 3. If no differentiators found, escalate to Product Team (see Integration Points).
+
+---
+
+### Phase 3: Demo Preparation & Delivery
+
+**Objective:** Deliver compelling technical demonstrations tailored to stakeholder priorities.
+
+**Checklist:**
+- [ ] Build demo environment matching customer's use case
+- [ ] Create demo script with talking points per stakeholder role
+- [ ] Prepare objection handling responses
+- [ ] Rehearse failure scenarios and recovery paths
+- [ ] Collect feedback and adjust approach
+
+**Templates:** Use `assets/demo_script_template.md` for structured demo preparation.
+
+**Output:** Customized demo, stakeholder-specific talking points, feedback capture.
+
+**Validation checkpoint:** Demo script must cover every must-have requirement flagged in `phase1_rfp_results.json` before delivery. Cross-reference with:
+```bash
+python -c "import json; rfp=json.load(open('phase1_rfp_results.json')); [print('UNCOVERED:', r) for r in rfp['must_have_requirements'] if r['coverage']=='Gap']"
+```
+
+---
+
+### Phase 4: POC & Evaluation
+
+**Objective:** Execute a structured proof-of-concept that validates the solution.
+
+**Checklist:**
+- [ ] Define POC scope, success criteria, and timeline
+- [ ] Allocate resources and set up environment
+- [ ] Execute phased testing (core, advanced, edge cases)
+- [ ] Track progress against success criteria
+- [ ] Generate evaluation scorecard
+
+**Tools:** Run `poc_planner.py` to generate the complete POC plan.
+
+```bash
+python scripts/poc_planner.py poc_data.json --format json > phase4_poc_plan.json
+
+python -c "import json; p=json.load(open('phase4_poc_plan.json')); print('Go/No-Go:', p['recommendation'])"
+```
+
+**Templates:** Use `assets/poc_scorecard_template.md` for evaluation tracking.
+
+**Output:** POC plan, evaluation scorecard, go/no-go recommendation.
+
+**Validation checkpoint:** POC conversion requires scorecard score >60% across all evaluation dimensions (functionality, performance, integration, usability, support). If score <60%, document gaps and loop back to Phase 2 for solution redesign.
+
+---
+
+### Phase 5: Proposal & Closing
+
+**Objective:** Deliver a technical proposal that supports the commercial close.
+
+**Checklist:**
+- [ ] Compile POC results and success metrics
+- [ ] Create technical proposal with implementation plan
+- [ ] Address outstanding objections with evidence
+- [ ] Support pricing and packaging discussions
+- [ ] Conduct win/loss analysis post-decision
+
+**Templates:** Use `assets/technical_proposal_template.md` for the proposal document.
+
+**Output:** Technical proposal, implementation timeline, risk mitigation plan.
+
+---
+
+## Python Automation Tools
+
+### 1. RFP Response Analyzer
+
+**Script:** `scripts/rfp_response_analyzer.py`
+
+**Purpose:** Parse RFP/RFI requirements, score coverage, identify gaps, and generate bid/no-bid recommendations.
+
+**Coverage Categories:** Full (100%), Partial (50%), Planned (25%), Gap (0%).  
+**Priority Weighting:** Must-Have 3×, Should-Have 2×, Nice-to-Have 1×.
+
+**Bid/No-Bid Logic:**
+- **Bid:** Coverage >70% AND must-have gaps ≤3
+- **Conditional Bid:** Coverage 50–70% OR must-have gaps 2–3
+- **No-Bid:** Coverage <50% OR must-have gaps >3
+
+**Usage:**
+```bash
+python scripts/rfp_response_analyzer.py assets/sample_rfp_data.json            # human-readable
+python scripts/rfp_response_analyzer.py assets/sample_rfp_data.json --format json  # JSON output
+python scripts/rfp_response_analyzer.py --help
+```
+
+**Input Format:** See `assets/sample_rfp_data.json` for the complete schema.
+
+---
+
+### 2. Competitive Matrix Builder
+
+**Script:** `scripts/competitive_matrix_builder.py`
+
+**Purpose:** Generate feature comparison matrices, calculate competitive scores, identify differentiators and vulnerabilities.
+
+**Feature Scoring:** Full (3), Partial (2), Limited (1), None (0).
+
+**Usage:**
+```bash
+python scripts/competitive_matrix_builder.py competitive_data.json              # human-readable
+python scripts/competitive_matrix_builder.py competitive_data.json --format json  # JSON output
+```
+
+**Output Includes:** Feature comparison matrix, weighted competitive scores, differentiators, vulnerabilities, and win themes.
+
+---
+
+### 3. POC Planner
+
+**Script:** `scripts/poc_planner.py`
+
+**Purpose:** Generate structured POC plans with timeline, resource allocation, success criteria, and evaluation scorecards.
+
+**Default Phase Breakdown:**
+- **Week 1:** Setup — environment provisioning, data migration, configuration
+- **Weeks 2–3:** Core Testing — primary use cases, integration testing
+- **Week 4:** Advanced Testing — edge cases, performance, security
+- **Week 5:** Evaluation — scorecard completion, stakeholder review, go/no-go
+
+**Usage:**
+```bash
+python scripts/poc_planner.py poc_data.json              # human-readable
+python scripts/poc_planner.py poc_data.json --format json  # JSON output
+```
+
+**Output Includes:** Phased POC plan, resource allocation, success criteria, evaluation scorecard, risk register, and go/no-go recommendation framework.
+
+---
+
+## Reference Knowledge Bases
+
+| Reference | Description |
+|-----------|-------------|
+| `references/rfp-response-guide.md` | RFP/RFI response best practices, compliance matrix, bid/no-bid framework |
+| `references/competitive-positioning-framework.md` | Competitive analysis methodology, battlecard creation, objection handling |
+| `references/poc-best-practices.md` | POC planning methodology, success criteria, evaluation frameworks |
+
+## Asset Templates
+
+| Template | Purpose |
+|----------|---------|
+| `assets/technical_proposal_template.md` | Technical proposal with executive summary, solution architecture, implementation plan |
+| `assets/demo_script_template.md` | Demo script with agenda, talking points, objection handling |
+| `assets/poc_scorecard_template.md` | POC evaluation scorecard with weighted scoring |
+| `assets/sample_rfp_data.json` | Sample RFP data for testing the analyzer |
+| `assets/expected_output.json` | Expected output from rfp_response_analyzer.py |
+
+## Integration Points
+
+- **Marketing Skills** - Leverage competitive intelligence and messaging frameworks from `../../marketing-skill/`
+- **Product Team** - Coordinate on roadmap items flagged as "Planned" in RFP analysis from `../../product-team/`
+- **C-Level Advisory** - Escalate strategic deals requiring executive engagement from `../../c-level-advisor/`
+- **Customer Success** - Hand off POC results and success criteria to CSM from `../customer-success-manager/`
+
+---
+
+**Last Updated:** February 2026
+**Status:** Production-ready
+**Tools:** 3 Python automation scripts
+**References:** 3 knowledge base documents
+**Templates:** 5 asset files
+
+---
+
+---
+name: "cold-email"
+description: "When the user wants to write, improve, or build a sequence of B2B cold outreach emails to prospects who haven't asked to hear from them. Use when the user mentions 'cold email,' 'cold outreach,' 'prospecting emails,' 'SDR emails,' 'sales emails,' 'first touch email,' 'follow-up sequence,' or 'email prospecting.' Also use when they share an email draft that sounds too sales-y and needs to be humanized. Distinct from email-sequence (lifecycle/nurture to opted-in subscribers) — this is unsolicited outreach to new prospects. NOT for lifecycle emails, newsletters, or drip campaigns (use email-sequence)."
+license: MIT
+metadata:
+  version: 1.0.0
+  author: Alireza Rezvani
+  category: marketing
+  updated: 2026-03-06
+---
+
+# Cold Email Outreach
+
+You are an expert in B2B cold email outreach. Your goal is to help write, build, and iterate on cold email sequences that sound like they came from a thoughtful human — not a sales machine — and actually get replies.
+
+## Before Starting
+
+**Check for context first:**
+If `marketing-context.md` exists, read it before asking questions.
+
+Gather this context:
+
+### 1. The Sender
+- Who are they at this company? (Role, seniority — affects how they write)
+- What do they sell and who buys it?
+- Do they have any real customer results or proof points they can reference?
+- Are they sending as an individual or as a company?
+
+### 2. The Prospect
+- Who is the target? (Job title, company type, company size)
+- What problem does this person likely have that the sender can solve?
+- Is there a specific trigger or reason to reach out now? (funding, hiring, news, tech stack signal)
+- Do they have specific names and companies to personalize to, or is this a template for a segment?
+
+### 3. The Ask
+- What's the goal of the first email? (Book a call? Get a reply? Get a referral?)
+- How aggressive is the timeline? (SDR with daily send volume vs founder doing targeted outreach)
+
+---
+
+## How This Skill Works
+
+### Mode 1: Write the First Email
+When they need a single first-touch email or a template for a segment.
+
+1. Understand the ICP, the problem, and the trigger
+2. Choose the right framework (see `references/frameworks.md`)
+3. Draft first email: subject line, opener, body, CTA
+4. Review against the principles below — cut anything that doesn't earn its place
+5. Deliver: email copy + 2-3 subject line variants + brief rationale
+
+### Mode 2: Build a Follow-Up Sequence
+When they need a multi-email sequence (typically 4-6 emails).
+
+1. Start with the first email (Mode 1)
+2. Plan follow-up angles — each email needs a different angle, not just a nudge
+3. Set the gap cadence (Day 1, Day 4, Day 9, Day 16, Day 25)
+4. Write each follow-up with a standalone hook that doesn't require reading previous emails
+5. End with a breakup email that closes the loop professionally
+6. Deliver: full sequence with send gaps, subject lines, and brief on what each email does
+
+### Mode 3: Iterate from Performance Data
+When they have an active sequence and want to improve it.
+
+1. Review their current sequence emails and performance (open rate, reply rate)
+2. Diagnose: is the problem subject lines (low open rate), email body (opens but no replies), or CTA (replies but wrong outcome)?
+3. Rewrite the underperforming element
+4. Deliver: revised emails + diagnosis + test recommendation
+
+---
+
+## Core Writing Principles
+
+### 1. Write Like a Peer, Not a Vendor
+
+The moment your email sounds like marketing copy, it's over. Think about how you'd actually email a smart colleague at another company who you want to have a conversation with.
+
+**The test:** Would a friend send this to another friend in business? If the answer is no — rewrite it.
+
+- ❌ "I'm reaching out because our platform helps companies like yours achieve unprecedented growth..."
+- ✅ "Noticed you're scaling your SDR team — timing question: are you doing outbound email in-house or using an agency?"
+
+### 2. Every Sentence Earns Its Place
+
+Cold email is the wrong place to be thorough. Every sentence should do one of these jobs: create curiosity, establish relevance, build credibility, or drive to the ask. If a sentence doesn't do one of those — cut it.
+
+Read your draft aloud. The moment you hear yourself droning, stop and cut.
+
+### 3. Personalization Must Connect to the Problem
+
+Generic personalization is worse than none. "I saw you went to MIT" followed by a pitch has nothing to do with MIT. That's fake personalization.
+
+Real personalization: "I saw you're hiring three SDRs — usually a signal that you're trying to scale cold outreach. That's exactly the challenge we help with."
+
+The personalization must connect to the reason you're reaching out.
+
+### 4. Lead With Their World, Not Yours
+
+The opener should be about them — their situation, their problem, their context. Not about you or your product.
+
+- ❌ "We're a sales intelligence platform that..."
+- ✅ "Your recent TechCrunch piece mentioned you're entering the SMB market — that transition is notoriously hard to do with an enterprise-built playbook."
+
+### 5. One Ask Per Email
+
+Don't ask them to book a call, watch a demo, read a case study, AND reply with their timeline. Pick one ask. The more you ask for, the less likely any of it happens.
+
+---
+
+## Voice Calibration by Audience
+
+Adjust tone, length, and specificity based on who you're writing to:
+
+| Audience | Length | Tone | Subject Line Style | What Works |
+|----------|--------|------|-------------------|------------|
+| C-suite (CEO, CRO, CMO) | 3-4 sentences | Ultra-brief, peer-level, strategic | Short, vague, internal-looking | Big problem → relevant proof → one question |
+| VP / Director | 5-7 sentences | Direct, metrics-conscious | Slightly more specific | Specific observation + clear business angle |
+| Mid-level (Manager, Analyst) | 7-10 sentences | Practical, shows you did homework | Can be more descriptive | Specific problem + practical value + easy CTA |
+| Technical (Engineer, Architect) | 7-10 sentences | Precise, no fluff | Technical specificity | Exact problem → precise solution → low-friction ask |
+
+The higher up the org chart, the shorter your email needs to be. A CEO gets 100+ emails per day. Three sentences and a clear question is a gift, not a slight.
+
+---
+
+## Subject Lines: The Anti-Marketing Approach
+
+The goal of a subject line is to get the email opened — not to convey value, not to be clever, not to impress anyone. Just open it.
+
+The best cold email subject lines look like internal emails. They're short, slightly vague, and create just enough curiosity to click.
+
+### What Works
+
+| Pattern | Example | Why It Works |
+|---------|---------|-------------|
+| Two or three words | `quick question` | Looks like an actual email from a colleague |
+| Specific trigger + question | `your TechCrunch piece` | Specific enough to not look like spam |
+| Shared context | `re: Series B` | Feels like a follow-up, not cold |
+| Observation | `your ATS setup` | Specific, relevant, not salesy |
+| Referral hook | `[mutual name] suggested I reach out` | Social proof front-loaded |
+
+### What Kills Opens
+
+- ALL CAPS anything
+- Emojis in subject lines (polarizing, often spam-filtered)
+- Fake Re: or Fwd: (people have learned this trick — it damages trust)
+- Asking a question in the subject line (e.g., "Are you struggling with X?") — sounds like an ad
+- Mentioning your company name ("Acme Corp: helping you achieve...")
+- Numbers that feel like blog headlines ("5 ways to improve your...")
+
+---
+
+## Follow-Up Strategy
+
+Most deals happen in follow-ups. Most follow-ups are useless. The difference is whether the follow-up adds value or just creates noise.
+
+### Cadence
+
+| Email | Send Day | Gap |
+|-------|----------|-----|
+| Email 1 | Day 1 | — |
+| Email 2 | Day 4 | +3 days |
+| Email 3 | Day 9 | +5 days |
+| Email 4 | Day 16 | +7 days |
+| Email 5 | Day 25 | +9 days |
+| Breakup | Day 35 | +10 days |
+
+Gaps increase over time. You're persistent but not annoying.
+
+### Follow-Up Rules
+
+**Each follow-up must have a new angle.** Rotate through:
+- New piece of evidence (case study, data point, recent result)
+- New angle on the problem (a different pain point in their world)
+- Related insight (something you noticed about their industry, tech stack, or news)
+- Direct question (just ask plainly — sometimes clarity cuts through)
+- Reverse ask (ask for referral to the right person if you can't reach them)
+
+**Never "just check in."** "Just following up to see if you had a chance to read my last email" is a waste of both your time and theirs. If you have nothing new to add, don't send the email.
+
+**Don't reference all previous emails.** Each follow-up should stand alone. The prospect doesn't remember your earlier emails. Don't make them scroll.
+
+### The Breakup Email
+
+The last email in a sequence should close the loop professionally. It signals this is the last one — which paradoxically increases reply rate because people don't like loose ends.
+
+Example breakup:
+> "I'll stop cluttering your inbox after this one. If [problem] ever becomes a priority, happy to reconnect — just reply here and I'll pick it up.
+>
+> If there's someone else at [Company] I should speak with, a name would go a long way.
+>
+> Either way — good luck with [whatever's relevant]."
+
+See `references/follow-up-playbook.md` for full cadence templates and angle rotation guide.
+
+---
+
+## What to Avoid
+
+These are not suggestions — they're patterns that mark you as a non-human and kill reply rates:
+
+| ❌ Avoid | Why It Fails |
+|----------|-------------|
+| "I hope this email finds you well" | Instant tell that this is templated. Cut it. |
+| "I wanted to reach out because..." | 3-word delay before actually saying anything |
+| Feature dump in email 1 | Nobody cares about features when they don't trust you yet |
+| HTML templates with logos and colors | Looks like marketing, gets spam-filtered |
+| Fake Re:/Fwd: subject lines | Feels deceptive — kills trust before the first word |
+| "Just checking in" follow-ups | Adds no value, removes credibility |
+| Opening with "My name is X and I work at Y" | They can see your name. Start with something interesting. |
+| Social proof that doesn't connect to their problem | "We work with 500 companies" means nothing without context |
+| Long-form case study in email 1 | Save it for follow-up when they've shown interest |
+| Passive CTAs ("Let me know if you're interested") | Weak. Ask a direct question or propose a specific next step. |
+
+---
+
+## Deliverability Basics
+
+A great email sent from a flagged domain never lands. Basics you need to have in place:
+
+- **Dedicated sending domain** — don't send cold email from your primary domain. Use `mail.yourdomain.com` or `outreach.yourdomain.com`.
+- **SPF, DKIM, DMARC** — all three must be configured and passing. Use mail-tester.com to verify.
+- **Domain warmup** — new domains need 4-6 weeks of warmup (start with 20/day, ramp up over time).
+- **Plain text emails** — or minimal HTML. Heavy HTML triggers spam filters.
+- **Unsubscribe mechanism** — required legally (CAN-SPAM, GDPR). Include a simple opt-out.
+- **Sending limits** — stay under 100-200 emails/day per domain until established reputation.
+- **Bounce rate** — above 5% hurts deliverability. Verify email lists before sending.
+
+See `references/deliverability-guide.md` for domain warmup schedule, SPF/DKIM setup, and spam trigger word list.
+
+---
+
+## Proactive Triggers
+
+Surface these without being asked:
+
+- **Email opens with "My name is" or "I'm reaching out because"** → rewrite the opener. These are dead-on-arrival openers. Flag and offer an alternative that leads with their world.
+- **First email is longer than 150 words** → almost certainly too long. Flag word count and offer to trim.
+- **No personalization beyond first name** → templated feel will hurt reply rates. Ask if there's a trigger or signal they can work with.
+- **Follow-up says "just checking in" or "circling back"** → useless follow-up. Ask what new angle or value they can bring to that touchpoint.
+- **HTML email template** → recommend plain text. Plain text emails have higher deliverability and look less like marketing blasts.
+- **CTA asks for 30-45 minute meeting in email 1** → too high-friction for cold outreach. Recommend a lower-commitment ask (a 15-minute call, or just a question to gauge interest first).
+
+---
+
+## Output Artifacts
+
+| When you ask for... | You get... |
+|---------------------|------------|
+| Write a cold email | First-touch email + 3 subject line variants + brief rationale for structure choices |
+| Build a sequence | 5-6 email sequence with send gaps, subject lines per email, and angle summary for each follow-up |
+| Critique my email | Line-by-line assessment + rewrite + explanation of each change |
+| Write follow-ups only | Follow-up emails 2-6 with unique angles per email + breakup email |
+| Analyze sequence performance | Diagnosis of where the sequence breaks (subject/body/CTA) + specific rewrite recommendations |
+
+---
+
+## Communication
+
+All output follows the structured communication standard:
+- **Bottom line first** — answer before explanation
+- **What + Why + How** — every finding has all three
+- **Actions have owners and deadlines** — no "we should consider"
+- **Confidence tagging** — 🟢 verified / 🟡 medium / 🔴 assumed
+
+---
+
+## Related Skills
+
+- **email-sequence**: For lifecycle and nurture emails to opted-in subscribers. Use email-sequence for onboarding flows, re-engagement campaigns, and automated drips. NOT for cold outreach — that's cold-email.
+- **copywriting**: For marketing page copy. Principles overlap, but cold email has different constraints — shorter, no CTAs like buttons, must feel personal.
+- **content-strategy**: For creating the content assets (case studies, guides) you reference in cold email follow-ups. Good follow-up sequences often link to content.
+- **marketing-strategy-pmm**: For positioning and ICP definition. If you don't know who you're targeting and why, cold email is the wrong tool to figure that out.
+
+---
+
+---
+name: "revenue-operations"
+description: Analyzes sales pipeline health, revenue forecasting accuracy, and go-to-market efficiency metrics for SaaS revenue optimization. Use when analyzing sales pipeline coverage, forecasting revenue, evaluating go-to-market performance, reviewing sales metrics, assessing pipeline analysis, tracking forecast accuracy with MAPE, calculating GTM efficiency, or measuring sales efficiency and unit economics for SaaS teams.
+---
+
+# Revenue Operations
+
+Pipeline analysis, forecast accuracy tracking, and GTM efficiency measurement for SaaS revenue teams.
+
+> **Output formats:** All scripts support `--format text` (human-readable) and `--format json` (dashboards/integrations).
+
+---
+
+## Quick Start
+
+```bash
+# Analyze pipeline health and coverage
+python scripts/pipeline_analyzer.py --input assets/sample_pipeline_data.json --format text
+
+# Track forecast accuracy over multiple periods
+python scripts/forecast_accuracy_tracker.py assets/sample_forecast_data.json --format text
+
+# Calculate GTM efficiency metrics
+python scripts/gtm_efficiency_calculator.py assets/sample_gtm_data.json --format text
+```
+
+---
+
+## Tools Overview
+
+### 1. Pipeline Analyzer
+
+Analyzes sales pipeline health including coverage ratios, stage conversion rates, deal velocity, aging risks, and concentration risks.
+
+**Input:** JSON file with deals, quota, and stage configuration
+**Output:** Coverage ratios, conversion rates, velocity metrics, aging flags, risk assessment
+
+**Usage:**
+
+```bash
+python scripts/pipeline_analyzer.py --input pipeline.json --format text
+```
+
+**Key Metrics Calculated:**
+- **Pipeline Coverage Ratio** -- Total pipeline value / quota target (healthy: 3-4x)
+- **Stage Conversion Rates** -- Stage-to-stage progression rates
+- **Sales Velocity** -- (Opportunities x Avg Deal Size x Win Rate) / Avg Sales Cycle
+- **Deal Aging** -- Flags deals exceeding 2x average cycle time per stage
+- **Concentration Risk** -- Warns when >40% of pipeline is in a single deal
+- **Coverage Gap Analysis** -- Identifies quarters with insufficient pipeline
+
+**Input Schema:**
+
+```json
+{
+  "quota": 500000,
+  "stages": ["Discovery", "Qualification", "Proposal", "Negotiation", "Closed Won"],
+  "average_cycle_days": 45,
+  "deals": [
+    {
+      "id": "D001",
+      "name": "Acme Corp",
+      "stage": "Proposal",
+      "value": 85000,
+      "age_days": 32,
+      "close_date": "2025-03-15",
+      "owner": "rep_1"
+    }
+  ]
+}
+```
+
+### 2. Forecast Accuracy Tracker
+
+Tracks forecast accuracy over time using MAPE, detects systematic bias, analyzes trends, and provides category-level breakdowns.
+
+**Input:** JSON file with forecast periods and optional category breakdowns
+**Output:** MAPE score, bias analysis, trends, category breakdown, accuracy rating
+
+**Usage:**
+
+```bash
+python scripts/forecast_accuracy_tracker.py forecast_data.json --format text
+```
+
+**Key Metrics Calculated:**
+- **MAPE** -- mean(|actual - forecast| / |actual|) x 100
+- **Forecast Bias** -- Over-forecasting (positive) vs under-forecasting (negative) tendency
+- **Weighted Accuracy** -- MAPE weighted by deal value for materiality
+- **Period Trends** -- Improving, stable, or declining accuracy over time
+- **Category Breakdown** -- Accuracy by rep, product, segment, or any custom dimension
+
+**Accuracy Ratings:**
+| Rating | MAPE Range | Interpretation |
+|--------|-----------|----------------|
+| Excellent | <10% | Highly predictable, data-driven process |
+| Good | 10-15% | Reliable forecasting with minor variance |
+| Fair | 15-25% | Needs process improvement |
+| Poor | >25% | Significant forecasting methodology gaps |
+
+**Input Schema:**
+
+```json
+{
+  "forecast_periods": [
+    {"period": "2025-Q1", "forecast": 480000, "actual": 520000},
+    {"period": "2025-Q2", "forecast": 550000, "actual": 510000}
+  ],
+  "category_breakdowns": {
+    "by_rep": [
+      {"category": "Rep A", "forecast": 200000, "actual": 210000},
+      {"category": "Rep B", "forecast": 280000, "actual": 310000}
+    ]
+  }
+}
+```
+
+### 3. GTM Efficiency Calculator
+
+Calculates core SaaS GTM efficiency metrics with industry benchmarking, ratings, and improvement recommendations.
+
+**Input:** JSON file with revenue, cost, and customer metrics
+**Output:** Magic Number, LTV:CAC, CAC Payback, Burn Multiple, Rule of 40, NDR with ratings
+
+**Usage:**
+
+```bash
+python scripts/gtm_efficiency_calculator.py gtm_data.json --format text
+```
+
+**Key Metrics Calculated:**
+
+| Metric | Formula | Target |
+|--------|---------|--------|
+| Magic Number | Net New ARR / Prior Period S&M Spend | >0.75 |
+| LTV:CAC | (ARPA x Gross Margin / Churn Rate) / CAC | >3:1 |
+| CAC Payback | CAC / (ARPA x Gross Margin) months | <18 months |
+| Burn Multiple | Net Burn / Net New ARR | <2x |
+| Rule of 40 | Revenue Growth % + FCF Margin % | >40% |
+| Net Dollar Retention | (Begin ARR + Expansion - Contraction - Churn) / Begin ARR | >110% |
+
+**Input Schema:**
+
+```json
+{
+  "revenue": {
+    "current_arr": 5000000,
+    "prior_arr": 3800000,
+    "net_new_arr": 1200000,
+    "arpa_monthly": 2500,
+    "revenue_growth_pct": 31.6
+  },
+  "costs": {
+    "sales_marketing_spend": 1800000,
+    "cac": 18000,
+    "gross_margin_pct": 78,
+    "total_operating_expense": 6500000,
+    "net_burn": 1500000,
+    "fcf_margin_pct": 8.4
+  },
+  "customers": {
+    "beginning_arr": 3800000,
+    "expansion_arr": 600000,
+    "contraction_arr": 100000,
+    "churned_arr": 300000,
+    "annual_churn_rate_pct": 8
+  }
+}
+```
+
+---
+
+## Revenue Operations Workflows
+
+### Weekly Pipeline Review
+
+Use this workflow for your weekly pipeline inspection cadence.
+
+1. **Verify input data:** Confirm pipeline export is current and all required fields (stage, value, close_date, owner) are populated before proceeding.
+
+2. **Generate pipeline report:**
+   ```bash
+   python scripts/pipeline_analyzer.py --input current_pipeline.json --format text
+   ```
+
+3. **Cross-check output totals** against your CRM source system to confirm data integrity.
+
+4. **Review key indicators:**
+   - Pipeline coverage ratio (is it above 3x quota?)
+   - Deals aging beyond threshold (which deals need intervention?)
+   - Concentration risk (are we over-reliant on a few large deals?)
+   - Stage distribution (is there a healthy funnel shape?)
+
+5. **Document using template:** Use `assets/pipeline_review_template.md`
+
+6. **Action items:** Address aging deals, redistribute pipeline concentration, fill coverage gaps
+
+### Forecast Accuracy Review
+
+Use monthly or quarterly to evaluate and improve forecasting discipline.
+
+1. **Verify input data:** Confirm all forecast periods have corresponding actuals and no periods are missing before running.
+
+2. **Generate accuracy report:**
+   ```bash
+   python scripts/forecast_accuracy_tracker.py forecast_history.json --format text
+   ```
+
+3. **Cross-check actuals** against closed-won records in your CRM before drawing conclusions.
+
+4. **Analyze patterns:**
+   - Is MAPE trending down (improving)?
+   - Which reps or segments have the highest error rates?
+   - Is there systematic over- or under-forecasting?
+
+5. **Document using template:** Use `assets/forecast_report_template.md`
+
+6. **Improvement actions:** Coach high-bias reps, adjust methodology, improve data hygiene
+
+### GTM Efficiency Audit
+
+Use quarterly or during board prep to evaluate go-to-market efficiency.
+
+1. **Verify input data:** Confirm revenue, cost, and customer figures reconcile with finance records before running.
+
+2. **Calculate efficiency metrics:**
+   ```bash
+   python scripts/gtm_efficiency_calculator.py quarterly_data.json --format text
+   ```
+
+3. **Cross-check computed ARR and spend totals** against your finance system before sharing results.
+
+4. **Benchmark against targets:**
+   - Magic Number (>0.75)
+   - LTV:CAC (>3:1)
+   - CAC Payback (<18 months)
+   - Rule of 40 (>40%)
+
+5. **Document using template:** Use `assets/gtm_dashboard_template.md`
+
+6. **Strategic decisions:** Adjust spend allocation, optimize channels, improve retention
+
+### Quarterly Business Review
+
+Combine all three tools for a comprehensive QBR analysis.
+
+1. Run pipeline analyzer for forward-looking coverage
+2. Run forecast tracker for backward-looking accuracy
+3. Run GTM calculator for efficiency benchmarks
+4. Cross-reference pipeline health with forecast accuracy
+5. Align GTM efficiency metrics with growth targets
+
+---
+
+## Reference Documentation
+
+| Reference | Description |
+|-----------|-------------|
+| [RevOps Metrics Guide](references/revops-metrics-guide.md) | Complete metrics hierarchy, definitions, formulas, and interpretation |
+| [Pipeline Management Framework](references/pipeline-management-framework.md) | Pipeline best practices, stage definitions, conversion benchmarks |
+| [GTM Efficiency Benchmarks](references/gtm-efficiency-benchmarks.md) | SaaS benchmarks by stage, industry standards, improvement strategies |
+
+---
+
+## Templates
+
+| Template | Use Case |
+|----------|----------|
+| [Pipeline Review Template](assets/pipeline_review_template.md) | Weekly/monthly pipeline inspection documentation |
+| [Forecast Report Template](assets/forecast_report_template.md) | Forecast accuracy reporting and trend analysis |
+| [GTM Dashboard Template](assets/gtm_dashboard_template.md) | GTM efficiency dashboard for leadership review |
+| [Sample Pipeline Data](assets/sample_pipeline_data.json) | Example input for pipeline_analyzer.py |
+| [Expected Output](assets/expected_output.json) | Reference output from pipeline_analyzer.py |
+
+---
+
+---
+name: cold-email
+description: Write B2B cold emails and follow-up sequences that get replies. Use for cold outreach emails, prospecting emails, cold email campaigns, sales development emails, or SDR emails.
+metadata:
+  version: 1.1.0
+---
+
+# Cold Email Writing (Sales)
+
+You are an expert cold email writer for B2B sales outreach. Write emails that sound like they came from a thoughtful human — not a sales machine.
+
+## Core Principles
+- **Write like a peer, not a vendor** — conversational, no buzzwords
+- **Every sentence earns its place** — if it doesn't move toward a reply, cut it
+- **Lead with their world, not yours** — "you/your" dominates over "I/we"
+- **One ask, low friction** — "Worth exploring?" beats "Can we schedule 30 minutes?"
+
+## Email Shapes That Work
+
+- **Observation → Problem → Proof → Ask**
+- **Trigger → Insight → Ask** (great for hiring signals, funding, etc.)
+- **Question → Value → Ask**
+
+## Subject Lines
+2-4 words, lowercase, internal-looking. Looks like an email from a colleague, not a vendor.
+
+## Follow-Up Sequence (5-6 emails)
+Each email adds a new angle — never "just checking in":
+- Email 1: First touch
+- Email 2 (+3 days): New proof point or angle
+- Email 3 (+5 days): Useful resource or insight
+- Email 4 (+7 days): Direct question
+- Email 5 (+9 days): Reverse ask (right person to speak with?)
+- Email 6 (+10 days): Breakup — professional close
+
+## What to Avoid
+- "I hope this email finds you well"
+- "My name is X and I work at Y"  
+- Jargon: "synergy," "leverage," "best-in-class"
+- HTML templates with logos
+- Fake Re: or Fwd: subject lines
+- Asking for 30-minute calls in first touch