indiecrm-cli 0.1.0 → 0.2.1

package/dist/domainfinder.js

@@ -0,0 +1,764 @@
+const DOMAIN_BLACKLIST = new Set(["linkedin.com", "bit.ly", "linktr.ee", "facebook.com"]);
+const COMPANY_NAME_STOPWORDS = new Set([
+    "group",
+    "gmbh",
+    "ag",
+    "kg",
+    "co",
+    "company",
+    "holding",
+    "holdings",
+    "solutions",
+    "systems",
+    "services",
+    "international",
+    "global",
+    "the",
+    "und",
+    "and",
+    "de",
+    "of"
+]);
+function marketCountries(market) {
+    if (market === "dach") {
+        return ["DE", "AT", "CH"];
+    }
+    if (market === "europe") {
+        return ["DE", "AT", "CH", "NL", "GB", "FR", "SE", "DK"];
+    }
+    return [];
+}
+function sqlCountryList(market) {
+    const countries = marketCountries(market);
+    if (countries.length === 0) {
+        return "";
+    }
+    return countries.map((country) => `"${country}"`).join(", ");
+}
+function normalizeDomain(value) {
+    if (!value) {
+        return null;
+    }
+    let normalized = value.trim().toLowerCase();
+    if (normalized.length === 0) {
+        return null;
+    }
+    normalized = normalized.replace(/^https?:\/\//, "");
+    normalized = normalized.replace(/^www\./, "");
+    normalized = normalized.replace(/\/.*$/, "");
+    return normalized.length > 0 ? normalized : null;
+}
+function rootDomain(value) {
+    const normalized = normalizeDomain(value);
+    if (!normalized) {
+        return null;
+    }
+    const parts = normalized.split(".");
+    if (parts.length <= 2) {
+        return normalized;
+    }
+    return parts.slice(-2).join(".");
+}
+function domainLabel(value) {
+    const root = rootDomain(value);
+    if (!root) {
+        return null;
+    }
+    return root.split(".")[0] ?? null;
+}
+function companyNameTokens(companyName) {
+    return (companyName ?? "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 3 && !COMPANY_NAME_STOPWORDS.has(token));
+}
+function domainCompanyMatchScore(domain, companyName) {
+    const label = domainLabel(domain);
+    if (!label) {
+        return -1;
+    }
+    const normalizedLabel = label.replace(/[^a-z0-9]/g, "");
+    if (normalizedLabel.length === 0) {
+        return -1;
+    }
+    const tokens = companyNameTokens(companyName);
+    if (tokens.length === 0) {
+        return normalizedLabel.length;
+    }
+    let score = 0;
+    for (const token of tokens) {
+        const normalizedToken = token.replace(/[^a-z0-9]/g, "");
+        if (normalizedToken.length === 0) {
+            continue;
+        }
+        if (normalizedLabel === normalizedToken) {
+            score += 100 + normalizedToken.length;
+            continue;
+        }
+        if (normalizedLabel.startsWith(normalizedToken)) {
+            score += 60 + normalizedToken.length;
+            continue;
+        }
+        if (normalizedLabel.includes(normalizedToken)) {
+            score += 40 + normalizedToken.length;
+            continue;
+        }
+        if (normalizedToken.startsWith(normalizedLabel) && normalizedLabel.length >= 4) {
+            score += 20 + normalizedLabel.length;
+        }
+    }
+    return score;
+}
+function chooseBetterCompanyMatchCandidate(candidates, baselineDomain) {
+    const baselineScore = domainCompanyMatchScore(baselineDomain, candidates[0]?.companyName);
+    const ranked = [...candidates]
+        .filter((candidate) => normalizeDomain(candidate.domain) !== null)
+        .filter((candidate) => !isBlacklistedDomain(candidate.domain))
+        .filter((candidate) => candidate.source !== "linkedin")
+        .sort((a, b) => {
+        const scoreDelta = domainCompanyMatchScore(b.domain, b.companyName) -
+            domainCompanyMatchScore(a.domain, a.companyName);
+        if (scoreDelta !== 0) {
+            return scoreDelta;
+        }
+        const hunterDelta = (b.hunterEmailCount ?? -1) - (a.hunterEmailCount ?? -1);
+        if (hunterDelta !== 0) {
+            return hunterDelta;
+        }
+        return (a.source ?? "").localeCompare(b.source ?? "");
+    });
+    const best = ranked[0] ?? null;
+    if (!best) {
+        return null;
+    }
+    const bestScore = domainCompanyMatchScore(best.domain, best.companyName);
+    const hasPositiveHunterSignal = (best.hunterEmailCount ?? 0) > 0;
+    if (hasPositiveHunterSignal && bestScore > baselineScore) {
+        return {
+            ...best,
+            domain: normalizeDomain(best.domain)
+        };
+    }
+    return null;
+}
+function isBlacklistedDomain(value) {
+    const normalized = normalizeDomain(value);
+    if (!normalized) {
+        return false;
+    }
+    return DOMAIN_BLACKLIST.has(normalized);
+}
+function getCompanyKey(candidate) {
+    if (candidate.companyId !== null) {
+        return `company:${candidate.companyId}`;
+    }
+    if (candidate.crmCompanyId !== null) {
+        return `crm:${candidate.crmCompanyId}`;
+    }
+    return `name:${candidate.companyName.trim().toLowerCase()}`;
+}
+function chooseBestDomainPipedreamLegacy(candidates) {
+    if (candidates.length === 0) {
+        return {
+            companyKey: "unknown",
+            selected: null,
+            reason: "no-domain",
+            candidates: []
+        };
+    }
+    const companyKey = getCompanyKey(candidates[0]);
+    const sourceOrder = { hunter: 0, openai: 1 };
+    const best = [...candidates].sort((a, b) => {
+        const hunterDelta = (b.hunterEmailCount ?? 0) - (a.hunterEmailCount ?? 0);
+        if (hunterDelta !== 0) {
+            return hunterDelta;
+        }
+        const aHasDomain = normalizeDomain(a.domain) !== null ? 0 : 1;
+        const bHasDomain = normalizeDomain(b.domain) !== null ? 0 : 1;
+        if (aHasDomain !== bHasDomain) {
+            return aHasDomain - bHasDomain;
+        }
+        return (sourceOrder[a.source] ?? 99) - (sourceOrder[b.source] ?? 99);
+    })[0] ?? null;
+    if (best && normalizeDomain(best.domain) !== null) {
+        return {
+            companyKey,
+            selected: {
+                ...best,
+                domain: normalizeDomain(best.domain)
+            },
+            reason: "highest-hunter-count",
+            candidates
+        };
+    }
+    return {
+        companyKey,
+        selected: null,
+        reason: "no-domain",
+        candidates
+    };
+}
+export function chooseBestDomain(candidates) {
+    if (candidates.length === 0) {
+        return {
+            companyKey: "unknown",
+            selected: null,
+            reason: "no-domain",
+            candidates: []
+        };
+    }
+    const companyKey = getCompanyKey(candidates[0]);
+    const nonNullCandidates = candidates.filter((candidate) => normalizeDomain(candidate.domain) !== null);
+    const linkedinDomain = normalizeDomain(candidates[0].linkedinDomain);
+    const linkedinWebsite = normalizeDomain(candidates[0].linkedinWebsite);
+    const betterThanLinkedinDomain = linkedinDomain
+        ? chooseBetterCompanyMatchCandidate(nonNullCandidates, linkedinDomain)
+        : null;
+    const betterThanLinkedinWebsite = !linkedinDomain && linkedinWebsite
+        ? chooseBetterCompanyMatchCandidate(nonNullCandidates, linkedinWebsite)
+        : null;
+    if (betterThanLinkedinDomain) {
+        return {
+            companyKey,
+            selected: betterThanLinkedinDomain,
+            reason: "better-company-match",
+            candidates
+        };
+    }
+    if (linkedinDomain && !isBlacklistedDomain(linkedinDomain)) {
+        const selectedCandidate = nonNullCandidates.find((candidate) => normalizeDomain(candidate.domain) === linkedinDomain) ?? {
+            ...candidates[0],
+            domain: linkedinDomain,
+            source: "linkedin",
+            type: "original",
+            hunterEmailCount: candidates[0].hunterEmailCount
+        };
+        const selected = {
+            ...selectedCandidate,
+            domain: linkedinDomain
+        };
+        return {
+            companyKey,
+            selected,
+            reason: "linkedin-domain",
+            candidates
+        };
+    }
+    if (betterThanLinkedinWebsite) {
+        return {
+            companyKey,
+            selected: betterThanLinkedinWebsite,
+            reason: "better-company-match",
+            candidates
+        };
+    }
+    if (linkedinWebsite && !isBlacklistedDomain(linkedinWebsite)) {
+        const websiteRoot = rootDomain(linkedinWebsite);
+        const selectedCandidate = nonNullCandidates.find((candidate) => rootDomain(candidate.domain) === websiteRoot) ?? {
+            ...candidates[0],
+            domain: websiteRoot,
+            source: "linkedin",
+            type: "original",
+            hunterEmailCount: candidates[0].hunterEmailCount
+        };
+        const selected = {
+            ...selectedCandidate,
+            domain: websiteRoot
+        };
+        return {
+            companyKey,
+            selected,
+            reason: "linkedin-website",
+            candidates
+        };
+    }
+    const bestByHunter = [...nonNullCandidates]
+        .filter((candidate) => !isBlacklistedDomain(candidate.domain))
+        .sort((a, b) => {
+        const hunterDelta = (b.hunterEmailCount ?? -1) - (a.hunterEmailCount ?? -1);
+        if (hunterDelta !== 0) {
+            return hunterDelta;
+        }
+        return (a.source ?? "").localeCompare(b.source ?? "");
+    })[0];
+    if (bestByHunter) {
+        return {
+            companyKey,
+            selected: bestByHunter,
+            reason: "highest-hunter-count",
+            candidates
+        };
+    }
+    const firstNonNull = nonNullCandidates.find((candidate) => !isBlacklistedDomain(candidate.domain)) ?? null;
+    if (firstNonNull) {
+        return {
+            companyKey,
+            selected: {
+                ...firstNonNull,
+                domain: normalizeDomain(firstNonNull.domain)
+            },
+            reason: "fallback-first-non-null",
+            candidates
+        };
+    }
+    return {
+        companyKey,
+        selected: null,
+        reason: "no-domain",
+        candidates
+    };
+}
+export function selectBestDomains(candidates) {
+    const groups = new Map();
+    for (const candidate of candidates) {
+        const key = getCompanyKey(candidate);
+        const existing = groups.get(key) ?? [];
+        existing.push(candidate);
+        groups.set(key, existing);
+    }
+    return Array.from(groups.values()).map((group) => chooseBestDomain(group));
+}
+export function compareDomainSelectionStrategies(candidates) {
+    const groups = new Map();
+    for (const candidate of candidates) {
+        const key = getCompanyKey(candidate);
+        const existing = groups.get(key) ?? [];
+        existing.push(candidate);
+        groups.set(key, existing);
+    }
+    const oldByReason = {};
+    const newByReason = {};
+    const changeFlags = {};
+    const changes = [];
+    for (const [companyKey, group] of groups.entries()) {
+        const legacy = chooseBestDomainPipedreamLegacy(group);
+        const improved = chooseBestDomain(group);
+        oldByReason[legacy.reason] = (oldByReason[legacy.reason] ?? 0) + 1;
+        newByReason[improved.reason] = (newByReason[improved.reason] ?? 0) + 1;
+        const oldDomain = normalizeDomain(legacy.selected?.domain);
+        const newDomain = normalizeDomain(improved.selected?.domain);
+        const oldSource = legacy.selected?.source ?? null;
+        const newSource = improved.selected?.source ?? null;
+        if (oldDomain === newDomain && oldSource === newSource && legacy.reason === improved.reason) {
+            continue;
+        }
+        const flags = [];
+        if (oldDomain !== newDomain) {
+            flags.push("domain-changed");
+        }
+        if (oldSource !== newSource) {
+            flags.push("source-changed");
+        }
+        if (oldDomain !== null && isBlacklistedDomain(oldDomain) && newDomain === null) {
+            flags.push("rejected-blacklisted-legacy-choice");
+        }
+        if (legacy.reason === "highest-hunter-count" && improved.reason !== "highest-hunter-count") {
+            flags.push("overrode-hunter-preference");
+        }
+        if (improved.reason === "linkedin-domain" || improved.reason === "linkedin-website") {
+            flags.push("preferred-linkedin");
+        }
+        if (improved.reason === "better-company-match") {
+            flags.push("preferred-hunter-company-match");
+        }
+        for (const flag of flags) {
+            changeFlags[flag] = (changeFlags[flag] ?? 0) + 1;
+        }
+        changes.push({
+            companyKey,
+            companyName: improved.selected?.companyName ?? legacy.selected?.companyName ?? group[0]?.companyName ?? null,
+            oldDomain,
+            newDomain,
+            oldSource,
+            newSource,
+            oldReason: legacy.reason,
+            newReason: improved.reason,
+            flags
+        });
+    }
+    return {
+        summary: {
+            companies: groups.size,
+            changedSelections: changes.length,
+            oldByReason,
+            newByReason,
+            changeFlags
+        },
+        changes
+    };
+}
+function escapeSqlString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function sqlStringLiteral(value) {
+    if (value === null) {
+        return "NULL";
+    }
+    return `'${escapeSqlString(value)}'`;
+}
+function sqlIntLiteral(value) {
+    return value === null ? "NULL" : `${value}`;
+}
+export function buildDomainfinderWritebackSql(decisions, traceId) {
+    const accepted = decisions.filter((decision) => decision.selected !== null && decision.reason !== "no-domain" && !isBlacklistedDomain(decision.selected.domain));
+    const rowSql = accepted.map((decision) => {
+        const selected = decision.selected;
+        return `SELECT
+  ${sqlIntLiteral(selected.companyId)} AS companyId,
+  ${sqlStringLiteral(selected.type ?? "selected")} AS type,
+  ${sqlStringLiteral(selected.companyName)} AS name,
+  ${sqlStringLiteral(selected.source)} AS source,
+  ${sqlIntLiteral(selected.hunterEmailCount)} AS total,
+  CURRENT_TIMESTAMP() AS ts,
+  ${sqlStringLiteral(traceId)} AS trace_id,
+  ${sqlStringLiteral(normalizeDomain(selected.domain))} AS domain,
+  ${sqlIntLiteral(selected.crmCompanyId)} AS crm_companyId`;
+    });
+    if (rowSql.length === 0) {
+        return `-- No accepted domain decisions to write back for trace_id ${traceId}\nSELECT 0 AS rows_to_insert;`;
+    }
+    return `INSERT INTO \`icpidentifier.SalesPrompter.domainFinder_output\`
+  (companyId, type, name, source, total, ts, trace_id, domain, crm_companyId)
+${rowSql.join("\nUNION ALL\n")};`;
+}
+export function auditDomainDecisions(decisions) {
+    const findings = decisions.map((decision) => {
+        const selected = decision.selected;
+        const selectedDomain = normalizeDomain(selected?.domain);
+        const linkedinDomain = normalizeDomain(selected?.linkedinDomain ?? decision.candidates[0]?.linkedinDomain);
+        const linkedinWebsiteRoot = rootDomain(selected?.linkedinWebsite ?? decision.candidates[0]?.linkedinWebsite);
+        const flags = [];
+        if (selected === null || selectedDomain === null) {
+            flags.push("no-selected-domain");
+        }
+        if (selectedDomain !== null && isBlacklistedDomain(selectedDomain)) {
+            flags.push("selected-blacklisted");
+        }
+        if (decision.reason === "fallback-first-non-null") {
+            flags.push("fallback-selected");
+        }
+        if (decision.reason === "better-company-match") {
+            flags.push("better-company-match-selected");
+        }
+        if (decision.reason === "highest-hunter-count") {
+            flags.push("hunter-selected");
+        }
+        if (selected?.source === "openai") {
+            flags.push("selected-openai");
+        }
+        if (selected?.source === "hunter") {
+            flags.push("selected-hunter");
+        }
+        if (selectedDomain !== null && linkedinDomain !== null && rootDomain(selectedDomain) !== rootDomain(linkedinDomain)) {
+            flags.push("mismatch-linkedin-domain");
+        }
+        if (selectedDomain !== null && linkedinWebsiteRoot !== null && rootDomain(selectedDomain) !== linkedinWebsiteRoot) {
+            flags.push("mismatch-linkedin-website");
+        }
+        if (selectedDomain !== null && selectedDomain.startsWith("www.")) {
+            flags.push("selected-not-root-domain");
+        }
+        return {
+            companyKey: decision.companyKey,
+            companyName: selected?.companyName ?? decision.candidates[0]?.companyName ?? null,
+            reason: decision.reason,
+            selectedDomain,
+            selectedSource: selected?.source ?? null,
+            flags
+        };
+    });
+    const byReason = {};
+    const byFlag = {};
+    let acceptedForWriteback = 0;
+    for (const decision of decisions) {
+        byReason[decision.reason] = (byReason[decision.reason] ?? 0) + 1;
+    }
+    for (const finding of findings) {
+        if (finding.flags.length === 0) {
+            acceptedForWriteback += 1;
+        }
+        for (const flag of finding.flags) {
+            byFlag[flag] = (byFlag[flag] ?? 0) + 1;
+        }
+    }
+    return {
+        summary: {
+            decisions: decisions.length,
+            acceptedForWriteback,
+            rejectedForWriteback: decisions.length - acceptedForWriteback,
+            byReason,
+            byFlag
+        },
+        findings: findings.filter((finding) => finding.flags.length > 0)
+    };
+}
+export function buildDomainfinderInputSql(market) {
+    const countries = sqlCountryList(market);
+    const countryFilter = countries.length > 0 ? `AND countryCode IN (${countries})` : "";
+    return `CREATE OR REPLACE VIEW \`icpidentifier.SalesPrompter.domainFinder_input_v2\` AS
+SELECT
+  CAST(NULL AS INT64) AS clientId,
+  id AS companyId,
+  CAST(NULL AS INT64) AS crm_companyId,
+  name AS companyName,
+  headquarters,
+  domain_linkedin AS domain
+FROM \`icpidentifier.SalesPrompter.linkedin_companies\`
+WHERE company_emailDomainFinder_toBeProcessed = TRUE
+  ${countryFilter}
+  AND COALESCE(blacklisted_bySalesPrompter, FALSE) = FALSE
+  AND (linkedin_companies_companyUnavailable IS NULL OR linkedin_companies_companyUnavailable = FALSE)
+  AND (domain_linkedin IS NOT NULL OR website_linkedin IS NOT NULL)
+  AND COALESCE(domainBlacklisted, FALSE) = FALSE;`;
+}
+export function buildDomainfinderCandidatesSql(market, limit) {
+    const countries = sqlCountryList(market);
+    const countryFilter = countries.length > 0 ? `AND comp.countryCode IN (${countries})` : "";
+    return `WITH backlog AS (
+  SELECT
+    comp.id AS companyId,
+    comp.name AS companyName,
+    comp.domain_linkedin AS linkedinDomain,
+    comp.website_linkedin AS linkedinWebsite,
+    comp.hunter_emailCount AS hunterEmailCount
+  FROM \`icpidentifier.SalesPrompter.linkedin_companies\` comp
+  WHERE comp.company_emailDomainFinder_toBeProcessed = TRUE
+    ${countryFilter}
+    AND COALESCE(comp.blacklisted_bySalesPrompter, FALSE) = FALSE
+    AND (comp.linkedin_companies_companyUnavailable IS NULL OR comp.linkedin_companies_companyUnavailable = FALSE)
+    AND (comp.domain_linkedin IS NOT NULL OR comp.website_linkedin IS NOT NULL)
+),
+existing_candidates AS (
+  SELECT
+    o.companyId,
+    CAST(NULL AS INT64) AS crmCompanyId,
+    b.companyName,
+    o.domain,
+    o.source,
+    o.type,
+    SAFE_CAST(o.total AS INT64) AS hunterEmailCount,
+    b.linkedinDomain,
+    b.linkedinWebsite
+  FROM backlog b
+  INNER JOIN \`icpidentifier.SalesPrompter.domainFinder_output\` o
+    ON o.companyId = b.companyId
+),
+linkedin_candidates AS (
+  SELECT
+    companyId,
+    CAST(NULL AS INT64) AS crmCompanyId,
+    companyName,
+    linkedinDomain AS domain,
+    "linkedin" AS source,
+    "original" AS type,
+    hunterEmailCount,
+    linkedinDomain,
+    linkedinWebsite
+  FROM backlog
+  WHERE linkedinDomain IS NOT NULL
+),
+website_candidates AS (
+  SELECT
+    companyId,
+    CAST(NULL AS INT64) AS crmCompanyId,
+    companyName,
+    linkedinWebsite AS domain,
+    "linkedin" AS source,
+    "website" AS type,
+    hunterEmailCount,
+    linkedinDomain,
+    linkedinWebsite
+  FROM backlog
+  WHERE linkedinDomain IS NULL
+    AND linkedinWebsite IS NOT NULL
+)
+SELECT *
+FROM (
+  SELECT * FROM existing_candidates
+  UNION ALL
+  SELECT * FROM linkedin_candidates
+  UNION ALL
+  SELECT * FROM website_candidates
+)
+LIMIT ${limit}`;
+}
+export function buildDomainfinderBacklogQueries(market) {
+    const countries = marketCountries(market);
+    const sqlCountries = sqlCountryList(market);
+    const marketClause = sqlCountries.length > 0 ? `WHERE countryCode IN (${sqlCountries})` : "";
+    return {
+        countries,
+        stages: [
+            {
+                key: "linkedin_companies_backlog",
+                description: "Backlog in linkedin_companies that still needs domain processing.",
+                sql: `SELECT
+  COUNT(*) AS companies,
+  COUNTIF(company_emailDomainFinder_toBeProcessed = TRUE) AS to_be_processed,
+  COUNTIF(company_emailDomainFinder_toBeProcessed = FALSE) AS processed,
+  COUNTIF(company_emailDomainFinder_toBeProcessed = TRUE AND domain_linkedin IS NOT NULL AND domain_linkedin != "") AS to_process_has_linkedin_domain,
+  COUNTIF(company_emailDomainFinder_toBeProcessed = TRUE AND website_linkedin IS NOT NULL AND website_linkedin != "") AS to_process_has_linkedin_website
+FROM \`icpidentifier.SalesPrompter.linkedin_companies\`
+${marketClause}`
+            },
+            {
+                key: "domainfinder_input_view",
+                description: "Current domainFinder_input view size.",
+                sql: `SELECT COUNT(*) AS rows_in_input FROM \`icpidentifier.SalesPrompter.domainFinder_input\``
+            },
+            {
+                key: "leadpool_bridge",
+                description: "Coverage of backlog companies inside SalesGPT.leadPool_new.",
+                sql: `WITH to_process AS (
+  SELECT id
+  FROM \`icpidentifier.SalesPrompter.linkedin_companies\`
+  WHERE company_emailDomainFinder_toBeProcessed = TRUE
+  ${sqlCountries.length > 0 ? `AND countryCode IN (${sqlCountries})` : ""}
+), leadpool_companies AS (
+  SELECT DISTINCT linkedin_contacts_companyId AS companyId
+  FROM \`icpidentifier.SalesGPT.leadPool_new\`
+  WHERE linkedin_contacts_companyId IS NOT NULL
+)
+SELECT
+  (SELECT COUNT(*) FROM to_process) AS to_process_total,
+  COUNTIF(lp.companyId IS NOT NULL) AS represented_in_leadpool,
+  COUNTIF(lp.companyId IS NULL) AS missing_from_leadpool
+FROM to_process tp
+LEFT JOIN leadpool_companies lp ON lp.companyId = tp.id`
+            },
+            {
+                key: "chosen_vs_linkedin",
+                description: "Chosen domain versus LinkedIn domain coverage and mismatch.",
+                sql: `SELECT
+  COUNT(*) AS companies,
+  COUNTIF(domain IS NOT NULL AND domain != "") AS with_chosen_domain,
+  COUNTIF(domain_linkedin IS NOT NULL AND domain_linkedin != "") AS with_domain_linkedin,
+  COUNTIF(website_linkedin IS NOT NULL AND website_linkedin != "") AS with_website_linkedin,
+  COUNTIF((domain IS NULL OR domain = "") AND (domain_linkedin IS NOT NULL AND domain_linkedin != "")) AS missing_chosen_has_linkedin,
+  COUNTIF(domain IS NOT NULL AND domain != "" AND domain_linkedin IS NOT NULL AND domain_linkedin != "" AND LOWER(domain) != LOWER(domain_linkedin)) AS chosen_differs_from_linkedin
+FROM \`icpidentifier.SalesPrompter.linkedin_companies\`
+${marketClause}`
+            }
+        ],
+        notes: [
+            "The old Pipedream workflow reads domainFinder_input, which is leadPool-driven and misses most of the linkedin_companies backlog.",
+            "A better input source is linkedin_companies where company_emailDomainFinder_toBeProcessed = TRUE.",
+            "LinkedIn domain or website should win before OpenAI or Hunter when present and not blacklisted."
+        ]
+    };
+}
+export function buildExistingDomainAuditQueries(market) {
+    const countries = marketCountries(market);
+    const sqlCountries = sqlCountryList(market);
+    const marketClause = sqlCountries.length > 0 ? `WHERE countryCode IN (${sqlCountries})` : "";
+    return {
+        countries,
+        stages: [
+            {
+                key: "summary",
+                description: "Existing chosen domains versus LinkedIn-derived references.",
+                sql: `SELECT
+  COUNT(*) AS companies,
+  COUNTIF(domain IS NOT NULL AND domain != "") AS with_chosen_domain,
+  COUNTIF(domain_linkedin IS NOT NULL AND domain_linkedin != "") AS with_linkedin_domain,
+  COUNTIF(website_linkedin IS NOT NULL AND website_linkedin != "") AS with_linkedin_website,
+  COUNTIF(LOWER(REGEXP_REPLACE(COALESCE(domain, ''), r'^https?://', '')) LIKE 'www.%') AS chosen_starts_with_www,
+  COUNTIF(LOWER(REGEXP_REPLACE(COALESCE(domain, ''), r'^https?://', '')) IN ('linkedin.com','www.linkedin.com','facebook.com','www.facebook.com','linktr.ee','bit.ly')) AS chosen_blacklisted,
+  COUNTIF(domain IS NOT NULL AND domain != '' AND domain_linkedin IS NOT NULL AND domain_linkedin != '' AND LOWER(REGEXP_REPLACE(domain, r'^www\\.', '')) != LOWER(REGEXP_REPLACE(domain_linkedin, r'^www\\.', ''))) AS chosen_differs_from_linkedin_domain,
+  COUNTIF(domain IS NOT NULL AND domain != '' AND website_linkedin IS NOT NULL AND website_linkedin != '' AND LOWER(REGEXP_REPLACE(REGEXP_EXTRACT(website_linkedin, r'^(?:https?://)?([^/]+)'), r'^www\\.', '')) != LOWER(REGEXP_REPLACE(domain, r'^www\\.', ''))) AS chosen_differs_from_linkedin_website
+FROM \`icpidentifier.SalesPrompter.linkedin_companies\`
+${marketClause}`
+            },
+            {
+                key: "samples",
+                description: "Sample problematic chosen domains from the current exposed linkedin_companies view.",
+                sql: `SELECT
+  id AS companyId,
+  name AS companyName,
+  countryCode,
+  domain,
+  domain_linkedin,
+  website_linkedin,
+  hunter_emailCount
+FROM \`icpidentifier.SalesPrompter.linkedin_companies\`
+${marketClause.length > 0 ? `${marketClause}\n  AND` : "WHERE"}
+  (
+    LOWER(REGEXP_REPLACE(COALESCE(domain, ''), r'^https?://', '')) IN ('linkedin.com','www.linkedin.com','facebook.com','www.facebook.com','linktr.ee','bit.ly')
+    OR (
+      domain IS NOT NULL AND domain != ''
+      AND domain_linkedin IS NOT NULL AND domain_linkedin != ''
+      AND LOWER(REGEXP_REPLACE(domain, r'^www\\.', '')) != LOWER(REGEXP_REPLACE(domain_linkedin, r'^www\\.', ''))
+    )
+  )
+ORDER BY hunter_emailCount DESC NULLS LAST, companyName
+LIMIT 100`
+            }
+        ]
+    };
+}
+export function buildExistingDomainRepairSql(market, traceId, limit, mode) {
+    const countries = sqlCountryList(market);
+    const marketClause = countries.length > 0 ? `AND comp.countryCode IN (${countries})` : "";
+    const repairPredicate = mode === "conservative"
+        ? `(
+      chosenDomain = ''
+      OR chosenDomain IN ('linkedin.com','facebook.com','linktr.ee','bit.ly')
+    )`
+        : mode === "mismatch-only"
+            ? `(chosenDomain != '' AND chosenDomain != targetDomain)`
+            : `(
+      chosenDomain = ''
+      OR chosenDomain IN ('linkedin.com','facebook.com','linktr.ee','bit.ly')
+      OR chosenDomain != targetDomain
+    )`;
+    return `INSERT INTO \`icpidentifier.SalesPrompter.domainFinder_output\`
+  (companyId, type, name, source, total, ts, trace_id, domain, crm_companyId)
+WITH normalized AS (
+  SELECT
+    comp.id AS companyId,
+    comp.name AS companyName,
+    comp.hunter_emailCount AS total,
+    LOWER(REGEXP_REPLACE(REGEXP_REPLACE(COALESCE(comp.domain, ''), r'^https?://', ''), r'^www\\.', '')) AS chosenDomain,
+    LOWER(REGEXP_REPLACE(COALESCE(comp.domain_linkedin, ''), r'^www\\.', '')) AS linkedinDomain,
+    LOWER(REGEXP_REPLACE(REGEXP_EXTRACT(COALESCE(comp.website_linkedin, ''), r'^(?:https?://)?([^/]+)'), r'^www\\.', '')) AS linkedinWebsiteHost
+  FROM \`icpidentifier.SalesPrompter.linkedin_companies\` comp
+  WHERE 1=1
+    ${marketClause}
+),
+targeted AS (
+  SELECT
+    companyId,
+    companyName,
+    total,
+    chosenDomain,
+    CASE
+      WHEN linkedinDomain != '' AND linkedinDomain NOT IN ('linkedin.com','facebook.com','linktr.ee','bit.ly')
+        THEN linkedinDomain
+      WHEN linkedinWebsiteHost != '' AND linkedinWebsiteHost NOT IN ('linkedin.com','facebook.com','linktr.ee','bit.ly')
+        THEN linkedinWebsiteHost
+      ELSE NULL
+    END AS targetDomain
+  FROM normalized
+),
+to_repair AS (
+  SELECT *
+  FROM targeted
+  WHERE targetDomain IS NOT NULL
+    AND ${repairPredicate}
+  ORDER BY total DESC NULLS LAST, companyName
+  LIMIT ${limit}
+)
+SELECT
+  companyId,
+  'repair-linkedin' AS type,
+  companyName AS name,
+  'repair' AS source,
+  total,
+  CURRENT_TIMESTAMP() AS ts,
+  '${traceId.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}' AS trace_id,
+  targetDomain AS domain,
+  CAST(NULL AS INT64) AS crm_companyId
+FROM to_repair;`;
+}