LinkedIn profile qualifier and enricher

You are helping me build a LinkedIn lead qualifier + enricher. The agent takes a single LinkedIn profile URL as input, fetches the profile + recent posts in one shot, applies hard disqualify rules, scores against my ICP rubric, and (only for high-fit leads) finds + verifies a contact email. It returns a structured JSON result.

REFERENCE DOCS (read these before writing code)
- Full agntdata API documentation: https://agnt.mintlify.app/apis/overview
- Endpoints we'll use (all behind one agntdata key):
  - `linkedin-data-api / Get_Profile_Data_By_URL` — fetch the LinkedIn profile (headline, experience, websites)
  - `linkedin-data-api / Get_Profile_s_Posts` — fetch recent posts for content scoring
  - `agntdata-agnt / people_email_finder` — find an email from {linkedin_url} or {full_name + domain}
  - `agntdata-agnt / people_email_verifier` — verify deliverability before we surface the email
- Plus the Exa connector for website summarization (and optional company-website discovery when the profile doesn't carry one).

ABOUT MY PRODUCT
- Product: <YOUR PRODUCT — one sentence>
- Top ICPs (in priority order, with a 1-sentence "what they look like on LinkedIn"):
  1. <ICP 1>: <signals — typical headline phrasing, role, company stage>
  2. <ICP 2>: <signals>
  3. <ICP 3 — optional>
- Tool stack mentions worth boosting (competitive or complementary tools — headline + recent posts):
  - <tool 1, tool 2, tool 3, ...>
- Hard disqualify rules (in priority order; first hit wins):
  1. <rule 1 — e.g. "no headline">
  2. <rule 2 — optional>

WHAT TO BUILD
An agent (claude-haiku-4-5) on agntdata. It accepts a LinkedIn profile URL as input — from chat, a webhook payload, or another agent's tool call — and runs the pipeline once per invocation.

Step 1 — Parse input. Pull the LinkedIn URL from the user message (must contain `/in/<slug>`). If missing or malformed, respond "expected a LinkedIn profile URL" and stop.

Step 2 — Run `fetch_linkedin_profile_and_posts` skill ({ linkedin_profile_url }). The skill makes both LinkedIn calls in one shot, returns a compact summary (`first_name`, `last_name`, `headline`, `company_name`, `company_url`, `post_count`), and keeps the heavy raw payloads out of your context. Use the returned fields for every subsequent step — do NOT make any separate LinkedIn calls.

Step 3 — Hard disqualify gates (apply IN ORDER, stop on first hit). My rules above. The standard one: empty `headline` → emit a structured "disqualified" result and stop.

Step 4 — Find a website to summarize. Try in this order:
  4A. Use `company_url` from the skill result if present.
  4B. Otherwise, Exa-search `"<company_name>" official website` (`type: "auto"`, `numResults: 3`) and pick the most plausible homepage (not a LinkedIn URL).
  4C. Otherwise, Exa-search `"<first_name> <last_name>" "<headline>"` and look for a personal site or company domain.
  4D. If still nothing: skip website entirely and let the scorer work without it.

Step 5 — Run `fetch_website_summary` skill ({ website_url }) when you have a URL. It returns a one-paragraph Exa summary.

Step 6 — Run `score_linkedin_lead` skill ({ linkedin_profile_details, linkedin_profile_recent_posts, website_summary }). It calls Claude Sonnet with my rubric and returns `lead_score` (0–100), `score_breakdown` (jsonb), `icp_match`, `reasoning`, and `qualification_notes` (only when score > 50).

Step 7 — If `lead_score <= 50`: emit the structured "scored, not enriched" result and stop.

Step 8 — Enrichment (only when `lead_score > 50`). **Hard cap of 4 tool calls total in this branch.**
  8A. Email finder via `people_email_finder` with `{ linkedin_url, max_cost_cents: 50 }`. If nothing, fall back ONCE to `{ full_name, domain, max_cost_cents: 50 }`. If neither viable: skip to result with `email_enrichment_status = 'not_found'`.
  8B. **Mandatory verify** via `people_email_verifier`. `deliverable` → surface with `email_verified = true`. `risky` → surface with `email_verified = false`. `undeliverable` → discard.

Step 9 — Emit the structured result. Always include:
```json
{
  "linkedin_profile_url": "...",
  "disqualified": false,
  "disqualify_reason": null,
  "lead_score": 72,
  "icp_match": "<matched ICP>",
  "score_breakdown": { ... },
  "qualification_notes": "...",
  "first_name": "...",
  "last_name": "...",
  "headline": "...",
  "company_name": "...",
  "company_url": "...",
  "company_description": "...",
  "website_url": "...",
  "website_summary": "...",
  "email": "...",
  "email_verified": true,
  "email_enrichment_status": "found"
}
```

GUARDRAILS
- Never call LinkedIn directly — always go through the agntdata endpoints.
- Don't compute `lead_score` / `score_breakdown` from the agent — only the `score_linkedin_lead` skill does.
- Verifier is mandatory before surfacing any email. No exceptions.
- The combined profile-and-posts skill is the ONLY LinkedIn fetch path. Never call `Get_Profile_Data_By_URL` or `Get_Profile_s_Posts` from the agent directly — the skill keeps the raw payloads out of your conversation cache.

RECOMMENDED PIPELINE (optional)
This agent is a function: `linkedin_url → qualified lead`. To turn it into a pipeline, pair it with the `linkedin-gtm-engager-scraper` blueprint (which fills a `leads` table with LinkedIn profile URLs from engaged posts in your topic space) and add a thin upstream agent that polls the table and calls this one per row. If you also run the X (Twitter) qualifier, scope each polling agent's claim predicate by identifier (`linkedin_profile_url IS NOT NULL AND x_username IS NULL` for this one; `x_username IS NOT NULL` for the X variant) so they don't fight over the same rows.

When ready, start by asking me the ABOUT MY PRODUCT questions.