@m13v/s4l 1.6.197-rc.10

package/scripts/discover_linkedin_candidates.py

@@ -0,0 +1,984 @@
+#!/usr/bin/env python3
+"""LinkedIn SERP discovery: read-only Phase A search-page scrape.
+
+Usage:
+    python3 discover_linkedin_candidates.py <vertical> <query>
+        # vertical = people | content | companies
+
+Attaches to the already-running LinkedIn Chrome via CDP and reuses its
+existing BrowserContext. Same Chrome process, same cookies, same UA, same
+fingerprint as whatever LinkedIn already trusts from the live session.
+Opens our own page in that context, navigates to the SERP, runs ONE
+page.evaluate() against the rendered DOM, closes our page, disconnects.
+
+CDP endpoint resolution (see _resolve_cdp_url, 2026-05-29):
+    Lane 1 (preferred): LINKEDIN_CDP_URL — the browser-harness Chrome on
+        :9556, exported by skill/lib/linkedin-backend.sh. The main
+        run-linkedin.sh pipeline now drives that harness Chrome
+        (mcp__linkedin-harness__bh_run) instead of the retired
+        linkedin-agent MCP, so this is the live, logged-in session.
+    Lane 2 (legacy): http://localhost:<port> read from the linkedin-agent
+        MCP's DevToolsActivePort. Kept for running outside the harness.
+
+Read-only DOM scrape: NO Voyager API, NO scroll-and-expand loops, NO
+permalink fan-out, NO clicks/typing, NO programmatic login.
+
+Pre-conditions for this to work:
+    1. A LinkedIn Chrome is running and reachable via one of the two CDP
+       lanes above (normally the harness Chrome on :9556 launched by
+       ensure_linkedin_browser_for_backend).
+    2. The user is logged in inside that browser. We do NOT log in.
+
+Why CDP attach rather than launch_persistent_context: the previous version
+launched its own Chrome against the shared profile dir. When LinkedIn
+redirected the SERP request (UA mismatch / fresh-launch fingerprint) the
+homepage response contained Set-Cookie headers that cleared li_at. On
+context.close() Chrome flushed the cleared cookies to disk, logging the
+shared profile out and breaking unread-dms + the linkedin-agent MCP.
+Attaching to the MCP's running Chrome eliminates the launch fingerprint,
+removes the cookie-flush risk (we never close the context), and keeps the
+profile fully owned by one process at a time.
+
+Per CLAUDE.md "LinkedIn: flagged patterns" carve-out (2026-04-29): the
+read-only DOM read is permitted because the request runs inside the same
+Chrome the MCP already drives. The 2026-04-17 restriction was caused by
+Voyager calls + permalink scroll loops, neither of which appear here.
+
+Rate-limited against linkedin_browser_searches per the 2026-04-29 research:
+~30s min gap, ~40/day, ~150/month soft cap leaves headroom under LinkedIn's
+~300/month commercial-use wall on free accounts. Fails CLOSED on DB errors:
+if we cannot enforce the budget we do not perform the search.
+
+Output (stdout, JSON):
+    {
+        "ok": true,
+        "url": "https://www.linkedin.com/search/results/people/?keywords=...",
+        "vertical": "people",
+        "query": "founder rag retrieval",
+        "result_count": 10,
+        "results": [...],
+        "rate_budget": {"daily_used": N, "daily_cap": null,
+                        "monthly_used": N, "monthly_cap": null},
+    }
+
+Failure shapes:
+    {"ok": false, "error": "session_invalid", "url": "..."}
+    {"ok": false, "error": "serp_redirected", "url": "..."}
+    {"ok": false, "error": "mcp_not_running", "detail": "..."}
+    {"ok": false, "error": "cdp_attach_failed", "detail": "..."}
+    {"ok": false, "error": "navigation_failed", "detail": "..."}
+    {"ok": false, "error": "bad_vertical", "detail": "..."}
+    {"ok": false, "error": "empty_query", "detail": ""}
+
+Note: rate_limited and db_unavailable are no longer raised. All caps were
+removed 2026-05-01; the script logs to linkedin_browser_searches for
+visibility but never refuses based on volume or recency.
+
+Exits 0 on success, 1 on failure.
+"""
+
+import json
+import os
+import random
+import sys
+import time
+import urllib.parse
+from typing import Optional
+
+
+def _bh_activity_log(action: str, cdp_url: str) -> None:
+    """Append to the universal browser-activity.log (Python-CDP path coverage)."""
+    try:
+        import time as _t
+        import os as _o
+        from pathlib import Path as _P
+        _p = _P(_o.environ.get(
+            "BH_ACTIVITY_LOG",
+            str(_P.home() / ".claude" / "browser-profiles" / "browser-activity.log"),
+        ))
+        _port = (cdp_url or "").rsplit(":", 1)[-1].split("/")[0] or "-"
+        _p.parent.mkdir(parents=True, exist_ok=True)
+        with _p.open("a") as _f:
+            _f.write(
+                f"[{_t.strftime('%Y-%m-%d %H:%M:%S')}] pycdp "
+                f"script={_o.path.basename(__file__)} action={action} "
+                f"pid={_o.getpid()} ppid={_o.getppid()} cdp={cdp_url or '-'} "
+                f"port={_port}\n"
+            )
+    except Exception:
+        pass
+
+# Reuse the lock helper + login-URL detector from linkedin_browser. We share
+# the lock so concurrent Python helpers (search vs unread-dms) serialize on
+# the same ~/.claude/linkedin-agent-lock.json. PROFILE_DIR also points at
+# the directory where the linkedin-agent MCP writes DevToolsActivePort.
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from linkedin_browser import (  # noqa: E402
+    PROFILE_DIR,
+    _acquire_browser_lock,
+    _is_login_or_checkpoint,
+)
+from score_linkedin_candidates import calculate_velocity_score  # noqa: E402
+try:  # author exclusion is fail-open: never let it break discovery
+    from linkedin_exclusions import load_exclusions, classify_author  # noqa: E402
+except Exception:  # pragma: no cover - helper missing -> exclusion becomes a no-op
+    def load_exclusions(platform="linkedin"):
+        return {"hard_slugs": set(), "soft_slugs": set(), "soft_names": set()}
+
+    def classify_author(author_name, author_profile_url, excl=None):
+        return None, ""
+from http_api import api_get, api_post  # noqa: E402
+
+DEVTOOLS_ACTIVE_PORT = os.path.join(PROFILE_DIR, "DevToolsActivePort")
+
+# Virality (velocity * reach_mult * age_decay * (1 + disc_bonus); see
+# score_linkedin_candidates.calculate_velocity_score) is a RANKING signal,
+# not a cutoff. Aligned with the Twitter model (2026-05-29): score every
+# SERP card, sort by velocity_score DESC so the Phase A picker sees the
+# strongest candidates first, and NEVER drop a card on virality. The picker
+# prompt already steers toward the top of the sorted list and leans toward
+# posting, so the old hard floor only caused zero-post cycles on quiet
+# topics where every card scored low (e.g. niche backend-dev SERPs). Twitter
+# (score_twitter_candidates.py) keeps every candidate the same way: "no cap,
+# no cutoff: this only ever raises a score, never removes a candidate."
+
+# Search rate-limit budget removed 2026-05-01 per user instruction. The
+# linkedin_browser_searches table is kept so daily/monthly volumes remain
+# observable, but no min-gap, daily, or monthly cap is enforced. Caller is
+# responsible for cadence. The 2026-04-17 LinkedIn restriction (see CLAUDE.md
+# "LinkedIn: flagged patterns") came from behavioral fingerprinting, not raw
+# volume, so volume caps weren't the load-bearing protection anyway — but
+# back-to-back machine-cadence search hits are now structurally possible
+# from this script.
+SEARCH_VERTICALS = ("people", "content", "companies")
+
+
+def _check_rate_limit() -> dict:
+    """Always returns ok=True. Caps removed 2026-05-01 per user instruction.
+
+    Reads current daily/monthly volume so the response shape keeps the
+    rate_budget block populated for the dashboard. A failure here is
+    non-fatal — the search proceeds anyway since there's no cap to enforce.
+
+    Migrated 2026-06-01 from a direct DB read (+ first-use CREATE TABLE) to
+    GET /api/v1/linkedin-browser-searches. The table now lives in the
+    social-autoposter-website schema; no client-side DDL needed.
+    """
+    daily = monthly = 0
+    try:
+        resp = api_get("/api/v1/linkedin-browser-searches")
+        data = resp.get("data") or {}
+        daily = int(data.get("daily_used") or 0)
+        monthly = int(data.get("monthly_used") or 0)
+    except (Exception, SystemExit):
+        # API down? Not our problem — caps are off, search proceeds.
+        pass
+    return {"ok": True, "daily_used": daily, "monthly_used": monthly}
+
+
+def _log_search(query: str, vertical: str, ok: bool, error: Optional[str]) -> None:
+    """Best-effort write of one row to linkedin_browser_searches.
+
+    Never raises: a failed log must not turn a successful search into a
+    failure. Note that if logging fails the next rate-limit check will
+    under-count. Acceptable: the monthly cap has 50% headroom under the
+    actual wall.
+
+    Migrated 2026-06-01 to POST /api/v1/linkedin-browser-searches. SystemExit
+    (raised by http_api on 4xx / exhausted retries) is swallowed too, so a
+    logging failure can never bubble up and fail a real search.
+    """
+    try:
+        api_post(
+            "/api/v1/linkedin-browser-searches",
+            {"query": query, "vertical": vertical, "ok": ok, "error": error},
+        )
+    except (Exception, SystemExit) as e:
+        print(
+            f"[discover_linkedin_candidates] _log_search: post failed: {e}",
+            file=sys.stderr,
+        )
+
+
+# DOM extractors per vertical. Each is a single querySelectorAll + map, with
+# multiple selector fallbacks because LinkedIn's class names rotate. Returns
+# JSON.stringify(...) so the Python side can json.loads regardless of how the
+# evaluate channel marshals nested objects. Limit to the first 25 cards on the
+# page — anything beyond that requires scrolling, which we explicitly do not
+# do.
+#
+# Provenance:
+#   _SEARCH_JS_CONTENT  — lifted from skill/run-linkedin.sh (production-tested).
+#   _SEARCH_JS_PEOPLE   — UNVERIFIED. Selectors based on widely-documented
+#                         LinkedIn patterns + multiple fallbacks. Smoke-test
+#                         against a real SERP before relying on the output.
+#   _SEARCH_JS_COMPANIES — UNVERIFIED. Same caveat as people.
+#
+# Reconciliation procedure for the UNVERIFIED extractors (do this once,
+# then update this block to mark them VERIFIED with the date):
+#   Preconditions:
+#     - linkedin-agent has been idle >= 1 hour. Check
+#       ~/.playwright-mcp/linkedin-agent/page-*.yml mtimes.
+#     - The persistent profile is logged in. Do NOT trigger a probe like
+#       "navigate to LinkedIn and tell me what you see" — that prompt itself
+#       is the high-risk behavior that invalidated cookies on 2026-04-29.
+#       If the session is dead, wait for the next normal pipeline cycle to
+#       re-auth, then resume reconciliation in a fresh hour.
+#   Steps (use the linkedin-agent MCP, NOT this script — the script logs to
+#   linkedin_browser_searches and burns the rate budget for nothing):
+#     1. mcp__linkedin-agent__browser_navigate to
+#        https://www.linkedin.com/search/results/people/?keywords=founder%20ai
+#     2. mcp__linkedin-agent__browser_evaluate, paste _SEARCH_JS_PEOPLE
+#        verbatim (including the JSON.stringify wrap). JSON.parse the
+#        returned string.
+#        Accept criterion: >= 5 entries with non-empty name AND profile_url.
+#        Reject: [] or rows with all-empty fields → snapshot the page,
+#        find the live card class names, patch the querySelectorAll lists.
+#        Keep existing fallback selectors at the END of each list to stay
+#        compatible with the older layout.
+#     3. Repeat for /search/results/companies/?keywords=founder%20ai with
+#        _SEARCH_JS_COMPANIES. Same accept criterion (>= 5 cards with
+#        company AND company_url).
+#   Hard limits during reconciliation: 2 navigations total, no
+#   close-and-reopen of the agent, no scroll, no clicks. Anything more is
+#   the same fingerprint pattern that triggered the 2026-04-29 lockouts.
+_SEARCH_JS_PEOPLE = r"""
+() => {
+  const out = [];
+  const cards = document.querySelectorAll(
+    "div.search-results-container li div.entity-result, "
+    + "li.reusable-search__result-container, "
+    + "[data-chameleon-result-urn]"
+  );
+  for (const c of Array.from(cards).slice(0, 25)) {
+    const link = c.querySelector(
+      "a[href*='/in/'].app-aware-link, a[href*='/in/']"
+    );
+    const profileUrl = link
+      ? (link.href || link.getAttribute("href") || "")
+      : "";
+    const nameEl = c.querySelector(
+      ".entity-result__title-text, .entity-result__title-line, "
+      + "span[aria-hidden='true']"
+    );
+    const name = nameEl ? (nameEl.textContent || "").trim() : "";
+    const headlineEl = c.querySelector(
+      ".entity-result__primary-subtitle, .t-14.t-black.t-normal"
+    );
+    const headline = headlineEl
+      ? (headlineEl.textContent || "").trim() : "";
+    const locEl = c.querySelector(
+      ".entity-result__secondary-subtitle, .t-14.t-normal"
+    );
+    const location = locEl ? (locEl.textContent || "").trim() : "";
+    if (!name && !profileUrl) continue;
+    out.push({
+      name: name.replace(/\s+/g, " "),
+      headline: headline.replace(/\s+/g, " "),
+      location: location.replace(/\s+/g, " "),
+      profile_url: profileUrl.split("?")[0],
+    });
+  }
+  return JSON.stringify(out);
+}
+"""
+
+# Content-search extractor. Two layouts coexist in the wild:
+#
+#   New SDUI layout (post 2026-04-30 reconciliation): obfuscated class names,
+#   results wrapped in [data-sdui-screen*="SearchResultsContent"], each card
+#   [role="listitem"][componentkey]. The activity URN is GONE from the DOM
+#   for most cards: only cards that embed a quoted/reposted share keep a
+#   visible /feed/update/<urn> link. So post_url/activity_id can legitimately
+#   be null on the new layout — callers must dedupe by
+#   (author_profile_url, post_text hash) when activity_id is missing.
+#
+#   Legacy class layout (pre-rollout, may still appear): div.feed-shared-update-v2
+#   / div[data-urn=...] cards with full URNs.
+#
+# Tries the new layout first, falls back to legacy, returns the same shape
+# either way. Verified 2026-04-30 against
+# /search/results/content/?keywords=ai%20agent%20founder
+# 8/8 cards extracted (author_name + author_profile_url + post_text + age_text);
+# 1/8 had activity_id (the only embedded-share case).
+_SEARCH_JS_CONTENT = r"""
+() => {
+  const out = [];
+
+  function parseRelativeAge(txt) {
+    if (!txt) return null;
+    const m = txt.match(/(\d+)\s*(s|min|m|hr|h|d|w|mo|y)\b/i);
+    if (!m) return null;
+    const n = parseInt(m[1], 10);
+    let u = m[2].toLowerCase();
+    if (u === 'hr') u = 'h';
+    if (u === 'min') u = 'm';
+    const map = { s: 1/3600, m: 1/60, h: 1, d: 24, w: 24*7, mo: 24*30, y: 24*365 };
+    return n * (map[u] || 0);
+  }
+  function parseCount(txt) {
+    if (!txt) return 0;
+    const t = String(txt).replace(/,/g, '').trim();
+    const m = t.match(/([\d.]+)\s*([KkMm]?)/);
+    if (!m) return 0;
+    const n = parseFloat(m[1]);
+    const u = (m[2] || '').toLowerCase();
+    return Math.round(n * (u === 'k' ? 1000 : u === 'm' ? 1_000_000 : 1));
+  }
+
+  // 1. New SDUI layout.
+  let items = [];
+  const screen = document.querySelector('[data-sdui-screen*="SearchResultsContent"]');
+  if (screen) {
+    items = Array.from(screen.querySelectorAll('[role="listitem"][componentkey]'));
+  }
+  // 2. Legacy fallback.
+  if (items.length === 0) {
+    items = Array.from(document.querySelectorAll(
+      'div.feed-shared-update-v2, '
+      + 'div[data-urn*="urn:li:activity"], '
+      + 'div[data-urn*="urn:li:share"], '
+      + 'div[data-urn*="urn:li:ugcPost"]'
+    ));
+  }
+
+  const seen = new Set();
+  const urnRe = /urn:li:(activity|share|ugcPost):(\d{16,19})/;
+  const urnReG = /urn:li:(activity|share|ugcPost):(\d{16,19})/g;
+
+  for (const item of items.slice(0, 25)) {
+    let urnType = null, activityId = null;
+    const allUrns = new Set();
+
+    const updateLink = item.querySelector('a[href*="/feed/update/"]');
+    if (updateLink) {
+      const m = (updateLink.href || '').match(urnRe);
+      if (m) { urnType = m[1]; activityId = m[2]; allUrns.add(m[2]); }
+    }
+    if (!activityId) {
+      const dataUrn = item.getAttribute('data-urn') || '';
+      const m = dataUrn.match(urnRe);
+      if (m) { urnType = m[1]; activityId = m[2]; allUrns.add(m[2]); }
+    }
+    if (!activityId) {
+      const html = item.outerHTML || '';
+      let mm;
+      urnReG.lastIndex = 0;
+      while ((mm = urnReG.exec(html)) !== null) {
+        allUrns.add(mm[2]);
+        if (!activityId) { urnType = mm[1]; activityId = mm[2]; }
+      }
+    }
+    if (activityId) {
+      if (seen.has(activityId)) continue;
+      seen.add(activityId);
+    }
+
+    const authorLink = item.querySelector('a[aria-label*="profile" i][href*="/in/"]')
+      || item.querySelector('a[href*="/in/"]');
+    const authorUrl = authorLink ? (authorLink.href || '').split('?')[0] : null;
+    let authorName = null;
+    if (authorLink) {
+      const al = authorLink.getAttribute('aria-label') || '';
+      const m = al.match(/View\s+(.+?)['’]s\s+profile/i);
+      if (m) authorName = m[1].trim();
+    }
+    // The new SDUI layout puts the View-profile aria on an inner <svg>, not
+    // the <a>. Probe descendants of the link too before falling back.
+    if (!authorName && authorLink) {
+      const inner = authorLink.querySelector('[aria-label*="profile" i]');
+      if (inner) {
+        const m = (inner.getAttribute('aria-label') || '').match(/View\s+(.+?)['’]s\s+profile/i);
+        if (m) authorName = m[1].trim();
+      }
+    }
+    if (!authorName) {
+      const followBtn = item.querySelector('button[aria-label^="Follow "]');
+      if (followBtn) {
+        const m = (followBtn.getAttribute('aria-label') || '').match(/^Follow\s+(.+)$/i);
+        if (m) authorName = m[1].trim();
+      }
+    }
+    if (!authorName) {
+      const nameEl = item.querySelector(
+        '.update-components-actor__name, span.feed-shared-actor__name'
+      );
+      if (nameEl) authorName = (nameEl.textContent || '').trim();
+    }
+
+    let authorFollowers = null;
+    const supplementary = item.querySelector(
+      '.update-components-actor__supplementary-actor-info, '
+      + '.feed-shared-actor__sub-description'
+    );
+    if (supplementary) {
+      const fm = (supplementary.textContent || '').match(/([\d.,]+[KkMm]?)\s*follower/);
+      if (fm) authorFollowers = parseCount(fm[1]);
+    }
+
+    // Actor block = the prefix of the listitem text before "• Follow". On the
+    // new SDUI layout it has the shape "Feed post<NAME> • <CONNECTION><HEADLINE><AGE>".
+    const fullItemText = (item.textContent || '').replace(/\s+/g, ' ').trim();
+    const followIdx0 = fullItemText.indexOf('• Follow');
+    const actorBlock = followIdx0 >= 0 ? fullItemText.slice(0, followIdx0) : fullItemText.slice(0, 300);
+
+    // Author headline: strip "Feed post" prefix, the name, the connection
+    // marker, and the trailing age. Best-effort; for company pages or
+    // non-standard layouts (no • <connection>) we still return whatever's
+    // left after the name.
+    let authorHeadline = null;
+    {
+      let h = actorBlock.replace(/^Feed post/, '').trim();
+      if (authorName && h.startsWith(authorName)) h = h.slice(authorName.length);
+      h = h.replace(/^\s*•\s*(1st|2nd|3rd\+?|Out of network|Following)\s*/i, '');
+      h = h.replace(/\s*(?:•\s*)?\d+\s*(?:s|min|m|hr|h|d|w|mo|y)\s*$/i, '');
+      h = h.trim();
+      if (h) authorHeadline = h;
+    }
+
+    // Post body. Legacy: prefer the dedicated text element. New SDUI: take
+    // text after "• Follow", then strip trailing CTA / count noise.
+    let postText = '';
+    const textEl = item.querySelector(
+      '.update-components-text, .feed-shared-update-v2__description, span.break-words'
+    );
+    if (textEl) {
+      postText = (textEl.textContent || '').replace(/\s+/g, ' ').trim();
+    } else {
+      let s = fullItemText.replace(/^Feed post/, '').trim();
+      const idx = s.indexOf('• Follow');
+      if (idx >= 0) s = s.slice(idx + '• Follow'.length).trim();
+      // Strip trailing "… more" / "...more" the new layout appends.
+      s = s.replace(/\s*[…\.]+\s*more\s*$/i, '').trim();
+      // Strip trailing count noise like "+132 comments23 reactions",
+      // "1 comment1", "+811 reaction", "23 reactions".
+      // Count widgets concatenate without delimiters; consume runs greedily.
+      for (let i = 0; i < 6; i++) {
+        const before = s;
+        s = s.replace(
+          /\s*\+?\s*\d+\s*(?:reactions?|comments?|reposts?)\s*\d*\s*$/i,
+          ''
+        ).trim();
+        if (s === before) break;
+      }
+      // Strip a stray trailing digit (artifact of glued-in count widgets).
+      s = s.replace(/\s+\d+\s*$/, '').trim();
+      postText = s;
+    }
+
+    let ageText = '';
+    const timeEl = item.querySelector(
+      'time, .update-components-actor__sub-description, '
+      + 'span.feed-shared-actor__sub-description'
+    );
+    if (timeEl) ageText = (timeEl.textContent || '').trim();
+    if (!ageText) {
+      const ageM = fullItemText.match(/(\d+\s*(?:s|min|m|hr|h|d|w|mo|y))\b/i);
+      if (ageM) ageText = ageM[1];
+    }
+    const ageHours = parseRelativeAge(ageText);
+
+    // Counts. New SDUI hides counts from button aria-labels and embeds them
+    // as plain leaf-divs ("1 comment", "23 reactions", "+811 reaction").
+    // We walk every leaf div/span and match the strict shape; we keep the
+    // max in case the same widget is mirrored across nested wrappers.
+    let reactions = 0, comments = 0, reposts = 0;
+    item.querySelectorAll('div, span').forEach(el => {
+      if (el.children.length > 0) return;
+      const t = (el.textContent || '').trim();
+      if (!t || t.length > 30) return;
+      let m;
+      if ((m = t.match(/^[+]?\s*([\d.,]+\s*[KkMm]?)\s+reactions?$/i))) {
+        const v = parseCount(m[1]);
+        if (v > reactions) reactions = v;
+      }
+      if ((m = t.match(/^[+]?\s*([\d.,]+\s*[KkMm]?)\s+comments?$/i))) {
+        const v = parseCount(m[1]);
+        if (v > comments) comments = v;
+      }
+      if ((m = t.match(/^[+]?\s*([\d.,]+\s*[KkMm]?)\s+reposts?$/i))) {
+        const v = parseCount(m[1]);
+        if (v > reposts) reposts = v;
+      }
+    });
+    // Legacy fallbacks (unchanged): aria-label-based counts on the old layout.
+    if (reactions === 0) {
+      const reactEl = item.querySelector(
+        '[aria-label*=" reaction" i], '
+        + '.social-details-social-counts__reactions-count'
+      );
+      if (reactEl) {
+        const m = (reactEl.getAttribute('aria-label') || reactEl.textContent || '')
+          .match(/([\d.,]+\s*[KkMm]?)\s*reaction/i);
+        if (m) reactions = parseCount(m[1]);
+      }
+    }
+    if (comments === 0) {
+      const commentEl = item.querySelector(
+        '[aria-label*=" comment" i], '
+        + 'li.social-details-social-counts__comments'
+      );
+      if (commentEl) {
+        const m = (commentEl.getAttribute('aria-label') || commentEl.textContent || '')
+          .match(/([\d.,]+\s*[KkMm]?)\s*comment/i);
+        if (m) comments = parseCount(m[1]);
+      }
+    }
+    if (reposts === 0) {
+      const repostEl = item.querySelector(
+        '[aria-label*=" repost" i], '
+        + 'li.social-details-social-counts__item--right-aligned'
+      );
+      if (repostEl) {
+        const m = (repostEl.getAttribute('aria-label') || repostEl.textContent || '')
+          .match(/([\d.,]+\s*[KkMm]?)\s*repost/i);
+        if (m) reposts = parseCount(m[1]);
+      }
+    }
+
+    if (!authorName && !authorUrl && !postText) continue;
+
+    // Comment gate: the author restricted commenting to their connections
+    // ("Only connections can comment on this post. You can still react or
+    // share it."). For a 3rd+ degree account the comment editor never renders,
+    // so the post is uncommentable. LinkedIn paints this notice straight into
+    // the card chrome, so we can detect it here (Phase A) and drop the
+    // candidate before it ever reaches the expensive compose/post phase.
+    const commentGated =
+      /only connections can comment on this post|you can still react or share it/i
+        .test(fullItemText);
+
+    out.push({
+      post_url: activityId
+        ? ('https://www.linkedin.com/feed/update/urn:li:' + urnType + ':' + activityId + '/')
+        : null,
+      activity_id: activityId,
+      all_urns: Array.from(allUrns),
+      author_name: authorName || null,
+      author_headline: authorHeadline,
+      author_profile_url: authorUrl,
+      author_followers: authorFollowers,
+      post_text: postText,
+      age_hours: ageHours,
+      reactions: reactions,
+      comments: comments,
+      reposts: reposts,
+      age_text: ageText,
+      comment_gated: commentGated
+    });
+  }
+  return JSON.stringify(out);
+}
+"""
+
+_SEARCH_JS_COMPANIES = r"""
+() => {
+  const out = [];
+  const cards = document.querySelectorAll(
+    "div.search-results-container li div.entity-result, "
+    + "li.reusable-search__result-container, "
+    + "[data-chameleon-result-urn]"
+  );
+  for (const c of Array.from(cards).slice(0, 25)) {
+    const link = c.querySelector(
+      "a[href*='/company/'].app-aware-link, a[href*='/company/']"
+    );
+    const url = link ? (link.href || link.getAttribute("href") || "") : "";
+    const nameEl = c.querySelector(
+      ".entity-result__title-text, .entity-result__title-line, "
+      + "span[aria-hidden='true']"
+    );
+    const name = nameEl ? (nameEl.textContent || "").trim() : "";
+    const taglineEl = c.querySelector(
+      ".entity-result__primary-subtitle, .t-14.t-black.t-normal"
+    );
+    const tagline = taglineEl ? (taglineEl.textContent || "").trim() : "";
+    if (!name && !url) continue;
+    out.push({
+      company: name.replace(/\s+/g, " "),
+      tagline: tagline.replace(/\s+/g, " "),
+      company_url: url.split("?")[0],
+    });
+  }
+  return JSON.stringify(out);
+}
+"""
+
+_SEARCH_JS_BY_VERTICAL = {
+    "people": _SEARCH_JS_PEOPLE,
+    "content": _SEARCH_JS_CONTENT,
+    "companies": _SEARCH_JS_COMPANIES,
+}
+
+
+def _read_devtools_port() -> Optional[int]:
+    """Return the CDP port the linkedin-agent MCP's Chrome is listening on,
+    or None if the file is missing/unreadable/stale. Chrome writes the port
+    on line 1 of DevToolsActivePort when launched with --remote-debugging-port.
+
+    Chrome SHOULD remove the file when it exits, but doesn't always — a
+    crashed/killed Chrome leaves a stale file pointing at a port nothing's
+    listening on. We probe the port with a non-blocking TCP connect; if the
+    connection is refused, we treat the file as stale and return None so
+    callers report the cleaner mcp_not_running error rather than dragging
+    out to a noisy cdp_attach_failed."""
+    try:
+        with open(DEVTOOLS_ACTIVE_PORT) as f:
+            port = int(f.readline().strip())
+        if port <= 0:
+            return None
+    except (OSError, ValueError):
+        return None
+    import socket
+    try:
+        with socket.create_connection(("127.0.0.1", port), timeout=0.5):
+            return port
+    except (OSError, socket.timeout):
+        return None
+
+
+def _resolve_cdp_url() -> Optional[str]:
+    """Resolve the CDP endpoint to attach the SERP read to.
+
+    Lane 1 (preferred, 2026-05-29): LINKEDIN_CDP_URL, exported by
+    skill/lib/linkedin-backend.sh to point at the browser-harness Chrome on
+    :9556. The main run-linkedin.sh pipeline now drives that harness Chrome
+    (mcp__linkedin-harness__bh_run) instead of the retired linkedin-agent
+    MCP, so this is the live session whose cookies/fingerprint we want. We
+    probe /json/version with a 1s GET so a stale/unset env falls through
+    cleanly rather than dragging into a noisy connect failure.
+
+    Lane 2 (legacy DevToolsActivePort attach to the linkedin-agent profile
+    under PROFILE_DIR) was REMOVED 2026-05-31. It silently sent the SERP read
+    to a SECOND Chrome (the retired linkedin-agent MCP browser) whenever the
+    harness was momentarily unreachable — the "two LinkedIn browsers in
+    parallel" bug. The harness Chrome on :9556 is now the ONLY allowed target.
+
+    Returns the harness CDP base URL (e.g. "http://127.0.0.1:9556") or None
+    when LINKEDIN_CDP_URL is unset or the harness is unreachable.
+    """
+    harness = os.environ.get("LINKEDIN_CDP_URL", "").strip()
+    if not harness:
+        return None
+    import urllib.request
+    try:
+        with urllib.request.urlopen(
+            f"{harness.rstrip('/')}/json/version", timeout=1.0
+        ):
+            return harness.rstrip("/")
+    except Exception:
+        return None
+
+
+def search(vertical: str, query: str) -> dict:
+    """Attach to the linkedin-agent MCP's Chrome via CDP and read one SERP.
+
+    ONE goto, ONE evaluate. No own-Chrome launch, no context.close(),
+    so we never write cookies back to disk. Rate-limited against
+    linkedin_browser_searches; fails closed if the DB budget is exhausted.
+    """
+    if vertical not in SEARCH_VERTICALS:
+        return {
+            "ok": False,
+            "error": "bad_vertical",
+            "detail": f"got {vertical!r}; want one of {SEARCH_VERTICALS}",
+        }
+    query = (query or "").strip()
+    if not query:
+        return {"ok": False, "error": "empty_query", "detail": ""}
+
+    rate = _check_rate_limit()
+    if not rate.get("ok"):
+        return rate
+
+    cdp_url = _resolve_cdp_url()
+    if cdp_url is None:
+        return {
+            "ok": False,
+            "error": "mcp_not_running",
+            "detail": (
+                "No LinkedIn CDP endpoint reachable. Set LINKEDIN_CDP_URL "
+                "(the browser-harness Chrome on :9556, exported by "
+                "skill/lib/linkedin-backend.sh) and make sure that Chrome is "
+                f"running; or, for the legacy lane, {DEVTOOLS_ACTIVE_PORT} "
+                "must point at a live linkedin-agent MCP Chrome launched with "
+                "--remote-debugging-port."
+            ),
+        }
+
+    from playwright.sync_api import sync_playwright
+
+    _acquire_browser_lock()
+
+    encoded = urllib.parse.quote(query)
+    # Content searches sort by date_posted to match skill/run-linkedin.sh
+    # Phase A behavior — fresh posts > stale ones for engagement work.
+    suffix = "&sortBy=date_posted" if vertical == "content" else ""
+    search_url = (
+        f"https://www.linkedin.com/search/results/{vertical}/"
+        f"?keywords={encoded}{suffix}"
+    )
+    serp_prefix = f"https://www.linkedin.com/search/results/{vertical}/"
+
+    with sync_playwright() as p:
+        try:
+            browser = p.chromium.connect_over_cdp(cdp_url)
+        except Exception as e:
+            _log_search(query, vertical, ok=False, error="cdp_attach_failed")
+            return {
+                "ok": False,
+                "error": "cdp_attach_failed",
+                "detail": f"connect_over_cdp({cdp_url}) failed: {e}",
+            }
+
+        _bh_activity_log("attach", cdp_url)
+
+        # Reuse the existing context (cookies / UA / fingerprint already set
+        # by the MCP launch). Never close it — that would kill the MCP's
+        # pages too. We only own the page we create below.
+        if not browser.contexts:
+            browser.disconnect()
+            _log_search(query, vertical, ok=False, error="cdp_attach_failed")
+            return {
+                "ok": False,
+                "error": "cdp_attach_failed",
+                "detail": "browser.contexts is empty; MCP has no open context",
+            }
+        context = browser.contexts[0]
+
+        page = None
+        _reused_page = False
+        try:
+            # Reuse an existing harness tab instead of spawning a throwaway one
+            # (mirrors reddit_browser / linkedin_browser). Prefer a tab already
+            # on linkedin.com (not login/checkpoint), else the first open page;
+            # only new_page() when the context has no usable tab. A reused tab
+            # is left open in the finally below so the next consumer reuses it.
+            for pg in context.pages:
+                u = pg.url or ""
+                if "linkedin.com" in u and "login" not in u and "checkpoint" not in u:
+                    page, _reused_page = pg, True
+                    break
+            if page is None and context.pages:
+                page, _reused_page = context.pages[0], True
+            if page is None:
+                page = context.new_page()
+            try:
+                page.goto(
+                    search_url,
+                    wait_until="domcontentloaded",
+                    timeout=30000,
+                )
+            except Exception as e:
+                _log_search(query, vertical, ok=False, error="navigation_failed")
+                return {
+                    "ok": False,
+                    "error": "navigation_failed",
+                    "detail": str(e),
+                }
+
+            # Settle: search results lazy-render after DOMContentLoaded.
+            # Selectors cover the new SDUI layout (post 2026-04 rollout) AND
+            # the legacy class layout, in that order.
+            try:
+                page.wait_for_selector(
+                    "[data-sdui-screen*='SearchResultsContent'], "
+                    "div.search-results-container, "
+                    "main[aria-label*='Search'], "
+                    "div.feed-shared-update-v2",
+                    timeout=10000,
+                )
+            except Exception:
+                pass  # extractor will return [] if nothing rendered
+
+            # Random 2-4s human-pacing delay before reading the DOM. The new
+            # SDUI layout streams cards in after the screen container exists;
+            # 1-3s sometimes returned 6/8 cards. 2-4s reliably gets 8/8.
+            page.wait_for_timeout(random.randint(2000, 4000))
+
+            cur_url = page.url
+            if _is_login_or_checkpoint(cur_url):
+                _log_search(query, vertical, ok=False, error="session_invalid")
+                return {
+                    "ok": False,
+                    "error": "session_invalid",
+                    "url": cur_url,
+                }
+            # LinkedIn's anti-automation likes to redirect a refused SERP to
+            # https://www.linkedin.com/ (no /login marker). Without this
+            # check the extractor would run on the homepage, find nothing,
+            # and we'd return ok:true with result_count:0 — masking failure
+            # as an empty query. Require landing on the SERP path.
+            if not cur_url.startswith(serp_prefix):
+                _log_search(query, vertical, ok=False, error="serp_redirected")
+                return {
+                    "ok": False,
+                    "error": "serp_redirected",
+                    "url": cur_url,
+                }
+
+            raw = page.evaluate(_SEARCH_JS_BY_VERTICAL[vertical])
+            try:
+                results = json.loads(raw or "[]")
+            except json.JSONDecodeError:
+                results = []
+
+            # Author exclusion (ALL verticals). Drop hard-excluded authors
+            # (config.json exclusions + author_blocklist, slug-keyed) before the
+            # Phase A picker, scoring, or the comment_gated logic can see them.
+            # Slug is the reliable key; display-name matches are intentionally
+            # soft (many real namesakes), so only "hard" verdicts drop here.
+            # The helper is fail-open, so a blocklist-API hiccup can't wedge
+            # discovery.
+            _excl = load_exclusions()
+            before_excl = len(results)
+            results = [
+                r for r in results
+                if classify_author(
+                    r.get("author_name"), r.get("author_profile_url"), _excl
+                )[0] != "hard"
+            ]
+            dropped_excluded = before_excl - len(results)
+            if dropped_excluded:
+                print(
+                    f"[discover_linkedin_candidates] dropped_excluded="
+                    f"{dropped_excluded} (author on exclusion list)",
+                    file=sys.stderr,
+                )
+
+            dropped_comment_gated = 0
+            if vertical == "content":
+                # Programmatic comment-gate pre-filter (Phase A). Posts whose
+                # author restricted commenting to connections-only are
+                # uncommentable by a 3rd+ degree account: the comment editor
+                # never renders and a full compose/post cycle ends in
+                # rejected_by_platform. Before this filter ~28% of posts that
+                # reached the comment stage died this way (35/123 since the
+                # 2026-05-29 harness migration). The gate is visible in the
+                # scraped card chrome, so we drop these here and never spend a
+                # Phase B cycle on them. The like-at-comment-time backstop in
+                # the posting agent still catches gates not shown in the card.
+                before = len(results)
+                results = [r for r in results if not r.get("comment_gated")]
+                dropped_comment_gated = before - len(results)
+                for r in results:
+                    velocity, virality, age_clamped = calculate_velocity_score(r)
+                    r["engagement_velocity"] = velocity
+                    r["velocity_score"] = virality
+                    r["age_hours_clamped"] = age_clamped
+                # Twitter model: rank, never drop. Sort by velocity_score DESC
+                # so the Phase A picker sees the strongest candidates first and
+                # takes from the top; weak cards stay eligible as fallback so
+                # quiet topics still yield a comment instead of zero-posting.
+                results.sort(key=lambda x: x.get("velocity_score") or 0, reverse=True)
+
+            _log_search(query, vertical, ok=True, error=None)
+            return {
+                "ok": True,
+                "url": cur_url,
+                "vertical": vertical,
+                "query": query,
+                "result_count": len(results),
+                "dropped_below_virality_floor": 0,
+                "dropped_comment_gated": dropped_comment_gated,
+                "dropped_excluded": dropped_excluded,
+                "virality_floor": None,
+                "results": results,
+                "rate_budget": {
+                    "daily_used": rate.get("daily_used"),
+                    "daily_cap": None,
+                    "monthly_used": rate.get("monthly_used"),
+                    "monthly_cap": None,
+                },
+            }
+
+        finally:
+            # Close ONLY a page WE created, never the context or the browser.
+            # The MCP keeps owning the Chrome instance and its existing pages.
+            # A reused tab is left open so the next consumer can reuse it.
+            try:
+                if page is not None and not _reused_page:
+                    page.close()
+            except Exception:
+                pass
+            try:
+                browser.disconnect()
+            except Exception:
+                pass
+
+
+def search_with_retry(vertical: str, query: str, max_attempts: int = 2) -> dict:
+    """One retry on transient browser-target failures only. Do NOT retry on
+    session_invalid / mcp_not_running / serp_redirected."""
+    last_result: dict = {"ok": False, "error": "no_attempts"}
+    for attempt in range(1, max_attempts + 1):
+        try:
+            result = search(vertical, query)
+        except Exception as e:
+            result = {
+                "ok": False,
+                "error": "exception",
+                "detail": f"{type(e).__name__}: {e}",
+                "attempt": attempt,
+            }
+        last_result = result
+        err = (result.get("error") or "").lower()
+        detail = (result.get("detail") or "").lower()
+        transient = (
+            "targetclosed" in detail
+            or "target page" in detail
+            or "browser has been closed" in detail
+            or err == "navigation_failed"
+        )
+        if result.get("ok") or not transient or attempt >= max_attempts:
+            if attempt > 1:
+                result["retry_attempt"] = attempt
+            return result
+        print(
+            f"[discover_linkedin_candidates] transient failure attempt "
+            f"{attempt}: {result.get('detail') or result.get('error')}; "
+            f"retrying...",
+            file=sys.stderr,
+        )
+        time.sleep(2)
+    return last_result
+
+
+def main():
+    # Guard: only authorized pipelines may invoke this helper. Other Claude
+    # subprocess planners auto-load CLAUDE.md as system context, see this
+    # helper documented there, and have wandered off-task to "smoke test"
+    # it — racing the linkedin profile's SingletonLock and triggering
+    # server-side session invalidation. The legitimate caller sets the
+    # matching env var immediately before invoking; nothing else does.
+    if os.environ.get("SOCIAL_AUTOPOSTER_LINKEDIN_SEARCH") != "1":
+        print(
+            json.dumps({
+                "ok": False,
+                "error": "unauthorized_caller",
+                "detail": (
+                    "discover_linkedin_candidates.py is invoked only by the "
+                    "run-linkedin Phase A discovery pipeline. Set "
+                    "SOCIAL_AUTOPOSTER_LINKEDIN_SEARCH=1 from the caller if "
+                    "this invocation is legitimate."
+                ),
+            }),
+            file=sys.stderr,
+        )
+        sys.exit(2)
+    if len(sys.argv) < 3:
+        print(
+            "Usage: discover_linkedin_candidates.py "
+            "<people|content|companies> <query>",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+    vertical = sys.argv[1]
+    query = " ".join(sys.argv[2:])
+    result = search_with_retry(vertical, query)
+    print(json.dumps(result, indent=2))
+    sys.exit(0 if result.get("ok") else 1)
+
+
+if __name__ == "__main__":
+    main()