@anysiteio/agent-skills 1.4.0 → 2.0.1

package/skills/anysite-competitor-intelligence/references/ANALYSIS_PATTERNS.md

@@ -9,23 +9,25 @@ Frameworks and templates for analyzing competitors using anysite MCP data.
 **Strengths**:
 ```
 LinkedIn:
-- get_linkedin_company → Company size, growth
-- get_linkedin_company_posts → Messaging, brand strength
-- search_linkedin_users → Leadership quality
+- execute("linkedin", "company", "company", {"company": "..."}) → Company size, growth
+- execute("linkedin", "company", "company_posts", {"urn": ..., "count": 20}) → Messaging, brand strength
+- execute("linkedin", "search", "search_users", {"company_keywords": "...", "title": "...", "count": 50}) → Leadership quality
 
 Y Combinator:
-- get_yc_company → Funding, pedigree
+- execute("yc", "company", "get", {"slug": "..."}) → Funding, pedigree
 
 Social:
 - Follower counts, engagement rates
 - Content quality and frequency
+- Use query_cache(cache_key, aggregate=[{"field": "like_count", "function": "avg"}]) for engagement benchmarks
 ```
 
 **Weaknesses**:
 ```
 Reddit:
-- search_reddit_posts(competitor) → Customer complaints
+- execute("reddit", "search", "search_posts", {"query": "competitor", "count": 50}) → Customer complaints
 - Product gaps, feature requests
+- Use query_cache(cache_key, sort_by=[{"field": "comment_count", "order": "desc"}]) to find most-discussed issues
 
 LinkedIn:
 - Employee turnover (departures)
@@ -48,8 +50,8 @@ Market gaps identified through:
 **Threats**:
 ```
 Competitive threats:
-- YC batch analysis (new entrants)
-- Hiring velocity (aggressive growth)
+- YC batch analysis (new entrants): execute("yc", "search", "search_companies", {"query": "...", "count": 50})
+- Hiring velocity (aggressive growth): execute("linkedin", "company", "company_employee_stats", {"urn": ...})
 - New product launches
 - Pricing changes
 ```
@@ -63,16 +65,18 @@ Competitive threats:
 4. Customer Type (Technical vs. Business Users)
 
 **Data Sources**:
-- Website messaging
-- LinkedIn company description
-- Pricing pages
-- Job postings (customer success vs. enterprise support)
+- Website messaging: `execute("webparser", "parse", "parse", {"url": "..."})`
+- LinkedIn company description: `execute("linkedin", "company", "company", {"company": "..."})`
+- Pricing pages: `execute("webparser", "parse", "parse", {"url": "<website>/pricing"})`
+- Job postings: `execute("linkedin", "search", "search_jobs", {"keywords": "...", "count": 50})`
+
+**Export**: Use `export_data(cache_key, "csv")` to build comparison spreadsheets.
 
 ## Porter's Five Forces Analysis
 
 **Threat of New Entrants**:
-- Monitor YC batches for new competitors
-- Track LinkedIn company formations in space
+- Monitor YC batches for new competitors: `execute("yc", "search", "search_companies", {"query": "...", "count": 50})`
+- Track LinkedIn company formations in space: `execute("linkedin", "search", "search_companies", {"keywords": "...", "count": 50})`
 - Watch for well-funded startups
 
 **Competitive Rivalry**:

package/skills/anysite-content-analytics/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: anysite-content-analytics
-description: Track and analyze content performance across Instagram, YouTube, LinkedIn, Twitter/X, and Reddit using anysite MCP server. Measure engagement metrics, analyze post effectiveness, benchmark content strategy, identify top-performing content, and optimize posting strategies. Supports post performance tracking, engagement analysis, content type comparison, and competitive benchmarking. Use when users need to measure content ROI, optimize social strategy, identify viral content patterns, or analyze content engagement across platforms.
+description: Track and analyze content performance across Instagram, YouTube, LinkedIn, Twitter/X, and Reddit using anysite MCP server. Measure engagement metrics, analyze post effectiveness, benchmark content strategy, identify top-performing content, and optimize posting strategies. Use when users need to measure content ROI, optimize social strategy, identify viral content patterns, or analyze content engagement across platforms.
 ---
 
 # anysite Content Analytics
@@ -25,18 +25,39 @@ Measure and optimize content performance across social platforms using anysite M
 - ✅ **Twitter/X**: Tweets, retweets, likes, replies
 - ✅ **Reddit**: Posts, upvotes, comments, awards
 
+## v2 Tool Interface
+
+All data fetching uses the anysite MCP v2 universal meta-tools:
+
+- **`execute(source, category, endpoint, params)`** - Fetch data from any source. Returns first page + `cache_key`.
+- **`get_page(cache_key, offset, limit)`** - Load more items from a previous execute() when `next_offset` is returned.
+- **`query_cache(cache_key, conditions?, sort_by?, aggregate?, group_by?)`** - Filter, sort, and aggregate cached data without new API calls.
+- **`export_data(cache_key, format)`** - Export full dataset as CSV, JSON, or JSONL. Returns a download URL.
+
+### Error Handling
+
+v2 responses may include `llm_hint` fields with guidance on how to resolve errors. Common patterns:
+- **412**: Entity not found - verify the identifier (username, URN, URL).
+- **422**: Invalid parameter format - check URN prefix format or param types.
+- Always check `llm_hint` in error responses for specific resolution steps.
+
 ## Quick Start
 
 **Step 1: Collect Content Data**
 
 Platform-specific:
-- Instagram: `get_instagram_user_posts(username, count=50)`
-- LinkedIn: `get_linkedin_user_posts(urn, count=50)`
-- Twitter: `get_twitter_user_posts(user, count=100)`
-- YouTube: `get_youtube_channel_videos(channel, count=30)`
+- Instagram: `execute("instagram", "user", "user_posts", {"user": "username", "count": 50})`
+- LinkedIn: `execute("linkedin", "user", "user_posts", {"urn": "fsd_profile:ACoAAA...", "count": 50})`
+- Twitter: `execute("twitter", "user", "user_posts", {"user": "username", "count": 100})`
+- YouTube: `execute("youtube", "channel", "channel_videos", {"channel": "channel_id", "count": 30})`
 
 **Step 2: Analyze Engagement**
 
+Use `query_cache()` on the returned `cache_key` to analyze without re-fetching:
+```
+query_cache(cache_key, sort_by="likes desc", aggregate="avg:likes,comments")
+```
+
 Calculate metrics:
 - Engagement rate: (likes + comments + shares) / followers
 - Best performing content: Top 10% by engagement
@@ -59,6 +80,14 @@ Based on findings:
 - Replicate successful topics
 - Adjust content mix
 
+**Step 5: Export Results**
+
+```
+export_data(cache_key, "csv")
+```
+
+Returns a download URL for the full dataset.
+
 ## Common Workflows
 
 ### Workflow 1: Instagram Content Audit
@@ -67,7 +96,13 @@ Based on findings:
 
 1. **Get All Posts**
 ```
-get_instagram_user_posts(username, count=100)
+execute("instagram", "user", "user_posts", {"user": "username", "count": 100})
+→ returns cache_key + first page of results
+```
+
+If more posts exist (response includes `next_offset`):
+```
+get_page(cache_key, offset=next_offset, limit=50)
 ```
 
 2. **Calculate Metrics**
@@ -78,9 +113,15 @@ For each post:
 - Content type (Reel, carousel, single image, video)
 ```
 
+Use `query_cache` to sort and filter:
+```
+query_cache(cache_key, sort_by="likes desc", aggregate="avg:likes,comments")
+```
+
 3. **Identify Top Performers**
 ```
-Sort by engagement rate
+query_cache(cache_key, sort_by="likes desc")
+
 Top 10%: Analyze for common patterns
 - Topics/themes
 - Visual style
@@ -90,7 +131,9 @@ Top 10%: Analyze for common patterns
 
 4. **Analyze Content Mix**
 ```
-Count by type:
+query_cache(cache_key, group_by="type", aggregate="count:id,avg:likes,avg:comments")
+
+Results show:
 - Reels: X% of posts, Y% of engagement
 - Carousels: X% of posts, Y% of engagement
 - Single images: X% of posts, Y% of engagement
@@ -99,7 +142,7 @@ Count by type:
 5. **Benchmark Against Competitors**
 ```
 For each competitor:
-  get_instagram_user_posts(competitor, count=50)
+  execute("instagram", "user", "user_posts", {"user": "competitor", "count": 50})
 Compare:
 - Posting frequency
 - Engagement rates
@@ -107,6 +150,11 @@ Compare:
 - Top themes
 ```
 
+6. **Export Results**
+```
+export_data(cache_key, "csv")
+```
+
 **Expected Output**:
 - Content performance report
 - Top 10 performing posts
@@ -120,9 +168,17 @@ Compare:
 
 1. **Collect Post History**
 ```
-get_linkedin_user_posts(urn, count=100)
+execute("linkedin", "user", "user_posts", {"urn": "fsd_profile:ACoAAA...", "count": 100})
+→ returns cache_key + first page
 ```
 
+For company page posts:
+```
+execute("linkedin", "company", "company_posts", {"urn": {"type": "company", "value": "1441"}, "count": 100})
+```
+
+Use `get_page(cache_key, offset, limit)` if more posts exist.
+
 2. **Categorize Content**
 ```
 Group by type:
@@ -136,6 +192,8 @@ Group by type:
 
 3. **Analyze Engagement by Type**
 ```
+query_cache(cache_key, aggregate="avg:comment_count,avg:share_count", group_by="type")
+
 For each content type:
 - Average reactions
 - Average comments
@@ -173,13 +231,16 @@ Calculate average engagement for each group
 
 1. **Get Channel Videos**
 ```
-get_youtube_channel_videos(channel, count=50)
+execute("youtube", "channel", "channel_videos", {"channel": "channel_id", "count": 50})
+→ returns cache_key + first page
 ```
 
+Use `get_page(cache_key, offset, limit)` for additional videos.
+
 2. **Analyze Each Video**
 ```
 For each video:
-  get_youtube_video(video_id)
+  execute("youtube", "video", "video", {"video": "video_id"})
 
 Metrics:
 - Views
@@ -190,6 +251,8 @@ Metrics:
 
 3. **Identify Patterns**
 ```
+query_cache(cache_key, sort_by="views desc")
+
 Analyze top 20% by views:
 - Video length
 - Titles (keywords, style)
@@ -201,7 +264,7 @@ Analyze top 20% by views:
 4. **Engagement Analysis**
 ```
 Check comments:
-  get_youtube_video_comments(video_id, count=100)
+  execute("youtube", "video", "video_comments", {"video": "video_id", "count": 100})
 
 Analyze:
 - Comment quality
@@ -225,44 +288,49 @@ Compare:
 - Title and thumbnail insights
 - Upload strategy recommendations
 
-## MCP Tools Reference
+## MCP Tools Reference (v2)
 
 ### Instagram
-- `get_instagram_user_posts(user, count)` - Get posts with engagement
-- `get_instagram_post(post_id)` - Get detailed post metrics
-- `get_instagram_post_likes(post, count)` - Analyze likers
-- `get_instagram_post_comments(post, count)` - Get comments
+- `execute("instagram", "user", "user_posts", {"user": username, "count": N})` - Get posts with engagement
+- `execute("instagram", "post", "post", {"post": post_id})` - Get detailed post metrics
+- `execute("instagram", "post", "post_likes", {"post": post_id, "count": N})` - Analyze likers
+- `execute("instagram", "post", "post_comments", {"post": post_id, "count": N})` - Get comments
 
 ### LinkedIn
-- `get_linkedin_user_posts(urn, count)` - Get post history
-- `get_linkedin_company_posts(urn, count)` - Company page posts
+- `execute("linkedin", "user", "user_posts", {"urn": "fsd_profile:ACoAAA...", "count": N})` - Get user post history
+- `execute("linkedin", "company", "company_posts", {"urn": {"type": "company", "value": "ID"}, "count": N})` - Company page posts
 
 ### Twitter/X
-- `get_twitter_user_posts(user, count)` - Get tweets
-- `search_twitter_posts(query, count)` - Find trending tweets
+- `execute("twitter", "user", "user_posts", {"user": username, "count": N})` - Get tweets
+- `execute("twitter", "search", "search_posts", {"query": query, "count": N})` - Find trending tweets
 
 ### YouTube
-- `get_youtube_channel_videos(channel, count)` - All videos
-- `get_youtube_video(video)` - Video details and metrics
-- `get_youtube_video_comments(video, count)` - Comments
+- `execute("youtube", "channel", "channel_videos", {"channel": channel, "count": N})` - All videos
+- `execute("youtube", "video", "video", {"video": video_id})` - Video details and metrics
+- `execute("youtube", "video", "video_comments", {"video": video_id, "count": N})` - Comments
 
 ### Reddit
-- `reddit_user_posts(username, count)` - User's posts
-- `search_reddit_posts(query, count)` - Find popular posts
+- `execute("reddit", "user", "user_posts", {"username": username, "count": N})` - User's posts
+- `execute("reddit", "search", "search_posts", {"query": query, "count": N})` - Find popular posts
+
+### Pagination & Analysis
+- `get_page(cache_key, offset, limit)` - Fetch next page of results from any execute() call
+- `query_cache(cache_key, conditions?, sort_by?, aggregate?, group_by?)` - Filter/sort/aggregate cached results
+- `export_data(cache_key, "csv"|"json"|"jsonl")` - Export dataset as downloadable file
 
 ## Key Metrics
 
 **Engagement Rate**:
-- Formula: (Likes + Comments + Shares) / Followers × 100
+- Formula: (Likes + Comments + Shares) / Followers x 100
 - Instagram benchmark: 3-6%
 - LinkedIn benchmark: 2-5% of connections
 - Twitter benchmark: 0.5-1%
 
 **Content Performance Score**:
 ```
-Score = (Engagement Rate × 40) +
-        (Comments/Likes Ratio × 30) +
-        (Share Rate × 30)
+Score = (Engagement Rate x 40) +
+        (Comments/Likes Ratio x 30) +
+        (Share Rate x 30)
 ```
 
 **Viral Potential Indicators**:
@@ -278,13 +346,13 @@ Score = (Engagement Rate × 40) +
 - Key insights and patterns
 - Recommendations for optimization
 
-**CSV Export**:
+**CSV Export** (via `export_data(cache_key, "csv")`):
 - Post URL, date, type
 - Likes, comments, shares
 - Engagement rate
 - Performance rank
 
-**JSON Export**:
+**JSON Export** (via `export_data(cache_key, "json")`):
 - Full post data with metadata
 - Time-series engagement data
 - Historical trends

package/skills/anysite-crm-account-brief/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: anysite-crm-account-brief
+description: Pre-meeting brief for an account that lives in the connected CRM - what the CRM already knows (fields, contacts, history) merged with fresh outside data (funding, exec changes, news, key people's recent LinkedIn activity) into a one-page brief with talking points. Read-only. Use when the user preps for a call/meeting/demo with a CRM account or asks for account research in the context of their pipeline. Requires an active CRM connection - for briefs on arbitrary companies without CRM context, other research skills apply.
+---
+
+# CRM Account Brief
+
+One account, twenty minutes of research, one page the user can read in the elevator.
+
+## Flow
+
+### 1. CRM context (if connected)
+
+```
+crm_query_records(object_type="companies", search="<name or domain>")
+crm_query_records(object_type="contacts", search="<domain>")   # linked people
+```
+What we already know: fields, mapped scores/signals, who we talk to, what stage. The brief
+must not contradict the CRM — where outside data disagrees (e.g. new title), flag it as
+an update candidate for `anysite-crm-enrich`/`anysite-crm-champions`.
+
+### 2. Company snapshot
+
+- `execute crunchbase/search {keywords: name}` → alias → `crunchbase/company` →
+  funding history, `leadership_hires[]`, `news[]`, `layoffs[]`, employee range, investors.
+- `execute linkedin/search/search_sql_companies {website: domain}` → description,
+  specialities, locations, employee_count.
+
+### 3. What's happening now
+
+- Hiring: `linkedin/search/search_jobs {company: [{"type": "company", "value": "<id>"}],
+  sort: "recent", count: 20}` (numeric id from the `fsd_company:<id>` URN) — what functions
+  they're growing (that's their current priorities, use in talking points).
+- News: crunchbase `news[]` first (already fetched); add
+  `techmeme/stories/stories_search {keyword: "<name>", count: 5}` for tech companies.
+- Employer sentiment (optional, for bigger companies): resolve the employer id first via
+  `glassdoor/companies/companies_search {company: "<name>", count: 1}` → then
+  `companies_ratings {company: <id>}`; `blind/companies/companies_reviews` — morale,
+  attrition themes. Use with care in messaging — background context, never a quoted opener.
+
+### 4. The people in the room
+
+For each known attendee / key CRM contact with linkedin_url:
+```
+execute linkedin/user/user {user: <url>}                       → role, tenure, background
+execute linkedin/user/user_posts {urn, count: 10,
+                                  posted_after: <90 days ago>} → what they talk about
+```
+Caveat: `user` called with a URL may omit the `urn` in its response, and `user_posts`
+accepts ONLY a URN. If the urn is missing, recover it via
+`search_users {first_name, last_name, company_keywords, count: 3}` → pick the match →
+use its urn. Posts are personalization gold: real interests, stated problems, conference
+activity.
+No posts ≠ no signal — check `user_comments` for lurker activity if it matters.
+
+### 5. The brief
+
+One page, this order:
+1. **Snapshot** — what they do, size, stage, funding, trajectory (3 lines).
+2. **What's new** — dated events (funding, hires, launches, layoffs), newest first.
+3. **People** — attendees with one-line "who they are + what they care about".
+4. **Angle** — 3 talking points tied to evidence, 1–2 risks/landmines (layoffs, churned
+   history in CRM, competitor relationship).
+5. **Sources** — links for every claim. No link → don't claim it.
+
+## Writes
+
+None by default. If the user asks to save the brief: a note via the CRM UI is their
+fastest path (note-writing is not exposed through crm_* tools); offer the brief as text
+they can paste, or stamp mapped summary fields via `crm_upsert_companies` (dry-run first)
+only if the profile maps them.

package/skills/anysite-crm-audit/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: anysite-crm-audit
+description: Read-only data quality audit of the connected CRM - field completeness per mapped property, duplicate candidates, stale records, enrichability estimate. Produces a report and a concrete fix plan, never writes anything - run it first when you don't yet know what's broken; the actual fixing happens in anysite-crm-enrich. Use when the user asks "what's the state of my CRM", wants a data quality report, duplicate check, or a safe first run after connecting a CRM. Requires an active CRM connection.
+---
+
+# CRM Audit
+
+The safe first date with a user's CRM: read everything, write nothing, show what's broken
+and what enrichment would fix. Also the natural funnel into `anysite-crm-enrich`.
+
+## Prerequisites
+
+Active CRM connection. No profile needed (works better with one — gap analysis follows the
+mapped fields).
+
+## Flow
+
+### 1. Inventory
+
+```
+crm_get_schema(object_type="contacts") / (object_type="companies")
+```
+Use `properties` filtering when you only need specific fields — the full schema is large.
+Then page through records:
+```
+crm_query_records(object_type=..., properties=[key fields], after=<cursor>)
+```
+Audit scope: whole portal if small; else the working list + a stated sample. Say which.
+
+### 2. Analyze (all local — no further API calls)
+
+- **Completeness:** % filled per mapped/target field (email, title, company, domain,
+  industry, size, linkedin_url). Rank by gap size.
+- **Match-key coverage:** how many contacts have email / linkedin_url / neither (the
+  "neither" group is unenrichable and un-dedupable — flag it).
+- **Duplicate candidates:** same normalized email; same domain with several company records;
+  same person name + company. Candidates only — never auto-merge.
+- **Staleness:** if `anysite_last_enriched_at` (or similar) is mapped — age distribution;
+  contacts with no activity fields; companies with dead domains (spot-check a few via
+  `webparser/parse` only if the user asks).
+- **Association health:** contacts without a company link (visible as missing company
+  fields when queried).
+
+### 3. Report
+
+Lead with the 3 numbers that matter: enrichable-now count, duplicate-candidate count,
+unenrichable count. Then per-field completeness table, then the fix plan:
+
+- "N contacts have linkedin_url but no title → `anysite-crm-enrich` fills them (~cost)"
+- "N companies missing industry/size → enrich via company lookup (~cost)"
+- "N duplicate candidates → list for manual review (merging is a CRM-side operation)"
+
+Cost estimates come from the anysite-mcp source map (credits per call × volume). Offer to
+run the enrichment as the next step — do not run it from this skill.
+
+## Hard rule
+
+This skill performs zero writes: no upserts, no dry-runs, no "small fixes". Its value is
+that it is provably safe to run on day one.

package/skills/anysite-crm-champions/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: anysite-crm-champions
+description: Detect job changes among CRM contacts (champion tracking) - find contacts who moved to a new company, flag past champions at new accounts, update the CRM and propose re-engagement plays. Widely considered the highest-converting B2B signal. Use specifically for job-change detection - "who changed jobs", "track champions", "are my contacts still there". For general field updates on contacts use anysite-crm-enrich instead. Requires an active CRM connection and contacts with linkedin_url or email.
+---
+
+# CRM Champion Tracking
+
+People move; CRMs rot (typically ~25%/year of contacts change jobs). A past champion at a
+new company is warm pipeline. This skill finds the movers and turns them into plays.
+
+## Prerequisites
+
+Active CRM connection. Profile mapping for any writes — the Writing rules in
+`anysite-crm-setup` apply, including its create policy: creating records here follows the
+profile's `allow_create`, same as in `anysite-crm-prospect`. Contacts need `linkedin_url`
+or `email` — run `anysite-crm-enrich` first if coverage is poor.
+
+## Flow
+
+### 1. Pick who to track
+
+Priority order (ask the user which tier, default to the first available):
+1. **Key champions** — closed-won contacts, power users, admins (if such a list/field exists),
+2. **Open/closed-lost opportunity contacts**,
+3. The working list / everyone with a linkedin_url.
+
+```
+crm_query_records(object_type="contacts", list_id=... | search=...,
+                  properties=[record_id, email, linkedin_url, <company field>, jobtitle])
+```
+
+Cap a run at ~100 contacts (one profile call each); more → propose batching by tier.
+
+### 2. Detect moves
+
+Per contact:
+- `linkedin_url` → `execute linkedin/user/user {user: <url>}` → current experience.
+- email only → `execute linkedin/email/email_sql_user {email}` → profile (live `email_user`
+  for the remainder).
+
+Compare the profile's **current company** against the CRM company. Normalize before
+comparing (legal suffixes, casing, known rebrands); when unsure, treat as "same" — false
+move-alarms erode trust. Also catch **promotions** (same company, new title) — a secondary
+but useful signal.
+
+### 3. Classify and propose plays
+
+- **Moved to an in-ICP company** → hottest: "past champion at new account" play. Propose:
+  update old record, create the new-company record and a fresh contact entry.
+- **Moved out of ICP** → update CRM only.
+- **Promoted** → update title; suggest congratulation touch if they're an active deal contact.
+- **Profile gone/private** → report, no change.
+
+### 4. Write back (with explicit user confirmation)
+
+Job-change writes touch the fields most likely to collide with CRM automations, so always
+dry-run and show the diff, even for small batches:
+
+- Update the old contact: new title/company per profile mapping (these need `overwrite` in
+  the profile — job data is volatile by design).
+- New account: `crm_upsert_companies` (match by domain, `allow_create` per profile).
+- New email at the new company: try `user_email`; the higher-yield `find_email_by_url` may
+  be disabled in MCP — check `discover("linkedin", "user")` before promising it. Note that
+  creating a NEW contact record requires an email; without one, update the existing record.
+- Association: pass `associate_company_domain` (or `associate_company_id` from the company
+  upsert result) so the contact links to the new company; the server keeps the old
+  association unless `overwrite_associations=true` — set it only if the user confirms the
+  contact should be re-linked.
+
+Save `run_id`s; mention `crm_undo`.
+
+### 5. Report
+
+Table: contact → old → new → play. Lead with movers into ICP accounts. Include suggested
+opener anchored on the shared history ("you used X at <old company>...") — personalization
+from facts, never invented familiarity.

package/skills/anysite-crm-competitor-intel/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: anysite-crm-competitor-intel
+description: Displacement hunting tied to the CRM - find companies using a competitor's product (Wappalyzer technographics), mine switching reasons and pains from software reviews (Capterra switched_from/switching_reason, TrustRadius, GetApp), cross-reference with CRM accounts and tag displacement targets. Use ONLY when the goal is a CRM-tied displacement list or competitor-user tagging. For general competitor strategy research (content, hiring, positioning, no CRM) use anysite-competitor-intelligence.
+---
+
+# CRM Competitor Intel
+
+Competitor-switch signals are the highest-intent plays in signal-based selling. This skill
+builds the target list and the ammunition: who uses the competitor, and what their users
+complain about.
+
+## Prerequisites
+
+Active CRM connection for the cross-reference/tagging part (Writing rules from
+`anysite-crm-setup` apply to tagging). The research part works without one.
+
+## Flow
+
+### 1. Who uses the competitor (technographics)
+
+Only works for competitors whose product is detectable on websites (martech, analytics,
+chat widgets, ecommerce...):
+```
+execute wappalyzer/technologies {technology: "<competitor slug>"}
+  → website_count (market size), top_websites[] (sample of users, with traffic/tech-spend),
+    alternatives[] (the category landscape), top_countries
+```
+Honest limitation: `top_websites` is a **sample**, not an exhaustive list. Frame it as
+"examples + market sizing", supplement with `linkedin/search/search_sql_companies`
+searching the competitor name in `specialities`/`description`, and with
+`producthunt/products/products_alternatives` for the category graph.
+
+Not website-detectable (e.g. a database vendor)? Skip to reviews and search: job posts
+mentioning the tool (`linkedin/search/search_jobs {keywords: "<tool>"}` — companies whose
+vacancies require competitor experience are its customers), reddit/community mentions.
+
+### 2. What their users complain about (review mining)
+
+```
+execute capterra/products/products_search {query: "<competitor>", count: 5}  → seo_id
+execute capterra/products/products_reviews {product: "<seo_id>", count: 50}
+```
+The `product` param wants the `seo_id` field (not `id`). Reviews include `switched_from[]`,
+`switching_reason` and `chosen_reason` — direct competitor-switch evidence, mine these
+first. Same pattern via `trustradius` and `getapp` `products_reviews` (g2 exposes search
+only). Filter low-rating reviews with `query_cache` (free), then extract with the LLM:
+recurring pains, switching triggers, praised alternatives, verbatim quotes worth reusing.
+Keep 3–7 pains with quote + source URL each — this is the personalization ammunition.
+
+### 3. Cross-reference with the CRM
+
+```
+crm_query_records(object_type="companies", search=<domain from step 1>)
+```
+Split: already in CRM (mark as competitor-user) / net-new fits (candidates for
+`anysite-crm-prospect`).
+
+### 4. Tag and hand off
+
+If the profile maps a field like `competitor_tool` / `displacement_target`:
+```
+crm_upsert_companies(records=[{domain: "<domain>", properties:{...}}], allow_create=false,
+                     dry_run=true) → confirm → write
+```
+(Company upserts match only by domain.)
+Report: market sizing, tagged accounts, pain library with quotes, and suggested play
+("lead with <pain #1>, they're on <competitor> per <evidence>"). Evidence links always —
+a displacement claim without a source is a guess, label it as such.
+
+## Boundaries
+
+- CRM-tied targeting lives here; broad competitor strategy analysis (content, hiring,
+  positioning) → `anysite-competitor-intelligence` skill.
+- Net-new companies go through `anysite-crm-prospect` (dedup + create rules), not directly.