salesprompter-cli 0.1.35 → 0.1.37

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
-import { access, appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { access, appendFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
@@ -33,7 +33,9 @@ import { buildSalesNavigatorHistoricalBackfillPlan, ensureSalesNavigatorPeopleCo
 const require = createRequire(import.meta.url);
 const { version: packageVersion } = require("../package.json");
 const program = new Command();
-const leadProvider = new AccountLeadProvider(new HeuristicCompanyProvider(), new HeuristicPeopleSearchProvider());
+const companyProvider = new HeuristicCompanyProvider();
+const peopleSearchProvider = new HeuristicPeopleSearchProvider();
+const leadProvider = new AccountLeadProvider(companyProvider, peopleSearchProvider);
 const enrichmentProvider = new HeuristicEnrichmentProvider();
 const scoringProvider = new HeuristicScoringProvider();
 const syncProvider = new RoutedSyncProvider(new DryRunSyncProvider(), new InstantlySyncProvider());
@@ -120,6 +122,28 @@ const LinkedInCompanyBackfillStatusResponseSchema = z.object({
     failureCode: z.string().nullable().optional(),
     failureMessage: z.string().nullable().optional()
 });
+const PhantombusterContainersSyncResponseSchema = z.object({
+    status: z.literal("ok"),
+    agentIds: z.array(z.string().min(1)),
+    agents: z.array(z.object({
+        agentId: z.string().min(1),
+        fetched: z.number().int().nonnegative(),
+        upserted: z.number().int().nonnegative(),
+        resultsSynced: z.number().int().nonnegative()
+    })),
+    fetched: z.number().int().nonnegative(),
+    upserted: z.number().int().nonnegative(),
+    resultsSynced: z.number().int().nonnegative(),
+    outputsStored: z.number().int().nonnegative(),
+    resultObjectsStored: z.number().int().nonnegative(),
+    resultRowsStored: z.number().int().nonnegative(),
+    leadListsProjected: z.number().int().nonnegative().optional(),
+    leadListContactsProjected: z.number().int().nonnegative().optional(),
+    contactsProjected: z.number().int().nonnegative().optional(),
+    leadPoolRows: z.number().int().nonnegative().nullable().optional(),
+    qualifiedContacts: z.number().int().nonnegative().nullable().optional(),
+    qualifiedCompanies: z.number().int().nonnegative().nullable().optional()
+});
 const CliEmailEnrichmentCompaniesResponseSchema = z.object({
     clientId: z.number().int().positive(),
     companies: z.array(z.object({
@@ -948,6 +972,13 @@ function splitLookupFullName(fullName) {
 function buildSyntheticLookupEmail(contactId) {
     return `linkedin-lookup+${contactId}@salesprompter.invalid`;
 }
+function normalizeLinkedInLookupField(value) {
+    if (value == null) {
+        return undefined;
+    }
+    const normalized = normalizeLookupWhitespace(String(value));
+    return normalized || undefined;
+}
 function looksLikeLookupCompanyRow(fullName, companyName) {
     const fullNameComparable = normalizeLooseMatchText(fullName);
     const companyComparable = normalizeLooseMatchText(companyName);
@@ -967,19 +998,32 @@ function parseLinkedInUrlLookupInput(content) {
         const parsed = z
             .array(z.object({
             clientId: z.union([z.string(), z.number()]).nullish(),
+            contactId: z.union([z.string(), z.number()]).nullish(),
+            companyId: z.union([z.string(), z.number()]).nullish(),
             fullName: z.string().nullish(),
             companyName: z.string().nullish(),
             email: z.string().nullish(),
-            jobTitle: z.string().nullish()
+            contact_email: z.string().nullish(),
+            jobTitle: z.string().nullish(),
+            jobtitle: z.string().nullish(),
+            title: z.string().nullish(),
+            linkedin_company_url: z.string().nullish(),
+            linkedinCompanyUrl: z.string().nullish(),
+            deep_dive_recommended_role: z.string().nullish(),
+            deepDiveRecommendedRole: z.string().nullish()
         }))
             .parse(JSON.parse(trimmed));
         return parsed
             .map((row) => ({
             clientId: row.clientId == null ? null : String(row.clientId).trim() || null,
+            contactId: row.contactId == null ? undefined : String(row.contactId).trim() || undefined,
+            companyId: row.companyId == null ? undefined : String(row.companyId).trim() || undefined,
             fullName: row.fullName?.trim() ?? "",
             companyName: row.companyName?.trim() ?? "",
-            email: row.email?.trim() || undefined,
-            jobTitle: row.jobTitle?.trim() || undefined
+            email: row.email?.trim() || row.contact_email?.trim() || undefined,
+            jobTitle: row.jobTitle?.trim() || row.jobtitle?.trim() || row.title?.trim() || undefined,
+            linkedinCompanyUrl: row.linkedin_company_url?.trim() || row.linkedinCompanyUrl?.trim() || undefined,
+            deepDiveRecommendedRole: row.deep_dive_recommended_role?.trim() || row.deepDiveRecommendedRole?.trim() || undefined
         }))
             .filter((row) => row.fullName.length > 0 || row.companyName.length > 0);
     }
@@ -1007,17 +1051,35 @@ function parseLinkedInUrlLookupInput(content) {
         ? headerValues.findIndex((value) => ["companyname", "company_name"].includes(value))
         : 2;
     const emailIndex = hasHeader ? headerValues.findIndex((value) => value === "email") : -1;
+    const contactEmailIndex = hasHeader ? headerValues.findIndex((value) => value === "contact_email") : -1;
     const jobTitleIndex = hasHeader
         ? headerValues.findIndex((value) => ["jobtitle", "job_title", "title"].includes(value))
         : -1;
+    const contactIdIndex = hasHeader
+        ? headerValues.findIndex((value) => ["contactid", "contact_id", "hubspot_contact_id"].includes(value))
+        : -1;
+    const companyIdIndex = hasHeader
+        ? headerValues.findIndex((value) => ["companyid", "company_id", "hubspot_company_id"].includes(value))
+        : -1;
+    const linkedinCompanyUrlIndex = hasHeader
+        ? headerValues.findIndex((value) => ["linkedin_company_url", "linkedincompanyurl"].includes(value))
+        : -1;
+    const deepDiveRecommendedRoleIndex = hasHeader
+        ? headerValues.findIndex((value) => ["deep_dive_recommended_role", "deepdiverecommendedrole"].includes(value))
+        : -1;
     return dataLines
         .map((line) => splitLooseDelimitedLine(line, delimiter).map((value) => value.trim()))
         .map((columns) => ({
         clientId: clientIdIndex >= 0 ? columns[clientIdIndex] || null : null,
+        contactId: contactIdIndex >= 0 ? columns[contactIdIndex] || undefined : undefined,
+        companyId: companyIdIndex >= 0 ? columns[companyIdIndex] || undefined : undefined,
         fullName: fullNameIndex >= 0 ? columns[fullNameIndex] || "" : "",
         companyName: companyNameIndex >= 0 ? columns[companyNameIndex] || "" : "",
-        email: emailIndex >= 0 ? columns[emailIndex] || undefined : undefined,
-        jobTitle: jobTitleIndex >= 0 ? columns[jobTitleIndex] || undefined : undefined
+        email: (emailIndex >= 0 ? columns[emailIndex] || undefined : undefined) ??
+            (contactEmailIndex >= 0 ? columns[contactEmailIndex] || undefined : undefined),
+        jobTitle: jobTitleIndex >= 0 ? columns[jobTitleIndex] || undefined : undefined,
+        linkedinCompanyUrl: linkedinCompanyUrlIndex >= 0 ? columns[linkedinCompanyUrlIndex] || undefined : undefined,
+        deepDiveRecommendedRole: deepDiveRecommendedRoleIndex >= 0 ? columns[deepDiveRecommendedRoleIndex] || undefined : undefined
     }))
         .filter((row) => row.fullName.length > 0 || row.companyName.length > 0);
 }
@@ -1072,7 +1134,7 @@ function parseLinkedInCompanyLookupInput(content) {
 }
 function toLinkedInUrlLookupContacts(rows, cleanedCompanyMap = new Map()) {
     return rows.flatMap((row, index) => {
-        const contactId = String(index + 1);
+        const contactId = normalizeLinkedInLookupField(row.contactId) ?? String(index + 1);
         const syntheticEmail = row.email?.trim() || buildSyntheticLookupEmail(contactId);
         const rawCompanyName = normalizeLookupWhitespace(row.companyName);
         const cleanedCompanyName = normalizeLookupCompanyForSearch(cleanedCompanyMap.get(normalizeLookupCompanyForCleaning(rawCompanyName)) ?? rawCompanyName);
@@ -1086,7 +1148,10 @@ function toLinkedInUrlLookupContacts(rows, cleanedCompanyMap = new Map()) {
                     companyName: cleanedCompanyName,
                     companyNameOriginal: rawCompanyName || undefined,
                     email: syntheticEmail,
-                    jobTitle: row.jobTitle
+                    jobTitle: row.jobTitle,
+                    companyId: normalizeLinkedInLookupField(row.companyId),
+                    linkedinCompanyUrl: row.linkedinCompanyUrl?.trim() || undefined,
+                    deepDiveRecommendedRole: row.deepDiveRecommendedRole?.trim() || undefined
                 }
             ];
         }
@@ -1101,7 +1166,10 @@ function toLinkedInUrlLookupContacts(rows, cleanedCompanyMap = new Map()) {
                 companyName: cleanedCompanyName,
                 companyNameOriginal: rawCompanyName || undefined,
                 email: syntheticEmail,
-                jobTitle: row.jobTitle
+                jobTitle: row.jobTitle,
+                companyId: normalizeLinkedInLookupField(row.companyId),
+                linkedinCompanyUrl: row.linkedinCompanyUrl?.trim() || undefined,
+                deepDiveRecommendedRole: row.deepDiveRecommendedRole?.trim() || undefined
             }
         ];
         const rawDiffers = rawSplit.firstName !== cleanedSplit.firstName ||
@@ -1115,6 +1183,9 @@ function toLinkedInUrlLookupContacts(rows, cleanedCompanyMap = new Map()) {
                 companyNameOriginal: rawCompanyName || undefined,
                 email: syntheticEmail,
                 jobTitle: row.jobTitle,
+                companyId: normalizeLinkedInLookupField(row.companyId),
+                linkedinCompanyUrl: row.linkedinCompanyUrl?.trim() || undefined,
+                deepDiveRecommendedRole: row.deepDiveRecommendedRole?.trim() || undefined,
                 isVariation: true
             });
         }
@@ -1137,10 +1208,132 @@ function readPipedreamLinkedInEnrichmentConfig() {
         projectEnvironment: resolveConfiguredEnvValue(process.env, "PIPEDREAM_PROJECT_ENVIRONMENT") || ""
     };
 }
+function isSyntheticLinkedInLookupEmail(value) {
+    const normalized = normalizeLookupWhitespace(value).toLowerCase();
+    return normalized.endsWith("@salesprompter.invalid");
+}
 function deriveCsrfTokenFromCookie(cookie) {
     const match = cookie.match(/JSESSIONID="?([^";]+)"?/i);
     return match?.[1]?.trim() || "";
 }
+function normalizeLinkedInDirectLookupCookieHeader(cookie) {
+    const trimmed = normalizeLookupWhitespace(cookie);
+    if (!trimmed) {
+        return "";
+    }
+    if (trimmed.includes("=") || trimmed.includes(";")) {
+        return trimmed;
+    }
+    return `li_at=${trimmed}`;
+}
+function parseLocalLinkedInExtensionTokenLog(content) {
+    const matches = [
+        ...content.matchAll(/\{"csrfToken":"([^"]+)","extractedFrom":"sales-api\/salesApiLeadSearch"[\s\S]*?"linkedInIdentity":"([^"]+)"[\s\S]*?"sessionCookie":"([\s\S]*?)","syncStatus":"(success|captured)"[\s\S]*?"userAgent":"([^"]+)"\}/g)
+    ];
+    const last = matches.at(-1);
+    if (!last) {
+        return null;
+    }
+    const csrfToken = normalizeLookupWhitespace(last[1]);
+    const linkedInIdentity = normalizeLookupWhitespace(last[2]);
+    const sessionCookie = normalizeLookupWhitespace(last[3]?.replace(/\\"/g, "\"").replace(/\\\\/g, "\\"));
+    const userAgent = normalizeLookupWhitespace(last[5]);
+    if (!csrfToken || !linkedInIdentity || !sessionCookie || !userAgent) {
+        return null;
+    }
+    return {
+        csrfToken,
+        linkedInIdentity,
+        sessionCookie,
+        userAgent
+    };
+}
+async function readLocalLinkedInExtensionTokenLog(filePath) {
+    try {
+        const content = await readFile(filePath, "latin1");
+        return parseLocalLinkedInExtensionTokenLog(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function listChromeExtensionTokenLogCandidates() {
+    const overrideFile = normalizeLookupWhitespace(process.env.SALESPROMPTER_LINKEDIN_EXTENSION_TOKENS_LOG_PATH);
+    if (overrideFile) {
+        return [overrideFile];
+    }
+    const overrideDir = normalizeLookupWhitespace(process.env.SALESPROMPTER_LINKEDIN_EXTENSION_TOKENS_DIR);
+    if (overrideDir) {
+        try {
+            const files = await readdir(overrideDir);
+            return files
+                .filter((file) => file.endsWith(".log") || file.endsWith(".ldb"))
+                .map((file) => path.join(overrideDir, file))
+                .sort()
+                .reverse();
+        }
+        catch {
+            return [];
+        }
+    }
+    const chromeRootCandidates = [
+        path.join(os.homedir(), "Library", "Application Support", "Google", "Chrome"),
+        path.join(os.homedir(), "Library", "Application Support", "Chromium")
+    ];
+    const paths = [];
+    for (const chromeRoot of chromeRootCandidates) {
+        let profileDirs = [];
+        try {
+            profileDirs = await readdir(chromeRoot);
+        }
+        catch {
+            continue;
+        }
+        for (const profileDir of profileDirs) {
+            const extensionSettingsRoot = path.join(chromeRoot, profileDir, "Local Extension Settings");
+            let extensionIds = [];
+            try {
+                extensionIds = await readdir(extensionSettingsRoot);
+            }
+            catch {
+                continue;
+            }
+            for (const extensionId of extensionIds) {
+                const extensionDir = path.join(extensionSettingsRoot, extensionId);
+                let files = [];
+                try {
+                    files = await readdir(extensionDir);
+                }
+                catch {
+                    continue;
+                }
+                for (const file of files) {
+                    if (!file.endsWith(".log")) {
+                        continue;
+                    }
+                    paths.push(path.join(extensionDir, file));
+                }
+            }
+        }
+    }
+    return paths.sort().reverse();
+}
+async function readLocalLinkedInExtensionDirectLookupConfig() {
+    const candidates = await listChromeExtensionTokenLogCandidates();
+    for (const candidate of candidates) {
+        const snapshot = await readLocalLinkedInExtensionTokenLog(candidate);
+        if (!snapshot) {
+            continue;
+        }
+        return {
+            csrfToken: snapshot.csrfToken,
+            identity: snapshot.linkedInIdentity,
+            cookie: normalizeLinkedInDirectLookupCookieHeader(snapshot.sessionCookie),
+            userAgent: snapshot.userAgent
+        };
+    }
+    return null;
+}
 function readLinkedInDirectLookupEnvConfig() {
     const cookie = process.env.SALESPROMPTER_LINKEDIN_SALES_NAV_COOKIE?.trim() ||
         process.env.LINKEDIN_SALES_NAV_COOKIE?.trim() ||
@@ -1157,7 +1350,7 @@ function readLinkedInDirectLookupEnvConfig() {
     return {
         csrfToken,
         identity,
-        cookie,
+        cookie: normalizeLinkedInDirectLookupCookieHeader(cookie),
         userAgent: process.env.SALESPROMPTER_LINKEDIN_USER_AGENT?.trim() ||
             "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
     };
@@ -1207,7 +1400,7 @@ async function readStoredLinkedInDirectLookupConfig() {
     return {
         csrfToken,
         identity,
-        cookie: claimed.sessionCookie,
+        cookie: normalizeLinkedInDirectLookupCookieHeader(claimed.sessionCookie),
         userAgent
     };
 }
@@ -1221,6 +1414,11 @@ async function readLinkedInDirectLookupConfig() {
         cachedLinkedInDirectLookupConfig = envConfig;
         return envConfig;
     }
+    const localExtensionConfig = await readLocalLinkedInExtensionDirectLookupConfig();
+    if (localExtensionConfig) {
+        cachedLinkedInDirectLookupConfig = localExtensionConfig;
+        return localExtensionConfig;
+    }
     const storedConfig = await readStoredLinkedInDirectLookupConfig();
     if (storedConfig) {
         cachedLinkedInDirectLookupConfig = storedConfig;
@@ -1237,46 +1435,200 @@ function buildLinkedInSalesApiUrl(params) {
     const encodedFirstName = encodeURIComponent(params.firstName);
     const encodedLastName = encodeURIComponent(params.lastName);
     const encodedCompanyName = encodeURIComponent(params.companyName);
+    const encodedKeywords = encodeURIComponent(params.keywordsText?.trim() || params.companyName);
     const filters = params.searchMode === "current_company"
         ? `(type:FIRST_NAME,values:List((text:${encodedFirstName},selectionType:INCLUDED))),(type:LAST_NAME,values:List((text:${encodedLastName},selectionType:INCLUDED))),(type:CURRENT_COMPANY,values:List((text:${encodedCompanyName},selectionType:INCLUDED)))`
         : `(type:FIRST_NAME,values:List((text:${encodedFirstName},selectionType:INCLUDED))),(type:LAST_NAME,values:List((text:${encodedLastName},selectionType:INCLUDED)))`;
-    const keywordsSegment = params.searchMode === "keywords" ? `,keywords:${encodedCompanyName}` : "";
+    const keywordsSegment = params.searchMode === "current_company" ? "" : `,keywords:${encodedKeywords}`;
     return `${baseUrl.replace(/\/+$/, "")}/sales-api/salesApiLeadSearch?q=searchQuery&query=(recentSearchParam:(id:${Date.now()},doLogHistory:true),filters:List(${filters})${keywordsSegment})&start=0&count=25&trackingParam=(sessionId:${generateLinkedInSessionId()})&decorationId=com.linkedin.sales.deco.desktop.searchv2.LeadSearchResult-14`;
 }
+function extractLookupTitleKeywords(value) {
+    const shortAllowlist = new Set(["hr", "it", "cfo"]);
+    return normalizeLooseMatchText(value)
+        .split(/\s+/)
+        .filter((token) => token.length >= 4 || shortAllowlist.has(token))
+        .filter((token) => ![
+        "head",
+        "senior",
+        "consultant",
+        "manager",
+        "specialist",
+        "lead",
+        "global",
+        "team",
+        "group"
+    ].includes(token))
+        .slice(0, 4);
+}
+function buildDeepDiveRoleSearchKeywords(role) {
+    const normalized = normalizeLooseMatchText(role);
+    switch (normalized) {
+        case "budgetholder":
+            return ["finance", "procurement", "purchasing", "accounting", "controlling", "cfo"];
+        case "decisionmaker":
+            return ["director", "head", "vp", "chief", "leiter", "lead"];
+        case "champion":
+            return ["hr", "workplace", "operations", "it", "people", "office"];
+        case "executivesponsor":
+            return ["executive", "board", "chief", "managing", "director", "ceo"];
+        case "influencer":
+            return ["specialist", "manager", "consultant", "project", "workplace", "hr"];
+        case "legalandcompliance":
+            return ["legal", "compliance", "datenschutz", "counsel"];
+        case "blocker":
+            return ["procurement", "legal", "compliance", "security"];
+        case "enduser":
+            return ["workplace", "office", "operations", "assistant", "admin"];
+        default:
+            return [];
+    }
+}
 function buildLinkedInAccountSearchApiUrl(companyName) {
     const baseUrl = process.env.SALESPROMPTER_LINKEDIN_SALES_API_BASE_URL?.trim() ||
         "https://www.linkedin.com";
     const encodedCompanyName = encodeURIComponent(companyName);
     return `${baseUrl.replace(/\/+$/, "")}/sales-api/salesApiAccountSearch?q=searchQuery&query=(recentSearchParam:(id:${Date.now()},doLogHistory:true),spellCorrectionEnabled:true,keywords:${encodedCompanyName})&start=0&count=10&trackingParam=(sessionId:${generateLinkedInSessionId()})&decorationId=com.linkedin.sales.deco.desktop.searchv2.AccountSearchResult-14`;
 }
-function buildLinkedInLookupSearchVariants(contact) {
+async function buildLinkedInLookupSearchVariants(contact, timeoutMs, resolvedCompanyAliases = []) {
     const variants = [];
     const seen = new Set();
-    const companyCandidates = [
-        normalizeLookupWhitespace(contact.companyName),
-        normalizeLookupWhitespace(contact.companyNameOriginal)
-    ].filter(Boolean);
-    for (const companyName of companyCandidates) {
-        for (const searchMode of ["current_company", "keywords"]) {
-            const key = [
-                contact.firstName.trim().toLowerCase(),
-                contact.lastName.trim().toLowerCase(),
-                companyName.toLowerCase(),
-                searchMode
-            ].join("|");
-            if (seen.has(key)) {
-                continue;
-            }
-            seen.add(key);
-            variants.push({
-                firstName: contact.firstName,
-                lastName: contact.lastName,
-                companyName,
-                searchMode
-            });
+    const companyCandidateScores = new Map();
+    const addCompanyCandidate = (value, score) => {
+        const normalized = normalizeLookupWhitespace(value);
+        if (!normalized) {
+            return;
+        }
+        companyCandidateScores.set(normalized, Math.max(score, companyCandidateScores.get(normalized) ?? 0));
+    };
+    addCompanyCandidate(contact.companyName, 80);
+    addCompanyCandidate(contact.companyNameOriginal, 70);
+    const linkedInHandle = normalizeLinkedInCompanyHandle(contact.linkedinCompanyUrl ?? "");
+    if (linkedInHandle && !/^\d+$/.test(linkedInHandle)) {
+        addCompanyCandidate(linkedInHandle.replace(/[-_]+/g, " "), 95);
+    }
+    for (const alias of resolvedCompanyAliases) {
+        addCompanyCandidate(alias, 110);
+    }
+    const emailDomain = (() => {
+        const email = normalizeLookupWhitespace(contact.email);
+        if (!email || isSyntheticLinkedInLookupEmail(email)) {
+            return "";
+        }
+        const at = email.lastIndexOf("@");
+        return at >= 0 ? email.slice(at + 1) : "";
+    })();
+    if (emailDomain) {
+        const host = emailDomain.replace(/^www\./i, "").split(".")[0] ?? "";
+        if (host) {
+            addCompanyCandidate(host.replace(/[-_]+/g, " "), 100);
         }
     }
-    return variants;
+    if (contact.jobTitle && contact.deepDiveRecommendedRole) {
+        const primaryWord = normalizeLookupWhitespace(contact.companyNameOriginal ?? contact.companyName)
+            .split(/\s+/)
+            .filter((part) => part.length >= 4)
+            .slice(-1)[0];
+        if (primaryWord) {
+            addCompanyCandidate(primaryWord, 45);
+        }
+    }
+    const companyHints = await buildLinkedInProfileCompanyHints(contact, timeoutMs);
+    for (const phrase of companyHints.phrases) {
+        const tokenCount = normalizeLooseMatchText(phrase).split(/\s+/).filter(Boolean).length;
+        if (tokenCount >= 1 && tokenCount <= 4) {
+            addCompanyCandidate(phrase, tokenCount <= 2 ? 75 : 60);
+        }
+    }
+    for (const keyword of companyHints.keywords.slice(0, 5)) {
+        addCompanyCandidate(keyword, keyword.includes(".") ? 90 : 55);
+    }
+    const titleKeywords = Array.from(new Set([
+        ...extractLookupTitleKeywords(contact.jobTitle),
+        ...buildDeepDiveRoleSearchKeywords(contact.deepDiveRecommendedRole)
+    ])).slice(0, 6);
+    const rankedCompanyCandidates = Array.from(companyCandidateScores.entries())
+        .sort((left, right) => right[1] - left[1] || left[0].length - right[0].length)
+        .slice(0, 6);
+    const emailHostCandidate = (() => {
+        if (!emailDomain) {
+            return "";
+        }
+        return normalizeLookupWhitespace(emailDomain.replace(/^www\./i, "").split(".")[0] ?? "").replace(/[-_]+/g, " ");
+    })();
+    const cleanCompanyCandidate = normalizeLookupWhitespace(contact.companyName) ||
+        normalizeLookupWhitespace(contact.companyNameOriginal) ||
+        "";
+    const linkedInHandleCandidate = linkedInHandle && !/^\d+$/.test(linkedInHandle)
+        ? normalizeLookupWhitespace(linkedInHandle.replace(/[-_]+/g, " "))
+        : "";
+    const pushVariant = (companyName, searchMode) => {
+        const normalizedCompany = normalizeLookupWhitespace(companyName);
+        if (!normalizedCompany) {
+            return;
+        }
+        const keywordsText = searchMode === "keywords_title" && titleKeywords.length > 0
+            ? `${normalizedCompany} ${titleKeywords.join(" ")}`
+            : undefined;
+        if (searchMode === "keywords_title" && !keywordsText) {
+            return;
+        }
+        const key = [
+            contact.firstName.trim().toLowerCase(),
+            contact.lastName.trim().toLowerCase(),
+            normalizedCompany.toLowerCase(),
+            searchMode,
+            keywordsText?.toLowerCase() ?? ""
+        ].join("|");
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        variants.push({
+            firstName: contact.firstName,
+            lastName: contact.lastName,
+            companyName: normalizedCompany,
+            searchMode,
+            keywordsText
+        });
+    };
+    const rankedCompanyNames = rankedCompanyCandidates.map(([companyName]) => companyName);
+    const currentCompanyStageCandidates = [
+        emailHostCandidate,
+        linkedInHandleCandidate,
+        ...resolvedCompanyAliases,
+        ...rankedCompanyNames.filter((companyName) => (companyCandidateScores.get(companyName) ?? 0) >= 90)
+    ];
+    const keywordStageCandidates = [
+        cleanCompanyCandidate,
+        ...rankedCompanyNames
+    ];
+    const keywordTitleStageCandidates = [
+        cleanCompanyCandidate,
+        ...rankedCompanyNames
+    ];
+    const fallbackCurrentCompanyCandidates = [
+        cleanCompanyCandidate,
+        normalizeLookupWhitespace(contact.companyNameOriginal),
+        ...rankedCompanyNames
+    ];
+    for (const companyName of currentCompanyStageCandidates) {
+        pushVariant(companyName, "current_company");
+    }
+    for (const companyName of keywordStageCandidates) {
+        pushVariant(companyName, "keywords");
+    }
+    for (const companyName of keywordTitleStageCandidates) {
+        pushVariant(companyName, "keywords_title");
+    }
+    for (const companyName of fallbackCurrentCompanyCandidates) {
+        pushVariant(companyName, "current_company");
+    }
+    for (const [companyName] of rankedCompanyCandidates) {
+        pushVariant(companyName, "current_company");
+        pushVariant(companyName, "keywords");
+        pushVariant(companyName, "keywords_title");
+    }
+    return variants.slice(0, 12);
 }
 function normalizeSalesNavLeadUrl(value) {
     const trimmed = String(value ?? "").trim();
@@ -1298,14 +1650,21 @@ function normalizePublicLinkedInProfileUrl(value) {
     if (!trimmed) {
         return null;
     }
-    const publicMatch = trimmed.match(/https:\/\/www\.linkedin\.com\/in\/[^/?#]+\/?/i);
-    if (!publicMatch) {
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (!/(^|\.)linkedin\.com$/i.test(parsed.hostname)) {
         return null;
     }
-    const candidate = publicMatch[0] ?? null;
-    if (!candidate) {
+    const pathMatch = parsed.pathname.match(/^\/in\/([^/?#]+)\/?/i);
+    if (!pathMatch?.[1]) {
         return null;
     }
+    const candidate = `https://www.linkedin.com/in/${pathMatch[1]}`;
     return normalizeSalesNavLeadUrl(candidate) ? null : candidate;
 }
 function extractLinkedInProfileUrlFromSalesApiElement(element) {
@@ -1448,6 +1807,112 @@ function extractLinkedInCompanyNameFromSalesApiElement(element) {
     }
     return null;
 }
+function extractLinkedInFullNameFromSalesApiElement(element) {
+    if (!element) {
+        return null;
+    }
+    const directCandidates = [
+        typeof element.fullName === "string" ? element.fullName : null,
+        typeof element.name === "string" ? element.name : null
+    ].filter(Boolean);
+    for (const candidate of directCandidates) {
+        const normalized = normalizeLookupWhitespace(candidate);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    const firstName = typeof element.firstName === "string" ? normalizeLookupWhitespace(element.firstName) : "";
+    const lastName = typeof element.lastName === "string" ? normalizeLookupWhitespace(element.lastName) : "";
+    const combined = normalizeLookupWhitespace(`${firstName} ${lastName}`);
+    return combined || null;
+}
+function extractLinkedInTitleFromSalesApiElement(element) {
+    if (!element) {
+        return null;
+    }
+    const directCandidates = [
+        typeof element.title === "string" ? element.title : null,
+        typeof element.occupation === "string" ? element.occupation : null
+    ].filter(Boolean);
+    for (const candidate of directCandidates) {
+        const normalized = normalizeLookupWhitespace(candidate);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    const currentPosition = Array.isArray(element.currentPositions) && element.currentPositions.length > 0
+        ? element.currentPositions[0]
+        : null;
+    const currentTitle = currentPosition && typeof currentPosition.title === "string"
+        ? normalizeLookupWhitespace(currentPosition.title)
+        : "";
+    return currentTitle || null;
+}
+function scoreLinkedInSalesApiElementMatch(contact, element) {
+    const fullName = extractLinkedInFullNameFromSalesApiElement(element);
+    const companyName = extractLinkedInCompanyNameFromSalesApiElement(Array.isArray(element?.currentPositions) && element.currentPositions.length > 0
+        ? element.currentPositions[0]
+        : element) ?? extractLinkedInCompanyNameFromSalesApiElement(element);
+    const title = extractLinkedInTitleFromSalesApiElement(element);
+    const expectedFullName = normalizeLooseMatchText(`${contact.firstName} ${contact.lastName}`);
+    const candidateFullName = normalizeLooseMatchText(fullName);
+    const expectedCompanies = Array.from(new Set([
+        normalizeLooseMatchText(contact.companyNameOriginal ?? contact.companyName),
+        normalizeLooseMatchText(aggressivelyCleanLookupCompanyName(contact.companyNameOriginal ?? contact.companyName)),
+        normalizeLooseMatchText(normalizeLinkedInCompanyHandle(contact.linkedinCompanyUrl ?? "")?.replace(/[-_]+/g, " ") ?? ""),
+        normalizeLooseMatchText((() => {
+            const email = normalizeLookupWhitespace(contact.email);
+            if (!email || isSyntheticLinkedInLookupEmail(email)) {
+                return "";
+            }
+            return email.split("@")[1]?.replace(/^www\./i, "").split(".")[0] ?? "";
+        })())
+    ].filter(Boolean)));
+    const candidateCompany = normalizeLooseMatchText(companyName);
+    const candidateTitle = normalizeLooseMatchText(title);
+    let score = 0;
+    let exactNameMatch = false;
+    let companyMatchCount = 0;
+    if (expectedFullName && candidateFullName === expectedFullName) {
+        score += 120;
+        exactNameMatch = true;
+    }
+    else if (expectedFullName &&
+        candidateFullName.includes(normalizeLooseMatchText(contact.firstName)) &&
+        candidateFullName.includes(normalizeLooseMatchText(contact.lastName))) {
+        score += 90;
+    }
+    for (const companyHint of expectedCompanies) {
+        if (!companyHint) {
+            continue;
+        }
+        if (candidateCompany === companyHint) {
+            score += 40;
+            companyMatchCount += 1;
+        }
+        else if (candidateCompany.includes(companyHint) || companyHint.includes(candidateCompany)) {
+            score += 25;
+            companyMatchCount += 1;
+        }
+    }
+    const titleHints = [
+        ...extractLookupTitleKeywords(contact.jobTitle),
+        ...buildDeepDiveRoleSearchKeywords(contact.deepDiveRecommendedRole)
+    ].slice(0, 6);
+    for (const hint of titleHints) {
+        if (hint && candidateTitle.includes(normalizeLooseMatchText(hint))) {
+            score += 6;
+        }
+    }
+    return {
+        score,
+        fullName,
+        companyName,
+        title,
+        exactNameMatch,
+        companyMatchCount
+    };
+}
 function extractLinkedInCompanyEmployeeCountFromSalesApiElement(element) {
     if (!element) {
         return null;
@@ -1496,6 +1961,111 @@ function buildLinkedInCompanyLookupVariants(params) {
     }
     return variants;
 }
+function buildDirectCompanyContextKey(contact) {
+    return normalizeLooseMatchText(contact.companyNameOriginal ?? contact.companyName);
+}
+async function resolveDirectLinkedInCompanyContexts(params) {
+    const perCompanyBudgetMs = Math.min(params.timeoutMs, 10_000);
+    const primaryByCompany = new Map();
+    for (const contact of params.contacts) {
+        const key = buildDirectCompanyContextKey(contact);
+        if (!key || primaryByCompany.has(key)) {
+            continue;
+        }
+        primaryByCompany.set(key, contact);
+    }
+    const contexts = new Map();
+    for (const [companyKey, contact] of primaryByCompany.entries()) {
+        const aliases = new Set();
+        const addAlias = (value) => {
+            const normalized = normalizeLookupWhitespace(value);
+            if (!normalized) {
+                return;
+            }
+            aliases.add(normalized);
+        };
+        addAlias(contact.companyNameOriginal);
+        addAlias(contact.companyName);
+        const existingHandle = normalizeLinkedInCompanyHandle(contact.linkedinCompanyUrl ?? "");
+        if (existingHandle && !/^\d+$/.test(existingHandle)) {
+            addAlias(existingHandle.replace(/[-_]+/g, " "));
+        }
+        let matchedCompanyUrl = contact.linkedinCompanyUrl ?? null;
+        let matchedSalesNavCompanyUrl = null;
+        let matchedCompanyName = null;
+        let matchedCompanyEmployeeCount = null;
+        const companyDeadline = Date.now() + perCompanyBudgetMs;
+        const variants = buildLinkedInCompanyLookupVariants({
+            contactId: contact.contact_id,
+            companyName: contact.companyName,
+            companyNameOriginal: contact.companyNameOriginal
+        }).slice(0, 4);
+        for (const variant of variants) {
+            if (Date.now() >= companyDeadline) {
+                break;
+            }
+            const controller = new AbortController();
+            const timeout = setTimeout(controller.abort.bind(controller), Math.min(6_000, Math.max(1_000, companyDeadline - Date.now())));
+            try {
+                const response = await fetch(buildLinkedInAccountSearchApiUrl(variant.companyName), {
+                    method: "GET",
+                    signal: controller.signal,
+                    headers: {
+                        accept: "*/*",
+                        "accept-language": "en-GB,en-US;q=0.9,en;q=0.8",
+                        "csrf-token": params.config.csrfToken,
+                        referer: "https://www.linkedin.com/sales/search/company",
+                        "sec-fetch-dest": "empty",
+                        "sec-fetch-mode": "cors",
+                        "sec-fetch-site": "same-origin",
+                        "user-agent": params.config.userAgent,
+                        "x-li-identity": params.config.identity,
+                        "x-li-lang": "en_US",
+                        "x-li-page-instance": "urn:li:page:d_sales2_search_accounts;13Jvve6kRGCao+iP0wwAag==",
+                        "x-restli-protocol-version": "2.0.0",
+                        cookie: params.config.cookie
+                    }
+                });
+                if (!response.ok) {
+                    if (response.status === 429) {
+                        break;
+                    }
+                    continue;
+                }
+                const data = (await response.json());
+                const first = data.elements?.[0];
+                const companyUrl = extractLinkedInCompanyUrlFromSalesApiElement(first);
+                const salesNavCompanyUrl = extractLinkedInSalesNavCompanyUrlFromSalesApiElement(first);
+                const companyName = extractLinkedInCompanyNameFromSalesApiElement(first);
+                if (companyUrl || salesNavCompanyUrl || companyName) {
+                    matchedCompanyUrl = companyUrl ?? matchedCompanyUrl;
+                    matchedSalesNavCompanyUrl = salesNavCompanyUrl ?? matchedSalesNavCompanyUrl;
+                    matchedCompanyName = companyName ?? matchedCompanyName;
+                    matchedCompanyEmployeeCount = extractLinkedInCompanyEmployeeCountFromSalesApiElement(first);
+                    addAlias(companyName);
+                    addAlias(companyUrl ? normalizeLinkedInCompanyHandle(companyUrl)?.replace(/[-_]+/g, " ") : null);
+                    addAlias(salesNavCompanyUrl ? normalizeLookupWhitespace(salesNavCompanyUrl.split("/sales/company/")[1]?.split(/[/?#]/)[0] ?? "") : null);
+                    break;
+                }
+            }
+            catch {
+                // Try next company variant.
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+        contexts.set(companyKey, {
+            normalizedCompanyKey: companyKey,
+            aliases: Array.from(aliases),
+            linkedinCompanyUrl: matchedCompanyUrl,
+            salesNavCompanyUrl: matchedSalesNavCompanyUrl,
+            matchedCompanyName,
+            matchedCompanyEmployeeCount
+        });
+    }
+    return contexts;
+}
 function buildPublicLinkedInCompanySearchUrl(companyName) {
     const baseUrl = process.env.SALESPROMPTER_LINKEDIN_COMPANY_SEARCH_BASE_URL?.trim() ||
         "https://duckduckgo.com/html/";
@@ -1559,7 +2129,8 @@ function extractSerperLinkedInCompanyCandidates(payload) {
     const organic = "organic" in payload && Array.isArray(payload.organic)
         ? (payload.organic ?? [])
         : [];
-    const candidates = new Set();
+    const seen = new Set();
+    const candidates = [];
     for (const result of organic) {
         if (!result || typeof result !== "object") {
             continue;
@@ -1569,60 +2140,685 @@ function extractSerperLinkedInCompanyCandidates(payload) {
             : "";
         const handle = normalizeLinkedInCompanyHandle(link);
         if (handle) {
-            candidates.add(normalizeLinkedInCompanyPage(handle));
+            const url = normalizeLinkedInCompanyPage(handle);
+            if (!seen.has(url)) {
+                seen.add(url);
+                candidates.push({
+                    url,
+                    title: "title" in result && typeof result.title === "string"
+                        ? normalizeLookupWhitespace(result.title)
+                        : "",
+                    snippet: "snippet" in result && typeof result.snippet === "string"
+                        ? normalizeLookupWhitespace(result.snippet)
+                        : ""
+                });
+            }
         }
     }
-    return Array.from(candidates);
-}
-function decodeHtmlEntities(value) {
-    return value
-        .replace(/&amp;/gi, "&")
-        .replace(/&quot;/gi, '"')
-        .replace(/&#39;/gi, "'")
-        .replace(/&lt;/gi, "<")
-        .replace(/&gt;/gi, ">");
+    return candidates;
 }
-async function fetchLinkedInCompanyPageSignals(url, timeoutMs) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), Math.min(timeoutMs, 12_000));
-    try {
-        const response = await fetch(url, {
-            method: "GET",
-            signal: controller.signal,
-            headers: {
-                "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
-            }
-        });
-        const html = await response.text();
-        const finalUrl = response.url || url;
-        const title = decodeHtmlEntities(html.match(/<title[^>]*>([^<]+)/i)?.[1] || "") ||
-            decodeHtmlEntities(html.match(/<meta[^>]+property="og:title"[^>]+content="([^"]+)/i)?.[1] || "");
-        const description = decodeHtmlEntities(html.match(/<meta[^>]+name="description"[^>]+content="([^"]+)/i)?.[1] || "");
-        const bodyText = decodeHtmlEntities(html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " "));
-        const unavailableText = normalizeLooseMatchText(`${title} ${description} ${bodyText}`);
-        const unavailable = response.status >= 400 ||
-            unavailableText.includes("page not found") ||
-            unavailableText.includes("this page does not exist") ||
-            unavailableText.includes("page isnt available");
-        const handle = normalizeLinkedInCompanyHandle(finalUrl) ?? normalizeLinkedInCompanyHandle(url);
-        if (!handle) {
-            return null;
+const linkedInCompanyHintCache = new Map();
+const linkedInProfilePageSignalCache = new Map();
+const linkedInCompanyPageSignalCache = new Map();
+const serperSearchCache = new Map();
+let serperCreditsExhausted = false;
+function extractKeywordPhrases(value) {
+    const normalized = normalizeLookupWhitespace(value);
+    if (!normalized) {
+        return [];
+    }
+    const phrases = new Set();
+    const push = (candidate) => {
+        const cleaned = normalizeLookupWhitespace(candidate);
+        if (!cleaned || cleaned.length < 3) {
+            return;
         }
-        return {
-            normalizedUrl: normalizeLinkedInCompanyPage(handle),
+        phrases.add(cleaned);
+    };
+    push(normalized);
+    push(normalizeLookupCompanyForSearch(normalized));
+    push(aggressivelyCleanLookupCompanyName(normalized));
+    const titleStripped = normalized
+        .replace(/\|\s*linkedin$/i, "")
+        .replace(/\|\s*overview$/i, "")
+        .replace(/\b(linkedin|home|about|posts|see all details)\b/gi, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    push(titleStripped);
+    const parts = titleStripped
+        .split(/[|,·•:()/-]+/)
+        .map((part) => normalizeLookupWhitespace(part))
+        .filter(Boolean);
+    for (const part of parts) {
+        push(part);
+    }
+    const looseTokens = normalizeLooseMatchText(titleStripped)
+        .split(/\s+/)
+        .filter((token) => token.length >= 4)
+        .filter((token) => ![
+        "group",
+        "holding",
+        "services",
+        "service",
+        "consulting",
+        "gmbh",
+        "publishing",
+        "company",
+        "linkedin",
+        "deutschland"
+    ].includes(token));
+    if (looseTokens.length > 0) {
+        push(looseTokens[0]);
+        push(looseTokens.slice(0, 2).join(" "));
+        push(looseTokens.slice(-2).join(" "));
+    }
+    return Array.from(phrases);
+}
+async function buildLinkedInProfileCompanyHints(contact, timeoutMs) {
+    const phrases = new Set();
+    const keywords = new Set();
+    const addPhrase = (value) => {
+        for (const phrase of extractKeywordPhrases(value)) {
+            phrases.add(phrase);
+            const looseTokens = normalizeLooseMatchText(phrase)
+                .split(/\s+/)
+                .filter((token) => token.length >= 4)
+                .filter((token) => ![
+                "group",
+                "holding",
+                "services",
+                "service",
+                "consulting",
+                "gmbh",
+                "publishing",
+                "company",
+                "linkedin",
+                "deutschland"
+            ].includes(token));
+            for (const token of looseTokens.slice(0, 5)) {
+                keywords.add(token);
+            }
+            if (looseTokens.length > 1) {
+                keywords.add(looseTokens.slice(0, 2).join(" "));
+                keywords.add(looseTokens.slice(-2).join(" "));
+            }
+        }
+    };
+    addPhrase(contact.companyNameOriginal ?? contact.companyName);
+    const linkedInHandle = normalizeLinkedInCompanyHandle(contact.linkedinCompanyUrl ?? "");
+    if (linkedInHandle && !/^\d+$/.test(linkedInHandle)) {
+        addPhrase(linkedInHandle.replace(/[-_]+/g, " "));
+    }
+    const normalizedEmail = normalizeLookupWhitespace(contact.email);
+    const emailDomain = normalizedEmail && !isSyntheticLinkedInLookupEmail(normalizedEmail)
+        ? normalizedEmail.split("@")[1] ?? ""
+        : "";
+    if (emailDomain) {
+        const normalizedDomain = emailDomain.replace(/^www\./i, "");
+        keywords.add(normalizedDomain);
+        const host = normalizedDomain.split(".")[0] ?? "";
+        if (host) {
+            addPhrase(host.replace(/[-_]+/g, " "));
+        }
+    }
+    const companyUrl = contact.linkedinCompanyUrl?.trim();
+    if (companyUrl) {
+        const cacheKey = companyUrl.replace(/\/$/, "");
+        let cachedHints = linkedInCompanyHintCache.get(cacheKey);
+        if (!cachedHints) {
+            const signals = await fetchLinkedInCompanyPageSignals(companyUrl, timeoutMs);
+            cachedHints = signals ? [...extractKeywordPhrases(signals.title), ...extractKeywordPhrases(signals.description)] : [];
+            linkedInCompanyHintCache.set(cacheKey, cachedHints);
+        }
+        for (const hint of cachedHints) {
+            addPhrase(hint);
+        }
+    }
+    return {
+        phrases: Array.from(phrases)
+            .map((value) => normalizeLookupWhitespace(value))
+            .filter((value) => value.length > 0),
+        keywords: Array.from(keywords)
+            .map((value) => normalizeLookupWhitespace(value))
+            .filter((value) => value.length > 0)
+    };
+}
+async function buildSerperLinkedInProfileQueries(contact, timeoutMs) {
+    const fullName = normalizeLookupWhitespace(`${contact.firstName} ${contact.lastName}`);
+    const title = normalizeLookupWhitespace(contact.jobTitle);
+    const queryEntries = [];
+    const seenQueries = new Set();
+    const pushQuery = (query, score) => {
+        const normalized = normalizeLookupWhitespace(query);
+        if (!normalized) {
+            return;
+        }
+        const key = normalized.toLowerCase();
+        if (seenQueries.has(key)) {
+            return;
+        }
+        seenQueries.add(key);
+        queryEntries.push({ query: normalized, score });
+    };
+    const { phrases, keywords } = await buildLinkedInProfileCompanyHints(contact, timeoutMs);
+    const enrichedPhrases = new Set(phrases);
+    const enrichedKeywords = new Set(keywords);
+    const preferredPhrases = [];
+    const normalizedEmail = normalizeLookupWhitespace(contact.email);
+    const trustedEmailDomain = normalizedEmail && !isSyntheticLinkedInLookupEmail(normalizedEmail)
+        ? normalizedEmail.split("@")[1]?.replace(/^www\./i, "") ?? ""
+        : "";
+    const emailHost = trustedEmailDomain.split(".")[0] ?? "";
+    const emailDomain = trustedEmailDomain;
+    const linkedInHandle = normalizeLinkedInCompanyHandle(contact.linkedinCompanyUrl ?? "")?.replace(/[-_]+/g, " ") ?? "";
+    if (contact.linkedinCompanyUrl?.trim()) {
+        const companySignals = await fetchLinkedInCompanyPageSignals(contact.linkedinCompanyUrl.trim(), timeoutMs);
+        for (const phrase of [
+            ...extractKeywordPhrases(companySignals?.title),
+            ...extractKeywordPhrases(companySignals?.description)
+        ]) {
+            enrichedPhrases.add(phrase);
+            preferredPhrases.push(phrase);
+            const looseTokens = normalizeLooseMatchText(phrase)
+                .split(/\s+/)
+                .filter((token) => token.length >= 4)
+                .filter((token) => ![
+                "group",
+                "holding",
+                "services",
+                "service",
+                "consulting",
+                "gmbh",
+                "publishing",
+                "company",
+                "linkedin",
+                "deutschland"
+            ].includes(token));
+            for (const token of looseTokens.slice(0, 4)) {
+                enrichedKeywords.add(token);
+            }
+            if (looseTokens.length > 1) {
+                enrichedKeywords.add(looseTokens.slice(0, 2).join(" "));
+            }
+        }
+    }
+    const phrasePriority = (value) => {
+        const loose = normalizeLooseMatchText(value);
+        const tokenCount = loose.split(/\s+/).filter(Boolean).length;
+        let score = 0;
+        if (emailHost && loose.includes(normalizeLooseMatchText(emailHost)))
+            score += 80;
+        if (linkedInHandle && loose.includes(normalizeLooseMatchText(linkedInHandle)))
+            score += 60;
+        if (tokenCount >= 1 && tokenCount <= 4)
+            score += 40;
+        if (!/\b(gmbh|holding|services|service|consulting|kg|co)\b/i.test(value))
+            score += 20;
+        if (tokenCount > 7)
+            score -= 40;
+        return score;
+    };
+    const keywordPriority = (value) => {
+        const loose = normalizeLooseMatchText(value);
+        let score = 0;
+        if (emailHost && loose.includes(normalizeLooseMatchText(emailHost)))
+            score += 80;
+        if (linkedInHandle && loose.includes(normalizeLooseMatchText(linkedInHandle)))
+            score += 60;
+        if (value.includes("."))
+            score += 20;
+        if (loose.split(/\s+/).filter(Boolean).length <= 2)
+            score += 10;
+        return score;
+    };
+    const rankedPhrases = [...enrichedPhrases].sort((left, right) => {
+        const preferredDelta = Number(preferredPhrases.includes(right)) - Number(preferredPhrases.includes(left));
+        if (preferredDelta !== 0) {
+            return preferredDelta;
+        }
+        return phrasePriority(right) - phrasePriority(left);
+    });
+    const cleanPhrases = rankedPhrases.slice(0, 6);
+    const fallbackKeywords = new Set(enrichedKeywords);
+    for (const phrase of cleanPhrases) {
+        const looseTokens = normalizeLooseMatchText(phrase)
+            .split(/\s+/)
+            .filter((token) => token.length >= 4)
+            .filter((token) => ![
+            "group",
+            "holding",
+            "services",
+            "service",
+            "consulting",
+            "gmbh",
+            "publishing",
+            "company",
+            "linkedin",
+            "deutschland"
+        ].includes(token));
+        for (const token of looseTokens.slice(0, 3)) {
+            fallbackKeywords.add(token);
+        }
+        if (looseTokens.length > 1) {
+            fallbackKeywords.add(looseTokens.slice(0, 2).join(" "));
+        }
+    }
+    if (emailHost) {
+        fallbackKeywords.add(emailHost);
+    }
+    if (emailDomain) {
+        fallbackKeywords.add(emailDomain);
+    }
+    if (linkedInHandle) {
+        fallbackKeywords.add(linkedInHandle);
+    }
+    const cleanKeywords = [...fallbackKeywords]
+        .sort((left, right) => keywordPriority(right) - keywordPriority(left))
+        .slice(0, 5);
+    cleanKeywords.forEach((keyword, index) => {
+        const keywordScore = 260 - index * 15;
+        pushQuery(`site:linkedin.com/in "${fullName}" ${keyword} linkedin`, keywordScore);
+        pushQuery(`site:linkedin.com/in ${fullName} ${keyword} linkedin`, keywordScore - 5);
+        if (title) {
+            pushQuery(`site:linkedin.com/in "${fullName}" ${keyword} "${title}"`, keywordScore - 10);
+        }
+    });
+    cleanPhrases.forEach((companyName, index) => {
+        const phraseScore = 180 - index * 10;
+        pushQuery(`site:linkedin.com/in "${fullName}" "${companyName}"`, phraseScore);
+        pushQuery(`site:linkedin.com/in ${fullName} ${companyName} linkedin`, phraseScore - 5);
+        if (title) {
+            pushQuery(`site:linkedin.com/in "${fullName}" "${companyName}" "${title}"`, phraseScore - 10);
+            pushQuery(`site:linkedin.com/in ${fullName} ${companyName} ${title} linkedin`, phraseScore - 15);
+        }
+    });
+    if (emailDomain) {
+        pushQuery(`site:linkedin.com/in "${fullName}" "${emailDomain}" linkedin`, 240);
+    }
+    pushQuery(`site:linkedin.com/in "${fullName}" linkedin`, 50);
+    if (title) {
+        pushQuery(`site:linkedin.com/in "${fullName}" "${title}" linkedin`, 40);
+    }
+    return queryEntries
+        .sort((left, right) => right.score - left.score)
+        .map((entry) => entry.query);
+}
+function extractPublicLinkedInProfileSearchCandidates(bodyText) {
+    const candidates = new Set();
+    const directMatches = bodyText.match(/https:\/\/(?:(?:www|[a-z]{2})\.)?linkedin\.com\/in\/[^"'&<>\s)]+/gi) ?? [];
+    for (const match of directMatches) {
+        const normalized = normalizePublicLinkedInProfileUrl(match);
+        if (normalized) {
+            candidates.add(normalized);
+        }
+    }
+    const encodedMatches = bodyText.match(/https?%3A%2F%2F(?:(?:www|[a-z]{2})\.)?linkedin\.com%2Fin%2F[^"'&<>\s)]+/gi) ?? [];
+    for (const match of encodedMatches) {
+        try {
+            const decoded = decodeURIComponent(match);
+            const normalized = normalizePublicLinkedInProfileUrl(decoded);
+            if (normalized) {
+                candidates.add(normalized);
+            }
+        }
+        catch {
+            // Ignore malformed encoded fragments.
+        }
+    }
+    return Array.from(candidates);
+}
+function buildPublicLinkedInProfileSearchUrl(query) {
+    const baseUrl = process.env.SALESPROMPTER_LINKEDIN_PROFILE_SEARCH_BASE_URL?.trim() ||
+        "https://duckduckgo.com/html/";
+    const url = new URL(baseUrl);
+    url.searchParams.set("q", query);
+    return url.toString();
+}
+async function fetchSerperSearchResults(query, num, timeoutMs) {
+    if (serperCreditsExhausted) {
+        return null;
+    }
+    const apiKey = getSerperApiKey();
+    if (!apiKey) {
+        return null;
+    }
+    const cacheKey = `${query}::${num}`;
+    if (serperSearchCache.has(cacheKey)) {
+        return serperSearchCache.get(cacheKey) ?? null;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.min(timeoutMs, 12_000));
+    try {
+        const response = await fetch(getSerperSearchEndpoint(), {
+            method: "POST",
+            signal: controller.signal,
+            headers: {
+                "X-API-KEY": apiKey,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({ q: query, num })
+        });
+        if (!response.ok) {
+            const bodyText = await response.text().catch(() => "");
+            if (response.status === 400 &&
+                /not enough credits/i.test(bodyText)) {
+                serperCreditsExhausted = true;
+            }
+            serperSearchCache.set(cacheKey, null);
+            return null;
+        }
+        const parsed = await response.json();
+        serperSearchCache.set(cacheKey, parsed);
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function extractSerperLinkedInProfileCandidates(payload) {
+    if (!payload || typeof payload !== "object") {
+        return [];
+    }
+    const organic = "organic" in payload && Array.isArray(payload.organic)
+        ? (payload.organic ?? [])
+        : [];
+    const seen = new Set();
+    const candidates = [];
+    for (const result of organic) {
+        if (!result || typeof result !== "object")
+            continue;
+        const link = "link" in result && typeof result.link === "string"
+            ? result.link
+            : "";
+        const normalized = normalizePublicLinkedInProfileUrl(link);
+        if (normalized) {
+            const canonical = normalized.replace(/\/$/, "");
+            if (!seen.has(canonical)) {
+                seen.add(canonical);
+                candidates.push({
+                    url: canonical,
+                    title: "title" in result && typeof result.title === "string"
+                        ? normalizeLookupWhitespace(result.title)
+                        : "",
+                    snippet: "snippet" in result && typeof result.snippet === "string"
+                        ? normalizeLookupWhitespace(result.snippet)
+                        : ""
+                });
+            }
+        }
+    }
+    return candidates;
+}
+async function fetchLinkedInProfilePageSignals(url, timeoutMs) {
+    const cacheKey = normalizePublicLinkedInProfileUrl(url)?.replace(/\/$/, "") ?? url.replace(/\/$/, "");
+    if (linkedInProfilePageSignalCache.has(cacheKey)) {
+        return linkedInProfilePageSignalCache.get(cacheKey) ?? null;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.min(timeoutMs, 12_000));
+    try {
+        const targetUrl = rewriteLinkedInUrlForConfiguredBase(url);
+        const response = await fetch(targetUrl, {
+            method: "GET",
+            signal: controller.signal,
+            headers: {
+                "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
+            }
+        });
+        const html = await response.text();
+        const finalUrl = normalizePublicLinkedInProfileUrl(url) ||
+            normalizePublicLinkedInProfileUrl(response.url || url);
+        if (!finalUrl) {
+            return null;
+        }
+        const title = decodeHtmlEntities(html.match(/<title[^>]*>([^<]+)/i)?.[1] || "") ||
+            decodeHtmlEntities(html.match(/<meta[^>]+property="og:title"[^>]+content="([^"]+)/i)?.[1] || "");
+        const description = decodeHtmlEntities(html.match(/<meta[^>]+name="description"[^>]+content="([^"]+)/i)?.[1] || "");
+        const bodyText = decodeHtmlEntities(html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " "));
+        const unavailableText = normalizeLooseMatchText(`${title} ${description} ${bodyText}`);
+        const unavailable = response.status >= 400 ||
+            unavailableText.includes("page not found") ||
+            unavailableText.includes("profile not found") ||
+            unavailableText.includes("member profile") && unavailableText.includes("not available");
+        const result = {
+            normalizedUrl: finalUrl.replace(/\/$/, ""),
+            title: normalizeLookupWhitespace(title),
+            description: normalizeLookupWhitespace(description),
+            bodyText: normalizeLookupWhitespace(bodyText),
+            unavailable
+        };
+        linkedInProfilePageSignalCache.set(cacheKey, result);
+        return result;
+    }
+    catch {
+        linkedInProfilePageSignalCache.set(cacheKey, null);
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function scoreLinkedInProfilePageSignals(contact, signals) {
+    const fullName = normalizeLooseMatchText(`${contact.firstName} ${contact.lastName}`);
+    const companyHints = [
+        normalizeLooseMatchText(contact.companyNameOriginal ?? contact.companyName),
+        normalizeLooseMatchText(aggressivelyCleanLookupCompanyName(contact.companyNameOriginal ?? contact.companyName))
+    ].filter(Boolean);
+    const titleHint = normalizeLooseMatchText(contact.jobTitle);
+    const haystack = normalizeLooseMatchText(`${signals.title} ${signals.description} ${signals.bodyText}`);
+    let score = 0;
+    if (fullName && haystack.includes(fullName))
+        score += 120;
+    for (const hint of companyHints) {
+        if (hint && haystack.includes(hint))
+            score += 30;
+    }
+    if (titleHint) {
+        const titleWords = titleHint.split(/\s+/).filter((token) => token.length >= 4).slice(0, 4);
+        score += titleWords.filter((token) => haystack.includes(token)).length * 8;
+    }
+    const slug = signals.normalizedUrl.split("/in/")[1]?.replace(/\/$/, "") ?? "";
+    const slugText = normalizeLooseMatchText(slug.replace(/[-_]+/g, " "));
+    if (fullName && slugText.includes(contact.firstName.toLowerCase()) && slugText.includes(contact.lastName.toLowerCase())) {
+        score += 40;
+    }
+    return score;
+}
+function analyzeSerperLinkedInProfileCandidate(contact, candidate) {
+    const fullName = normalizeLooseMatchText(`${contact.firstName} ${contact.lastName}`);
+    const titleHint = normalizeLooseMatchText(contact.jobTitle);
+    const companyTokens = [
+        normalizeLooseMatchText(contact.companyNameOriginal ?? contact.companyName),
+        normalizeLooseMatchText(aggressivelyCleanLookupCompanyName(contact.companyNameOriginal ?? contact.companyName)),
+        normalizeLooseMatchText(normalizeLinkedInCompanyHandle(contact.linkedinCompanyUrl ?? "")?.replace(/[-_]+/g, " ") ?? ""),
+        normalizeLooseMatchText((() => {
+            const normalizedEmail = normalizeLookupWhitespace(contact.email);
+            if (!normalizedEmail || isSyntheticLinkedInLookupEmail(normalizedEmail)) {
+                return "";
+            }
+            return normalizedEmail.split("@")[1]?.replace(/^www\./i, "").split(".")[0] ?? "";
+        })())
+    ].filter(Boolean);
+    const haystack = normalizeLooseMatchText(`${candidate.title} ${candidate.snippet}`);
+    let score = 0;
+    let companyMatches = 0;
+    let titleMatches = 0;
+    if (fullName && haystack.includes(fullName))
+        score += 120;
+    for (const token of companyTokens) {
+        if (!token)
+            continue;
+        if (haystack.includes(token)) {
+            companyMatches += 1;
+            score += token.split(/\s+/).length <= 2 ? 30 : 20;
+        }
+    }
+    if (titleHint) {
+        const titleWords = titleHint.split(/\s+/).filter((token) => token.length >= 4).slice(0, 4);
+        titleMatches = titleWords.filter((token) => haystack.includes(token)).length;
+        score += titleMatches * 8;
+    }
+    const slugText = normalizeLooseMatchText(candidate.url.split("/in/")[1]?.replace(/\/$/, "").replace(/[-_]+/g, " ") ?? "");
+    if (fullName &&
+        slugText.includes(contact.firstName.toLowerCase()) &&
+        slugText.includes(contact.lastName.toLowerCase()) &&
+        (companyMatches > 0 || titleMatches > 0)) {
+        score += 40;
+    }
+    return { score, companyMatches, titleMatches };
+}
+async function searchSerperLinkedInProfileUrl(contact, timeoutMs, options) {
+    if (!contact.firstName || !contact.lastName) {
+        return null;
+    }
+    const maxQueries = options?.maxQueries && Number.isFinite(options.maxQueries) && options.maxQueries > 0
+        ? Math.trunc(options.maxQueries)
+        : Number.POSITIVE_INFINITY;
+    for (const query of (await buildSerperLinkedInProfileQueries(contact, timeoutMs)).slice(0, maxQueries)) {
+        try {
+            const parsed = await fetchSerperSearchResults(query, 5, timeoutMs);
+            if (!parsed) {
+                continue;
+            }
+            const candidates = extractSerperLinkedInProfileCandidates(parsed);
+            let bestUrl = null;
+            let bestScore = 0;
+            for (const candidate of candidates) {
+                const serperAnalysis = analyzeSerperLinkedInProfileCandidate(contact, candidate);
+                const serperScore = serperAnalysis.score;
+                if (serperScore >= 150 && (serperAnalysis.companyMatches > 0 || serperAnalysis.titleMatches > 0)) {
+                    return candidate.url;
+                }
+                const signals = await fetchLinkedInProfilePageSignals(candidate.url, timeoutMs);
+                if (!signals || signals.unavailable) {
+                    if (serperScore > bestScore) {
+                        bestScore = serperScore;
+                        bestUrl = candidate.url;
+                    }
+                    continue;
+                }
+                const score = Math.max(serperScore, scoreLinkedInProfilePageSignals(contact, signals));
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestUrl = signals.normalizedUrl;
+                }
+            }
+            if (bestUrl && bestScore >= 130) {
+                return bestUrl;
+            }
+        }
+        catch {
+            // Continue with the next query variant.
+        }
+    }
+    return searchPublicLinkedInProfileUrl(contact, timeoutMs, {
+        maxQueries: Math.min(Number.isFinite(maxQueries) ? maxQueries : 4, 4)
+    });
+}
+function decodeHtmlEntities(value) {
+    return value
+        .replace(/&amp;/gi, "&")
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/gi, "'")
+        .replace(/&lt;/gi, "<")
+        .replace(/&gt;/gi, ">");
+}
+async function fetchLinkedInCompanyPageSignals(url, timeoutMs) {
+    const cacheKey = url.replace(/\/$/, "");
+    if (linkedInCompanyPageSignalCache.has(cacheKey)) {
+        return linkedInCompanyPageSignalCache.get(cacheKey) ?? null;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.min(timeoutMs, 12_000));
+    try {
+        const response = await fetch(url, {
+            method: "GET",
+            signal: controller.signal,
+            headers: {
+                "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
+            }
+        });
+        const html = await response.text();
+        const finalUrl = response.url || url;
+        const title = decodeHtmlEntities(html.match(/<title[^>]*>([^<]+)/i)?.[1] || "") ||
+            decodeHtmlEntities(html.match(/<meta[^>]+property="og:title"[^>]+content="([^"]+)/i)?.[1] || "");
+        const description = decodeHtmlEntities(html.match(/<meta[^>]+name="description"[^>]+content="([^"]+)/i)?.[1] || "");
+        const bodyText = decodeHtmlEntities(html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " "));
+        const unavailableText = normalizeLooseMatchText(`${title} ${description} ${bodyText}`);
+        const unavailable = response.status >= 400 ||
+            unavailableText.includes("page not found") ||
+            unavailableText.includes("this page does not exist") ||
+            unavailableText.includes("page isnt available");
+        const result = {
+            normalizedUrl: normalizeLinkedInCompanyHandle(finalUrl ?? "") || normalizeLinkedInCompanyHandle(url)
+                ? normalizeLinkedInCompanyPage(normalizeLinkedInCompanyHandle(finalUrl ?? "") ?? normalizeLinkedInCompanyHandle(url) ?? "")
+                : finalUrl,
             title: normalizeLookupWhitespace(title),
             description: normalizeLookupWhitespace(description),
             bodyText: normalizeLookupWhitespace(bodyText),
             unavailable
         };
+        linkedInCompanyPageSignalCache.set(cacheKey, result);
+        return result;
     }
     catch {
+        linkedInCompanyPageSignalCache.set(cacheKey, null);
         return null;
     }
     finally {
         clearTimeout(timeout);
     }
 }
+async function searchPublicLinkedInProfileUrl(contact, timeoutMs, options) {
+    const maxQueries = options?.maxQueries && Number.isFinite(options.maxQueries) && options.maxQueries > 0
+        ? Math.trunc(options.maxQueries)
+        : 4;
+    const queries = (await buildSerperLinkedInProfileQueries(contact, timeoutMs)).slice(0, maxQueries);
+    for (const query of queries) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), Math.min(timeoutMs, 12_000));
+        try {
+            const response = await fetch(buildPublicLinkedInProfileSearchUrl(query), {
+                method: "GET",
+                signal: controller.signal,
+                headers: {
+                    "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
+                }
+            });
+            if (!response.ok) {
+                continue;
+            }
+            const bodyText = await response.text();
+            const candidates = extractPublicLinkedInProfileSearchCandidates(bodyText);
+            let bestUrl = null;
+            let bestScore = 0;
+            for (const candidateUrl of candidates.slice(0, 5)) {
+                const signals = await fetchLinkedInProfilePageSignals(candidateUrl, timeoutMs);
+                if (!signals || signals.unavailable) {
+                    continue;
+                }
+                const score = scoreLinkedInProfilePageSignals(contact, signals);
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestUrl = signals.normalizedUrl;
+                }
+            }
+            if (bestUrl && bestScore >= 130) {
+                return bestUrl;
+            }
+        }
+        catch {
+            // Continue with the next query variant.
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    return null;
+}
 function scoreLinkedInCompanyPageSignals(companyName, signals) {
     const inputTokens = normalizeLooseMatchText(companyName).split(/\s+/).filter((token) => token.length >= 4);
     const haystack = normalizeLooseMatchText(`${signals.title} ${signals.description}`);
@@ -1637,6 +2833,20 @@ function scoreLinkedInCompanyPageSignals(companyName, signals) {
     }
     return score;
 }
+function scoreSerperLinkedInCompanyCandidate(companyName, candidate) {
+    const inputTokens = normalizeLooseMatchText(companyName).split(/\s+/).filter((token) => token.length >= 4);
+    const haystack = normalizeLooseMatchText(`${candidate.title} ${candidate.snippet}`);
+    let score = scoreLinkedInCompanyUrlCandidate(companyName, candidate.url);
+    for (const token of inputTokens) {
+        if (haystack.includes(token)) {
+            score += 12;
+        }
+    }
+    if (haystack.includes(normalizeLooseMatchText(aggressivelyCleanLookupCompanyName(companyName)))) {
+        score += 40;
+    }
+    return score;
+}
 function scoreLinkedInCompanyUrlCandidate(companyName, url) {
     const handle = normalizeLinkedInCompanyHandle(url);
     if (!handle || /^\d+$/.test(handle)) {
@@ -1730,9 +2940,15 @@ async function searchSerperLinkedInCompanyUrl(companyName, timeoutMs) {
             const parsed = (await response.json());
             const candidates = extractSerperLinkedInCompanyCandidates(parsed);
             const ranked = candidates
-                .map((url) => ({ url, score: scoreLinkedInCompanyUrlCandidate(companyName, url) }))
+                .map((candidate) => ({
+                ...candidate,
+                score: scoreSerperLinkedInCompanyCandidate(companyName, candidate)
+            }))
                 .filter((candidate) => candidate.score > 0)
                 .sort((left, right) => right.score - left.score);
+            if (ranked[0] && ranked[0].score >= 80) {
+                return ranked[0].url;
+            }
             let anySignalsFetched = false;
             let bestValidated = null;
             for (const candidate of ranked.slice(0, 3)) {
@@ -1772,6 +2988,11 @@ async function searchSerperLinkedInCompanyUrl(companyName, timeoutMs) {
 }
 async function invokeLinkedInUrlEnrichmentDirect(params) {
     const config = await readLinkedInDirectLookupConfig();
+    const companyContexts = await resolveDirectLinkedInCompanyContexts({
+        contacts: params.contacts.filter((contact) => !contact.isVariation),
+        timeoutMs: params.timeoutMs,
+        config
+    });
     const groupedContacts = new Map();
     for (const contact of params.contacts) {
         const key = contact.email?.trim().toLowerCase() || `contact:${contact.contact_id}`;
@@ -1780,15 +3001,25 @@ async function invokeLinkedInUrlEnrichmentDirect(params) {
         groupedContacts.set(key, existing);
     }
     const results = [];
-    let rateLimited = false;
+    const perAttemptTimeoutMs = params.perAttemptTimeoutMs && Number.isFinite(params.perAttemptTimeoutMs) && params.perAttemptTimeoutMs > 0
+        ? Math.trunc(params.perAttemptTimeoutMs)
+        : Math.min(params.timeoutMs, 8_000);
+    const perContactBudgetMs = params.perContactBudgetMs && Number.isFinite(params.perContactBudgetMs) && params.perContactBudgetMs > 0
+        ? Math.trunc(params.perContactBudgetMs)
+        : Math.min(params.timeoutMs, 15_000);
+    const rateLimitCooldownMs = Math.max(750, Math.min(3_000, Math.trunc(perAttemptTimeoutMs / 2)));
+    const maxRateLimitCooldowns = 4;
+    let rateLimitCooldownUntil = 0;
+    let consecutiveRateLimitCount = 0;
+    let totalRateLimitCooldowns = 0;
     for (const variations of groupedContacts.values()) {
         const primary = variations.find((contact) => !contact.isVariation) ?? variations[0];
         const blankPerson = !primary?.firstName.trim() || !primary?.lastName.trim();
-        if (rateLimited) {
+        if (totalRateLimitCooldowns >= maxRateLimitCooldowns) {
             results.push({
                 contact_id: primary.contact_id,
                 linkedin_url: null,
-                error: "LinkedIn rate limit"
+                error: "LinkedIn rate limit budget exhausted"
             });
             continue;
         }
@@ -1802,11 +3033,23 @@ async function invokeLinkedInUrlEnrichmentDirect(params) {
         }
         let matchedUrl = null;
         let matchedSalesNavUrl = null;
+        let matchedFullName = null;
+        let matchedCompanyName = null;
+        let matchedTitle = null;
         let lastError = null;
+        const contactDeadline = Date.now() + perContactBudgetMs;
+        const companyContext = companyContexts.get(buildDirectCompanyContextKey(primary));
         for (const candidate of variations) {
-            for (const searchVariant of buildLinkedInLookupSearchVariants(candidate)) {
+            for (const searchVariant of await buildLinkedInLookupSearchVariants(candidate, params.timeoutMs, companyContext?.aliases ?? [])) {
+                if (Date.now() < rateLimitCooldownUntil) {
+                    await new Promise((resolve) => setTimeout(resolve, rateLimitCooldownUntil - Date.now()));
+                }
+                if (Date.now() >= contactDeadline) {
+                    lastError = lastError || "Direct lookup budget exhausted";
+                    break;
+                }
                 const controller = new AbortController();
-                const timeout = setTimeout(controller.abort.bind(controller), Math.min(params.timeoutMs, 20_000));
+                const timeout = setTimeout(controller.abort.bind(controller), Math.min(perAttemptTimeoutMs, Math.max(1_000, contactDeadline - Date.now())));
                 try {
                     const response = await fetch(buildLinkedInSalesApiUrl(searchVariant), {
                         method: "GET",
@@ -1827,20 +3070,51 @@ async function invokeLinkedInUrlEnrichmentDirect(params) {
                         }
                     });
                     if (response.status === 429) {
-                        rateLimited = true;
                         lastError = "LinkedIn rate limit";
+                        consecutiveRateLimitCount += 1;
+                        totalRateLimitCooldowns += 1;
+                        rateLimitCooldownUntil =
+                            Date.now() + Math.min(15_000, rateLimitCooldownMs * Math.max(1, consecutiveRateLimitCount));
+                        if (totalRateLimitCooldowns >= maxRateLimitCooldowns) {
+                            break;
+                        }
                         break;
                     }
                     if (!response.ok) {
                         lastError = `LinkedIn returned ${response.status}`;
                         continue;
                     }
+                    consecutiveRateLimitCount = 0;
+                    rateLimitCooldownUntil = 0;
                     const data = (await response.json());
                     const profilesFound = data.paging?.total ?? 0;
                     if (profilesFound > 0) {
-                        const first = data.elements?.[0];
-                        matchedUrl = extractLinkedInProfileUrlFromSalesApiElement(first) ?? null;
-                        matchedSalesNavUrl = extractLinkedInSalesNavLeadUrlFromSalesApiElement(first) ?? null;
+                        const bestCandidate = (data.elements ?? [])
+                            .map((element) => ({
+                            element,
+                            ...scoreLinkedInSalesApiElementMatch(candidate, element)
+                        }))
+                            .sort((left, right) => right.score - left.score)[0];
+                        const hasTrustedCompanyContext = Boolean(candidate.linkedinCompanyUrl ||
+                            companyContext?.linkedinCompanyUrl ||
+                            companyContext?.matchedCompanyName);
+                        const hasTrustedEmailContext = Boolean(candidate.email && !isSyntheticLinkedInLookupEmail(candidate.email));
+                        const acceptBestCandidate = Boolean(bestCandidate &&
+                            (bestCandidate.score >= 140 ||
+                                (bestCandidate.exactNameMatch &&
+                                    (bestCandidate.companyMatchCount > 0 || hasTrustedCompanyContext || hasTrustedEmailContext))));
+                        if (bestCandidate && acceptBestCandidate) {
+                            matchedUrl = extractLinkedInProfileUrlFromSalesApiElement(bestCandidate.element) ?? null;
+                            matchedSalesNavUrl = extractLinkedInSalesNavLeadUrlFromSalesApiElement(bestCandidate.element) ?? null;
+                            matchedFullName = bestCandidate.fullName;
+                            matchedCompanyName = bestCandidate.companyName;
+                            matchedTitle = bestCandidate.title;
+                        }
+                        else {
+                            lastError = bestCandidate
+                                ? `LinkedIn top result score too low (${bestCandidate.score})`
+                                : "LinkedIn returned no usable results";
+                        }
                         if (matchedUrl || matchedSalesNavUrl) {
                             break;
                         }
@@ -1852,11 +3126,14 @@ async function invokeLinkedInUrlEnrichmentDirect(params) {
                 finally {
                     clearTimeout(timeout);
                 }
-                if (matchedUrl || matchedSalesNavUrl || rateLimited) {
+                if (matchedUrl || matchedSalesNavUrl || totalRateLimitCooldowns >= maxRateLimitCooldowns) {
                     break;
                 }
             }
-            if (matchedUrl || matchedSalesNavUrl || rateLimited) {
+            if (matchedUrl || matchedSalesNavUrl || totalRateLimitCooldowns >= maxRateLimitCooldowns) {
+                break;
+            }
+            if (Date.now() >= contactDeadline) {
                 break;
             }
         }
@@ -1864,16 +3141,21 @@ async function invokeLinkedInUrlEnrichmentDirect(params) {
             contact_id: primary.contact_id,
             linkedin_url: matchedUrl ?? matchedSalesNavUrl,
             sales_nav_profile_url: matchedSalesNavUrl,
+            matched_full_name: matchedFullName,
+            matched_company_name: matchedCompanyName,
+            matched_title: matchedTitle,
             error: matchedUrl || matchedSalesNavUrl ? null : lastError
         });
     }
     return {
         success: true,
-        contacts: results
+        contacts: results,
+        companyContexts: Array.from(companyContexts.values())
     };
 }
 async function invokeLinkedInCompanyEnrichmentDirect(params) {
     const config = await readLinkedInDirectLookupConfig();
+    const precomputedContextByKey = new Map((params.precomputedContexts ?? []).map((context) => [context.normalizedCompanyKey, context]));
     const primaryContacts = new Map();
     for (const contact of params.contacts) {
         const existing = primaryContacts.get(contact.contact_id);
@@ -1897,11 +3179,23 @@ async function invokeLinkedInCompanyEnrichmentDirect(params) {
             companyName: contact.companyName,
             companyNameOriginal: contact.companyNameOriginal
         });
-        let matchedCompanyUrl = null;
-        let matchedSalesNavCompanyUrl = null;
-        let matchedCompanyName = null;
-        let matchedCompanyEmployeeCount = null;
+        const precomputedContext = precomputedContextByKey.get(buildDirectCompanyContextKey(contact));
+        let matchedCompanyUrl = precomputedContext?.linkedinCompanyUrl ?? null;
+        let matchedSalesNavCompanyUrl = precomputedContext?.salesNavCompanyUrl ?? null;
+        let matchedCompanyName = precomputedContext?.matchedCompanyName ?? null;
+        let matchedCompanyEmployeeCount = precomputedContext?.matchedCompanyEmployeeCount ?? null;
         let lastError = null;
+        if (matchedCompanyUrl || matchedSalesNavCompanyUrl || matchedCompanyName) {
+            results.push({
+                contact_id: contact.contact_id,
+                linkedin_company_url: matchedCompanyUrl,
+                sales_nav_company_url: matchedSalesNavCompanyUrl,
+                matched_company_name: matchedCompanyName,
+                matched_company_employee_count: matchedCompanyEmployeeCount,
+                error: null
+            });
+            continue;
+        }
         for (const variant of variants) {
             const controller = new AbortController();
             const timeout = setTimeout(controller.abort.bind(controller), Math.min(params.timeoutMs, 20_000));
@@ -2044,9 +3338,34 @@ async function invokeLinkedInUrlEnrichmentWorkflow(params) {
     }
 }
 function normalizeWorkflowLinkedInUrlResult(params) {
+    const inputContactIds = new Set(params.contacts.map((contact) => contact.contact_id));
     const contactIdsBySyntheticEmail = new Map(params.contacts
         .filter((contact) => contact.email)
         .map((contact) => [String(contact.email).toLowerCase(), contact.contact_id]));
+    const contactIdsByNormalizedIdentity = new Map(params.contacts
+        .filter((contact) => !contact.isVariation)
+        .map((contact) => {
+        const fullName = normalizeLooseMatchText(normalizeLookupWhitespace(`${contact.firstName} ${contact.lastName}`));
+        const companyName = normalizeLooseMatchText(contact.companyNameOriginal ?? contact.companyName);
+        return [`${fullName}|${companyName}`, contact.contact_id];
+    })
+        .filter(([key]) => key !== "|"));
+    const normalizedNameCounts = new Map();
+    for (const contact of params.contacts) {
+        if (contact.isVariation)
+            continue;
+        const fullName = normalizeLooseMatchText(normalizeLookupWhitespace(`${contact.firstName} ${contact.lastName}`));
+        if (!fullName)
+            continue;
+        normalizedNameCounts.set(fullName, (normalizedNameCounts.get(fullName) ?? 0) + 1);
+    }
+    const contactIdsByNormalizedName = new Map(params.contacts
+        .filter((contact) => !contact.isVariation)
+        .map((contact) => {
+        const fullName = normalizeLooseMatchText(normalizeLookupWhitespace(`${contact.firstName} ${contact.lastName}`));
+        return [fullName, contact.contact_id];
+    })
+        .filter(([fullName]) => Boolean(fullName) && (normalizedNameCounts.get(fullName) ?? 0) === 1));
     const rowsByContactId = new Map();
     const body = params.parsedBody && typeof params.parsedBody === "object" && !Array.isArray(params.parsedBody)
         ? params.parsedBody
@@ -2056,13 +3375,34 @@ function normalizeWorkflowLinkedInUrlResult(params) {
         ...(Array.isArray(body?.profiles) ? body?.profiles : [])
     ];
     for (const contact of workflowRows) {
+        const fullNameCandidate = normalizeLookupWhitespace(typeof contact.full_name === "string"
+            ? contact.full_name
+            : typeof contact.fullName === "string"
+                ? contact.fullName
+                : typeof contact.name === "string"
+                    ? contact.name
+                    : [contact.first_name, contact.last_name]
+                        .filter((value) => typeof value === "string" && value.trim().length > 0)
+                        .join(" "));
+        const companyNameCandidate = normalizeLookupWhitespace(typeof contact.company_name === "string"
+            ? contact.company_name
+            : typeof contact.companyName === "string"
+                ? contact.companyName
+                : typeof contact.current_company === "string"
+                    ? contact.current_company
+                    : "");
+        const normalizedIdentityKey = `${normalizeLooseMatchText(fullNameCandidate)}|${normalizeLooseMatchText(companyNameCandidate)}`;
         const explicitContactId = typeof contact.contact_id === "string"
             ? contact.contact_id
             : typeof contact.contact_id === "number"
                 ? String(contact.contact_id)
                 : "";
         const emailKey = typeof contact.email === "string" ? contact.email.toLowerCase() : "";
-        const contactId = explicitContactId || contactIdsBySyntheticEmail.get(emailKey) || "";
+        const contactId = (inputContactIds.has(explicitContactId) ? explicitContactId : "") ||
+            contactIdsBySyntheticEmail.get(emailKey) ||
+            contactIdsByNormalizedIdentity.get(normalizedIdentityKey) ||
+            contactIdsByNormalizedName.get(normalizeLooseMatchText(fullNameCandidate)) ||
+            "";
         const linkedinUrl = normalizePublicLinkedInProfileUrl(typeof contact.linkedin_profile_url === "string"
             ? contact.linkedin_profile_url
             : typeof contact.linkedinProfileUrl === "string"
@@ -2149,7 +3489,8 @@ async function fetchSalesNavLookupCandidates(params) {
 }
 async function resolveLinkedInUrlsFromSalesNavRows(params) {
     const results = [];
-    for (const [index, row] of params.rows.entries()) {
+    for (const row of params.rows) {
+        const contactId = normalizeLinkedInLookupField(row.contactId) ?? `${results.length + 1}`;
         const candidates = await fetchSalesNavLookupCandidates({
             companyName: row.companyName,
             orgId: params.orgId
@@ -2199,19 +3540,20 @@ async function resolveLinkedInUrlsFromSalesNavRows(params) {
         const salesNavCompanyUrl = typeof best?.companyUrl === "string" && /\/sales\/company\//i.test(best.companyUrl)
             ? best.companyUrl
             : null;
+        const existingLinkedInCompanyUrl = row.linkedinCompanyUrl?.trim() || null;
         results.push({
             clientId: row.clientId,
             fullName: row.fullName,
             companyName: row.companyName,
             linkedinUrl,
             salesNavProfileUrl,
-            linkedinCompanyUrl,
+            linkedinCompanyUrl: linkedinCompanyUrl ?? existingLinkedInCompanyUrl,
             salesNavCompanyUrl,
             found: Boolean(linkedinUrl),
-            companyFound: Boolean(linkedinCompanyUrl),
-            contactId: String(index + 1),
+            companyFound: Boolean(linkedinCompanyUrl ?? existingLinkedInCompanyUrl),
+            contactId,
             source: linkedinUrl ? "salesnav-supabase" : null,
-            companySource: linkedinCompanyUrl ? "salesnav-supabase" : null,
+            companySource: linkedinCompanyUrl ? "salesnav-supabase" : existingLinkedInCompanyUrl ? "input" : null,
             matchedFullName: best?.fullName ?? null,
             matchedCompanyName: best?.companyName ?? null,
             matchedTitle: best?.title ?? null,
@@ -2221,6 +3563,223 @@ async function resolveLinkedInUrlsFromSalesNavRows(params) {
     }
     return results;
 }
+function shouldUseSalesNavRowPrepass(params) {
+    const env = params.env ?? process.env;
+    const explicit = env.SALESPROMPTER_LINKEDIN_ROW_PREPASS?.trim().toLowerCase();
+    if (explicit === "0" || explicit === "false" || explicit === "off") {
+        return false;
+    }
+    if (explicit === "1" || explicit === "true" || explicit === "on") {
+        return true;
+    }
+    const hasOrgId = Boolean(params.orgId?.trim());
+    const hasSupabase = Boolean(env.NEXT_PUBLIC_SUPABASE_URL?.trim() && env.SUPABASE_SERVICE_ROLE_KEY?.trim());
+    const maxRows = Number(env.SALESPROMPTER_LINKEDIN_ROW_PREPASS_MAX_ROWS ?? 200);
+    if (!hasOrgId || !hasSupabase) {
+        return false;
+    }
+    return params.rows.length <= (Number.isFinite(maxRows) && maxRows > 0 ? maxRows : 200);
+}
+function shouldUseDirectPeopleLookup(params) {
+    const env = params.env ?? process.env;
+    const explicit = env.SALESPROMPTER_LINKEDIN_DIRECT_PROFILE_LOOKUP?.trim().toLowerCase();
+    if (explicit === "0" || explicit === "false" || explicit === "off") {
+        return false;
+    }
+    if (explicit === "1" || explicit === "true" || explicit === "on") {
+        return true;
+    }
+    const maxRows = Number(env.SALESPROMPTER_LINKEDIN_DIRECT_PROFILE_MAX_ROWS ?? 50);
+    return params.rowCount <= (Number.isFinite(maxRows) && maxRows > 0 ? maxRows : 50);
+}
+function shouldUseWorkflowPeopleLookup(params) {
+    const env = params.env ?? process.env;
+    const explicit = env.SALESPROMPTER_LINKEDIN_WORKFLOW_PROFILE_LOOKUP?.trim().toLowerCase();
+    if (explicit === "0" || explicit === "false" || explicit === "off") {
+        return false;
+    }
+    if (explicit === "1" || explicit === "true" || explicit === "on") {
+        return true;
+    }
+    const hasSerper = Boolean(getSerperApiKey(env));
+    const maxRows = Number(env.SALESPROMPTER_LINKEDIN_WORKFLOW_PROFILE_MAX_ROWS ?? (hasSerper ? 75 : 250));
+    return params.rowCount <= (Number.isFinite(maxRows) && maxRows > 0 ? maxRows : hasSerper ? 75 : 250);
+}
+function shouldUseBulkProfileResolutionStrategy(params) {
+    const env = params.env ?? process.env;
+    const explicit = env.SALESPROMPTER_LINKEDIN_BULK_MODE?.trim().toLowerCase();
+    if (explicit === "0" || explicit === "false" || explicit === "off") {
+        return false;
+    }
+    if (explicit === "1" || explicit === "true" || explicit === "on") {
+        return true;
+    }
+    const minRows = Number(env.SALESPROMPTER_LINKEDIN_BULK_MODE_MIN_ROWS ?? 75);
+    return params.rowCount >= (Number.isFinite(minRows) && minRows > 0 ? minRows : 75);
+}
+function resolveLinkedInBulkStrategyConfig(params) {
+    const env = params.env ?? process.env;
+    const bulkMode = shouldUseBulkProfileResolutionStrategy({
+        rowCount: params.rowCount,
+        env
+    });
+    const serperConcurrencyDefault = bulkMode ? 12 : 6;
+    const serperConcurrency = Number(env.SALESPROMPTER_LINKEDIN_SERPER_CONCURRENCY ?? serperConcurrencyDefault);
+    const serperMaxQueriesDefault = bulkMode ? 4 : 8;
+    const serperMaxQueries = Number(env.SALESPROMPTER_LINKEDIN_SERPER_MAX_QUERIES ?? serperMaxQueriesDefault);
+    const workflowStageBudgetDefault = bulkMode ? 8_000 : 15_000;
+    const workflowStageBudgetMs = Number(env.SALESPROMPTER_LINKEDIN_WORKFLOW_STAGE_TIMEOUT_MS ?? workflowStageBudgetDefault);
+    const serperStageBudgetDefault = bulkMode
+        ? Math.max(15_000, Math.min(params.timeoutMs * 2, 45_000))
+        : Math.max(10_000, Math.min(params.timeoutMs, 20_000));
+    const serperStageBudgetMs = Number(env.SALESPROMPTER_LINKEDIN_SERPER_STAGE_TIMEOUT_MS ?? serperStageBudgetDefault);
+    const bulkDirectProfileMaxRowsDefault = 0;
+    const bulkDirectProfileMaxRows = Number(env.SALESPROMPTER_LINKEDIN_BULK_DIRECT_PROFILE_MAX_ROWS ?? bulkDirectProfileMaxRowsDefault);
+    const bulkDirectProfileTimeoutDefault = bulkMode ? Math.min(params.timeoutMs, 6_000) : 0;
+    const bulkDirectProfileTimeoutMs = Number(env.SALESPROMPTER_LINKEDIN_BULK_DIRECT_PROFILE_TIMEOUT_MS ?? bulkDirectProfileTimeoutDefault);
+    return {
+        bulkMode,
+        serperConcurrency: Number.isFinite(serperConcurrency) && serperConcurrency > 0
+            ? Math.trunc(serperConcurrency)
+            : serperConcurrencyDefault,
+        serperMaxQueries: Number.isFinite(serperMaxQueries) && serperMaxQueries > 0
+            ? Math.trunc(serperMaxQueries)
+            : serperMaxQueriesDefault,
+        workflowStageBudgetMs: Number.isFinite(workflowStageBudgetMs) && workflowStageBudgetMs > 0
+            ? Math.trunc(workflowStageBudgetMs)
+            : workflowStageBudgetDefault,
+        serperStageBudgetMs: Number.isFinite(serperStageBudgetMs) && serperStageBudgetMs > 0
+            ? Math.trunc(serperStageBudgetMs)
+            : serperStageBudgetDefault,
+        bulkDirectProfileMaxRows: Number.isFinite(bulkDirectProfileMaxRows) && bulkDirectProfileMaxRows > 0
+            ? Math.trunc(bulkDirectProfileMaxRows)
+            : 0,
+        bulkDirectProfileTimeoutMs: Number.isFinite(bulkDirectProfileTimeoutMs) && bulkDirectProfileTimeoutMs > 0
+            ? Math.trunc(bulkDirectProfileTimeoutMs)
+            : 0
+    };
+}
+function shouldAttemptBulkDirectProfileLookup(params) {
+    return (params.strategy.bulkMode &&
+        params.strategy.bulkDirectProfileMaxRows > 0 &&
+        params.strategy.bulkDirectProfileTimeoutMs > 0 &&
+        params.unresolvedRowCount > 0);
+}
+function rankContactsForBulkDirectProfileLookup(params) {
+    const scored = params.contacts
+        .filter((contact) => !contact.isVariation)
+        .map((contact) => {
+        const row = params.rowsByContactId.get(contact.contact_id);
+        const normalizedName = normalizeLookupWhitespace(`${contact.firstName} ${contact.lastName}`);
+        const normalizedEmail = normalizeLookupWhitespace(contact.email);
+        const titleKeywords = extractLookupTitleKeywords(contact.jobTitle);
+        const roleKeywords = buildDeepDiveRoleSearchKeywords(contact.deepDiveRecommendedRole);
+        let score = 0;
+        if (row?.linkedinCompanyUrl || contact.linkedinCompanyUrl)
+            score += 80;
+        if (row?.salesNavCompanyUrl)
+            score += 20;
+        if (normalizedEmail && !isSyntheticLinkedInLookupEmail(normalizedEmail))
+            score += 40;
+        if (contact.jobTitle?.trim())
+            score += 25;
+        if (contact.deepDiveRecommendedRole?.trim())
+            score += 15;
+        score += Math.min(20, titleKeywords.length * 5);
+        score += Math.min(15, roleKeywords.length * 5);
+        if (/^contact\s+\d+$/i.test(normalizedName))
+            score -= 100;
+        if (/^(hr|support|facility|buchhaltung|rechnungen)$/i.test(normalizedName))
+            score -= 25;
+        return { contact, score };
+    })
+        .filter((entry) => entry.score > 0)
+        .sort((left, right) => right.score - left.score);
+    return scored.slice(0, params.limit).map((entry) => entry.contact);
+}
+async function resolveSerperLinkedInProfilesInParallel(params) {
+    const results = new Map();
+    const contacts = params.contacts;
+    const concurrency = Math.max(1, Math.min(params.concurrency ?? 3, contacts.length || 1));
+    const deadline = params.overallBudgetMs && Number.isFinite(params.overallBudgetMs) && params.overallBudgetMs > 0
+        ? Date.now() + Math.trunc(params.overallBudgetMs)
+        : Number.POSITIVE_INFINITY;
+    let nextIndex = 0;
+    const worker = async () => {
+        while (true) {
+            if (Date.now() >= deadline) {
+                return;
+            }
+            const index = nextIndex++;
+            if (index >= contacts.length) {
+                return;
+            }
+            const contact = contacts[index];
+            const remainingBudget = deadline - Date.now();
+            if (remainingBudget <= 0) {
+                return;
+            }
+            const linkedinUrl = await searchSerperLinkedInProfileUrl(contact, Math.min(params.timeoutMs, remainingBudget), {
+                maxQueries: params.maxQueries
+            });
+            if (linkedinUrl) {
+                results.set(contact.contact_id, linkedinUrl);
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: concurrency }, () => worker()));
+    return results;
+}
+async function resolveLinkedInCompanyUrlsForContacts(params) {
+    const contacts = params.contacts.filter((contact) => !contact.isVariation && !contact.linkedinCompanyUrl);
+    const uniqueCompanies = new Map();
+    for (const contact of contacts) {
+        const key = normalizeLookupCompanyForCleaning(contact.companyNameOriginal ?? contact.companyName);
+        if (!key || uniqueCompanies.has(key)) {
+            continue;
+        }
+        uniqueCompanies.set(key, contact.companyNameOriginal ?? contact.companyName);
+    }
+    const resultsByCompany = new Map();
+    const entries = Array.from(uniqueCompanies.entries());
+    const concurrency = Math.max(1, Math.min(params.concurrency ?? 4, entries.length || 1));
+    const deadline = params.overallBudgetMs && Number.isFinite(params.overallBudgetMs) && params.overallBudgetMs > 0
+        ? Date.now() + Math.trunc(params.overallBudgetMs)
+        : Number.POSITIVE_INFINITY;
+    let nextIndex = 0;
+    const worker = async () => {
+        while (true) {
+            if (Date.now() >= deadline) {
+                return;
+            }
+            const index = nextIndex++;
+            if (index >= entries.length) {
+                return;
+            }
+            const [key, companyName] = entries[index];
+            const remainingBudget = deadline - Date.now();
+            if (remainingBudget <= 0) {
+                return;
+            }
+            const perCompanyTimeout = Math.min(params.timeoutMs, remainingBudget);
+            const linkedinUrl = (await searchSerperLinkedInCompanyUrl(companyName, perCompanyTimeout)) ??
+                (await searchPublicLinkedInCompanyUrl(companyName, perCompanyTimeout));
+            if (linkedinUrl) {
+                resultsByCompany.set(key, linkedinUrl);
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: concurrency }, () => worker()));
+    const results = new Map();
+    for (const contact of params.contacts) {
+        const key = normalizeLookupCompanyForCleaning(contact.companyNameOriginal ?? contact.companyName);
+        const linkedinUrl = resultsByCompany.get(key);
+        if (linkedinUrl) {
+            results.set(contact.contact_id, linkedinUrl);
+        }
+    }
+    return results;
+}
 function buildCommandLine(args) {
     return args.map((arg) => shellQuote(arg)).join(" ");
 }
@@ -3208,6 +4767,72 @@ async function fetchWorkspaceLeadSearch(session, requestBody) {
     }
     return WorkspaceLeadSearchResponseSchema.parse(payload).leads;
 }
+async function buildWorkspaceLeadAccount(icp, target, leads) {
+    const firstLead = leads[0];
+    if (firstLead) {
+        const keywords = Array.from(new Set([target.companyDomain?.split(".")[0], firstLead.industry, firstLead.region, ...icp.keywords].filter((value) => typeof value === "string" && value.trim().length > 0)));
+        return AccountProfileSchema.parse({
+            companyName: target.companyName?.trim() || firstLead.companyName,
+            domain: target.companyDomain?.trim().toLowerCase() || firstLead.domain,
+            industry: firstLead.industry,
+            region: firstLead.region,
+            employeeCount: firstLead.employeeCount,
+            keywords,
+            sources: ["workspace-qualified-leads"]
+        });
+    }
+    return await companyProvider.resolveCompany({
+        companyDomain: target.companyDomain,
+        companyName: target.companyName
+    }, icp);
+}
+async function generateLeadsForCommand(options) {
+    const source = z.enum(["auto", "workspace", "fallback"]).parse(options.source ?? "auto");
+    if (source === "fallback") {
+        return await leadProvider.generateLeads(options.icp, options.count, options.target);
+    }
+    if (shouldBypassAuth()) {
+        if (source === "workspace") {
+            throw new Error("workspace lead generation requires authentication. Disable SALESPROMPTER_SKIP_AUTH and log in first.");
+        }
+        return await leadProvider.generateLeads(options.icp, options.count, options.target);
+    }
+    try {
+        const session = await requireAuthSession();
+        const requestBody = options.target.companyDomain || options.target.linkedinCompanyPage
+            ? {
+                mode: "target-company",
+                domain: options.target.companyDomain,
+                linkedinCompanyPage: options.target.linkedinCompanyPage,
+                limit: options.count
+            }
+            : {
+                mode: "reference-company",
+                icp: options.icp,
+                limit: options.count
+            };
+        const leads = await fetchWorkspaceLeadSearch(session, requestBody);
+        const account = await buildWorkspaceLeadAccount(options.icp, options.target, leads);
+        return {
+            provider: "salesprompter-app-workspace-search",
+            mode: "real",
+            account,
+            leads,
+            warnings: []
+        };
+    }
+    catch (error) {
+        if (source === "workspace") {
+            throw error;
+        }
+        const fallback = await leadProvider.generateLeads(options.icp, options.count, options.target);
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ...fallback,
+            warnings: [`Workspace lead search unavailable: ${message}`, ...fallback.warnings]
+        };
+    }
+}
 function buildLinkedInProductsOutputPath(categorySlug) {
     return `./data/linkedin-products-${categorySlug}.json`;
 }
@@ -3215,19 +4840,29 @@ function buildLinkedInProductCategorySalesNavigatorOutputPath(categorySlug) {
     return `./data/salesnav-product-category-${categorySlug}.json`;
 }
 const SALES_NAVIGATOR_TERMINAL_JOB_STATUSES = new Set(["completed", "completed_with_failures"]);
+const WORKFLOW_LOCAL_LOG_MAX_FILE_BYTES = 10 * 1024 * 1024;
+const WORKFLOW_LOCAL_LOG_MAX_LINE_BYTES = 32 * 1024;
+const WORKFLOW_LOCAL_LOG_MAX_STRING_CHARS = 4000;
+const WORKFLOW_LOCAL_LOG_MAX_ARRAY_ITEMS = 50;
+const WORKFLOW_LOCAL_LOG_MAX_OBJECT_KEYS = 50;
+const WORKFLOW_LOCAL_LOG_MAX_DEPTH = 5;
 function isSalesNavigatorCrawlJobTerminal(status) {
     return SALES_NAVIGATOR_TERMINAL_JOB_STATUSES.has(status);
 }
 function buildWorkflowTraceId(prefix) {
     return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
 }
+function buildWorkflowLogRunSuffix() {
+    const timestamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+    return `${timestamp}-${Math.random().toString(36).slice(2, 8)}`;
+}
 function buildSalesNavigatorWorkflowLogPath(input) {
     const slug = slugify(input) || "salesnav-product-category";
-    return `./data/${slug}-salesnav.log.jsonl`;
+    return `./data/${slug}-${buildWorkflowLogRunSuffix()}-salesnav.log.jsonl`;
 }
 function buildSalesNavigatorCrawlLogPath(input) {
     const slug = slugify(input) || "salesnav-crawl";
-    return `./data/${slug}-crawl.log.jsonl`;
+    return `./data/${slug}-${buildWorkflowLogRunSuffix()}-crawl.log.jsonl`;
 }
 function buildSalesNavigatorCrawlOutputPath(input) {
     const slug = slugify(input) || "salesnav-crawl";
@@ -3259,6 +4894,83 @@ function decodeSalesNavigatorQueryParam(url) {
         return null;
     }
 }
+function sanitizeWorkflowLogValue(value, depth = 0, seen = new WeakSet()) {
+    if (typeof value === "string") {
+        if (value.length <= WORKFLOW_LOCAL_LOG_MAX_STRING_CHARS) {
+            return value;
+        }
+        return `${value.slice(0, WORKFLOW_LOCAL_LOG_MAX_STRING_CHARS)}... [truncated ${value.length - WORKFLOW_LOCAL_LOG_MAX_STRING_CHARS} chars]`;
+    }
+    if (typeof value !== "object" || value === null) {
+        return value;
+    }
+    if (seen.has(value)) {
+        return "[Circular]";
+    }
+    if (depth >= WORKFLOW_LOCAL_LOG_MAX_DEPTH) {
+        return "[MaxDepth]";
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const items = value
+            .slice(0, WORKFLOW_LOCAL_LOG_MAX_ARRAY_ITEMS)
+            .map((item) => sanitizeWorkflowLogValue(item, depth + 1, seen));
+        if (value.length > WORKFLOW_LOCAL_LOG_MAX_ARRAY_ITEMS) {
+            items.push({ truncatedItems: value.length - WORKFLOW_LOCAL_LOG_MAX_ARRAY_ITEMS });
+        }
+        return items;
+    }
+    const entries = Object.entries(value);
+    const sanitized = {};
+    for (const [key, entryValue] of entries.slice(0, WORKFLOW_LOCAL_LOG_MAX_OBJECT_KEYS)) {
+        sanitized[key] = sanitizeWorkflowLogValue(entryValue, depth + 1, seen);
+    }
+    if (entries.length > WORKFLOW_LOCAL_LOG_MAX_OBJECT_KEYS) {
+        sanitized.truncatedKeys = entries.length - WORKFLOW_LOCAL_LOG_MAX_OBJECT_KEYS;
+    }
+    return sanitized;
+}
+function serializeWorkflowLogEntry(entry) {
+    const sanitizedEntry = {
+        ...entry,
+        metadata: sanitizeWorkflowLogValue(entry.metadata)
+    };
+    let line = JSON.stringify(sanitizedEntry);
+    if (Buffer.byteLength(line, "utf8") <= WORKFLOW_LOCAL_LOG_MAX_LINE_BYTES) {
+        return `${line}\n`;
+    }
+    const originalMetadata = entry.metadata ?? {};
+    const metadataKeys = Object.keys(originalMetadata);
+    line = JSON.stringify({
+        ...entry,
+        metadata: {
+            localLogTruncated: true,
+            originalMetadataKeys: metadataKeys.slice(0, WORKFLOW_LOCAL_LOG_MAX_OBJECT_KEYS),
+            truncatedKeys: Math.max(0, metadataKeys.length - WORKFLOW_LOCAL_LOG_MAX_OBJECT_KEYS),
+            originalMetadataBytes: Buffer.byteLength(JSON.stringify(sanitizeWorkflowLogValue(originalMetadata)), "utf8")
+        }
+    });
+    return `${line}\n`;
+}
+async function appendWorkflowLocalLog(logPath, entry) {
+    try {
+        const current = await stat(logPath).catch((error) => {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        });
+        if (current && current.size >= WORKFLOW_LOCAL_LOG_MAX_FILE_BYTES) {
+            writeProgress(`[${entry.timestamp}] ${entry.event} (local log skipped because ${logPath} is already over 10 MB; durable event storage still runs when configured)`);
+            return;
+        }
+        await appendFile(logPath, serializeWorkflowLogEntry(entry), "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        writeProgress(`[${entry.timestamp}] workflow.local_log.write_failed: ${message}`);
+    }
+}
 async function createWorkflowLogger(options) {
     const traceId = options.traceId ?? buildWorkflowTraceId("salesprompter-cli");
     const logPath = options.logPath;
@@ -3277,7 +4989,7 @@ async function createWorkflowLogger(options) {
                 event,
                 metadata
             };
-            await appendFile(logPath, `${JSON.stringify(entry)}\n`, "utf8");
+            await appendWorkflowLocalLog(logPath, entry);
             if (eventStore) {
                 try {
                     await eventStore.append({
@@ -3994,6 +5706,17 @@ async function fetchLinkedInCompaniesBackfillStatus(session, payload) {
     }), LinkedInCompanyBackfillStatusResponseSchema);
     return value;
 }
+async function syncPhantombusterContainersViaApp(session, payload) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/phantombuster/containers/sync`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify(payload)
+    }), PhantombusterContainersSyncResponseSchema);
+    return value;
+}
 function serializeSalesNavigatorFiltersForApi(filters) {
     return filters.map((filter) => ({
         type: filter.type,
@@ -4020,6 +5743,12 @@ function buildSalesNavigatorSliceRawPayload(slice, extra = {}) {
         resultRetryCount: slice.resultRetryCount ?? null
     };
 }
+function parseOptionalSalesNavigatorClientId(value) {
+    if (value == null || String(value).trim().length === 0) {
+        return null;
+    }
+    return z.coerce.number().int().positive().parse(value);
+}
 function buildSalesNavigatorCrawlReportRawPayload(slice, traceId, extra = {}) {
     return buildSalesNavigatorSliceRawPayload({
         sourceQueryUrl: slice.sourceQueryUrl,
@@ -4480,11 +6209,12 @@ function isSalesNavigatorSessionError(error) {
     return /can't connect profile|sales navigator account|upsell|linkedin session invalid|linkedin_rate_limited|too many requests|rate.?limit|invalid session cookie|disconnected by linkedin|linkedin-disconnected-while-using-api|provide a new linkedin session cookie/i.test(message);
 }
 function isSalesNavigatorResultArtifactError(error) {
-    if (error instanceof SalesNavigatorExportRequestError && error.errorCode === "phantombuster_result_invalid") {
+    if (error instanceof SalesNavigatorExportRequestError &&
+        ["phantombuster_result_invalid", "partial_result_artifact"].includes(error.errorCode ?? "")) {
         return true;
     }
     const message = error instanceof Error ? error.message : String(error);
-    return /page has crashed|no valid sales navigator people rows/i.test(message);
+    return /page has crashed|no valid sales navigator people rows|partial result artifact|returned \d+ valid sales navigator people rows, but \d+ were expected/i.test(message);
 }
 function isSalesNavigatorTransientExportError(error) {
     if (isSalesNavigatorSessionError(error) || isSalesNavigatorResultArtifactError(error)) {
@@ -4575,6 +6305,7 @@ async function runSalesNavigatorCrawlAttempt(session, attempt, options, context)
         crawlSliceId: context?.crawlSliceId,
         rawPayload: buildSalesNavigatorSliceRawPayload(attempt, {
             traceId: context?.traceId ?? null,
+            clientId: context?.clientId ?? null,
             phase: shouldProbe ? "probe" : "full_export",
             requestedProfiles: probeProfiles,
             crawlJobId: context?.crawlJobId ?? null,
@@ -4611,6 +6342,7 @@ async function runSalesNavigatorCrawlAttempt(session, attempt, options, context)
         crawlSliceId: context?.crawlSliceId,
         rawPayload: buildSalesNavigatorSliceRawPayload(attempt, {
             traceId: context?.traceId ?? null,
+            clientId: context?.clientId ?? null,
             phase: "full_export_after_probe",
             requestedProfiles: attempt.numberOfProfiles,
             crawlJobId: context?.crawlJobId ?? null,
@@ -4709,6 +6441,8 @@ const SALES_NAVIGATOR_SPLIT_TRIGGER_RESULTS = 1500;
 const SALES_NAVIGATOR_FILTER_IMPACT_MIN_OBSERVATIONS = 3;
 let salesNavigatorFilterImpactModel = null;
 let salesNavigatorFilterImpactLoaded = false;
+let linkedInProfileHitCache = null;
+let linkedInProfileHitCacheLoaded = false;
 function getSalesprompterConfigDir() {
     const override = process.env.SALESPROMPTER_CONFIG_DIR?.trim();
     if (override !== undefined && override.length > 0) {
@@ -4719,6 +6453,76 @@ function getSalesprompterConfigDir() {
 function getSalesNavigatorFilterImpactPath() {
     return path.join(getSalesprompterConfigDir(), "salesnav-filter-impact.json");
 }
+function getLinkedInProfileHitCachePath() {
+    return path.join(getSalesprompterConfigDir(), "linkedin-profile-hits.json");
+}
+function buildLinkedInProfileHitCacheKeys(params) {
+    const keys = new Set();
+    const normalizedName = normalizeLooseMatchText(params.fullName);
+    const normalizedCompany = normalizeLooseMatchText(params.companyName);
+    const normalizedEmail = normalizeLookupWhitespace(params.email);
+    const trustedEmail = normalizedEmail && !isSyntheticLinkedInLookupEmail(normalizedEmail) ? normalizedEmail.toLowerCase() : "";
+    const contactId = normalizeLinkedInLookupField(params.contactId);
+    if (contactId && !/^[1-9]\d?$/.test(contactId)) {
+        keys.add(`contact:${contactId}`);
+    }
+    if (normalizedName && normalizedCompany && trustedEmail) {
+        keys.add(`identity:${normalizedName}|${normalizedCompany}|${trustedEmail}`);
+    }
+    if (normalizedName && normalizedCompany) {
+        keys.add(`identity:${normalizedName}|${normalizedCompany}`);
+    }
+    return Array.from(keys);
+}
+async function loadLinkedInProfileHitCache() {
+    if (linkedInProfileHitCacheLoaded) {
+        return linkedInProfileHitCache;
+    }
+    linkedInProfileHitCacheLoaded = true;
+    try {
+        const content = await readFile(getLinkedInProfileHitCachePath(), "utf8");
+        const parsed = JSON.parse(content);
+        if (parsed?.version === 1 && parsed.entries && typeof parsed.entries === "object") {
+            linkedInProfileHitCache = parsed;
+        }
+    }
+    catch {
+        linkedInProfileHitCache = null;
+    }
+    return linkedInProfileHitCache;
+}
+async function persistLinkedInProfileHitCache() {
+    if (!linkedInProfileHitCache) {
+        return;
+    }
+    const filePath = getLinkedInProfileHitCachePath();
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(linkedInProfileHitCache, null, 2)}\n`, "utf8");
+}
+function upsertLinkedInProfileHitCacheEntry(params) {
+    if (!params.linkedinUrl && !params.salesNavProfileUrl && !params.linkedinCompanyUrl && !params.salesNavCompanyUrl) {
+        return;
+    }
+    if (!linkedInProfileHitCache) {
+        linkedInProfileHitCache = {
+            version: 1,
+            updatedAt: new Date().toISOString(),
+            entries: {}
+        };
+    }
+    const updatedAt = new Date().toISOString();
+    linkedInProfileHitCache.updatedAt = updatedAt;
+    const entry = {
+        linkedinUrl: params.linkedinUrl,
+        salesNavProfileUrl: params.salesNavProfileUrl,
+        linkedinCompanyUrl: params.linkedinCompanyUrl,
+        salesNavCompanyUrl: params.salesNavCompanyUrl,
+        updatedAt
+    };
+    for (const key of buildLinkedInProfileHitCacheKeys(params)) {
+        linkedInProfileHitCache.entries[key] = entry;
+    }
+}
 async function loadSalesNavigatorFilterImpactModel() {
     if (salesNavigatorFilterImpactLoaded) {
         return salesNavigatorFilterImpactModel;
@@ -4991,6 +6795,7 @@ async function processSalesNavigatorClaimedCrawlSlice(session, jobId, slice, opt
         }, {
             crawlJobId: jobId,
             crawlSliceId: slice.id,
+            clientId: options.clientId ?? null,
             traceId: options.traceId
         });
         const reported = await reportSalesNavigatorCrawlSlice(currentSession, jobId, {
@@ -5267,6 +7072,7 @@ async function executeSalesNavigatorCrawlJob(session, jobId, options) {
                 agentBusyWaitSeconds: options.agentBusyWaitSeconds,
                 agentBusyMaxWaits: options.agentBusyMaxWaits,
                 claimedSlices: claimedSliceNumber,
+                clientId: options.clientId ?? null,
                 traceId: options.traceId,
                 logger: options.logger
             }).then((value) => ({ slot, value })));
@@ -6230,6 +8036,7 @@ program
     const companyCleaningMode = resolveCompanyCleaningMode(String(options.companyCleaning ?? process.env.SALESPROMPTER_COMPANY_CLEANING_MODE ?? "basic"));
     const cleanedCompanyMap = await buildCompanyNameCleaningMap(rows, companyCleaningMode);
     const contacts = toLinkedInUrlLookupContacts(rows, cleanedCompanyMap);
+    await loadLinkedInProfileHitCache();
     if (options.dryRun) {
         const payload = {
             status: "ok",
@@ -6245,79 +8052,70 @@ program
         printOutput(payload);
         return;
     }
-    const enrichedRows = await resolveLinkedInUrlsFromSalesNavRows({
-        rows,
-        orgId: String(options.orgId ?? "").trim() || undefined
+    const orgId = String(options.orgId ?? "").trim() || undefined;
+    const strategy = resolveLinkedInBulkStrategyConfig({
+        rowCount: rows.length,
+        timeoutMs
     });
-    let directAttempted = false;
-    let workflowAttempted = false;
-    const missingRows = enrichedRows.filter((row) => !row.found);
-    if (missingRows.length > 0) {
-        const directContacts = contacts.filter((contact) => missingRows.some((row) => row.contactId === contact.contact_id));
-        let linkedInUrlByContactId = new Map();
-        try {
-            directAttempted = true;
-            const result = await invokeLinkedInUrlEnrichmentDirect({
-                contacts: directContacts,
-                timeoutMs
-            });
-            linkedInUrlByContactId = new Map(result.contacts.map((contact) => [
-                contact.contact_id,
-                {
-                    linkedinUrl: contact.linkedin_url ?? null,
-                    salesNavProfileUrl: contact.sales_nav_profile_url ?? null,
-                    linkedinCompanyUrl: null,
-                    salesNavCompanyUrl: null
-                }
-            ]));
-            for (const row of enrichedRows) {
-                if (row.found)
-                    continue;
-                const profile = linkedInUrlByContactId.get(row.contactId);
-                if (profile?.linkedinUrl) {
-                    row.linkedinUrl = profile.linkedinUrl;
-                    row.salesNavProfileUrl = profile.salesNavProfileUrl ?? row.salesNavProfileUrl ?? null;
-                    row.found = true;
-                    row.source = "linkedin-direct";
-                }
-            }
+    const useSalesNavRowPrepass = !strategy.bulkMode &&
+        shouldUseSalesNavRowPrepass({
+            rows,
+            orgId
+        });
+    const enrichedRows = useSalesNavRowPrepass
+        ? await resolveLinkedInUrlsFromSalesNavRows({
+            rows,
+            orgId
+        })
+        : rows.map((row, index) => ({
+            clientId: row.clientId,
+            fullName: row.fullName,
+            companyName: row.companyName,
+            linkedinUrl: null,
+            salesNavProfileUrl: null,
+            linkedinCompanyUrl: row.linkedinCompanyUrl?.trim() || null,
+            salesNavCompanyUrl: null,
+            found: false,
+            companyFound: Boolean(row.linkedinCompanyUrl?.trim()),
+            contactId: normalizeLinkedInLookupField(row.contactId) ?? `${index + 1}`,
+            source: null,
+            companySource: row.linkedinCompanyUrl?.trim() ? "input" : null,
+            matchedFullName: null,
+            matchedCompanyName: null,
+            matchedTitle: null,
+            matchedOrgId: null,
+            matchedCompanyEmployeeCount: null
+        }));
+    const contactById = new Map(contacts.filter((contact) => !contact.isVariation).map((contact) => [contact.contact_id, contact]));
+    for (const row of enrichedRows) {
+        if (row.found) {
+            continue;
         }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (!/Missing LinkedIn direct lookup session/i.test(message)) {
-                throw error;
-            }
-            workflowAttempted = true;
-            const workflow = await invokeLinkedInUrlEnrichmentWorkflow({
-                contacts: directContacts,
-                externalUserId: String(options.orgId ?? "").trim() || sessionOrgId || "cli_direct_lookup",
-                timeoutMs
-            });
-            if (!workflow.response.ok) {
-                throw new Error(`LinkedIn enrichment workflow returned ${workflow.response.status}: ${workflow.bodyText.slice(0, 300)}`);
-            }
-            linkedInUrlByContactId = normalizeWorkflowLinkedInUrlResult({
-                parsedBody: workflow.parsedBody,
-                contacts: directContacts
-            });
-            for (const row of enrichedRows) {
-                if (row.found)
-                    continue;
-                const profile = linkedInUrlByContactId.get(row.contactId);
-                if (profile?.linkedinUrl) {
-                    row.linkedinUrl = profile.linkedinUrl;
-                    row.salesNavProfileUrl = profile.salesNavProfileUrl ?? row.salesNavProfileUrl ?? null;
-                    row.linkedinCompanyUrl = profile.linkedinCompanyUrl ?? row.linkedinCompanyUrl ?? null;
-                    row.salesNavCompanyUrl = profile.salesNavCompanyUrl ?? row.salesNavCompanyUrl ?? null;
-                    row.found = true;
-                    row.companyFound = Boolean(row.linkedinCompanyUrl || row.salesNavCompanyUrl);
-                    row.source = "workflow";
-                    row.companySource =
-                        row.linkedinCompanyUrl || row.salesNavCompanyUrl ? "workflow" : row.companySource ?? null;
-                }
-            }
+        const contact = contactById.get(row.contactId);
+        const cacheKeys = buildLinkedInProfileHitCacheKeys({
+            fullName: row.fullName,
+            companyName: row.companyName,
+            email: contact?.email,
+            contactId: row.contactId
+        });
+        const cachedEntry = cacheKeys
+            .map((key) => linkedInProfileHitCache?.entries[key] ?? null)
+            .find(Boolean);
+        if (!cachedEntry) {
+            continue;
         }
+        row.linkedinUrl = cachedEntry.linkedinUrl ?? row.linkedinUrl ?? null;
+        row.salesNavProfileUrl = cachedEntry.salesNavProfileUrl ?? row.salesNavProfileUrl ?? null;
+        row.linkedinCompanyUrl = cachedEntry.linkedinCompanyUrl ?? row.linkedinCompanyUrl ?? null;
+        row.salesNavCompanyUrl = cachedEntry.salesNavCompanyUrl ?? row.salesNavCompanyUrl ?? null;
+        row.found = Boolean(row.linkedinUrl || row.salesNavProfileUrl);
+        row.companyFound = Boolean(row.linkedinCompanyUrl || row.salesNavCompanyUrl);
+        row.source = row.found ? "cache" : row.source;
+        row.companySource =
+            row.companyFound && !row.companySource ? "cache" : row.companySource;
     }
+    let directAttempted = false;
+    let workflowAttempted = false;
     const parsedClientIds = Array.from(new Set(rows
         .map((row) => Number(row.clientId))
         .filter((value) => Number.isFinite(value) && value > 0)));
@@ -6364,37 +8162,265 @@ program
             writeProgress(`Skipping app-backed company enrichment: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    try {
-        const companyResult = await invokeLinkedInCompanyEnrichmentDirect({
-            contacts,
-            timeoutMs
+    const contactsMissingCompanyUrl = contacts.filter((contact) => !contact.isVariation &&
+        enrichedRows.some((row) => row.contactId === contact.contact_id && !row.linkedinCompanyUrl));
+    if (contactsMissingCompanyUrl.length > 0) {
+        const companyUrlByContactId = await resolveLinkedInCompanyUrlsForContacts({
+            contacts: contactsMissingCompanyUrl,
+            timeoutMs: Math.min(timeoutMs, 15_000),
+            concurrency: strategy.bulkMode ? 6 : 3,
+            overallBudgetMs: strategy.bulkMode ? 20_000 : 10_000
         });
-        const companyByContactId = new Map(companyResult.contacts.map((contact) => [
-            contact.contact_id,
-            {
-                linkedinCompanyUrl: contact.linkedin_company_url ?? null,
-                salesNavCompanyUrl: contact.sales_nav_company_url ?? null,
-                matchedCompanyName: contact.matched_company_name ?? null,
-                matchedCompanyEmployeeCount: contact.matched_company_employee_count ?? null
-            }
-        ]));
         for (const row of enrichedRows) {
-            const company = companyByContactId.get(row.contactId);
-            if (!company || row.linkedinCompanyUrl) {
+            if (row.linkedinCompanyUrl) {
                 continue;
             }
-            row.linkedinCompanyUrl = company.linkedinCompanyUrl;
-            row.salesNavCompanyUrl = company.salesNavCompanyUrl ?? row.salesNavCompanyUrl ?? null;
-            row.companyFound = Boolean(company.linkedinCompanyUrl || company.salesNavCompanyUrl);
-            row.companySource =
-                company.linkedinCompanyUrl || company.salesNavCompanyUrl ? "linkedin-direct" : row.companySource ?? null;
-            row.matchedCompanyName = company.matchedCompanyName ?? row.matchedCompanyName ?? null;
-            row.matchedCompanyEmployeeCount =
-                company.matchedCompanyEmployeeCount ?? row.matchedCompanyEmployeeCount ?? null;
+            const linkedinCompanyUrl = companyUrlByContactId.get(row.contactId);
+            if (!linkedinCompanyUrl) {
+                continue;
+            }
+            row.linkedinCompanyUrl = linkedinCompanyUrl;
+            row.companyFound = true;
+            row.companySource = "web-search";
         }
     }
-    catch (error) {
-        writeProgress(`Skipping separate company enrichment: ${error instanceof Error ? error.message : String(error)}`);
+    const missingRows = enrichedRows.filter((row) => !row.found);
+    const useDirectPeopleLookup = !strategy.bulkMode &&
+        shouldUseDirectPeopleLookup({
+            rowCount: missingRows.length
+        });
+    const useWorkflowPeopleLookup = !strategy.bulkMode &&
+        shouldUseWorkflowPeopleLookup({
+            rowCount: missingRows.length
+        });
+    if (missingRows.length > 0) {
+        const rowByContactId = new Map(enrichedRows.map((row) => [row.contactId, row]));
+        const directContacts = contacts
+            .filter((contact) => missingRows.some((row) => row.contactId === contact.contact_id))
+            .map((contact) => {
+            const row = rowByContactId.get(contact.contact_id);
+            if (!row) {
+                return contact;
+            }
+            return {
+                ...contact,
+                linkedinCompanyUrl: row.linkedinCompanyUrl ?? contact.linkedinCompanyUrl,
+                companyNameOriginal: row.matchedCompanyName ?? contact.companyNameOriginal,
+                companyName: row.matchedCompanyName && normalizeLookupCompanyForSearch(row.matchedCompanyName)
+                    ? normalizeLookupCompanyForSearch(row.matchedCompanyName)
+                    : contact.companyName
+            };
+        });
+        let linkedInUrlByContactId = new Map();
+        if (useDirectPeopleLookup) {
+            try {
+                directAttempted = true;
+                const result = await invokeLinkedInUrlEnrichmentDirect({
+                    contacts: directContacts,
+                    timeoutMs
+                });
+                const directCompanyContextByKey = new Map((result.companyContexts ?? []).map((context) => [context.normalizedCompanyKey, context]));
+                linkedInUrlByContactId = new Map(result.contacts.map((contact) => [
+                    contact.contact_id,
+                    {
+                        linkedinUrl: contact.linkedin_url ?? null,
+                        salesNavProfileUrl: contact.sales_nav_profile_url ?? null,
+                        linkedinCompanyUrl: null,
+                        salesNavCompanyUrl: null,
+                        matchedFullName: contact.matched_full_name ?? null,
+                        matchedCompanyName: contact.matched_company_name ?? null,
+                        matchedTitle: contact.matched_title ?? null
+                    }
+                ]));
+                for (const row of enrichedRows) {
+                    if (row.found)
+                        continue;
+                    const profile = linkedInUrlByContactId.get(row.contactId);
+                    if (profile?.linkedinUrl) {
+                        row.linkedinUrl = profile.linkedinUrl;
+                        row.salesNavProfileUrl = profile.salesNavProfileUrl ?? row.salesNavProfileUrl ?? null;
+                        row.found = true;
+                        row.source = "linkedin-direct";
+                        row.matchedFullName = profile.matchedFullName ?? row.matchedFullName ?? null;
+                        row.matchedCompanyName = profile.matchedCompanyName ?? row.matchedCompanyName ?? null;
+                        row.matchedTitle = profile.matchedTitle ?? row.matchedTitle ?? null;
+                    }
+                    const directContact = directContacts.find((candidate) => candidate.contact_id === row.contactId && !candidate.isVariation);
+                    const companyContext = directContact
+                        ? directCompanyContextByKey.get(buildDirectCompanyContextKey(directContact))
+                        : null;
+                    if (companyContext && !row.linkedinCompanyUrl) {
+                        row.linkedinCompanyUrl = companyContext.linkedinCompanyUrl ?? row.linkedinCompanyUrl ?? null;
+                        row.salesNavCompanyUrl = companyContext.salesNavCompanyUrl ?? row.salesNavCompanyUrl ?? null;
+                        row.companyFound = Boolean(row.linkedinCompanyUrl || row.salesNavCompanyUrl);
+                        row.companySource =
+                            row.linkedinCompanyUrl || row.salesNavCompanyUrl ? "linkedin-direct" : row.companySource ?? null;
+                        row.matchedCompanyName = companyContext.matchedCompanyName ?? row.matchedCompanyName ?? null;
+                        row.matchedCompanyEmployeeCount =
+                            companyContext.matchedCompanyEmployeeCount ?? row.matchedCompanyEmployeeCount ?? null;
+                    }
+                }
+                const contactsStillMissingCompany = contacts.filter((contact) => !contact.isVariation &&
+                    enrichedRows.some((row) => row.contactId === contact.contact_id && !row.linkedinCompanyUrl && !row.salesNavCompanyUrl));
+                if (contactsStillMissingCompany.length > 0) {
+                    const companyResult = await invokeLinkedInCompanyEnrichmentDirect({
+                        contacts: contactsStillMissingCompany,
+                        timeoutMs,
+                        precomputedContexts: result.companyContexts
+                    });
+                    const companyByContactId = new Map(companyResult.contacts.map((contact) => [
+                        contact.contact_id,
+                        {
+                            linkedinCompanyUrl: contact.linkedin_company_url ?? null,
+                            salesNavCompanyUrl: contact.sales_nav_company_url ?? null,
+                            matchedCompanyName: contact.matched_company_name ?? null,
+                            matchedCompanyEmployeeCount: contact.matched_company_employee_count ?? null
+                        }
+                    ]));
+                    for (const row of enrichedRows) {
+                        const company = companyByContactId.get(row.contactId);
+                        if (!company || row.linkedinCompanyUrl) {
+                            continue;
+                        }
+                        row.linkedinCompanyUrl = company.linkedinCompanyUrl;
+                        row.salesNavCompanyUrl = company.salesNavCompanyUrl ?? row.salesNavCompanyUrl ?? null;
+                        row.companyFound = Boolean(company.linkedinCompanyUrl || company.salesNavCompanyUrl);
+                        row.companySource =
+                            company.linkedinCompanyUrl || company.salesNavCompanyUrl ? "linkedin-direct" : row.companySource ?? null;
+                        row.matchedCompanyName = company.matchedCompanyName ?? row.matchedCompanyName ?? null;
+                        row.matchedCompanyEmployeeCount =
+                            company.matchedCompanyEmployeeCount ?? row.matchedCompanyEmployeeCount ?? null;
+                    }
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (!/Missing LinkedIn direct lookup session/i.test(message)) {
+                    throw error;
+                }
+            }
+        }
+        const stillMissingAfterDirect = enrichedRows.filter((row) => !row.found);
+        const contactsStillMissing = directContacts.filter((contact) => stillMissingAfterDirect.some((row) => row.contactId === contact.contact_id));
+        if (contactsStillMissing.length > 0 && useWorkflowPeopleLookup) {
+            workflowAttempted = true;
+            try {
+                const workflow = await invokeLinkedInUrlEnrichmentWorkflow({
+                    contacts: contactsStillMissing,
+                    externalUserId: orgId || sessionOrgId || "cli_direct_lookup",
+                    timeoutMs: Math.min(timeoutMs, strategy.workflowStageBudgetMs)
+                });
+                if (!workflow.response.ok) {
+                    throw new Error(`LinkedIn enrichment workflow returned ${workflow.response.status}: ${workflow.bodyText.slice(0, 300)}`);
+                }
+                linkedInUrlByContactId = normalizeWorkflowLinkedInUrlResult({
+                    parsedBody: workflow.parsedBody,
+                    contacts: contactsStillMissing
+                });
+                for (const row of enrichedRows) {
+                    if (row.found)
+                        continue;
+                    const profile = linkedInUrlByContactId.get(row.contactId);
+                    if (profile?.linkedinUrl) {
+                        row.linkedinUrl = profile.linkedinUrl;
+                        row.salesNavProfileUrl = profile.salesNavProfileUrl ?? row.salesNavProfileUrl ?? null;
+                        row.linkedinCompanyUrl = profile.linkedinCompanyUrl ?? row.linkedinCompanyUrl ?? null;
+                        row.salesNavCompanyUrl = profile.salesNavCompanyUrl ?? row.salesNavCompanyUrl ?? null;
+                        row.found = true;
+                        row.companyFound = Boolean(row.linkedinCompanyUrl || row.salesNavCompanyUrl);
+                        row.source = "workflow";
+                        row.companySource =
+                            row.linkedinCompanyUrl || row.salesNavCompanyUrl ? "workflow" : row.companySource ?? null;
+                    }
+                }
+            }
+            catch (error) {
+                writeProgress(`Skipping workflow profile enrichment: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const serperContacts = directContacts.filter((contact) => enrichedRows.some((row) => row.contactId === contact.contact_id && !row.found));
+        if (strategy.bulkMode && serperContacts.length > 0) {
+            writeProgress(`Using bulk profile resolution strategy for ${serperContacts.length} remaining contacts.`);
+        }
+        const serperResults = await resolveSerperLinkedInProfilesInParallel({
+            contacts: serperContacts.filter((contact) => !contact.isVariation),
+            timeoutMs,
+            concurrency: Math.min(strategy.serperConcurrency, serperContacts.length || 1),
+            maxQueries: strategy.serperMaxQueries,
+            overallBudgetMs: strategy.serperStageBudgetMs
+        });
+        for (const row of enrichedRows) {
+            if (row.found)
+                continue;
+            const linkedinUrl = serperResults.get(row.contactId);
+            if (!linkedinUrl)
+                continue;
+            row.linkedinUrl = linkedinUrl;
+            row.found = true;
+            row.source = "web-search";
+        }
+        const stillMissingAfterSerper = enrichedRows.filter((row) => !row.found);
+        if (shouldAttemptBulkDirectProfileLookup({
+            strategy,
+            unresolvedRowCount: stillMissingAfterSerper.length
+        })) {
+            const bulkDirectCandidates = rankContactsForBulkDirectProfileLookup({
+                contacts: directContacts.filter((contact) => stillMissingAfterSerper.some((row) => row.contactId === contact.contact_id)),
+                rowsByContactId: rowByContactId,
+                limit: strategy.bulkDirectProfileMaxRows
+            });
+            if (bulkDirectCandidates.length > 0) {
+                writeProgress(`Using bulk direct profile follow-up for ${bulkDirectCandidates.length} high-signal unresolved contacts.`);
+                try {
+                    directAttempted = true;
+                    const result = await invokeLinkedInUrlEnrichmentDirect({
+                        contacts: bulkDirectCandidates,
+                        timeoutMs: strategy.bulkDirectProfileTimeoutMs,
+                        perAttemptTimeoutMs: Math.min(strategy.bulkDirectProfileTimeoutMs, 2_500),
+                        perContactBudgetMs: strategy.bulkDirectProfileTimeoutMs
+                    });
+                    const directCompanyContextByKey = new Map((result.companyContexts ?? []).map((context) => [context.normalizedCompanyKey, context]));
+                    const bulkDirectByContactId = new Map(result.contacts.map((contact) => [
+                        contact.contact_id,
+                        {
+                            linkedinUrl: contact.linkedin_url ?? null,
+                            salesNavProfileUrl: contact.sales_nav_profile_url ?? null
+                        }
+                    ]));
+                    for (const row of enrichedRows) {
+                        if (row.found)
+                            continue;
+                        const profile = bulkDirectByContactId.get(row.contactId);
+                        if (profile?.linkedinUrl) {
+                            row.linkedinUrl = profile.linkedinUrl;
+                            row.salesNavProfileUrl = profile.salesNavProfileUrl ?? row.salesNavProfileUrl ?? null;
+                            row.found = true;
+                            row.source = "linkedin-direct";
+                        }
+                        const directContact = bulkDirectCandidates.find((candidate) => candidate.contact_id === row.contactId && !candidate.isVariation);
+                        const companyContext = directContact
+                            ? directCompanyContextByKey.get(buildDirectCompanyContextKey(directContact))
+                            : null;
+                        if (companyContext && !row.linkedinCompanyUrl) {
+                            row.linkedinCompanyUrl = companyContext.linkedinCompanyUrl ?? row.linkedinCompanyUrl ?? null;
+                            row.salesNavCompanyUrl = companyContext.salesNavCompanyUrl ?? row.salesNavCompanyUrl ?? null;
+                            row.companyFound = Boolean(row.linkedinCompanyUrl || row.salesNavCompanyUrl);
+                            row.companySource =
+                                row.linkedinCompanyUrl || row.salesNavCompanyUrl ? "linkedin-direct" : row.companySource ?? null;
+                            row.matchedCompanyName = companyContext.matchedCompanyName ?? row.matchedCompanyName ?? null;
+                            row.matchedCompanyEmployeeCount =
+                                companyContext.matchedCompanyEmployeeCount ?? row.matchedCompanyEmployeeCount ?? null;
+                        }
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (!/Missing LinkedIn direct lookup session/i.test(message)) {
+                        writeProgress(`Skipping bulk direct profile follow-up: ${message}`);
+                    }
+                }
+            }
+        }
     }
     const payload = {
         status: "ok",
@@ -6404,8 +8430,23 @@ program
         companiesFound: enrichedRows.filter((row) => row.companyFound).length,
         directAttempted,
         workflowAttempted,
+        bulkMode: strategy.bulkMode,
         rows: enrichedRows
     };
+    for (const row of enrichedRows) {
+        const contact = contactById.get(row.contactId);
+        upsertLinkedInProfileHitCacheEntry({
+            fullName: row.fullName,
+            companyName: row.companyName,
+            email: contact?.email,
+            contactId: row.contactId,
+            linkedinUrl: row.linkedinUrl ?? null,
+            salesNavProfileUrl: row.salesNavProfileUrl ?? null,
+            linkedinCompanyUrl: row.linkedinCompanyUrl ?? null,
+            salesNavCompanyUrl: row.salesNavCompanyUrl ?? null
+        });
+    }
+    await persistLinkedInProfileHitCache();
     if (options.out) {
         await writeJsonFile(options.out, payload);
     }
@@ -6743,12 +8784,14 @@ program
 });
 program
     .command("leads:generate")
-    .description("Generate leads for a target account or from fallback seeds.")
+    .description("Generate leads from your Salesprompter workspace when authenticated, or from fallback seeds.")
     .requiredOption("--icp <path>", "Path to ICP JSON")
     .option("--count <number>", "Number of leads to generate", "10")
     .option("--domain <domain>", "Target a specific company domain like company.com")
     .option("--company-domain <domain>", "Deprecated alias for --domain")
     .option("--company-name <name>", "Optional company name override for a targeted domain")
+    .option("--linkedin-company-page <url>", "LinkedIn company page to target when the domain is unknown")
+    .option("--source <source>", "auto|workspace|fallback", "auto")
     .requiredOption("--out <path>", "Output file path")
     .action(async (options) => {
     const icp = await readJsonFile(options.icp, IcpSchema);
@@ -6756,9 +8799,15 @@ program
     const domain = options.domain ?? options.companyDomain;
     const target = {
         companyDomain: domain,
-        companyName: options.companyName
+        companyName: options.companyName,
+        linkedinCompanyPage: options.linkedinCompanyPage
     };
-    const result = await leadProvider.generateLeads(icp, count, target);
+    const result = await generateLeadsForCommand({
+        icp,
+        count,
+        target,
+        source: options.source
+    });
     await writeJsonFile(options.out, result.leads);
     printOutput({
         status: "ok",
@@ -6803,6 +8852,8 @@ program
     .option("--domain <domain>", "Target a specific company domain like company.com")
     .option("--company-domain <domain>", "Deprecated alias for --domain")
     .option("--company-name <name>", "Optional company name override for a targeted domain")
+    .option("--linkedin-company-page <url>", "LinkedIn company page to target when the domain is unknown")
+    .option("--source <source>", "auto|workspace|fallback", "auto")
     .option("--out-prefix <path>", "Output path prefix (writes <prefix>-leads.json, <prefix>-enriched.json, <prefix>-scored.json)", "./data/leads-pipeline")
     .action(async (options) => {
     const icp = await readJsonFile(options.icp, IcpSchema);
@@ -6810,13 +8861,19 @@ program
     const domain = options.domain ?? options.companyDomain;
     const target = {
         companyDomain: domain,
-        companyName: options.companyName
+        companyName: options.companyName,
+        linkedinCompanyPage: options.linkedinCompanyPage
     };
     const outPrefix = String(options.outPrefix);
     const leadsOut = `${outPrefix}-leads.json`;
     const enrichedOut = `${outPrefix}-enriched.json`;
     const scoredOut = `${outPrefix}-scored.json`;
-    const generated = await leadProvider.generateLeads(icp, count, target);
+    const generated = await generateLeadsForCommand({
+        icp,
+        count,
+        target,
+        source: options.source
+    });
     await writeJsonFile(leadsOut, generated.leads);
     const enriched = await enrichmentProvider.enrichLeads(generated.leads);
     await writeJsonFile(enrichedOut, enriched);
@@ -7554,6 +9611,7 @@ program
     .option("--max-results-per-search <number>", "Maximum results allowed for a sliced search", "2500")
     .option("--number-of-profiles <number>", "Profiles to export per sliced query", "2500")
     .option("--slice-preset <name>", "Slice preset label stored with the export runs", "human-resources-crawl")
+    .option("--client-id <number>", "Client id used to generate and store the legacy Neon lead list projection")
     .option("--max-split-depth <number>", "Maximum number of adaptive split dimensions to use", "6")
     .option("--max-slices <number>", "Safety cap for total claimed slices in this invocation", "1000")
     .option("--max-retries <number>", "Retries for non-splitting export failures", "3")
@@ -7572,6 +9630,7 @@ program
     const jobId = z.string().uuid().optional().parse(options.jobId);
     const maxResultsPerSearch = z.coerce.number().int().min(1).max(2500).parse(options.maxResultsPerSearch);
     const numberOfProfiles = z.coerce.number().int().min(1).max(2500).parse(options.numberOfProfiles);
+    const clientId = parseOptionalSalesNavigatorClientId(options.clientId);
     const maxSplitDepth = z.coerce.number().int().min(1).max(6).parse(options.maxSplitDepth);
     const maxSlices = z.coerce.number().int().min(1).max(10000).parse(options.maxSlices);
     const maxRetries = z.coerce.number().int().min(0).max(5).parse(options.maxRetries);
@@ -7591,6 +9650,7 @@ program
         jobId: jobId ?? null,
         maxResultsPerSearch,
         numberOfProfiles,
+        clientId,
         slicePreset: options.slicePreset,
         maxSplitDepth,
         maxSlices,
@@ -7691,6 +9751,7 @@ program
                 traceId: logger.traceId,
                 command: {
                     sourceQueryUrl: queryUrl,
+                    clientId,
                     slicePreset: options.slicePreset,
                     maxResultsPerSearch,
                     numberOfProfiles,
@@ -7712,6 +9773,7 @@ program
                 splitTrail: seed.splitTrail,
                 rawPayload: {
                     workflow: "salesnav:crawl",
+                    clientId,
                     traceId: logger.traceId
                 }
             }
@@ -7751,6 +9813,7 @@ program
         idlePollSeconds,
         idleMaxPolls,
         parallelExports,
+        clientId,
         traceId: logger.traceId,
         logger
     });
@@ -7831,6 +9894,45 @@ program
         recentEvents
     });
 });
+program
+    .command("phantombuster:containers:sync")
+    .alias("pb:containers:sync")
+    .description("Fetch Phantombuster containers for configured agents and store them in Neon.")
+    .option("--agent-id <id>", "Phantombuster agent id to sync. Repeat to sync multiple agents.", collectStringOptionValue, [])
+    .option("--limit <number>", "Maximum containers to fetch per Phantombuster page", "100")
+    .option("--max-pages <number>", "Maximum Phantombuster pages to fetch per agent", "50")
+    .option("--mode <mode>", "Phantombuster container mode: all or finalized", "all")
+    .option("--before-ended-at <iso>", "Only fetch containers that ended before this ISO timestamp")
+    .option("--metadata-only", "Store container metadata without fetching output and result objects", false)
+    .option("--refresh-lead-pool", "After syncing results, rebuild the Neon lead_pool_new reporting table. This can take several minutes.", false)
+    .option("--out <path>", "Optional local JSON output path")
+    .action(async (options) => {
+    const agentIds = z.array(z.string().min(1)).parse(options.agentId);
+    const limit = z.coerce.number().int().min(1).max(500).parse(options.limit);
+    const maxPages = z.coerce.number().int().min(1).max(500).parse(options.maxPages);
+    const mode = z.enum(["all", "finalized"]).parse(options.mode);
+    const beforeEndedAt = options.beforeEndedAt
+        ? z.string().datetime().parse(options.beforeEndedAt)
+        : undefined;
+    const session = await requireAuthSession();
+    const result = await syncPhantombusterContainersViaApp(session, {
+        agentIds: agentIds.length > 0 ? agentIds : undefined,
+        limit,
+        maxPages,
+        mode,
+        beforeEndedAt,
+        includeResults: !options.metadataOnly,
+        refreshLeadPool: Boolean(options.refreshLeadPool)
+    });
+    const payload = {
+        ...result,
+        dryRun: false
+    };
+    if (options.out) {
+        await writeJsonFile(options.out, payload);
+    }
+    printOutput(payload);
+});
 program
     .command("salesnav:export")
     .alias("search:export")
@@ -7839,12 +9941,18 @@ program
     .option("--max-results-per-search <number>", "Maximum results allowed for a sliced search", "2500")
     .option("--number-of-profiles <number>", "Profiles to export per sliced query", "2500")
     .option("--slice-preset <name>", "Slice preset label stored with the export run", "human-resources-default")
+    .option("--client-id <number>", "Client id used to generate and store the legacy Neon lead list projection")
+    .option("--agent-busy-wait-seconds <number>", "Seconds to wait before retrying when the export agent is already busy", "30")
+    .option("--agent-busy-max-waits <number>", "How many busy-agent waits to tolerate before failing the export", "20")
     .option("--out <path>", "Optional local JSON output path")
     .option("--dry-run", "Only generate sliced query URLs without exporting them", false)
     .action(async (options) => {
     const queryUrls = z.array(z.string().url()).min(1).parse(options.queryUrl);
     const maxResultsPerSearch = z.coerce.number().int().min(1).max(2500).parse(options.maxResultsPerSearch);
     const numberOfProfiles = z.coerce.number().int().min(1).max(2500).parse(options.numberOfProfiles);
+    const agentBusyWaitSeconds = z.coerce.number().int().min(1).max(300).parse(options.agentBusyWaitSeconds);
+    const agentBusyMaxWaits = z.coerce.number().int().min(0).max(100).parse(options.agentBusyMaxWaits);
+    const clientId = parseOptionalSalesNavigatorClientId(options.clientId);
     const prepared = queryUrls.map((queryUrl) => buildSalesNavigatorPeopleSlice(queryUrl));
     const effectiveDryRun = Boolean(options.dryRun || shouldBypassAuth());
     if (effectiveDryRun) {
@@ -7866,10 +9974,10 @@ program
         printOutput(payload);
         return;
     }
-    const session = await requireAuthSession();
+    let session = await requireAuthSession();
     const exported = [];
     for (const item of prepared) {
-        const result = await runSalesNavigatorExport(session, {
+        const result = await runSalesNavigatorExportWithAgentWait(session, {
             sourceQueryUrl: item.sourceQueryUrl,
             slicedQueryUrl: item.slicedQueryUrl,
             appliedFilters: item.appliedFilters,
@@ -7878,12 +9986,17 @@ program
             slicePreset: options.slicePreset,
             rawPayload: {
                 workflow: "salesnav:export",
+                clientId,
                 sourceQueryUrl: item.sourceQueryUrl,
                 slicedQueryUrl: item.slicedQueryUrl,
                 appliedFilters: item.appliedFilters
             }
+        }, {
+            waitSeconds: agentBusyWaitSeconds,
+            maxWaits: agentBusyMaxWaits
         });
         exported.push(result);
+        session = await requireAuthSession();
     }
     const payload = {
         status: "ok",