salesprompter-cli 0.1.25 → 0.1.26

package/dist/cli.js

@@ -19,11 +19,13 @@ import { buildDeelLeadPoolContactSql, buildDeelOutreachExportSql, buildDeelOutre
 import { buildDirectPathLeadExportSql, normalizeDirectPathRows, segmentDirectPathRows } from "./direct-path.js";
 import { AccountLeadProvider, DryRunSyncProvider, HeuristicCompanyProvider, HeuristicEnrichmentProvider, HeuristicPeopleSearchProvider, HeuristicScoringProvider, RoutedSyncProvider } from "./engine.js";
 import { analyzeHistoricalQueries } from "./historical-queries.js";
+import { buildHunterEmailfinderQueueSql, buildHunterEmailfinderTriggerPayload, directEmailEnrichmentInputRowArraySchema, hunterEmailfinderQueueRowArraySchema, parseDirectEmailEnrichmentInput, readHunterEmailfinderConfig, resolveDirectEmailEnrichmentClientId, triggerHunterEmailfinderWorkflow } from "./hunter-emailfinder.js";
 import { buildHistoricalVendorIcp, buildVendorIcp } from "./icp-templates.js";
 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 } from "./linkedin-session.js";
+import { claimValidatedSalesNavigatorSessionCookieForCli, createLinkedInSessionSupabaseClient } 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";
@@ -78,6 +80,16 @@ const LinkedInCompanyBackfillStatusResponseSchema = z.object({
     processed: z.boolean(),
     remaining: z.number().int().nonnegative()
 });
+const CliEmailEnrichmentCompaniesResponseSchema = z.object({
+    clientId: z.number().int().positive(),
+    companies: z.array(z.object({
+        companyId: z.string().min(1),
+        companyName: z.string().min(1),
+        companyNameCleaned: z.string().nullable().optional(),
+        domain: z.string().nullable(),
+        linkedinCompanyPage: z.string().nullable()
+    }))
+});
 const SalesNavigatorLaunchDiagnosticsSchema = z.object({
     orderedCandidateAgentIds: z.array(z.string().min(1)),
     runningAgentIds: z.array(z.string().min(1)),
@@ -238,6 +250,7 @@ const SalesNavigatorCrawlReportResponseSchema = z.object({
 });
 const helpAliasByCommandName = new Map([
     ["contacts:find-linkedin-urls", "contacts:resolve-profiles"],
+    ["contacts:process-emails", "contacts:resolve-emails"],
     ["linkedin-companies:backfill", "companies:enrich"],
     ["linkedin-products:scrape", "market:scrape"],
     ["salesnav:from-product-category", "leads:discover"],
@@ -252,6 +265,7 @@ const helpVisibleCommandNames = new Set([
     "auth:whoami",
     "llm:ready",
     "contacts:find-linkedin-urls",
+    "contacts:process-emails",
     "auth:logout",
     "account:resolve",
     "icp:define",
@@ -498,6 +512,296 @@ function normalizeLookupCompanyForSearch(value) {
         .replace(/\s+/g, " ")
         .trim();
 }
+function normalizeLookupCompanyForCleaning(value) {
+    return normalizeLookupWhitespace(value)
+        .replace(/[+]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function stripLookupCompanyLegalSuffixes(value) {
+    let cleaned = normalizeLookupCompanyForCleaning(value);
+    if (!cleaned) {
+        return "";
+    }
+    cleaned = cleaned.replace(/\s*\([^)]*\)\s*$/g, "").trim();
+    const suffixes = [
+        "gmbh & co. kgaa",
+        "gmbh & co kgaa",
+        "gmbh & co. kg",
+        "gmbh & co kg",
+        "ug (haftungsbeschrankt)",
+        "ug (haftungsbeschränkt)",
+        "wirtschaftsprufungsgesellschaft",
+        "wirtschaftsprüfungsgesellschaft",
+        "gesellschaft",
+        "corporation",
+        "holdings",
+        "holding",
+        "international",
+        "services",
+        "service",
+        "solutions",
+        "systems",
+        "consulting",
+        "management",
+        "technologies",
+        "technology",
+        "digital",
+        "software",
+        "global",
+        "worldwide",
+        "deutschland",
+        "germany",
+        "america",
+        "europe",
+        "company",
+        "verlag",
+        "servtec",
+        "group",
+        "gruppe",
+        "tech",
+        "gmbh",
+        "kgaa",
+        "mbh",
+        "ohg",
+        "kg",
+        "ag",
+        "ug",
+        "se",
+        "sa",
+        "s.a.",
+        "sarl",
+        "s.r.l.",
+        "srl",
+        "llc",
+        "ltd",
+        "limited",
+        "inc.",
+        "inc",
+        "corp.",
+        "corp",
+        "co.",
+        "co",
+        "plc",
+        "bv",
+        "b.v.",
+        "nv",
+        "n.v.",
+        "oyj",
+        "oy",
+        "aps",
+        "a/s",
+        "ab",
+        "as"
+    ];
+    const escapedSuffixes = suffixes
+        .map((suffix) => suffix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+        .sort((left, right) => right.length - left.length)
+        .join("|");
+    const separatorPattern = String.raw `(?:\s*[,|/]\s*|\s+[-–]\s+|\s+)`;
+    const trailingSuffixPattern = new RegExp(`${separatorPattern}(?:${escapedSuffixes})\\s*$`, "i");
+    const suffixBeforeSeparatorPattern = new RegExp(`\\s+(?:${escapedSuffixes})(?=\\s*[-–|/])`, "ig");
+    for (let index = 0; index < 6; index += 1) {
+        const next = cleaned
+            .replace(suffixBeforeSeparatorPattern, "")
+            .replace(trailingSuffixPattern, "")
+            .trim();
+        if (next === cleaned) {
+            break;
+        }
+        cleaned = next;
+    }
+    return normalizeLookupWhitespace(cleaned);
+}
+function aggressivelyCleanLookupCompanyName(value) {
+    let cleaned = stripLookupCompanyLegalSuffixes(value);
+    if (!cleaned) {
+        return "";
+    }
+    const suffixesToRemove = [
+        "group",
+        "gruppe",
+        "international",
+        "global",
+        "worldwide",
+        "services",
+        "service",
+        "servtec",
+        "solutions",
+        "systems",
+        "consulting",
+        "management",
+        "technologies",
+        "technology",
+        "digital",
+        "tech",
+        "it",
+        "software",
+        "europe",
+        "deutschland",
+        "germany",
+        "usa",
+        "uk",
+        "america",
+        "holdings",
+        "holding",
+        "corporation",
+        "company",
+        "verlag",
+        "gesellschaft",
+        "wirtschaftsprüfungsgesellschaft",
+        "wirtschaftsprufungsgesellschaft"
+    ];
+    for (const suffix of suffixesToRemove) {
+        const pattern = new RegExp(`(?:\\s+|\\s*[-–|/]\\s*)${suffix}\\s*$`, "i");
+        cleaned = cleaned.replace(pattern, "").trim();
+    }
+    const segments = cleaned
+        .split(/\s*[-–|/]\s*/)
+        .map((segment) => normalizeLookupWhitespace(segment))
+        .filter(Boolean);
+    if (segments.length > 1) {
+        const descriptorPattern = /^(robotic|solutions?|systems?|services?|service|consulting|management|technologies?|technology|digital|tech|software|logistics|distribution|distributions|trading|handel|messtechnik|produktionstechnik|umwelttechnik|reinigungstechnik|pflanzenschutz|betonwerk|export|import|export import|vertrieb|wholesale|retail|agro|center|centre|center)$/i;
+        const trailingSegments = segments.slice(1);
+        const shouldCollapseToFirstSegment = trailingSegments.every((segment) => segment
+            .split(/\s+/)
+            .filter(Boolean)
+            .every((word) => descriptorPattern.test(word)));
+        if (shouldCollapseToFirstSegment) {
+            cleaned = segments[0] ?? cleaned;
+        }
+    }
+    const words = cleaned.split(/\s+/).filter(Boolean);
+    if (words.length === 2) {
+        const [firstWord, secondWord] = words;
+        if (/^(servtec|digital|tech|solutions|systems|services|consulting|management|technologies)$/i.test(secondWord ?? "")) {
+            cleaned = firstWord ?? cleaned;
+        }
+    }
+    const descriptorTailPattern = /^(robotic|solutions?|systems?|services?|service|consulting|management|technologies?|technology|digital|tech|software|logistics|distribution|distributions|trading|handel)$/i;
+    const cleanedWords = cleaned.split(/\s+/).filter(Boolean);
+    if (cleanedWords.length >= 2 &&
+        cleanedWords.slice(1).every((word) => descriptorTailPattern.test(word))) {
+        cleaned = cleanedWords[0] ?? cleaned;
+    }
+    return normalizeLookupWhitespace(cleaned);
+}
+function resolveCompanyCleaningMode(value) {
+    const normalized = String(value ?? "basic").trim().toLowerCase();
+    if (normalized === "off" || normalized === "raw" || normalized === "none") {
+        return "off";
+    }
+    if (normalized === "ai" || normalized === "openai") {
+        return "ai";
+    }
+    return "basic";
+}
+function readOpenAiCompanyCleanerConfig() {
+    const apiKey = process.env.SALESPROMPTER_OPENAI_API_KEY?.trim() ||
+        process.env.OPENAI_API_KEY?.trim() ||
+        "";
+    if (!apiKey) {
+        throw new Error("Missing OpenAI API key for AI company cleaning. Set OPENAI_API_KEY or SALESPROMPTER_OPENAI_API_KEY.");
+    }
+    const baseUrl = process.env.SALESPROMPTER_OPENAI_BASE_URL?.trim().replace(/\/+$/, "") || "https://api.openai.com/v1";
+    const promptId = process.env.SALESPROMPTER_COMPANY_CLEANER_PROMPT_ID?.trim() ||
+        "pmpt_69c164c582a48196b288a8909de87c700694068fbd1b0e55";
+    const promptVersion = process.env.SALESPROMPTER_COMPANY_CLEANER_PROMPT_VERSION?.trim() || "2";
+    const maxOutputTokens = z.coerce
+        .number()
+        .int()
+        .min(256)
+        .max(32768)
+        .parse(process.env.SALESPROMPTER_COMPANY_CLEANER_MAX_OUTPUT_TOKENS ?? "4096");
+    return {
+        apiKey,
+        baseUrl,
+        promptId,
+        promptVersion,
+        maxOutputTokens
+    };
+}
+async function cleanCompanyNamesWithOpenAi(companyNames, config) {
+    if (companyNames.length === 0) {
+        return new Map();
+    }
+    const response = await fetch(`${config.baseUrl}/responses`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${config.apiKey}`,
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            prompt: {
+                id: config.promptId,
+                version: config.promptVersion
+            },
+            input: [
+                {
+                    role: "user",
+                    content: JSON.stringify(companyNames)
+                }
+            ],
+            text: {
+                format: {
+                    type: "text"
+                }
+            },
+            reasoning: {},
+            max_output_tokens: config.maxOutputTokens,
+            store: true
+        })
+    });
+    if (!response.ok) {
+        const details = await response.text();
+        throw new Error(`OpenAI company cleaning failed with ${response.status}: ${details}`);
+    }
+    const payload = (await response.json());
+    const incomplete = payload.status === "incomplete" || payload.incomplete_details;
+    if (incomplete) {
+        const reason = payload.incomplete_details?.reason || payload.status || "unknown";
+        throw new Error(`OpenAI company cleaning returned an incomplete response (${reason}).`);
+    }
+    const rawText = payload.output_text ??
+        payload.output?.flatMap((item) => item.content ?? []).map((item) => item.text ?? "").join("") ??
+        "";
+    if (!rawText.trim()) {
+        throw new Error("OpenAI company cleaning returned no text.");
+    }
+    const parsed = z
+        .array(z.object({
+        companyName_input: z.string(),
+        companyName_cleaned: z.string().nullish()
+    }))
+        .parse(JSON.parse(rawText));
+    const cleanedByInput = new Map();
+    for (const item of parsed) {
+        cleanedByInput.set(normalizeLookupCompanyForCleaning(item.companyName_input), aggressivelyCleanLookupCompanyName(item.companyName_cleaned ?? item.companyName_input));
+    }
+    return cleanedByInput;
+}
+async function buildCompanyNameCleaningMap(rows, mode) {
+    const uniqueCompanyNames = Array.from(new Set(rows
+        .map((row) => normalizeLookupCompanyForCleaning(row.companyName))
+        .filter((value) => value.length > 0)));
+    if (uniqueCompanyNames.length === 0) {
+        return new Map();
+    }
+    const cleanedByInput = new Map();
+    for (const companyName of uniqueCompanyNames) {
+        cleanedByInput.set(companyName, aggressivelyCleanLookupCompanyName(companyName));
+    }
+    if (mode !== "ai") {
+        return cleanedByInput;
+    }
+    const aiCleanedByInput = await cleanCompanyNamesWithOpenAi(uniqueCompanyNames, readOpenAiCompanyCleanerConfig());
+    for (const [input, cleaned] of aiCleanedByInput.entries()) {
+        if (cleaned) {
+            cleanedByInput.set(input, cleaned);
+        }
+    }
+    return cleanedByInput;
+}
 function splitLookupFullName(fullName) {
     const parts = normalizeLookupWhitespace(fullName).split(" ").filter(Boolean);
     return {
@@ -581,12 +885,12 @@ function parseLinkedInUrlLookupInput(content) {
     }))
         .filter((row) => row.fullName.length > 0 || row.companyName.length > 0);
 }
-function toLinkedInUrlLookupContacts(rows) {
+function toLinkedInUrlLookupContacts(rows, cleanedCompanyMap = new Map()) {
     return rows.flatMap((row, index) => {
         const contactId = String(index + 1);
         const syntheticEmail = row.email?.trim() || buildSyntheticLookupEmail(contactId);
         const rawCompanyName = normalizeLookupWhitespace(row.companyName);
-        const cleanedCompanyName = normalizeLookupCompanyForSearch(rawCompanyName);
+        const cleanedCompanyName = normalizeLookupCompanyForSearch(cleanedCompanyMap.get(normalizeLookupCompanyForCleaning(rawCompanyName)) ?? rawCompanyName);
         const rawFullName = normalizeLookupWhitespace(row.fullName);
         if (looksLikeLookupCompanyRow(rawFullName, rawCompanyName)) {
             return [
@@ -652,45 +956,265 @@ function deriveCsrfTokenFromCookie(cookie) {
     const match = cookie.match(/JSESSIONID="?([^";]+)"?/i);
     return match?.[1]?.trim() || "";
 }
-function readLinkedInDirectLookupConfig() {
-    const csrfToken = process.env.SALESPROMPTER_LINKEDIN_CSRF_TOKEN?.trim() ||
-        process.env.LINKEDIN_CSRF_TOKEN?.trim() ||
-        deriveCsrfTokenFromCookie(process.env.SALESPROMPTER_LINKEDIN_SALES_NAV_COOKIE?.trim() ||
-            process.env.LINKEDIN_SALES_NAV_COOKIE?.trim() ||
-            "");
-    const identity = process.env.SALESPROMPTER_LINKEDIN_X_LI_IDENTITY?.trim() ||
-        process.env.LINKEDIN_X_LI_IDENTITY?.trim() ||
-        "";
+function readLinkedInDirectLookupEnvConfig() {
     const cookie = process.env.SALESPROMPTER_LINKEDIN_SALES_NAV_COOKIE?.trim() ||
         process.env.LINKEDIN_SALES_NAV_COOKIE?.trim() ||
         "";
-    const 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";
+    const identity = process.env.SALESPROMPTER_LINKEDIN_X_LI_IDENTITY?.trim() ||
+        process.env.LINKEDIN_X_LI_IDENTITY?.trim() ||
+        "";
+    const csrfToken = process.env.SALESPROMPTER_LINKEDIN_CSRF_TOKEN?.trim() ||
+        process.env.LINKEDIN_CSRF_TOKEN?.trim() ||
+        deriveCsrfTokenFromCookie(cookie);
     if (!csrfToken || !identity || !cookie) {
-        throw new Error("Missing LinkedIn direct lookup tokens. Set LINKEDIN_CSRF_TOKEN, LINKEDIN_X_LI_IDENTITY, and LINKEDIN_SALES_NAV_COOKIE.");
+        return null;
     }
     return {
         csrfToken,
         identity,
         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"
+    };
+}
+function extractStoredLinkedInLookupValue(metadata, key) {
+    if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+        return "";
+    }
+    const record = metadata;
+    const linkedInSession = record.linkedInSession && typeof record.linkedInSession === "object" && !Array.isArray(record.linkedInSession)
+        ? record.linkedInSession
+        : null;
+    const value = linkedInSession?.[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+async function readStoredLinkedInDirectLookupConfig() {
+    const supabase = createLinkedInSessionSupabaseClient();
+    if (!supabase) {
+        return null;
+    }
+    const claimed = await claimValidatedSalesNavigatorSessionCookieForCli({
+        queryUrl: "https://www.linkedin.com/sales/search/people",
+        source: "cli_direct_lookup",
+        supabase
+    });
+    if (!claimed) {
+        return null;
+    }
+    const lookupResult = await supabase
+        .from("linkedin_session_cookies")
+        .select("metadata")
+        .eq("session_cookie_sha256", claimed.sessionCookieSha256)
+        .maybeSingle();
+    if (lookupResult.error && !/linkedin_session_cookies/.test(lookupResult.error.message)) {
+        throw new Error(`Failed to read stored LinkedIn session metadata: ${lookupResult.error.message}`);
+    }
+    const metadata = lookupResult.data?.metadata;
+    const identity = extractStoredLinkedInLookupValue(metadata, "linkedInIdentity");
+    const csrfToken = extractStoredLinkedInLookupValue(metadata, "csrfToken") ||
+        deriveCsrfTokenFromCookie(claimed.sessionCookie);
+    const userAgent = process.env.SALESPROMPTER_LINKEDIN_USER_AGENT?.trim() ||
+        extractStoredLinkedInLookupValue(metadata, "userAgent") ||
+        "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 (!identity || !csrfToken) {
+        return null;
+    }
+    return {
+        csrfToken,
+        identity,
+        cookie: claimed.sessionCookie,
         userAgent
     };
 }
+let cachedLinkedInDirectLookupConfig = null;
+async function readLinkedInDirectLookupConfig() {
+    if (cachedLinkedInDirectLookupConfig) {
+        return cachedLinkedInDirectLookupConfig;
+    }
+    const envConfig = readLinkedInDirectLookupEnvConfig();
+    if (envConfig) {
+        cachedLinkedInDirectLookupConfig = envConfig;
+        return envConfig;
+    }
+    const storedConfig = await readStoredLinkedInDirectLookupConfig();
+    if (storedConfig) {
+        cachedLinkedInDirectLookupConfig = storedConfig;
+        return storedConfig;
+    }
+    throw new Error("Missing LinkedIn direct lookup session. Set LINKEDIN_CSRF_TOKEN, LINKEDIN_X_LI_IDENTITY, and LINKEDIN_SALES_NAV_COOKIE, or connect the Salesprompter Chrome extension to sync your LinkedIn session to salesprompter.ai.");
+}
 function generateLinkedInSessionId() {
     return Array.from({ length: 22 }, () => "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".charAt(Math.floor(Math.random() * 62))).join("");
 }
-function buildLinkedInSalesApiUrl(firstName, lastName, companyName) {
+function buildLinkedInSalesApiUrl(params) {
     const baseUrl = process.env.SALESPROMPTER_LINKEDIN_SALES_API_BASE_URL?.trim() ||
         "https://www.linkedin.com";
-    return `${baseUrl.replace(/\/+$/, "")}/sales-api/salesApiLeadSearch?q=searchQuery&query=(recentSearchParam:(id:${Date.now()},doLogHistory:true),filters:List((type:FIRST_NAME,values:List((text:${encodeURIComponent(firstName)},selectionType:INCLUDED))),(type:LAST_NAME,values:List((text:${encodeURIComponent(lastName)},selectionType:INCLUDED))),(type:CURRENT_COMPANY,values:List((text:${encodeURIComponent(companyName)},selectionType:INCLUDED)))))&start=0&count=25&trackingParam=(sessionId:${generateLinkedInSessionId()})&decorationId=com.linkedin.sales.deco.desktop.searchv2.LeadSearchResult-14`;
+    const encodedFirstName = encodeURIComponent(params.firstName);
+    const encodedLastName = encodeURIComponent(params.lastName);
+    const encodedCompanyName = encodeURIComponent(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}` : "";
+    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 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) {
+    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
+            });
+        }
+    }
+    return variants;
 }
 function extractLinkedInProfileUrlFromSalesApiElement(element) {
     const entityUrn = typeof element?.entityUrn === "string" ? element.entityUrn : "";
     const salesIdMatch = entityUrn.match(/\(([^,]+),/);
     return salesIdMatch ? `https://www.linkedin.com/in/${salesIdMatch[1]}` : null;
 }
+function collectNestedStrings(value, seen = new Set()) {
+    if (value == null || seen.has(value)) {
+        return [];
+    }
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (typeof value !== "object") {
+        return [];
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return value.flatMap((entry) => collectNestedStrings(entry, seen));
+    }
+    return Object.values(value).flatMap((entry) => collectNestedStrings(entry, seen));
+}
+function extractLinkedInCompanyUrlFromSalesApiElement(element) {
+    if (!element) {
+        return null;
+    }
+    const explicitUrlCandidates = [
+        typeof element.companyPageUrl === "string" ? element.companyPageUrl : null,
+        typeof element.regularCompanyUrl === "string" ? element.regularCompanyUrl : null,
+        typeof element.url === "string" ? element.url : null
+    ].filter(Boolean);
+    const nestedUrlMatch = collectNestedStrings(element).find((value) => /https:\/\/www\.linkedin\.com\/company\/[^/?#]+/i.test(value));
+    if (nestedUrlMatch) {
+        return nestedUrlMatch.match(/https:\/\/www\.linkedin\.com\/company\/[^/?#]+/i)?.[0] ?? null;
+    }
+    for (const candidate of explicitUrlCandidates) {
+        const normalized = normalizeLinkedInCompanyHandle(candidate);
+        if (normalized) {
+            return normalizeLinkedInCompanyPage(normalized);
+        }
+    }
+    const entityUrn = typeof element.entityUrn === "string" ? element.entityUrn : "";
+    const idMatch = entityUrn.match(/\(([^,]+),/);
+    const companyId = idMatch?.[1]?.trim() ?? "";
+    if (/^\d+$/.test(companyId)) {
+        return normalizeLinkedInCompanyPage(companyId);
+    }
+    return null;
+}
+function extractLinkedInCompanyNameFromSalesApiElement(element) {
+    if (!element) {
+        return null;
+    }
+    const directCandidates = [
+        typeof element.companyName === "string" ? element.companyName : null,
+        typeof element.name === "string" ? element.name : null,
+        typeof element.title === "string" ? element.title : null
+    ].filter(Boolean);
+    for (const candidate of directCandidates) {
+        const normalized = normalizeLookupWhitespace(candidate);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    const nestedTitle = element.title;
+    if (nestedTitle && typeof nestedTitle === "object" && "text" in nestedTitle) {
+        const text = typeof nestedTitle.text === "string" ? normalizeLookupWhitespace(nestedTitle.text) : "";
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
+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];
+    });
+    for (const companyName of normalizedCandidates) {
+        if (!companyName) {
+            continue;
+        }
+        const key = companyName.toLowerCase();
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        variants.push({
+            contact_id: params.contactId,
+            companyName
+        });
+    }
+    return variants;
+}
 async function invokeLinkedInUrlEnrichmentDirect(params) {
-    const config = readLinkedInDirectLookupConfig();
+    const config = await readLinkedInDirectLookupConfig();
     const groupedContacts = new Map();
     for (const contact of params.contacts) {
         const key = contact.email?.trim().toLowerCase() || `contact:${contact.contact_id}`;
@@ -722,23 +1246,119 @@ async function invokeLinkedInUrlEnrichmentDirect(params) {
         let matchedUrl = null;
         let lastError = null;
         for (const candidate of variations) {
+            for (const searchVariant of buildLinkedInLookupSearchVariants(candidate)) {
+                const controller = new AbortController();
+                const timeout = setTimeout(controller.abort.bind(controller), Math.min(params.timeoutMs, 20_000));
+                try {
+                    const response = await fetch(buildLinkedInSalesApiUrl(searchVariant), {
+                        method: "GET",
+                        signal: controller.signal,
+                        headers: {
+                            accept: "*/*",
+                            "accept-language": "en-GB,en-US;q=0.9,en;q=0.8",
+                            "csrf-token": config.csrfToken,
+                            referer: "https://www.linkedin.com/sales/search/people",
+                            "sec-fetch-dest": "empty",
+                            "sec-fetch-mode": "cors",
+                            "sec-fetch-site": "same-origin",
+                            "user-agent": config.userAgent,
+                            "x-li-identity": config.identity,
+                            "x-li-lang": "en_US",
+                            "x-restli-protocol-version": "2.0.0",
+                            cookie: config.cookie
+                        }
+                    });
+                    if (response.status === 429) {
+                        rateLimited = true;
+                        lastError = "LinkedIn rate limit";
+                        break;
+                    }
+                    if (!response.ok) {
+                        lastError = `LinkedIn returned ${response.status}`;
+                        continue;
+                    }
+                    const data = (await response.json());
+                    const profilesFound = data.paging?.total ?? 0;
+                    if (profilesFound > 0) {
+                        matchedUrl = extractLinkedInProfileUrlFromSalesApiElement(data.elements?.[0]) ?? null;
+                        if (matchedUrl) {
+                            break;
+                        }
+                    }
+                }
+                catch (error) {
+                    lastError = error instanceof Error ? error.message : "Unknown direct lookup error";
+                }
+                finally {
+                    clearTimeout(timeout);
+                }
+                if (matchedUrl || rateLimited) {
+                    break;
+                }
+            }
+            if (matchedUrl || rateLimited) {
+                break;
+            }
+        }
+        results.push({
+            contact_id: primary.contact_id,
+            linkedin_url: matchedUrl,
+            error: matchedUrl ? null : lastError
+        });
+    }
+    return {
+        success: true,
+        contacts: results
+    };
+}
+async function invokeLinkedInCompanyEnrichmentDirect(params) {
+    const config = await readLinkedInDirectLookupConfig();
+    const primaryContacts = new Map();
+    for (const contact of params.contacts) {
+        const existing = primaryContacts.get(contact.contact_id);
+        if (!existing || existing.isVariation) {
+            primaryContacts.set(contact.contact_id, contact);
+        }
+    }
+    const results = [];
+    let rateLimited = false;
+    for (const contact of primaryContacts.values()) {
+        if (rateLimited) {
+            results.push({
+                contact_id: contact.contact_id,
+                linkedin_company_url: null,
+                error: "LinkedIn rate limit"
+            });
+            continue;
+        }
+        const variants = buildLinkedInCompanyLookupVariants({
+            contactId: contact.contact_id,
+            companyName: contact.companyName,
+            companyNameOriginal: contact.companyNameOriginal
+        });
+        let matchedCompanyUrl = null;
+        let matchedCompanyName = null;
+        let matchedCompanyEmployeeCount = null;
+        let lastError = null;
+        for (const variant of variants) {
             const controller = new AbortController();
             const timeout = setTimeout(controller.abort.bind(controller), Math.min(params.timeoutMs, 20_000));
             try {
-                const response = await fetch(buildLinkedInSalesApiUrl(candidate.firstName, candidate.lastName, candidate.companyName), {
+                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": config.csrfToken,
-                        referer: "https://www.linkedin.com/sales/search/people",
+                        referer: "https://www.linkedin.com/sales/search/company",
                         "sec-fetch-dest": "empty",
                         "sec-fetch-mode": "cors",
                         "sec-fetch-site": "same-origin",
                         "user-agent": config.userAgent,
                         "x-li-identity": 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: config.cookie
                     }
@@ -749,29 +1369,35 @@ async function invokeLinkedInUrlEnrichmentDirect(params) {
                     break;
                 }
                 if (!response.ok) {
-                    lastError = `LinkedIn returned ${response.status}`;
+                    lastError = `LinkedIn company search returned ${response.status}`;
                     continue;
                 }
                 const data = (await response.json());
-                const profilesFound = data.paging?.total ?? 0;
-                if (profilesFound > 0) {
-                    matchedUrl = extractLinkedInProfileUrlFromSalesApiElement(data.elements?.[0]) ?? null;
-                    if (matchedUrl) {
-                        break;
-                    }
+                const first = data.elements?.[0];
+                const companyUrl = extractLinkedInCompanyUrlFromSalesApiElement(first);
+                if (companyUrl) {
+                    matchedCompanyUrl = companyUrl;
+                    matchedCompanyName = extractLinkedInCompanyNameFromSalesApiElement(first);
+                    matchedCompanyEmployeeCount = extractLinkedInCompanyEmployeeCountFromSalesApiElement(first);
+                    break;
                 }
             }
             catch (error) {
-                lastError = error instanceof Error ? error.message : "Unknown direct lookup error";
+                lastError = error instanceof Error ? error.message : "Unknown direct company lookup error";
             }
             finally {
                 clearTimeout(timeout);
             }
+            if (matchedCompanyUrl || rateLimited) {
+                break;
+            }
         }
         results.push({
-            contact_id: primary.contact_id,
-            linkedin_url: matchedUrl,
-            error: matchedUrl ? null : lastError
+            contact_id: contact.contact_id,
+            linkedin_company_url: matchedCompanyUrl,
+            matched_company_name: matchedCompanyName,
+            matched_company_employee_count: matchedCompanyEmployeeCount,
+            error: matchedCompanyUrl ? null : lastError
         });
     }
     return {
@@ -869,13 +1495,15 @@ async function fetchSalesNavLookupCandidates(params) {
         fullName: row.full_name == null ? null : String(row.full_name),
         companyName: row.company_name == null ? null : String(row.company_name),
         title: row.title == null ? null : String(row.title),
+        companyUrl: row.company_url == null ? null : String(row.company_url),
+        regularCompanyUrl: row.regular_company_url == null ? null : String(row.regular_company_url),
         salesNavProfileUrl: row.sales_nav_profile_url == null ? null : String(row.sales_nav_profile_url),
         linkedInProfileUrl: row.linkedin_profile_url == null ? null : String(row.linkedin_profile_url)
     }));
     const fetchRows = async (operator, value) => {
         let query = supabase
             .from("linkedin_sales_nav_people")
-            .select("org_id,full_name,company_name,title,sales_nav_profile_url,linkedin_profile_url")
+            .select("org_id,full_name,company_name,title,company_url,regular_company_url,sales_nav_profile_url,linkedin_profile_url")
             .limit(10);
         if (params.orgId?.trim()) {
             query = query.eq("org_id", params.orgId.trim());
@@ -932,18 +1560,31 @@ async function resolveLinkedInUrlsFromSalesNavRows(params) {
         });
         const best = ranked[0]?.candidate;
         const linkedinUrl = best?.linkedInProfileUrl ?? best?.salesNavProfileUrl ?? null;
+        const linkedinCompanyUrl = (() => {
+            const handle = normalizeLinkedInCompanyHandle(best?.regularCompanyUrl ?? "") ??
+                normalizeLinkedInCompanyHandle(best?.companyUrl ?? "");
+            if (handle) {
+                return normalizeLinkedInCompanyPage(handle);
+            }
+            const numericCompanyUrl = typeof best?.companyUrl === "string" ? best.companyUrl.trim() : "";
+            return numericCompanyUrl.length > 0 ? numericCompanyUrl : null;
+        })();
         results.push({
             clientId: row.clientId,
             fullName: row.fullName,
             companyName: row.companyName,
             linkedinUrl,
+            linkedinCompanyUrl,
             found: Boolean(linkedinUrl),
+            companyFound: Boolean(linkedinCompanyUrl),
             contactId: String(index + 1),
             source: linkedinUrl ? "salesnav-supabase" : null,
+            companySource: linkedinCompanyUrl ? "salesnav-supabase" : null,
             matchedFullName: best?.fullName ?? null,
             matchedCompanyName: best?.companyName ?? null,
             matchedTitle: best?.title ?? null,
-            matchedOrgId: best?.orgId ?? null
+            matchedOrgId: best?.orgId ?? null,
+            matchedCompanyEmployeeCount: null
         });
     }
     return results;
@@ -1021,6 +1662,199 @@ function normalizeLinkedInCompanyHandle(value) {
 function normalizeLinkedInCompanyPage(handle) {
     return `https://www.linkedin.com/company/${handle}`;
 }
+function rewriteLinkedInUrlForConfiguredBase(url, env = process.env) {
+    const overrideBase = env.SALESPROMPTER_LINKEDIN_BASE_URL?.trim();
+    if (!overrideBase) {
+        return url;
+    }
+    try {
+        const source = new URL(url);
+        if (!/(^|\.)linkedin\.com$/i.test(source.hostname)) {
+            return url;
+        }
+        const targetBase = new URL(overrideBase);
+        targetBase.pathname = source.pathname;
+        targetBase.search = source.search;
+        targetBase.hash = source.hash;
+        return targetBase.toString();
+    }
+    catch {
+        return url;
+    }
+}
+function extractDirectLookupNameParts(contact) {
+    return {
+        firstName: normalizeLookupWhitespace(contact.firstName),
+        lastName: normalizeLookupWhitespace(contact.lastName)
+    };
+}
+async function resolveDomainFromLinkedInCompanyUrl(params) {
+    const config = await readLinkedInDirectLookupConfig();
+    const targetUrl = rewriteLinkedInUrlForConfiguredBase(params.companyUrl);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.min(params.timeoutMs, 20_000));
+    try {
+        const response = await fetch(targetUrl, {
+            method: "GET",
+            signal: controller.signal,
+            headers: {
+                accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "accept-language": "en-GB,en-US;q=0.9,en;q=0.8",
+                "user-agent": config.userAgent,
+                cookie: config.cookie
+            }
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const html = await response.text();
+        const parsed = parseLinkedInCompanyPage(html, params.companyUrl);
+        return parsed.domain ?? null;
+    }
+    catch (error) {
+        if (error.name === "AbortError") {
+            throw new Error(`LinkedIn company page lookup timed out after ${params.timeoutMs}ms.`);
+        }
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function buildDirectEmailEnrichmentBatch(params) {
+    const parsedInput = directEmailEnrichmentInputRowArraySchema.parse(parseDirectEmailEnrichmentInput(params.rawInput));
+    if (parsedInput.length === 0) {
+        throw new Error("No contact rows found. Provide TSV/CSV/JSON input via --in.");
+    }
+    const clientId = resolveDirectEmailEnrichmentClientId(parsedInput, params.clientIdOption);
+    const lookupRows = parsedInput.map((row) => ({
+        clientId: String(clientId),
+        fullName: row.fullName,
+        companyName: row.companyName
+    }));
+    const cleanedCompanyMap = await buildCompanyNameCleaningMap(lookupRows, params.companyCleaningMode);
+    const contacts = toLinkedInUrlLookupContacts(lookupRows, cleanedCompanyMap);
+    let companyEnrichmentByName = new Map();
+    if (!shouldBypassAuth()) {
+        const session = await requireAuthSession().catch(() => null);
+        if (session) {
+            const uniqueCompanies = Array.from(new Map(contacts
+                .filter((contact) => !contact.isVariation)
+                .map((contact) => {
+                const cleanedName = cleanedCompanyMap.get(normalizeLookupCompanyForCleaning(contact.companyNameOriginal ?? contact.companyName)) ??
+                    normalizeLookupWhitespace(contact.companyNameOriginal ?? contact.companyName);
+                return [
+                    normalizeLookupCompanyForCleaning(contact.companyNameOriginal ?? contact.companyName),
+                    {
+                        companyId: contact.contact_id,
+                        companyName: contact.companyNameOriginal ?? contact.companyName,
+                        companyNameCleaned: cleanedName || null
+                    }
+                ];
+            })).values());
+            if (uniqueCompanies.length > 0) {
+                const enrichedCompanies = await enrichDirectEmailCompaniesViaApp(session, {
+                    clientId,
+                    companies: uniqueCompanies
+                });
+                companyEnrichmentByName = new Map(enrichedCompanies.companies.map((company) => [
+                    normalizeLookupCompanyForCleaning(company.companyName),
+                    {
+                        domain: company.domain ?? null,
+                        linkedinCompanyPage: company.linkedinCompanyPage ?? null
+                    }
+                ]));
+            }
+        }
+    }
+    const [profileResult, companyResult] = await Promise.all([
+        invokeLinkedInUrlEnrichmentDirect({
+            contacts,
+            timeoutMs: params.timeoutMs
+        }),
+        companyEnrichmentByName.size > 0
+            ? Promise.resolve({
+                success: true,
+                contacts: contacts
+                    .filter((contact) => !contact.isVariation)
+                    .map((contact) => ({
+                    contact_id: contact.contact_id,
+                    linkedin_company_url: companyEnrichmentByName.get(normalizeLookupCompanyForCleaning(contact.companyNameOriginal ?? contact.companyName))?.linkedinCompanyPage ?? null,
+                    matched_company_name: null,
+                    matched_company_employee_count: null,
+                    error: null
+                }))
+            })
+            : invokeLinkedInCompanyEnrichmentDirect({
+                contacts,
+                timeoutMs: params.timeoutMs
+            })
+    ]);
+    const profileByContactId = new Map(profileResult.contacts.map((row) => [row.contact_id, row.linkedin_url ?? null]));
+    const companyByContactId = new Map(companyResult.contacts.map((row) => [row.contact_id, row.linkedin_company_url ?? null]));
+    const reportRows = [];
+    const queueRows = [];
+    for (let index = 0; index < contacts.length; index += 1) {
+        const contact = contacts[index];
+        if (contact.isVariation) {
+            continue;
+        }
+        const names = extractDirectLookupNameParts(contact);
+        const appCompanyEnrichment = companyEnrichmentByName.get(normalizeLookupCompanyForCleaning(contact.companyNameOriginal ?? contact.companyName)) ?? { domain: null, linkedinCompanyPage: null };
+        const linkedinCompanyUrl = appCompanyEnrichment.linkedinCompanyPage ??
+            companyByContactId.get(contact.contact_id) ??
+            null;
+        const domain = appCompanyEnrichment.domain ??
+            (linkedinCompanyUrl
+                ? await resolveDomainFromLinkedInCompanyUrl({
+                    companyUrl: linkedinCompanyUrl,
+                    timeoutMs: params.timeoutMs
+                })
+                : null);
+        let skippedReason = null;
+        if (!names.firstName || !names.lastName) {
+            skippedReason = "missing-name";
+        }
+        else if (!domain) {
+            skippedReason = "missing-domain";
+        }
+        const companyHandle = linkedinCompanyUrl ? normalizeLinkedInCompanyHandle(linkedinCompanyUrl) : null;
+        const numericCompanyId = companyHandle && /^\d+$/.test(companyHandle) ? companyHandle : String(index + 1);
+        const reportRow = {
+            contactId: contact.contact_id,
+            clientId: String(clientId),
+            companyId: numericCompanyId,
+            companyName: contact.companyNameOriginal ?? contact.companyName,
+            fullName: normalizeLookupWhitespace(`${names.firstName} ${names.lastName}`),
+            firstName: names.firstName,
+            lastName: names.lastName,
+            linkedinUrl: profileByContactId.get(contact.contact_id) ?? null,
+            linkedinCompanyUrl,
+            domain,
+            ready: skippedReason == null,
+            skippedReason
+        };
+        reportRows.push(reportRow);
+        if (!reportRow.ready || !domain) {
+            continue;
+        }
+        queueRows.push({
+            clientId: String(clientId),
+            contactId: contact.contact_id,
+            companyId: numericCompanyId,
+            firstName_cleaned: names.firstName,
+            lastName_cleaned: names.lastName,
+            domain,
+            companyScore: null,
+            seniorityId: null
+        });
+    }
+    return {
+        clientId,
+        queueRows,
+        reportRows
+    };
+}
 function titleCaseSlug(value) {
     return value
         .split(/[-_]/)
@@ -2105,6 +2939,17 @@ async function launchLinkedInCompaniesBackfill(session, payload) {
     }), LinkedInCompanyBackfillLaunchResponseSchema);
     return value;
 }
+async function enrichDirectEmailCompaniesViaApp(session, payload) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/email-enrichment/companies`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify(payload)
+    }), CliEmailEnrichmentCompaniesResponseSchema);
+    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)}`, {
         method: "GET",
@@ -3667,6 +4512,7 @@ program.configureHelp({
 });
 program.addHelpText("after", `
 LLM operator tips:
+  - New here? Create your account at https://salesprompter.ai/sign-up, then run: salesprompter auth:login
   - Prefer non-interactive auth: set SALESPROMPTER_TOKEN (+ optional SALESPROMPTER_API_BASE_URL).
   - Use machine output for tools: add --json.
   - One-shot leads flow: leads:pipeline --icp <path> --domain <company.com> --count <n>.
@@ -3773,6 +4619,7 @@ program
     .option("--org-id <id>", "Optional Sales Nav workspace org id for the lookup-first pass.")
     .option("--external-user-id <id>", "Deprecated compatibility option. Ignored by the direct CLI lookup.")
     .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);
@@ -3791,12 +4638,15 @@ program
             sessionOrgId = "";
         }
     }
-    const contacts = toLinkedInUrlLookupContacts(rows);
+    const companyCleaningMode = resolveCompanyCleaningMode(String(options.companyCleaning ?? process.env.SALESPROMPTER_COMPANY_CLEANING_MODE ?? "basic"));
+    const cleanedCompanyMap = await buildCompanyNameCleaningMap(rows, companyCleaningMode);
+    const contacts = toLinkedInUrlLookupContacts(rows, cleanedCompanyMap);
     if (options.dryRun) {
         const payload = {
             status: "ok",
             dryRun: true,
             orgId: String(options.orgId ?? "").trim() || null,
+            companyCleaningMode,
             contacts: contacts.length,
             sample: contacts.slice(0, 5)
         };
@@ -3831,11 +4681,41 @@ program
             }
         }
     }
+    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
+            }
+        ]));
+        for (const row of enrichedRows) {
+            const company = companyByContactId.get(row.contactId);
+            if (!company || row.linkedinCompanyUrl) {
+                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;
+            row.matchedCompanyEmployeeCount =
+                company.matchedCompanyEmployeeCount ?? row.matchedCompanyEmployeeCount ?? null;
+        }
+    }
+    catch (error) {
+        writeProgress(`Skipping separate company enrichment: ${error instanceof Error ? error.message : String(error)}`);
+    }
     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
     };
@@ -5818,6 +6698,123 @@ program
         execution
     });
 });
+program
+    .command("contacts:process-emails")
+    .alias("contacts:resolve-emails")
+    .alias("hunter-emailfinder:run:bq")
+    .description("Process the next batch of contact email enrichment for a workspace.")
+    .option("--client-id <number>", "Queue clientId to process")
+    .option("--in <path>", "Optional TSV/CSV/JSON input path with company and contact rows")
+    .option("--limit <number>", "Max queue rows to fetch", "500")
+    .requiredOption("--out-dir <path>", "Output directory for artifacts")
+    .option("--trace-id <traceId>", "Trace id for this batch")
+    .option("--endpoint-url <url>", "Override the enrichment workflow endpoint")
+    .option("--timeout-ms <number>", "Workflow trigger timeout in milliseconds", "30000")
+    .option("--company-cleaning <mode>", "Company cleaning mode for direct input: off, basic, or ai", "basic")
+    .option("--dry-run", "Preview the next batch without starting background processing", false)
+    .action(async (options) => {
+    const limit = z.coerce.number().int().min(1).max(50000).parse(options.limit);
+    const outDir = z.string().min(1).parse(options.outDir);
+    const timeoutMs = z.coerce.number().int().min(1000).max(300000).parse(options.timeoutMs);
+    const usingDirectInput = typeof options.in === "string" && options.in.trim().length > 0;
+    const companyCleaningMode = resolveCompanyCleaningMode(String(options.companyCleaning ?? process.env.SALESPROMPTER_COMPANY_CLEANING_MODE ?? "basic"));
+    let clientId;
+    let queueRows;
+    let directReportRows = null;
+    let queueSqlPath = null;
+    let directReportPath = null;
+    if (usingDirectInput) {
+        const rawInput = await readFile(options.in, "utf8");
+        const directBatch = await buildDirectEmailEnrichmentBatch({
+            rawInput,
+            clientIdOption: options.clientId,
+            timeoutMs,
+            companyCleaningMode
+        });
+        clientId = directBatch.clientId;
+        queueRows = directBatch.queueRows.slice(0, limit);
+        directReportRows = directBatch.reportRows;
+    }
+    else {
+        clientId = z.coerce.number().int().positive().parse(options.clientId);
+        queueSqlPath = `${outDir}/email-enrichment-input-${clientId}.sql`;
+        const queueSql = buildHunterEmailfinderQueueSql(clientId, limit);
+        await writeTextFile(queueSqlPath, `${queueSql}\n`);
+        const rawQueueRows = await runBigQueryRows(queueSql, { maxRows: limit });
+        queueRows = hunterEmailfinderQueueRowArraySchema.parse(rawQueueRows);
+    }
+    const traceId = z.string().min(1).parse(options.traceId ?? `salesprompter-cli-email-${clientId}-${Date.now()}`);
+    const queueRowsPath = `${outDir}/email-enrichment-input-${clientId}.json`;
+    const requestPath = `${outDir}/email-enrichment-request-${clientId}.json`;
+    const responsePath = `${outDir}/email-enrichment-response-${clientId}.json`;
+    await writeJsonFile(queueRowsPath, queueRows);
+    if (directReportRows) {
+        directReportPath = `${outDir}/email-enrichment-direct-${clientId}.json`;
+        await writeJsonFile(directReportPath, {
+            clientId,
+            companyCleaningMode,
+            rows: directReportRows
+        });
+    }
+    const payload = buildHunterEmailfinderTriggerPayload({
+        traceId,
+        clientId: String(clientId),
+        queueRows
+    });
+    await writeJsonFile(requestPath, {
+        traceId,
+        clientId,
+        queueRows: queueRows.length,
+        payload
+    });
+    let trigger = null;
+    if (!options.dryRun && queueRows.length > 0) {
+        const config = readHunterEmailfinderConfig(process.env, options.endpointUrl);
+        const result = await triggerHunterEmailfinderWorkflow({
+            config,
+            externalUserId: `email-enrichment-client-${clientId}`,
+            timeoutMs,
+            payload
+        });
+        trigger = {
+            triggered: result.response.ok,
+            status: result.response.status
+        };
+        await writeJsonFile(responsePath, {
+            traceId,
+            clientId,
+            status: result.response.status,
+            ok: result.response.ok,
+            endpoint: result.endpoint,
+            body: result.parsedBody
+        });
+        if (!result.response.ok) {
+            throw new Error(`Email enrichment workflow returned ${result.response.status}: ${result.bodyText || "No response body"}`);
+        }
+    }
+    printOutput({
+        status: "ok",
+        clientId,
+        limit,
+        traceId,
+        dryRun: Boolean(options.dryRun),
+        mode: usingDirectInput ? "direct-input" : "workspace-queue",
+        companyCleaningMode: usingDirectInput ? companyCleaningMode : null,
+        contactsRead: directReportRows?.length ?? null,
+        contactsQueued: queueRows.length,
+        started: Boolean(trigger?.triggered),
+        profilesFound: directReportRows ? directReportRows.filter((row) => row.linkedinUrl).length : null,
+        companiesFound: directReportRows ? directReportRows.filter((row) => row.linkedinCompanyUrl).length : null,
+        domainsFound: directReportRows ? directReportRows.filter((row) => row.domain).length : null,
+        artifacts: {
+            inputSqlPath: queueSqlPath,
+            inputRowsPath: queueRowsPath,
+            directReportPath,
+            requestPath,
+            responsePath: trigger ? responsePath : null
+        }
+    });
+});
 async function main() {
     if (shouldAutoRunWizard(process.argv)) {
         await runWizard();