salesprompter-cli 0.1.27 → 0.1.29

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, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
@@ -25,7 +25,7 @@ import { InstantlySyncProvider } from "./instantly.js";
 import { backfillLinkedInCompanies } from "./linkedin-companies.js";
 import { parseLinkedInCompanyPage } from "./linkedin-companies.js";
 import { crawlLinkedInProductCategory } from "./linkedin-products.js";
-import { claimValidatedSalesNavigatorSessionCookieForCli, createLinkedInSessionSupabaseClient } from "./linkedin-session.js";
+import { claimValidatedSalesNavigatorSessionCookieForCli, createLinkedInSessionSupabaseClient, resolveConfiguredEnvValue } from "./linkedin-session.js";
 import { buildLeadlistsFunnelQueries } from "./leadlists-funnel.js";
 import { readJsonFile, splitCsv, writeJsonFile, writeTextFile } from "./io.js";
 import { buildSalesNavigatorCrawlPreview, createSalesNavigatorCrawlSeed, DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS, buildSalesNavigatorPeopleSlice, deriveSalesNavigatorTitleQuerySeeds, expandSalesNavigatorCrawlAttempt, SalesNavigatorSliceTooBroadError } from "./sales-navigator.js";
@@ -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());
@@ -42,6 +44,14 @@ const runtimeOutputOptions = {
     quiet: false
 };
 const nullableOptionalString = z.string().min(1).nullish().transform((value) => value ?? undefined);
+const LinkedInCompanyBackfillClientIdStateSchema = z
+    .object({
+    clientId: z.number().int().positive(),
+    userId: z.string().optional(),
+    orgId: z.string().optional(),
+    updatedAt: z.string().datetime()
+})
+    .passthrough();
 const WorkspaceLeadSchema = LeadSchema.extend({
     companySize: nullableOptionalString.optional(),
     country: nullableOptionalString.optional()
@@ -66,6 +76,9 @@ const LinkedInCompanyBackfillLaunchResponseSchema = z.object({
     webhookUrl: z.string().url(),
     inputUrl: z.string().url().nullable(),
     containerId: z.string().min(1).nullable(),
+    selectedSessionCookieSha256: z.string().min(1).nullable().optional(),
+    selectedSessionUserEmail: z.string().min(1).nullable().optional(),
+    selectedSessionUserHandle: z.string().min(1).nullable().optional(),
     candidates: z.array(z.object({
         companyId: z.number().int().positive(),
         companyUrl: z.string().url(),
@@ -78,7 +91,26 @@ const LinkedInCompanyBackfillStatusResponseSchema = z.object({
     containerId: z.string().min(1),
     running: z.boolean(),
     processed: z.boolean(),
-    remaining: z.number().int().nonnegative()
+    remaining: z.number().int().nonnegative(),
+    failed: z.boolean().default(false),
+    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()
 });
 const CliEmailEnrichmentCompaniesResponseSchema = z.object({
     clientId: z.number().int().positive(),
@@ -280,6 +312,7 @@ const cliPacks = [
 ];
 const helpAliasByCommandName = new Map([
     ["contacts:find-linkedin-urls", "contacts:resolve-profiles"],
+    ["companies:find-linkedin-urls", "companies:resolve-linkedin-urls"],
     ["contacts:process-emails", "contacts:resolve-emails"],
     ["linkedin-companies:backfill", "companies:enrich"],
     ["linkedin-products:scrape", "market:scrape"],
@@ -300,6 +333,7 @@ const helpVisibleCommandNames = new Set([
     "auth:whoami",
     "llm:ready",
     "contacts:find-linkedin-urls",
+    "companies:find-linkedin-urls",
     "contacts:process-emails",
     "auth:logout",
     "account:resolve",
@@ -339,6 +373,64 @@ function formatHelpArgumentTerm(argument) {
     }
     return argument.required ? `<${term}>` : `[${term}]`;
 }
+function parsePositiveClientIdValue(rawValue) {
+    if (rawValue == null) {
+        throw new Error("clientId is required and must be a positive integer.");
+    }
+    const asString = String(rawValue).trim();
+    if (!asString) {
+        throw new Error("clientId is required and must be a positive integer.");
+    }
+    return z.coerce.number().int().positive().parse(asString);
+}
+function getLinkedInCompanyBackfillClientStatePath() {
+    return path.join(getSalesprompterConfigDir(), "linkedin-companies-backfill.json");
+}
+async function readLinkedInCompanyBackfillClientIdFromCache(session) {
+    const path = getLinkedInCompanyBackfillClientStatePath();
+    try {
+        const content = await readFile(path, "utf8");
+        const parsed = JSON.parse(content);
+        const state = LinkedInCompanyBackfillClientIdStateSchema.parse(parsed);
+        if (session?.user?.id != null && state.userId != null && state.userId !== session.user.id) {
+            return undefined;
+        }
+        if (session?.user?.orgId != null &&
+            state.orgId != null &&
+            String(state.orgId) !== String(session.user.orgId)) {
+            return undefined;
+        }
+        return state.clientId;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeLinkedInCompanyBackfillClientIdToCache(clientId, session) {
+    const filePath = getLinkedInCompanyBackfillClientStatePath();
+    const state = {
+        clientId,
+        userId: session?.user?.id,
+        orgId: session?.user?.orgId,
+        updatedAt: new Date().toISOString()
+    };
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+async function resolveLinkedInCompanyBackfillClientId(params) {
+    if (params.clientIdOption != null && String(params.clientIdOption).trim().length > 0) {
+        return parsePositiveClientIdValue(params.clientIdOption);
+    }
+    const envClientId = process.env.PIPEDREAM_CLIENT_ID?.trim() || process.env.SALESPROMPTER_CLIENT_ID?.trim();
+    if (envClientId) {
+        return parsePositiveClientIdValue(envClientId);
+    }
+    const cachedClientId = await readLinkedInCompanyBackfillClientIdFromCache(params.session);
+    if (cachedClientId != null) {
+        return cachedClientId;
+    }
+    throw new Error("Missing LinkedIn company backfill clientId. Pass --client-id, set PIPEDREAM_CLIENT_ID or SALESPROMPTER_CLIENT_ID, or run once with --client-id so the CLI can reuse it.");
+}
 function applyGlobalOutputOptions(actionCommand) {
     const globalOptions = actionCommand.optsWithGlobals();
     runtimeOutputOptions.json = Boolean(globalOptions.json);
@@ -847,6 +939,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);
@@ -866,19 +965,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);
     }
@@ -906,23 +1018,90 @@ 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);
 }
+function parseLinkedInCompanyLookupInput(content) {
+    const trimmed = content.trim();
+    if (!trimmed) {
+        return [];
+    }
+    if (trimmed.startsWith("[")) {
+        const parsed = z
+            .array(z.object({
+            clientId: z.union([z.string(), z.number()]).nullish(),
+            companyName: z.string().nullish(),
+            name: z.string().nullish()
+        }))
+            .parse(JSON.parse(trimmed));
+        return parsed
+            .map((row) => ({
+            clientId: row.clientId == null ? null : String(row.clientId).trim() || null,
+            companyName: normalizeLookupWhitespace(row.companyName?.trim() || row.name?.trim() || "")
+        }))
+            .filter((row) => row.companyName.length > 0);
+    }
+    const lines = trimmed
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (lines.length === 0) {
+        return [];
+    }
+    const delimiter = detectLooseDelimiter(lines[0] ?? "");
+    const headerValues = splitLooseDelimitedLine(lines[0] ?? "", delimiter).map((value) => value.trim().toLowerCase());
+    const hasHeader = headerValues.includes("companyname") ||
+        headerValues.includes("company_name") ||
+        headerValues.includes("name");
+    if (hasHeader) {
+        const companyNameIndex = headerValues.findIndex((value) => ["companyname", "company_name", "name"].includes(value));
+        const clientIdIndex = headerValues.findIndex((value) => ["clientid", "client_id"].includes(value));
+        return lines
+            .slice(1)
+            .map((line) => splitLooseDelimitedLine(line, delimiter).map((value) => value.trim()))
+            .map((columns) => ({
+            clientId: clientIdIndex >= 0 ? columns[clientIdIndex] || null : null,
+            companyName: normalizeLookupWhitespace(companyNameIndex >= 0 ? columns[companyNameIndex] || "" : "")
+        }))
+            .filter((row) => row.companyName.length > 0);
+    }
+    return lines.map((line) => ({
+        clientId: null,
+        companyName: normalizeLookupWhitespace(line)
+    }));
+}
 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);
@@ -936,7 +1115,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
                 }
             ];
         }
@@ -951,7 +1133,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 ||
@@ -965,6 +1150,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
             });
         }
@@ -972,25 +1160,147 @@ function toLinkedInUrlLookupContacts(rows, cleanedCompanyMap = new Map()) {
     });
 }
 function readPipedreamLinkedInEnrichmentConfig() {
-    const endpointUrl = process.env.SALESPROMPTER_LINKEDIN_ENRICHMENT_ENDPOINT_URL?.trim() ||
-        (process.env.PIPEDREAM_ENDPOINT_ID?.trim()
-            ? `https://${process.env.PIPEDREAM_ENDPOINT_ID.trim()}.m.pipedream.net`
+    const endpointUrl = resolveConfiguredEnvValue(process.env, "SALESPROMPTER_LINKEDIN_ENRICHMENT_ENDPOINT_URL") ||
+        (resolveConfiguredEnvValue(process.env, "PIPEDREAM_ENDPOINT_ID")
+            ? `https://${resolveConfiguredEnvValue(process.env, "PIPEDREAM_ENDPOINT_ID")?.trim()}.m.pipedream.net`
             : "");
     if (!endpointUrl) {
         throw new Error("Missing LinkedIn enrichment endpoint. Set SALESPROMPTER_LINKEDIN_ENRICHMENT_ENDPOINT_URL or PIPEDREAM_ENDPOINT_ID.");
     }
     return {
         endpointUrl,
-        secret: process.env.PIPEDREAM_SECRET_KEY?.trim() || "",
-        clientId: process.env.PIPEDREAM_CLIENT_ID?.trim() || "",
-        projectId: process.env.PIPEDREAM_PROJECT_ID?.trim() || "",
-        projectEnvironment: process.env.PIPEDREAM_PROJECT_ENVIRONMENT?.trim() || ""
+        secret: resolveConfiguredEnvValue(process.env, "PIPEDREAM_SECRET_KEY") || "",
+        clientId: resolveConfiguredEnvValue(process.env, "PIPEDREAM_CLIENT_ID") || "",
+        projectId: resolveConfiguredEnvValue(process.env, "PIPEDREAM_PROJECT_ID") || "",
+        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() ||
@@ -1007,7 +1317,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"
     };
@@ -1057,7 +1367,7 @@ async function readStoredLinkedInDirectLookupConfig() {
     return {
         csrfToken,
         identity,
-        cookie: claimed.sessionCookie,
+        cookie: normalizeLinkedInDirectLookupCookieHeader(claimed.sessionCookie),
         userAgent
     };
 }
@@ -1071,6 +1381,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;
@@ -1087,51 +1402,310 @@ 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();
+    if (!trimmed) {
+        return null;
+    }
+    const directMatch = trimmed.match(/https:\/\/www\.linkedin\.com\/sales\/lead\/[^/?#]+/i);
+    if (directMatch) {
+        return directMatch[0] ?? null;
+    }
+    const disguisedLeadIdMatch = trimmed.match(/https:\/\/www\.linkedin\.com\/in\/(ACw[A-Za-z0-9_-]+)/i);
+    if (disguisedLeadIdMatch?.[1]) {
+        return `https://www.linkedin.com/sales/lead/${disguisedLeadIdMatch[1]}`;
+    }
+    return null;
+}
+function normalizePublicLinkedInProfileUrl(value) {
+    const trimmed = String(value ?? "").trim();
+    if (!trimmed) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (!/(^|\.)linkedin\.com$/i.test(parsed.hostname)) {
+        return null;
+    }
+    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) {
-    const entityUrn = typeof element?.entityUrn === "string" ? element.entityUrn : "";
+    if (!element) {
+        return null;
+    }
+    const explicitCandidates = [
+        typeof element.linkedinProfileUrl === "string" ? element.linkedinProfileUrl : null,
+        typeof element.profileUrl === "string" ? element.profileUrl : null,
+        typeof element.url === "string" ? element.url : null
+    ].filter(Boolean);
+    for (const candidate of explicitCandidates) {
+        const normalized = normalizePublicLinkedInProfileUrl(candidate);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    for (const value of collectNestedStrings(element)) {
+        const normalized = normalizePublicLinkedInProfileUrl(value);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return null;
+}
+function extractLinkedInSalesNavLeadUrlFromSalesApiElement(element) {
+    if (!element) {
+        return null;
+    }
+    const explicitCandidates = [
+        typeof element.salesNavProfileUrl === "string" ? element.salesNavProfileUrl : null,
+        typeof element.sales_nav_profile_url === "string" ? element.sales_nav_profile_url : null,
+        typeof element.url === "string" ? element.url : null
+    ].filter(Boolean);
+    for (const candidate of explicitCandidates) {
+        const normalized = normalizeSalesNavLeadUrl(candidate);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    for (const value of collectNestedStrings(element)) {
+        const normalized = normalizeSalesNavLeadUrl(value);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    const entityUrn = typeof element.entityUrn === "string" ? element.entityUrn : "";
     const salesIdMatch = entityUrn.match(/\(([^,]+),/);
-    return salesIdMatch ? `https://www.linkedin.com/in/${salesIdMatch[1]}` : null;
+    return salesIdMatch?.[1] ? `https://www.linkedin.com/sales/lead/${salesIdMatch[1]}` : null;
+}
+function extractLinkedInSalesNavCompanyUrlFromSalesApiElement(element) {
+    if (!element) {
+        return null;
+    }
+    const explicitCandidates = [
+        typeof element.salesNavCompanyUrl === "string" ? element.salesNavCompanyUrl : null,
+        typeof element.sales_nav_company_url === "string" ? element.sales_nav_company_url : null,
+        typeof element.url === "string" ? element.url : null
+    ].filter(Boolean);
+    for (const candidate of explicitCandidates) {
+        const directMatch = candidate.match(/https:\/\/www\.linkedin\.com\/sales\/company\/[^/?#]+/i);
+        if (directMatch) {
+            return directMatch[0] ?? null;
+        }
+    }
+    for (const value of collectNestedStrings(element)) {
+        const directMatch = value.match(/https:\/\/www\.linkedin\.com\/sales\/company\/[^/?#]+/i);
+        if (directMatch) {
+            return directMatch[0] ?? null;
+        }
+    }
+    const entityUrn = typeof element.entityUrn === "string" ? element.entityUrn : "";
+    const idMatch = entityUrn.match(/\(([^,]+),/);
+    return idMatch?.[1] ? `https://www.linkedin.com/sales/company/${idMatch[1]}` : null;
 }
 function collectNestedStrings(value, seen = new Set()) {
     if (value == null || seen.has(value)) {
@@ -1200,34 +1774,140 @@ function extractLinkedInCompanyNameFromSalesApiElement(element) {
     }
     return null;
 }
-function extractLinkedInCompanyEmployeeCountFromSalesApiElement(element) {
+function extractLinkedInFullNameFromSalesApiElement(element) {
     if (!element) {
         return null;
     }
-    const numericCandidates = [
-        typeof element.employeeCount === "number" ? element.employeeCount : null,
-        typeof element.employeesOnLinkedInCount === "number" ? element.employeesOnLinkedInCount : null
-    ].filter((value) => Number.isFinite(value));
-    if (numericCandidates.length > 0) {
-        return Math.max(0, Math.trunc(numericCandidates[0] ?? 0));
-    }
-    for (const value of collectNestedStrings(element)) {
-        const match = value.match(/(\d[\d.,]*)\s+employees\b/i);
-        if (match) {
-            return Number(match[1].replace(/[.,]/g, ""));
+    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;
         }
     }
-    return null;
+    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 buildLinkedInCompanyLookupVariants(params) {
-    const variants = [];
-    const seen = new Set();
-    const rawCandidates = [
-        normalizeLookupWhitespace(params.companyName),
-        normalizeLookupWhitespace(params.companyNameOriginal)
+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);
-    const normalizedCandidates = rawCandidates.flatMap((candidate) => {
-        const aggressive = aggressivelyCleanLookupCompanyName(candidate);
+    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;
+    }
+    const numericCandidates = [
+        typeof element.employeeCount === "number" ? element.employeeCount : null,
+        typeof element.employeesOnLinkedInCount === "number" ? element.employeesOnLinkedInCount : null
+    ].filter((value) => Number.isFinite(value));
+    if (numericCandidates.length > 0) {
+        return Math.max(0, Math.trunc(numericCandidates[0] ?? 0));
+    }
+    for (const value of collectNestedStrings(element)) {
+        const match = value.match(/(\d[\d.,]*)\s+employees\b/i);
+        if (match) {
+            return Number(match[1].replace(/[.,]/g, ""));
+        }
+    }
+    return null;
+}
+function buildLinkedInCompanyLookupVariants(params) {
+    const variants = [];
+    const seen = new Set();
+    const rawCandidates = [
+        normalizeLookupWhitespace(params.companyName),
+        normalizeLookupWhitespace(params.companyNameOriginal)
+    ].filter(Boolean);
+    const normalizedCandidates = rawCandidates.flatMap((candidate) => {
+        const aggressive = aggressivelyCleanLookupCompanyName(candidate);
         const searchable = normalizeLookupCompanyForSearch(candidate);
         const dePunctuated = normalizeLookupWhitespace(candidate.replace(/[^\p{L}\p{N}]+/gu, " "));
         return [candidate, aggressive, searchable, dePunctuated];
@@ -1236,20 +1916,1050 @@ function buildLinkedInCompanyLookupVariants(params) {
         if (!companyName) {
             continue;
         }
-        const key = companyName.toLowerCase();
-        if (seen.has(key)) {
-            continue;
+        const key = companyName.toLowerCase();
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        variants.push({
+            contact_id: params.contactId,
+            companyName
+        });
+    }
+    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/";
+    const url = new URL(baseUrl);
+    url.searchParams.set("q", `site:linkedin.com/company "${companyName}"`);
+    return url.toString();
+}
+function getSerperApiKey(env = process.env) {
+    return env.SALESPROMPTER_SERPER_API_KEY?.trim() || env.SERPER_API_KEY?.trim() || "";
+}
+function getSerperSearchEndpoint(env = process.env) {
+    return env.SALESPROMPTER_SERPER_SEARCH_URL?.trim() || "https://google.serper.dev/search";
+}
+function buildSerperLinkedInCompanyQueries(companyName) {
+    const normalized = normalizeLookupWhitespace(companyName);
+    const coreName = normalized.split(/\s*[-,|]\s*/)[0]?.trim() || normalized.trim();
+    const searchable = normalizeLookupCompanyForSearch(normalized);
+    const loose = normalizeLooseMatchText(normalized).replace(/\s+/g, " ").trim();
+    const keywordTokens = loose
+        .split(/\s+/)
+        .filter((token) => token.length >= 4)
+        .filter((token) => !["oder", "with", "from", "handel", "beratung"].includes(token))
+        .slice(0, 4);
+    const keywordQuery = keywordTokens.join(" ");
+    return Array.from(new Set([
+        `site:linkedin.com/company "${companyName}"`,
+        `site:linkedin.com/company "${coreName}"`,
+        `site:linkedin.com/company ${searchable} linkedin`,
+        `site:linkedin.com/company ${loose} linkedin`,
+        keywordQuery ? `site:linkedin.com/company ${keywordQuery} linkedin` : ""
+    ])).filter((query) => query.length > 0);
+}
+function extractLinkedInCompanySearchCandidates(bodyText) {
+    const candidates = new Set();
+    const directMatches = bodyText.match(/https:\/\/www\.linkedin\.com\/company\/[^"'&<>\s)]+/gi) ?? [];
+    for (const match of directMatches) {
+        const handle = normalizeLinkedInCompanyHandle(match);
+        if (handle) {
+            candidates.add(normalizeLinkedInCompanyPage(handle));
+        }
+    }
+    const encodedMatches = bodyText.match(/https?%3A%2F%2Fwww\.linkedin\.com%2Fcompany%2F[^"'&<>\s)]+/gi) ?? [];
+    for (const match of encodedMatches) {
+        try {
+            const decoded = decodeURIComponent(match);
+            const handle = normalizeLinkedInCompanyHandle(decoded);
+            if (handle) {
+                candidates.add(normalizeLinkedInCompanyPage(handle));
+            }
+        }
+        catch {
+            // Ignore malformed encoded fragments from search result pages.
+        }
+    }
+    return Array.from(candidates);
+}
+function extractSerperLinkedInCompanyCandidates(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 handle = normalizeLinkedInCompanyHandle(link);
+        if (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 candidates;
+}
+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;
+        }
+        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}`);
+    let score = 0;
+    for (const token of inputTokens) {
+        if (haystack.includes(token)) {
+            score += 12;
+        }
+    }
+    if (signals.description && normalizeLooseMatchText(signals.description).includes(normalizeLooseMatchText(companyName))) {
+        score += 50;
+    }
+    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)) {
+        return 0;
+    }
+    const normalizedCompanyWords = normalizeLookupCompanyForSearch(companyName)
+        .split(/\s+/)
+        .filter((part) => part.length >= 3);
+    const normalizedCompany = normalizedCompanyWords.join("");
+    const aggressiveCompany = aggressivelyCleanLookupCompanyName(companyName).replace(/\s+/g, "");
+    const normalizedHandle = handle.toLowerCase().replace(/[-_]/g, "");
+    const slugCompany = (slugify(companyName) || "").replace(/-/g, "");
+    let score = 0;
+    if (normalizedHandle === normalizedCompany || normalizedHandle === aggressiveCompany || normalizedHandle === slugCompany) {
+        score += 100;
+    }
+    if (normalizedCompany &&
+        (normalizedHandle.includes(normalizedCompany) || normalizedCompany.includes(normalizedHandle))) {
+        score += 60;
+    }
+    if (aggressiveCompany &&
+        (normalizedHandle.includes(aggressiveCompany) || aggressiveCompany.includes(normalizedHandle))) {
+        score += 40;
+    }
+    if (normalizedCompanyWords.length > 0) {
+        const primaryWord = normalizedCompanyWords[0] ?? "";
+        if (primaryWord && normalizedHandle.includes(primaryWord)) {
+            score += 35;
+        }
+        const overlap = normalizedCompanyWords.filter((word) => normalizedHandle.includes(word)).length;
+        score += Math.min(30, overlap * 10);
+    }
+    return score;
+}
+async function searchPublicLinkedInCompanyUrl(companyName, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.min(timeoutMs, 15_000));
+    try {
+        const response = await fetch(buildPublicLinkedInCompanySearchUrl(companyName), {
+            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) {
+            return null;
+        }
+        const bodyText = await response.text();
+        const candidates = extractLinkedInCompanySearchCandidates(bodyText);
+        const ranked = candidates
+            .map((url) => ({ url, score: scoreLinkedInCompanyUrlCandidate(companyName, url) }))
+            .filter((candidate) => candidate.score > 0)
+            .sort((left, right) => right.score - left.score);
+        return ranked[0]?.url ?? candidates[0] ?? null;
+    }
+    catch (error) {
+        if (error.name === "AbortError") {
+            return null;
+        }
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function searchSerperLinkedInCompanyUrl(companyName, timeoutMs) {
+    const apiKey = getSerperApiKey();
+    if (!apiKey) {
+        return null;
+    }
+    for (const query of buildSerperLinkedInCompanyQueries(companyName)) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), Math.min(timeoutMs, 15_000));
+        try {
+            const response = await fetch(getSerperSearchEndpoint(), {
+                method: "POST",
+                signal: controller.signal,
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-API-KEY": apiKey
+                },
+                body: JSON.stringify({
+                    q: query,
+                    num: 5
+                })
+            });
+            if (!response.ok) {
+                continue;
+            }
+            const parsed = (await response.json());
+            const candidates = extractSerperLinkedInCompanyCandidates(parsed);
+            const ranked = candidates
+                .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)) {
+                const signals = await fetchLinkedInCompanyPageSignals(candidate.url, timeoutMs);
+                if (!signals || signals.unavailable) {
+                    continue;
+                }
+                anySignalsFetched = true;
+                const validationScore = scoreLinkedInCompanyPageSignals(companyName, signals);
+                if (validationScore >= 24) {
+                    const combinedScore = candidate.score + validationScore;
+                    if (!bestValidated || combinedScore > bestValidated.score) {
+                        bestValidated = {
+                            url: signals.normalizedUrl,
+                            score: combinedScore
+                        };
+                    }
+                }
+            }
+            if (bestValidated) {
+                return bestValidated.url;
+            }
+            if (!anySignalsFetched && ranked[0]?.url) {
+                return ranked[0].url;
+            }
+        }
+        catch (error) {
+            if (error.name === "AbortError") {
+                continue;
+            }
+        }
+        finally {
+            clearTimeout(timeout);
         }
-        seen.add(key);
-        variants.push({
-            contact_id: params.contactId,
-            companyName
-        });
     }
-    return variants;
+    return null;
 }
 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}`;
@@ -1258,15 +2968,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;
         }
@@ -1279,11 +2999,24 @@ async function invokeLinkedInUrlEnrichmentDirect(params) {
             continue;
         }
         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",
@@ -1304,19 +3037,52 @@ 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) {
-                        matchedUrl = extractLinkedInProfileUrlFromSalesApiElement(data.elements?.[0]) ?? null;
-                        if (matchedUrl) {
+                        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;
                         }
                     }
@@ -1327,27 +3093,36 @@ async function invokeLinkedInUrlEnrichmentDirect(params) {
                 finally {
                     clearTimeout(timeout);
                 }
-                if (matchedUrl || rateLimited) {
+                if (matchedUrl || matchedSalesNavUrl || totalRateLimitCooldowns >= maxRateLimitCooldowns) {
                     break;
                 }
             }
-            if (matchedUrl || rateLimited) {
+            if (matchedUrl || matchedSalesNavUrl || totalRateLimitCooldowns >= maxRateLimitCooldowns) {
+                break;
+            }
+            if (Date.now() >= contactDeadline) {
                 break;
             }
         }
         results.push({
             contact_id: primary.contact_id,
-            linkedin_url: matchedUrl,
-            error: matchedUrl ? null : lastError
+            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);
@@ -1371,10 +3146,23 @@ async function invokeLinkedInCompanyEnrichmentDirect(params) {
             companyName: contact.companyName,
             companyNameOriginal: contact.companyNameOriginal
         });
-        let matchedCompanyUrl = 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));
@@ -1410,8 +3198,10 @@ async function invokeLinkedInCompanyEnrichmentDirect(params) {
                 const data = (await response.json());
                 const first = data.elements?.[0];
                 const companyUrl = extractLinkedInCompanyUrlFromSalesApiElement(first);
-                if (companyUrl) {
+                const salesNavCompanyUrl = extractLinkedInSalesNavCompanyUrlFromSalesApiElement(first);
+                if (companyUrl || salesNavCompanyUrl) {
                     matchedCompanyUrl = companyUrl;
+                    matchedSalesNavCompanyUrl = salesNavCompanyUrl;
                     matchedCompanyName = extractLinkedInCompanyNameFromSalesApiElement(first);
                     matchedCompanyEmployeeCount = extractLinkedInCompanyEmployeeCountFromSalesApiElement(first);
                     break;
@@ -1430,9 +3220,10 @@ async function invokeLinkedInCompanyEnrichmentDirect(params) {
         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: matchedCompanyUrl ? null : lastError
+            error: matchedCompanyUrl || matchedSalesNavCompanyUrl ? null : lastError
         });
     }
     return {
@@ -1513,6 +3304,113 @@ async function invokeLinkedInUrlEnrichmentWorkflow(params) {
         clearTimeout(timeout);
     }
 }
+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
+        : null;
+    const workflowRows = [
+        ...(Array.isArray(body?.contacts) ? body?.contacts : []),
+        ...(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 = (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"
+                ? contact.linkedinProfileUrl
+                : typeof contact.default_profile_url === "string"
+                    ? contact.default_profile_url
+                    : typeof contact.defaultProfileUrl === "string"
+                        ? contact.defaultProfileUrl
+                        : typeof contact.linkedin_url === "string"
+                            ? contact.linkedin_url
+                            : typeof contact.linkedinUrl === "string"
+                                ? contact.linkedinUrl
+                                : null);
+        const salesNavProfileUrl = normalizeSalesNavLeadUrl(typeof contact.sales_nav_profile_url === "string"
+            ? contact.sales_nav_profile_url
+            : typeof contact.salesNavProfileUrl === "string"
+                ? contact.salesNavProfileUrl
+                : typeof contact.linkedin_url === "string"
+                    ? contact.linkedin_url
+                    : typeof contact.linkedinUrl === "string"
+                        ? contact.linkedinUrl
+                        : null) ?? null;
+        const regularCompanyHandle = normalizeLinkedInCompanyHandle(typeof contact.regular_company_url === "string"
+            ? contact.regular_company_url
+            : typeof contact.regularCompanyUrl === "string"
+                ? contact.regularCompanyUrl
+                : "");
+        const linkedinCompanyUrl = extractLinkedInCompanyUrlFromSalesApiElement(contact) ??
+            (regularCompanyHandle ? normalizeLinkedInCompanyPage(regularCompanyHandle) : null);
+        const salesNavCompanyUrl = extractLinkedInSalesNavCompanyUrlFromSalesApiElement(contact);
+        if (contactId) {
+            rowsByContactId.set(contactId, {
+                linkedinUrl: linkedinUrl ?? salesNavProfileUrl,
+                salesNavProfileUrl,
+                linkedinCompanyUrl,
+                salesNavCompanyUrl
+            });
+        }
+    }
+    return rowsByContactId;
+}
 async function fetchSalesNavLookupCandidates(params) {
     const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL?.trim();
     const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY?.trim();
@@ -1558,7 +3456,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
@@ -1594,6 +3493,7 @@ async function resolveLinkedInUrlsFromSalesNavRows(params) {
             return right.score - left.score || Number(Boolean(rightUrl)) - Number(Boolean(leftUrl));
         });
         const best = ranked[0]?.candidate;
+        const salesNavProfileUrl = best?.salesNavProfileUrl ?? null;
         const linkedinUrl = best?.linkedInProfileUrl ?? best?.salesNavProfileUrl ?? null;
         const linkedinCompanyUrl = (() => {
             const handle = normalizeLinkedInCompanyHandle(best?.regularCompanyUrl ?? "") ??
@@ -1604,17 +3504,23 @@ async function resolveLinkedInUrlsFromSalesNavRows(params) {
             const numericCompanyUrl = typeof best?.companyUrl === "string" ? best.companyUrl.trim() : "";
             return numericCompanyUrl.length > 0 ? numericCompanyUrl : null;
         })();
+        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,
-            linkedinCompanyUrl,
+            salesNavProfileUrl,
+            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,
@@ -1624,6 +3530,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(" ");
 }
@@ -1679,7 +3802,16 @@ function normalizeLinkedInCompanyHandle(value) {
     }
     try {
         const url = new URL(trimmed);
-        if (!/(^|\.)linkedin\.com$/i.test(url.hostname)) {
+        const overrideHostname = (() => {
+            try {
+                const overrideBase = process.env.SALESPROMPTER_LINKEDIN_BASE_URL?.trim();
+                return overrideBase ? new URL(overrideBase).hostname : "";
+            }
+            catch {
+                return "";
+            }
+        })();
+        if (!/(^|\.)linkedin\.com$/i.test(url.hostname) && (!overrideHostname || url.hostname !== overrideHostname)) {
             return null;
         }
         const segments = url.pathname.split("/").filter((segment) => segment.length > 0);
@@ -2279,6 +4411,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`;
 }
@@ -2891,6 +5089,49 @@ class SalesNavigatorExportRequestError extends Error {
         this.launchDiagnostics = options.launchDiagnostics ?? null;
     }
 }
+class CliApiRequestError extends Error {
+    statusCode;
+    errorCode;
+    constructor(message, options) {
+        super(message);
+        this.name = "CliApiRequestError";
+        this.statusCode = options.statusCode;
+        this.errorCode = options.errorCode;
+    }
+}
+class LinkedInCompanyBackfillBatchError extends Error {
+    failureCode;
+    constructor(message, options) {
+        super(message);
+        this.name = "LinkedInCompanyBackfillBatchError";
+        this.failureCode = options.failureCode;
+    }
+}
+function formatLinkedInCompanyBackfillSessionLabel(launch) {
+    const identity = launch.selectedSessionUserEmail?.trim() ||
+        launch.selectedSessionUserHandle?.trim() ||
+        null;
+    const shortHash = launch.selectedSessionCookieSha256?.trim()
+        ? launch.selectedSessionCookieSha256.trim().slice(0, 12)
+        : null;
+    if (identity && shortHash) {
+        return `${identity} (${shortHash})`;
+    }
+    return identity || shortHash || 'the selected LinkedIn session';
+}
+function isLinkedInCompanyBackfillInvalidSessionMessage(message) {
+    return /session cookie not valid anymore|expired session cookie|invalid session cookie|can't connect to linkedin with this session cookie|no valid credentials found|please log in to linkedin to get a new one/i.test(message);
+}
+function buildLinkedInCompanyBackfillSessionRecoveryMessage(labels) {
+    const uniqueLabels = Array.from(new Set(labels
+        .map((label) => label.trim())
+        .filter((label) => label.length > 0)));
+    if (uniqueLabels.length === 0) {
+        return "Company enrichment exhausted the LinkedIn session pool. Open LinkedIn Sales Navigator in Chrome, reconnect the Salesprompter extension, and retry companies:enrich.";
+    }
+    const attemptedSessions = uniqueLabels.join(", ");
+    return `Company enrichment exhausted the LinkedIn session pool. Phantombuster rejected ${uniqueLabels.length} synced LinkedIn session${uniqueLabels.length === 1 ? "" : "s"} as expired: ${attemptedSessions}. Open LinkedIn Sales Navigator in Chrome, reconnect the Salesprompter extension, and retry companies:enrich.`;
+}
 const SALES_NAVIGATOR_EXPORT_START_TIMEOUT_MS = 90_000;
 async function withRefreshableAuthSession(session, run, contextLabel = "Salesprompter session expired during crawl. Refreshing login...") {
     let currentSession = session;
@@ -2921,13 +5162,22 @@ async function fetchCliJson(session, request, schema) {
         const text = await response.text();
         const parsed = text.length > 0 ? JSON.parse(text) : {};
         if (!response.ok) {
+            const errorCode = typeof parsed === "object" &&
+                parsed !== null &&
+                "code" in parsed &&
+                typeof parsed.code === "string"
+                ? parsed.code
+                : undefined;
             const errorMessage = typeof parsed === "object" &&
                 parsed !== null &&
                 "error" in parsed &&
                 typeof parsed.error === "string"
                 ? parsed.error
                 : `request failed (${response.status})`;
-            throw new Error(errorMessage);
+            throw new CliApiRequestError(errorMessage, {
+                statusCode: response.status,
+                errorCode
+            });
         }
         return schema.parse(parsed);
     });
@@ -2986,7 +5236,13 @@ async function enrichDirectEmailCompaniesViaApp(session, payload) {
     return value;
 }
 async function fetchLinkedInCompaniesBackfillStatus(session, payload) {
-    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/linkedin-companies/status?clientId=${encodeURIComponent(String(payload.clientId))}&containerId=${encodeURIComponent(payload.containerId)}`, {
+    const url = new URL('/api/cli/linkedin-companies/status', session.apiBaseUrl);
+    url.searchParams.set('clientId', String(payload.clientId));
+    url.searchParams.set('containerId', payload.containerId);
+    if (payload.selectedSessionCookieSha256?.trim()) {
+        url.searchParams.set('selectedSessionCookieSha256', payload.selectedSessionCookieSha256.trim());
+    }
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(url.toString(), {
         method: "GET",
         headers: {
             Authorization: `Bearer ${currentSession.accessToken}`
@@ -2994,6 +5250,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,
@@ -3020,6 +5287,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,
@@ -3242,10 +5515,24 @@ async function drainLinkedInCompanyBackfill(session, payload) {
     let startedCompanies = 0;
     let remaining = 0;
     let consecutiveBusyPolls = 0;
+    let consecutiveRetryableFailures = 0;
+    const maxRetryableFailures = 3;
+    let consecutiveInvalidSessionFailures = 0;
+    const maxInvalidSessionFailures = 2;
+    const invalidSessionLabels = [];
+    const excludedSessionCookieSha256 = new Set();
+    const excludedUserEmails = new Set();
+    const excludedUserHandles = new Set();
+    let lastProcessedRemaining = null;
     for (;;) {
         let launched;
         try {
-            launched = await launchLinkedInCompaniesBackfill(session, payload);
+            launched = await launchLinkedInCompaniesBackfill(session, {
+                ...payload,
+                excludedSessionCookieSha256: Array.from(excludedSessionCookieSha256),
+                excludedUserEmails: Array.from(excludedUserEmails),
+                excludedUserHandles: Array.from(excludedUserHandles),
+            });
         }
         catch (error) {
             if (isSalesNavigatorAgentBusyError(error)) {
@@ -3256,6 +5543,19 @@ async function drainLinkedInCompanyBackfill(session, payload) {
                 await delay(30_000);
                 continue;
             }
+            if (isRecoverableLinkedInCompanyBackfillSessionFailure(error) &&
+                consecutiveInvalidSessionFailures < maxInvalidSessionFailures) {
+                consecutiveInvalidSessionFailures += 1;
+                writeProgress(`Company enrichment session expired. Trying another synced LinkedIn session (${consecutiveInvalidSessionFailures}/${maxInvalidSessionFailures})...`);
+                await delay(5_000);
+                continue;
+            }
+            if (isRecoverableLinkedInCompanyBackfillSessionFailure(error)) {
+                throw new Error(buildLinkedInCompanyBackfillSessionRecoveryMessage(invalidSessionLabels));
+            }
+            if (isCompanyBackfillSourceInvalidError(error)) {
+                throw new Error("Company enrichment source is broken. Refresh leadPool_inner_merged and recreate leadPool_new, then retry.");
+            }
             throw error;
         }
         consecutiveBusyPolls = 0;
@@ -3268,24 +5568,178 @@ async function drainLinkedInCompanyBackfill(session, payload) {
             };
         }
         batches += 1;
-        startedCompanies += launched.candidates.length;
-        writeProgress(`Started company enrichment batch ${batches} for ${launched.candidates.length} companies.`);
+        const launchedCompanies = launched.candidates.length;
+        startedCompanies += launchedCompanies;
+        let initialStatus;
+        try {
+            initialStatus = await waitForLinkedInCompanyBackfillStart(session, {
+                clientId: payload.clientId,
+                containerId: launched.containerId,
+                selectedSessionCookieSha256: launched.selectedSessionCookieSha256 ?? null,
+            });
+        }
+        catch (error) {
+            if (isRetryableLinkedInCompanyBackfillFailure(error) && consecutiveRetryableFailures < maxRetryableFailures) {
+                consecutiveRetryableFailures += 1;
+                batches -= 1;
+                startedCompanies -= launchedCompanies;
+                writeProgress(`Company enrichment batch failed before start (${error.message}). Retrying automatically (${consecutiveRetryableFailures}/${maxRetryableFailures})...`);
+                await delay(5_000);
+                continue;
+            }
+            throw error;
+        }
+        writeProgress(initialStatus.processed
+            ? `Finished company enrichment batch ${batches} for ${launchedCompanies} companies.`
+            : `Started company enrichment batch ${batches} for ${launchedCompanies} companies.`);
+        const batchStartedAt = Date.now();
+        let lastRunningHeartbeatAt = batchStartedAt;
+        let lastPendingPersistenceHeartbeatAt = batchStartedAt;
         for (;;) {
             const status = await fetchLinkedInCompaniesBackfillStatus(session, {
                 clientId: payload.clientId,
-                containerId: launched.containerId
+                containerId: launched.containerId,
+                selectedSessionCookieSha256: launched.selectedSessionCookieSha256 ?? null,
             });
             remaining = status.remaining;
+            if (!status.running && status.failed) {
+                const batchError = new LinkedInCompanyBackfillBatchError(status.failureMessage ?? "Company enrichment batch failed.", { failureCode: status.failureCode ?? undefined });
+                if (isRetryableLinkedInCompanyBackfillFailure(batchError) &&
+                    consecutiveRetryableFailures < maxRetryableFailures) {
+                    consecutiveRetryableFailures += 1;
+                    batches -= 1;
+                    startedCompanies -= launchedCompanies;
+                    writeProgress(`Company enrichment batch failed (${batchError.message}). Retrying automatically (${consecutiveRetryableFailures}/${maxRetryableFailures})...`);
+                    await delay(5_000);
+                    break;
+                }
+                if (isRecoverableLinkedInCompanyBackfillSessionFailure(batchError) &&
+                    consecutiveInvalidSessionFailures < maxInvalidSessionFailures) {
+                    consecutiveInvalidSessionFailures += 1;
+                    invalidSessionLabels.push(formatLinkedInCompanyBackfillSessionLabel(launched));
+                    if (launched.selectedSessionCookieSha256?.trim()) {
+                        excludedSessionCookieSha256.add(launched.selectedSessionCookieSha256.trim());
+                    }
+                    if (launched.selectedSessionUserEmail?.trim()) {
+                        excludedUserEmails.add(launched.selectedSessionUserEmail.trim());
+                    }
+                    if (launched.selectedSessionUserHandle?.trim()) {
+                        excludedUserHandles.add(launched.selectedSessionUserHandle.trim());
+                    }
+                    batches -= 1;
+                    startedCompanies -= launchedCompanies;
+                    writeProgress(`Company enrichment rejected ${formatLinkedInCompanyBackfillSessionLabel(launched)} as expired. Trying another synced LinkedIn session (${consecutiveInvalidSessionFailures}/${maxInvalidSessionFailures})...`);
+                    await delay(5_000);
+                    break;
+                }
+                if (isRecoverableLinkedInCompanyBackfillSessionFailure(batchError)) {
+                    invalidSessionLabels.push(formatLinkedInCompanyBackfillSessionLabel(launched));
+                    if (launched.selectedSessionCookieSha256?.trim()) {
+                        excludedSessionCookieSha256.add(launched.selectedSessionCookieSha256.trim());
+                    }
+                    if (launched.selectedSessionUserEmail?.trim()) {
+                        excludedUserEmails.add(launched.selectedSessionUserEmail.trim());
+                    }
+                    if (launched.selectedSessionUserHandle?.trim()) {
+                        excludedUserHandles.add(launched.selectedSessionUserHandle.trim());
+                    }
+                    throw new Error(buildLinkedInCompanyBackfillSessionRecoveryMessage(invalidSessionLabels));
+                }
+                throw batchError;
+            }
             if (!status.running && status.processed) {
+                if (lastProcessedRemaining !== null && status.remaining >= lastProcessedRemaining) {
+                    const settledStatus = await waitForLinkedInCompanyBackfillRemainingDrop(session, {
+                        clientId: payload.clientId,
+                        containerId: launched.containerId,
+                        selectedSessionCookieSha256: launched.selectedSessionCookieSha256 ?? null,
+                        previousRemaining: lastProcessedRemaining
+                    });
+                    remaining = settledStatus.remaining;
+                    if (remaining >= lastProcessedRemaining) {
+                        throw new Error(`Company enrichment batch ${batches} finished but remaining stayed at ${remaining}. Stopping to avoid duplicate launches.`);
+                    }
+                }
+                consecutiveRetryableFailures = 0;
+                consecutiveInvalidSessionFailures = 0;
+                lastProcessedRemaining = remaining;
+                const completionMessage = `Finished company enrichment batch ${batches} for ${launchedCompanies} companies.`;
                 writeProgress(remaining > 0
-                    ? `${remaining} companies still waiting. Starting the next batch...`
-                    : "Company enrichment finished.");
+                    ? `${completionMessage} ${remaining} companies still waiting. Starting the next batch...`
+                    : `${completionMessage} Company enrichment finished.`);
                 break;
             }
+            if (status.running) {
+                const now = Date.now();
+                if (now - lastRunningHeartbeatAt >= 30_000) {
+                    const elapsedSeconds = Math.max(1, Math.round((now - batchStartedAt) / 1000));
+                    writeProgress(`Company enrichment batch ${batches} is still running (${elapsedSeconds}s elapsed)...`);
+                    lastRunningHeartbeatAt = now;
+                }
+            }
+            else if (!status.processed) {
+                const now = Date.now();
+                if (now - lastPendingPersistenceHeartbeatAt >= 30_000) {
+                    writeProgress(`Company enrichment batch ${batches} finished remotely. Waiting for results to sync...`);
+                    lastPendingPersistenceHeartbeatAt = now;
+                }
+            }
             await delay(15_000);
         }
     }
 }
+async function waitForLinkedInCompanyBackfillStart(session, payload) {
+    const deadline = Date.now() + 45_000;
+    for (;;) {
+        const status = await fetchLinkedInCompaniesBackfillStatus(session, payload);
+        if (status.failed) {
+            throw new LinkedInCompanyBackfillBatchError(status.failureMessage ?? "Company enrichment batch failed.", { failureCode: status.failureCode ?? undefined });
+        }
+        if (status.running || status.processed) {
+            return status;
+        }
+        if (Date.now() >= deadline) {
+            return status;
+        }
+        await delay(5_000);
+    }
+}
+async function waitForLinkedInCompanyBackfillRemainingDrop(session, payload) {
+    const deadline = Date.now() + 90_000;
+    let latestStatus = await fetchLinkedInCompaniesBackfillStatus(session, payload);
+    let lastHeartbeatAt = Date.now();
+    while (Date.now() < deadline) {
+        if (latestStatus.failed) {
+            throw new LinkedInCompanyBackfillBatchError(latestStatus.failureMessage ?? "Company enrichment batch failed.", { failureCode: latestStatus.failureCode ?? undefined });
+        }
+        if (latestStatus.remaining < payload.previousRemaining) {
+            return latestStatus;
+        }
+        const now = Date.now();
+        if (now - lastHeartbeatAt >= 30_000) {
+            writeProgress(`Company enrichment batch finished. Waiting for backlog to update below ${payload.previousRemaining}...`);
+            lastHeartbeatAt = now;
+        }
+        await delay(10_000);
+        latestStatus = await fetchLinkedInCompaniesBackfillStatus(session, payload);
+    }
+    return latestStatus;
+}
+function isRetryableLinkedInCompanyBackfillFailure(error) {
+    return error instanceof LinkedInCompanyBackfillBatchError && error.failureCode === "input_empty";
+}
+function isRecoverableLinkedInCompanyBackfillSessionFailure(error) {
+    if (error instanceof LinkedInCompanyBackfillBatchError) {
+        return error.failureCode === "invalid_session" || isLinkedInCompanyBackfillInvalidSessionMessage(error.message);
+    }
+    if (error instanceof CliApiRequestError) {
+        return error.errorCode === "invalid_session" || isLinkedInCompanyBackfillInvalidSessionMessage(error.message);
+    }
+    return false;
+}
+function isCompanyBackfillSourceInvalidError(error) {
+    return error instanceof CliApiRequestError && error.errorCode === "company_backfill_source_invalid";
+}
 function isSalesNavigatorSessionError(error) {
     if (error instanceof SalesNavigatorExportRequestError) {
         if (error.errorCode === "invalid_session") {
@@ -3299,11 +5753,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)) {
@@ -3394,6 +5849,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,
@@ -3430,6 +5886,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,
@@ -3528,15 +5985,87 @@ 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) {
         return override;
     }
-    return path.join(os.homedir(), ".config", "salesprompter");
+    return path.join(os.homedir(), ".config", "salesprompter");
+}
+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;
 }
-function getSalesNavigatorFilterImpactPath() {
-    return path.join(getSalesprompterConfigDir(), "salesnav-filter-impact.json");
+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) {
@@ -3718,7 +6247,8 @@ async function ensureSalesNavigatorSessionPoolReady(queryUrl, options) {
             status: claimed ? "ok" : "skipped",
             selectedSessionUserEmail: claimed?.userEmail ?? null,
             selectedSessionUserHandle: claimed?.userHandle ?? null,
-            selectedSessionCookieSha256: claimed?.sessionCookieSha256 ?? null
+            selectedSessionCookieSha256: claimed?.sessionCookieSha256 ?? null,
+            selectedSessionLastIngestedSource: claimed?.lastIngestedSource ?? null
         });
         return {
             ready: true
@@ -3809,6 +6339,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, {
@@ -3949,9 +6480,11 @@ async function executeSalesNavigatorCrawlJob(session, jobId, options) {
     let nextSessionPoolRetryAt = 0;
     let lastSessionPoolReadyAt = 0;
     const sessionPoolReadinessCooldownMs = 120_000;
+    let allowRetryClaimBeyondMaxSlices = false;
+    let allowedRetrySliceId = null;
     while (true) {
         while (!noMoreClaimableWork && inFlight.size < parallelExports) {
-            if (claimedSlices >= options.maxSlices) {
+            if (claimedSlices >= options.maxSlices && !allowRetryClaimBeyondMaxSlices) {
                 break;
             }
             if (inFlight.size === 0) {
@@ -4058,6 +6591,15 @@ async function executeSalesNavigatorCrawlJob(session, jobId, options) {
                 break;
             }
             const slice = claimed.value.slice;
+            if (claimedSlices >= options.maxSlices &&
+                allowRetryClaimBeyondMaxSlices &&
+                allowedRetrySliceId &&
+                slice.id !== allowedRetrySliceId) {
+                noMoreClaimableWork = true;
+                break;
+            }
+            allowRetryClaimBeyondMaxSlices = false;
+            allowedRetrySliceId = null;
             idlePollCount = 0;
             activeSlice = slice;
             const isNewSlice = !seenSliceIds.has(slice.id);
@@ -4074,6 +6616,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 })));
@@ -4087,6 +6630,8 @@ async function executeSalesNavigatorCrawlJob(session, jobId, options) {
         job = completed.value.job;
         activeSlice = completed.value.activeSlice;
         lastOutcome = completed.value.lastOutcome;
+        allowRetryClaimBeyondMaxSlices = lastOutcome?.outcome === "retryable_failed";
+        allowedRetrySliceId = lastOutcome?.outcome === "retryable_failed" ? completed.value.activeSlice.id : null;
         if (completed.value.forceSessionPoolRecheck) {
             lastSessionPoolReadyAt = 0;
             nextSessionPoolRetryAt = 0;
@@ -4097,6 +6642,11 @@ async function executeSalesNavigatorCrawlJob(session, jobId, options) {
         currentSession = status.session;
         job = status.value.job;
     }
+    else if (!isSalesNavigatorCrawlJobTerminal(job.status)) {
+        const status = await getSalesNavigatorCrawlStatus(currentSession, jobId, options.traceId);
+        currentSession = status.session;
+        job = status.value.job;
+    }
     await options.logger?.log("salesnav.crawl.job.completed", {
         jobId,
         status: job.status,
@@ -4406,6 +6956,15 @@ function buildCliError(error) {
         };
     }
     const message = error instanceof Error ? error.message : "Unknown error";
+    if (message === "linkedin_session_invalid" ||
+        isLinkedInCompanyBackfillInvalidSessionMessage(message) ||
+        /no eligible linkedin session cookies available for company backfill|company session preflight returned/i.test(message)) {
+        return {
+            status: "error",
+            code: "runtime_error",
+            message: buildLinkedInCompanyBackfillSessionRecoveryMessage([])
+        };
+    }
     if (message.includes("not logged in")) {
         return {
             status: "error",
@@ -4494,6 +7053,7 @@ const domainDecisionArraySchema = z.array(z.object({
     reason: z.enum([
         "linkedin-domain",
         "linkedin-website",
+        "better-company-match",
         "highest-hunter-count",
         "fallback-first-non-null",
         "no-domain"
@@ -4777,19 +7337,22 @@ program
     if (rows.length === 0) {
         throw new Error("No contact rows found. Provide TSV/CSV/JSON input via --in or stdin.");
     }
+    let authSession = null;
     let sessionOrgId = "";
     if (!shouldBypassAuth()) {
         try {
-            const session = await requireAuthSession();
-            sessionOrgId = session.user.orgId ?? "";
+            authSession = await requireAuthSession();
+            sessionOrgId = authSession.user.orgId ?? "";
         }
         catch {
+            authSession = null;
             sessionOrgId = "";
         }
     }
     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",
@@ -4805,68 +7368,558 @@ 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
     });
+    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;
+        }
+        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)));
+    if (authSession && parsedClientIds.length === 1) {
+        try {
+            const uniqueCompanies = Array.from(new Map(contacts
+                .filter((contact) => !contact.isVariation)
+                .map((contact) => {
+                const key = normalizeLookupCompanyForCleaning(contact.companyNameOriginal ?? contact.companyName);
+                return [
+                    key,
+                    {
+                        companyId: contact.contact_id,
+                        companyName: contact.companyNameOriginal ?? contact.companyName,
+                        companyNameCleaned: cleanedCompanyMap.get(key) ?? normalizeLookupWhitespace(contact.companyNameOriginal ?? contact.companyName)
+                    }
+                ];
+            })).values());
+            if (uniqueCompanies.length > 0) {
+                const appCompanyResult = await enrichDirectEmailCompaniesViaApp(authSession, {
+                    clientId: parsedClientIds[0],
+                    companies: uniqueCompanies
+                });
+                const companyByNormalizedName = new Map(appCompanyResult.companies.map((company) => [
+                    normalizeLookupCompanyForCleaning(company.companyName),
+                    company.linkedinCompanyPage ?? null
+                ]));
+                for (const row of enrichedRows) {
+                    if (row.linkedinCompanyUrl) {
+                        continue;
+                    }
+                    const normalizedName = normalizeLookupCompanyForCleaning(row.companyName);
+                    const linkedinCompanyUrl = companyByNormalizedName.get(normalizedName) ?? null;
+                    if (!linkedinCompanyUrl) {
+                        continue;
+                    }
+                    row.linkedinCompanyUrl = linkedinCompanyUrl;
+                    row.companyFound = true;
+                    row.companySource = "workflow";
+                }
+            }
+        }
+        catch (error) {
+            writeProgress(`Skipping app-backed company enrichment: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    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
+        });
+        for (const row of enrichedRows) {
+            if (row.linkedinCompanyUrl) {
+                continue;
+            }
+            const linkedinCompanyUrl = companyUrlByContactId.get(row.contactId);
+            if (!linkedinCompanyUrl) {
+                continue;
+            }
+            row.linkedinCompanyUrl = linkedinCompanyUrl;
+            row.companyFound = true;
+            row.companySource = "web-search";
+        }
+    }
     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) {
-        directAttempted = true;
-        const directContacts = contacts.filter((contact) => missingRows.some((row) => row.contactId === contact.contact_id));
-        const result = await invokeLinkedInUrlEnrichmentDirect({
-            contacts: directContacts,
-            timeoutMs
+        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
         });
-        const linkedInUrlByContactId = new Map(result.contacts.map((contact) => [contact.contact_id, contact.linkedin_url]));
         for (const row of enrichedRows) {
             if (row.found)
                 continue;
-            const linkedinUrl = linkedInUrlByContactId.get(row.contactId) ?? null;
-            if (linkedinUrl) {
-                row.linkedinUrl = linkedinUrl;
-                row.found = true;
-                row.source = "linkedin-direct";
+            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",
+        orgId: String(options.orgId ?? "").trim() || null,
+        requested: rows.length,
+        found: enrichedRows.filter((row) => row.found).length,
+        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);
+    }
+    printOutput(payload);
+});
+program
+    .command("companies:find-linkedin-urls")
+    .alias("companies:resolve-linkedin-urls")
+    .description("Resolve LinkedIn company URLs from a pasted company list directly in the CLI.")
+    .option("--in <path>", "Input TSV/CSV/JSON file path. Omit to read from stdin.")
+    .option("--out <path>", "Optional output JSON path for the enriched rows.")
+    .option("--client-id <id>", "Optional clientId override for app-backed enrichment.")
+    .option("--timeout-ms <number>", "Lookup timeout in milliseconds", "30000")
+    .option("--company-cleaning <mode>", "Company cleaning mode: off, basic, or ai", "basic")
+    .option("--dry-run", "Preview the normalized payload without calling LinkedIn", false)
+    .action(async (options) => {
+    const timeoutMs = z.coerce.number().int().min(1000).max(300000).parse(options.timeoutMs);
+    const inputContent = options.in ? await readFile(options.in, "utf8") : await readAllStdin();
+    const rows = parseLinkedInCompanyLookupInput(inputContent);
+    if (rows.length === 0) {
+        throw new Error("No company rows found. Provide TSV/CSV/JSON input via --in or stdin.");
+    }
+    let authSession = null;
+    if (!shouldBypassAuth()) {
+        authSession = await requireAuthSession().catch(() => null);
+    }
+    const companyCleaningMode = resolveCompanyCleaningMode(String(options.companyCleaning ?? process.env.SALESPROMPTER_COMPANY_CLEANING_MODE ?? "basic"));
+    const lookupRows = rows.map((row) => ({
+        clientId: row.clientId,
+        fullName: "",
+        companyName: row.companyName
+    }));
+    const cleanedCompanyMap = await buildCompanyNameCleaningMap(lookupRows, companyCleaningMode);
+    const contacts = toLinkedInUrlLookupContacts(lookupRows, cleanedCompanyMap);
+    if (options.dryRun) {
+        const payload = {
+            status: "ok",
+            dryRun: true,
+            companyCleaningMode,
+            companies: contacts.length,
+            sample: contacts.slice(0, 5).map((contact) => ({
+                companyId: contact.contact_id,
+                companyName: contact.companyNameOriginal ?? contact.companyName,
+                companyNameCleaned: contact.companyName
+            }))
+        };
+        if (options.out) {
+            await writeJsonFile(options.out, payload);
+        }
+        printOutput(payload);
+        return;
+    }
+    const clientId = resolveDirectEmailEnrichmentClientId(rows.map((row) => ({
+        clientId: row.clientId,
+        companyName: row.companyName,
+        fullName: ""
+    })), options.clientId);
+    const results = contacts
+        .filter((contact) => !contact.isVariation)
+        .map((contact) => ({
+        clientId: String(clientId),
+        companyName: contact.companyNameOriginal ?? contact.companyName,
+        linkedinCompanyUrl: null,
+        salesNavCompanyUrl: null,
+        domain: null,
+        found: false,
+        source: null,
+        matchedCompanyName: null,
+        matchedCompanyEmployeeCount: null
+    }));
+    const resultByNormalizedName = new Map(results.map((row) => [normalizeLookupCompanyForCleaning(row.companyName), row]));
+    if (authSession) {
+        try {
+            const uniqueCompanies = contacts
+                .filter((contact) => !contact.isVariation)
+                .map((contact) => ({
+                companyId: contact.contact_id,
+                companyName: contact.companyNameOriginal ?? contact.companyName,
+                companyNameCleaned: cleanedCompanyMap.get(normalizeLookupCompanyForCleaning(contact.companyNameOriginal ?? contact.companyName)) ?? normalizeLookupWhitespace(contact.companyNameOriginal ?? contact.companyName)
+            }));
+            if (uniqueCompanies.length > 0) {
+                const enrichedCompanies = await enrichDirectEmailCompaniesViaApp(authSession, {
+                    clientId,
+                    companies: uniqueCompanies
+                });
+                for (const company of enrichedCompanies.companies) {
+                    const row = resultByNormalizedName.get(normalizeLookupCompanyForCleaning(company.companyName));
+                    if (!row) {
+                        continue;
+                    }
+                    row.domain = company.domain ?? row.domain ?? null;
+                    row.linkedinCompanyUrl = company.linkedinCompanyPage ?? row.linkedinCompanyUrl ?? null;
+                    row.found = Boolean(row.linkedinCompanyUrl || row.salesNavCompanyUrl);
+                    row.source = row.linkedinCompanyUrl ? "app" : row.source;
+                }
             }
         }
+        catch {
+            // Ignore app failures here and keep falling back to direct or public lookup.
+        }
     }
     try {
         const companyResult = await invokeLinkedInCompanyEnrichmentDirect({
             contacts,
             timeoutMs
         });
-        const companyByContactId = new Map(companyResult.contacts.map((contact) => [
-            contact.contact_id,
-            {
-                linkedinCompanyUrl: contact.linkedin_company_url ?? null,
-                matchedCompanyName: contact.matched_company_name ?? null,
-                matchedCompanyEmployeeCount: contact.matched_company_employee_count ?? null
+        const companyByContactId = new Map(companyResult.contacts.map((contact) => [contact.contact_id, contact]));
+        for (const contact of contacts) {
+            if (contact.isVariation) {
+                continue;
             }
-        ]));
-        for (const row of enrichedRows) {
-            const company = companyByContactId.get(row.contactId);
-            if (!company || row.linkedinCompanyUrl) {
+            const row = resultByNormalizedName.get(normalizeLookupCompanyForCleaning(contact.companyNameOriginal ?? contact.companyName));
+            const company = companyByContactId.get(contact.contact_id);
+            if (!row || !company) {
                 continue;
             }
-            row.linkedinCompanyUrl = company.linkedinCompanyUrl;
-            row.companyFound = Boolean(company.linkedinCompanyUrl);
-            row.companySource = company.linkedinCompanyUrl ? "linkedin-direct" : row.companySource ?? null;
-            row.matchedCompanyName = company.matchedCompanyName ?? row.matchedCompanyName ?? null;
+            if (!row.linkedinCompanyUrl && company.linkedin_company_url) {
+                row.linkedinCompanyUrl = company.linkedin_company_url;
+            }
+            if (!row.salesNavCompanyUrl && company.sales_nav_company_url) {
+                row.salesNavCompanyUrl = company.sales_nav_company_url;
+            }
+            row.matchedCompanyName = company.matched_company_name ?? row.matchedCompanyName ?? null;
             row.matchedCompanyEmployeeCount =
-                company.matchedCompanyEmployeeCount ?? row.matchedCompanyEmployeeCount ?? null;
+                company.matched_company_employee_count ?? row.matchedCompanyEmployeeCount ?? null;
+            if ((company.linkedin_company_url || company.sales_nav_company_url) && row.source == null) {
+                row.source = "linkedin-direct";
+            }
+            row.found = Boolean(row.linkedinCompanyUrl || row.salesNavCompanyUrl);
         }
     }
     catch (error) {
-        writeProgress(`Skipping separate company enrichment: ${error instanceof Error ? error.message : String(error)}`);
+        const message = error instanceof Error ? error.message : String(error);
+        if (!/Missing LinkedIn direct lookup session/i.test(message)) {
+            throw error;
+        }
+    }
+    for (const row of results) {
+        if (row.linkedinCompanyUrl) {
+            continue;
+        }
+        const linkedinCompanyUrl = (await searchSerperLinkedInCompanyUrl(row.companyName, timeoutMs)) ??
+            (await searchPublicLinkedInCompanyUrl(row.companyName, timeoutMs));
+        if (!linkedinCompanyUrl) {
+            continue;
+        }
+        row.linkedinCompanyUrl = linkedinCompanyUrl;
+        row.found = true;
+        if (row.source == null) {
+            row.source = "web-search";
+        }
     }
     const payload = {
         status: "ok",
-        orgId: String(options.orgId ?? "").trim() || null,
         requested: rows.length,
-        found: enrichedRows.filter((row) => row.found).length,
-        companiesFound: enrichedRows.filter((row) => row.companyFound).length,
-        directAttempted,
-        rows: enrichedRows
+        found: results.filter((row) => row.found).length,
+        rows: results
     };
     if (options.out) {
         await writeJsonFile(options.out, payload);
@@ -4893,6 +7946,7 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
         commandName === "wizard" ||
         commandName === "llm:ready" ||
         commandName === "contacts:find-linkedin-urls" ||
+        commandName === "companies:find-linkedin-urls" ||
         commandName.startsWith("packs:") ||
         ((commandName === "list" || commandName === "add") && parentCommandName === "packs")) {
         return;
@@ -5046,12 +8100,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);
@@ -5059,9 +8115,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",
@@ -5106,6 +8168,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);
@@ -5113,13 +8177,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);
@@ -5176,16 +8246,21 @@ program
     .command("linkedin-companies:backfill")
     .alias("companies:enrich")
     .description("Backfill missing or unavailable company profiles for the current workspace.")
-    .requiredOption("--client-id <number>", "Legacy BigQuery clientId to backfill")
+    .option("--client-id <number>", "Legacy BigQuery clientId to backfill (optional if set in cache or env)")
     .option("--limit <number>", "Maximum companies to scrape in one run", "25")
     .option("--concurrency <number>", "How many LinkedIn company pages to scrape in parallel", "4")
     .option("--dry-run", "Preview the scrape result and generated MERGE SQL without writing to BigQuery", false)
     .action(async (options) => {
-    const clientId = z.coerce.number().int().positive().parse(options.clientId);
+    const authenticatedRun = !shouldBypassAuth() && !options.dryRun;
+    const session = authenticatedRun ? await requireAuthSession() : undefined;
+    const clientId = await resolveLinkedInCompanyBackfillClientId({
+        clientIdOption: options.clientId,
+        session
+    });
     const limit = z.coerce.number().int().min(1).max(500).parse(options.limit);
     const concurrency = z.coerce.number().int().min(1).max(20).parse(options.concurrency);
-    if (!options.dryRun && !shouldBypassAuth()) {
-        const session = await requireAuthSession();
+    await writeLinkedInCompanyBackfillClientIdToCache(clientId, session);
+    if (authenticatedRun && session) {
         const drained = await drainLinkedInCompanyBackfill(session, {
             clientId,
             limit
@@ -5852,6 +8927,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")
@@ -5870,6 +8946,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);
@@ -5889,6 +8966,7 @@ program
         jobId: jobId ?? null,
         maxResultsPerSearch,
         numberOfProfiles,
+        clientId,
         slicePreset: options.slicePreset,
         maxSplitDepth,
         maxSlices,
@@ -5989,6 +9067,7 @@ program
                 traceId: logger.traceId,
                 command: {
                     sourceQueryUrl: queryUrl,
+                    clientId,
                     slicePreset: options.slicePreset,
                     maxResultsPerSearch,
                     numberOfProfiles,
@@ -6010,6 +9089,7 @@ program
                 splitTrail: seed.splitTrail,
                 rawPayload: {
                     workflow: "salesnav:crawl",
+                    clientId,
                     traceId: logger.traceId
                 }
             }
@@ -6049,6 +9129,7 @@ program
         idlePollSeconds,
         idleMaxPolls,
         parallelExports,
+        clientId,
         traceId: logger.traceId,
         logger
     });
@@ -6129,6 +9210,43 @@ 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("--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
+    });
+    const payload = {
+        ...result,
+        dryRun: false
+    };
+    if (options.out) {
+        await writeJsonFile(options.out, payload);
+    }
+    printOutput(payload);
+});
 program
     .command("salesnav:export")
     .alias("search:export")
@@ -6137,12 +9255,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) {
@@ -6164,10 +9288,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,
@@ -6176,12 +9300,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",
@@ -6983,7 +10112,17 @@ async function main() {
     }
     await program.parseAsync(process.argv);
 }
-main().catch((error) => {
+async function closeGlobalHttpDispatcher() {
+    try {
+        const undici = await import("undici");
+        await undici.getGlobalDispatcher().close();
+    }
+    catch {
+        // Best-effort shutdown for keep-alive sockets; ignore when undici is unavailable.
+    }
+}
+main()
+    .catch((error) => {
     if (error instanceof Error &&
         (error.message === "prompt cancelled" || error.message === "readline was closed")) {
         process.exitCode = 130;
@@ -6998,4 +10137,8 @@ main().catch((error) => {
         process.stderr.write(`${cliError.message}\n`);
     }
     process.exitCode = exitCodeForError(cliError.code);
+})
+    .finally(async () => {
+    await closeGlobalHttpDispatcher();
+    process.exit(process.exitCode ?? 0);
 });