salesprompter-cli 0.1.22 → 0.1.24

package/dist/cli.js

@@ -14,11 +14,14 @@ import { clearAuthSession, loginWithBrowserConnect, loginWithDeviceFlow, loginWi
 import { buildBigQueryLeadLookupSql, executeBigQuerySql, normalizeBigQueryLeadRows, runBigQueryQuery, runBigQueryRows } from "./bigquery.js";
 import { AccountProfileSchema, EnrichedLeadSchema, IcpSchema, LeadSchema, ScoredLeadSchema, SyncTargetSchema } from "./domain.js";
 import { auditDomainDecisions, buildDomainfinderBacklogQueries, buildDomainfinderCandidatesSql, buildDomainfinderInputSql, buildDomainfinderWritebackSql, buildExistingDomainRepairSql, buildExistingDomainAuditQueries, compareDomainSelectionStrategies, selectBestDomains } from "./domainfinder.js";
+import { buildDeelSalesNavCsvHeader, buildDeelSalesNavCsvLines, isDeelRelevantSalesNavTitle, normalizeDeelSalesNavRow } from "./deel-salesnav.js";
+import { buildDeelLeadPoolContactSql, buildDeelOutreachExportSql, buildDeelOutreachPack, normalizeDeelOutreachRows } from "./deel-outreach.js";
 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 { buildHistoricalVendorIcp, buildVendorIcp } from "./icp-templates.js";
 import { InstantlySyncProvider } from "./instantly.js";
+import { backfillLinkedInCompanies } from "./linkedin-companies.js";
 import { crawlLinkedInProductCategory } from "./linkedin-products.js";
 import { claimValidatedSalesNavigatorSessionCookieForCli } from "./linkedin-session.js";
 import { buildLeadlistsFunnelQueries } from "./leadlists-funnel.js";
@@ -54,6 +57,27 @@ const LinkedInProductIngestResponseSchema = z.object({
     upserted: z.number().int().nonnegative(),
     totalInCatalog: z.number().int().nonnegative().optional()
 });
+const LinkedInCompanyBackfillLaunchResponseSchema = z.object({
+    clientId: z.number().int().positive(),
+    launched: z.boolean(),
+    agentId: z.string().min(1),
+    webhookUrl: z.string().url(),
+    inputUrl: z.string().url().nullable(),
+    containerId: z.string().min(1).nullable(),
+    candidates: z.array(z.object({
+        companyId: z.number().int().positive(),
+        companyUrl: z.string().url(),
+        companyName: z.string().nullable().optional(),
+        companyFilter: z.string().nullable().optional()
+    }))
+});
+const LinkedInCompanyBackfillStatusResponseSchema = z.object({
+    status: z.literal("ok"),
+    containerId: z.string().min(1),
+    running: z.boolean(),
+    processed: z.boolean(),
+    remaining: z.number().int().nonnegative()
+});
 const SalesNavigatorLaunchDiagnosticsSchema = z.object({
     orderedCandidateAgentIds: z.array(z.string().min(1)),
     runningAgentIds: z.array(z.string().min(1)),
@@ -212,6 +236,40 @@ const SalesNavigatorCrawlReportResponseSchema = z.object({
     status: z.literal("ok"),
     job: SalesNavigatorCrawlJobSummarySchema
 });
+const helpAliasByCommandName = new Map([
+    ["contacts:find-linkedin-urls", "contacts:resolve-profiles"],
+    ["linkedin-companies:backfill", "companies:enrich"],
+    ["linkedin-products:scrape", "market:scrape"],
+    ["salesnav:from-product-category", "leads:discover"],
+    ["salesnav:crawl", "search:run"],
+    ["salesnav:crawl:status", "search:status"],
+    ["salesnav:export", "search:export"],
+    ["salesnav:count", "search:count"]
+]);
+const helpVisibleCommandNames = new Set([
+    "auth:login",
+    "wizard",
+    "auth:whoami",
+    "llm:ready",
+    "contacts:find-linkedin-urls",
+    "auth:logout",
+    "account:resolve",
+    "icp:define",
+    "icp:vendor",
+    "leads:generate",
+    "leads:enrich",
+    "leads:score",
+    "leads:pipeline",
+    "sync:crm",
+    "sync:outreach",
+    "linkedin-companies:backfill",
+    "linkedin-products:scrape",
+    "salesnav:from-product-category",
+    "salesnav:crawl",
+    "salesnav:crawl:status",
+    "salesnav:export",
+    "salesnav:count"
+]);
 function printOutput(value) {
     if (runtimeOutputOptions.quiet) {
         return;
@@ -225,6 +283,13 @@ function writeProgress(message) {
     }
     process.stderr.write(`${message}\n`);
 }
+function formatHelpArgumentTerm(argument) {
+    const term = argument.name();
+    if (argument.variadic) {
+        return argument.required ? `<${term}...>` : `[${term}...]`;
+    }
+    return argument.required ? `<${term}>` : `[${term}]`;
+}
 function applyGlobalOutputOptions(actionCommand) {
     const globalOptions = actionCommand.optsWithGlobals();
     runtimeOutputOptions.json = Boolean(globalOptions.json);
@@ -329,6 +394,27 @@ function canPromptForInteractiveLogin() {
     }
     return Boolean(process.stdin.isTTY && process.stderr.isTTY);
 }
+function resolveNonInteractiveAuthToken(env = process.env) {
+    const token = env.SALESPROMPTER_TOKEN?.trim() ||
+        env.SALESPROMPTER_API_TOKEN?.trim() ||
+        env.SALESPROMPTER_AUTH_TOKEN?.trim() ||
+        "";
+    return token.length > 0 ? token : null;
+}
+async function readAllStdin() {
+    if (process.stdin.isTTY) {
+        return "";
+    }
+    return await new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", reject);
+    });
+}
 async function ensureInteractiveAuthSession(apiUrl) {
     if (!canPromptForInteractiveLogin()) {
         return;
@@ -345,6 +431,523 @@ function shellQuote(value) {
     }
     return `'${value.replaceAll("'", "'\\''")}'`;
 }
+function splitLooseDelimitedLine(line, delimiter) {
+    if (delimiter !== ",") {
+        return line.split(delimiter);
+    }
+    const values = [];
+    let current = "";
+    let inQuotes = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const character = line[index];
+        const nextCharacter = line[index + 1];
+        if (character === '"') {
+            if (inQuotes && nextCharacter === '"') {
+                current += '"';
+                index += 1;
+                continue;
+            }
+            inQuotes = !inQuotes;
+            continue;
+        }
+        if (character === "," && !inQuotes) {
+            values.push(current);
+            current = "";
+            continue;
+        }
+        current += character;
+    }
+    values.push(current);
+    return values;
+}
+function detectLooseDelimiter(sampleLine) {
+    if (sampleLine.includes("\t")) {
+        return "\t";
+    }
+    if (sampleLine.includes(";")) {
+        return ";";
+    }
+    return ",";
+}
+function normalizeLooseMatchText(value) {
+    return String(value ?? "")
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/ß/g, "ss")
+        .toLowerCase()
+        .replace(/&/g, " and ")
+        .replace(/[^a-z0-9]+/g, " ")
+        .replace(/\b(gmbh|mbh|co|kg|ohg|ag|ltd|limited|ges|gesellschaft|m|b|h|und|and)\b/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function normalizeLookupWhitespace(value) {
+    return String(value ?? "")
+        .replace(/[\u2010-\u2015]/g, "-")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function stripLookupHonorifics(value) {
+    return value.replace(/^(dr\.?|dipl\.-?ing\.?|prof\.?|ing\.?|mag\.?)\s+/i, "").trim();
+}
+function normalizeLookupCompanyForSearch(value) {
+    return normalizeLookupWhitespace(value)
+        .replace(/[+]/g, " ")
+        .replace(/\s*-\s*/g, " ")
+        .replace(/[.,]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function splitLookupFullName(fullName) {
+    const parts = normalizeLookupWhitespace(fullName).split(" ").filter(Boolean);
+    return {
+        firstName: parts[0] ?? "",
+        lastName: parts.slice(1).join(" ")
+    };
+}
+function buildSyntheticLookupEmail(contactId) {
+    return `linkedin-lookup+${contactId}@salesprompter.invalid`;
+}
+function looksLikeLookupCompanyRow(fullName, companyName) {
+    const fullNameComparable = normalizeLooseMatchText(fullName);
+    const companyComparable = normalizeLooseMatchText(companyName);
+    if (!fullNameComparable || !companyComparable) {
+        return false;
+    }
+    return (fullNameComparable === companyComparable ||
+        fullNameComparable.includes(companyComparable) ||
+        companyComparable.includes(fullNameComparable));
+}
+function parseLinkedInUrlLookupInput(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(),
+            fullName: z.string().nullish(),
+            companyName: z.string().nullish(),
+            email: z.string().nullish(),
+            jobTitle: z.string().nullish()
+        }))
+            .parse(JSON.parse(trimmed));
+        return parsed
+            .map((row) => ({
+            clientId: row.clientId == null ? null : String(row.clientId).trim() || null,
+            fullName: row.fullName?.trim() ?? "",
+            companyName: row.companyName?.trim() ?? "",
+            email: row.email?.trim() || undefined,
+            jobTitle: row.jobTitle?.trim() || undefined
+        }))
+            .filter((row) => row.fullName.length > 0 || 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("fullname") ||
+        headerValues.includes("full_name") ||
+        headerValues.includes("companyname") ||
+        headerValues.includes("company_name");
+    const dataLines = hasHeader ? lines.slice(1) : lines;
+    const clientIdIndex = hasHeader
+        ? headerValues.findIndex((value) => ["clientid", "client_id"].includes(value))
+        : 0;
+    const fullNameIndex = hasHeader
+        ? headerValues.findIndex((value) => ["fullname", "full_name", "contact_name", "name"].includes(value))
+        : 1;
+    const companyNameIndex = hasHeader
+        ? headerValues.findIndex((value) => ["companyname", "company_name"].includes(value))
+        : 2;
+    const emailIndex = hasHeader ? headerValues.findIndex((value) => value === "email") : -1;
+    const jobTitleIndex = hasHeader
+        ? headerValues.findIndex((value) => ["jobtitle", "job_title", "title"].includes(value))
+        : -1;
+    return dataLines
+        .map((line) => splitLooseDelimitedLine(line, delimiter).map((value) => value.trim()))
+        .map((columns) => ({
+        clientId: clientIdIndex >= 0 ? columns[clientIdIndex] || null : null,
+        fullName: fullNameIndex >= 0 ? columns[fullNameIndex] || "" : "",
+        companyName: companyNameIndex >= 0 ? columns[companyNameIndex] || "" : "",
+        email: emailIndex >= 0 ? columns[emailIndex] || undefined : undefined,
+        jobTitle: jobTitleIndex >= 0 ? columns[jobTitleIndex] || undefined : undefined
+    }))
+        .filter((row) => row.fullName.length > 0 || row.companyName.length > 0);
+}
+function toLinkedInUrlLookupContacts(rows) {
+    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 rawFullName = normalizeLookupWhitespace(row.fullName);
+        if (looksLikeLookupCompanyRow(rawFullName, rawCompanyName)) {
+            return [
+                {
+                    contact_id: contactId,
+                    firstName: "",
+                    lastName: "",
+                    companyName: cleanedCompanyName,
+                    companyNameOriginal: rawCompanyName || undefined,
+                    email: syntheticEmail,
+                    jobTitle: row.jobTitle
+                }
+            ];
+        }
+        const cleanedFullName = stripLookupHonorifics(rawFullName);
+        const rawSplit = splitLookupFullName(rawFullName);
+        const cleanedSplit = splitLookupFullName(cleanedFullName);
+        const contacts = [
+            {
+                contact_id: contactId,
+                firstName: cleanedSplit.firstName,
+                lastName: cleanedSplit.lastName,
+                companyName: cleanedCompanyName,
+                companyNameOriginal: rawCompanyName || undefined,
+                email: syntheticEmail,
+                jobTitle: row.jobTitle
+            }
+        ];
+        const rawDiffers = rawSplit.firstName !== cleanedSplit.firstName ||
+            rawSplit.lastName !== cleanedSplit.lastName;
+        if (rawDiffers && (rawSplit.firstName || rawSplit.lastName)) {
+            contacts.push({
+                contact_id: contactId,
+                firstName: rawSplit.firstName,
+                lastName: rawSplit.lastName,
+                companyName: cleanedCompanyName,
+                companyNameOriginal: rawCompanyName || undefined,
+                email: syntheticEmail,
+                jobTitle: row.jobTitle,
+                isVariation: true
+            });
+        }
+        return contacts;
+    });
+}
+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`
+            : "");
+    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() || ""
+    };
+}
+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() ||
+        "";
+    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";
+    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 {
+        csrfToken,
+        identity,
+        cookie,
+        userAgent
+    };
+}
+function generateLinkedInSessionId() {
+    return Array.from({ length: 22 }, () => "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".charAt(Math.floor(Math.random() * 62))).join("");
+}
+function buildLinkedInSalesApiUrl(firstName, lastName, companyName) {
+    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`;
+}
+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;
+}
+async function invokeLinkedInUrlEnrichmentDirect(params) {
+    const config = readLinkedInDirectLookupConfig();
+    const groupedContacts = new Map();
+    for (const contact of params.contacts) {
+        const key = contact.email?.trim().toLowerCase() || `contact:${contact.contact_id}`;
+        const existing = groupedContacts.get(key) ?? [];
+        existing.push(contact);
+        groupedContacts.set(key, existing);
+    }
+    const results = [];
+    let rateLimited = false;
+    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) {
+            results.push({
+                contact_id: primary.contact_id,
+                linkedin_url: null,
+                error: "LinkedIn rate limit"
+            });
+            continue;
+        }
+        if (blankPerson) {
+            results.push({
+                contact_id: primary.contact_id,
+                linkedin_url: null,
+                error: "Skipped blank or company-only row"
+            });
+            continue;
+        }
+        let matchedUrl = null;
+        let lastError = null;
+        for (const candidate of variations) {
+            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), {
+                    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);
+            }
+        }
+        results.push({
+            contact_id: primary.contact_id,
+            linkedin_url: matchedUrl,
+            error: matchedUrl ? null : lastError
+        });
+    }
+    return {
+        success: true,
+        contacts: results
+    };
+}
+async function invokeLinkedInUrlEnrichmentWorkflow(params) {
+    const config = readPipedreamLinkedInEnrichmentConfig();
+    const endpoint = new URL(config.endpointUrl);
+    if (config.secret && !endpoint.searchParams.has("secret")) {
+        endpoint.searchParams.set("secret", config.secret);
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), params.timeoutMs);
+    const headers = {
+        "Content-Type": "application/json",
+        "x-pd-external-user-id": params.externalUserId
+    };
+    if (config.secret) {
+        headers.Authorization = `Bearer ${config.secret}`;
+        headers["x-pd-secret"] = config.secret;
+        headers["x-secret-key"] = config.secret;
+    }
+    if (config.clientId) {
+        headers["X-Client-ID"] = config.clientId;
+    }
+    if (config.projectId) {
+        headers["X-Project-ID"] = config.projectId;
+    }
+    if (config.projectEnvironment) {
+        headers["X-Environment"] = config.projectEnvironment;
+        headers["x-pd-environment"] = config.projectEnvironment;
+    }
+    const payload = {
+        action: "find_linkedin_urls",
+        workflow_target: "find_contact_linkedin_urls",
+        app_source: "salesprompter_cli",
+        integration: "hubspot",
+        integration_type: "hubspot",
+        trigger_source: "cli_bulk_linkedin_url_lookup",
+        contact_count: params.contacts.length,
+        contacts: params.contacts,
+        payload: {
+            contacts: params.contacts
+        }
+    };
+    try {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+            signal: controller.signal
+        });
+        const bodyText = await response.text();
+        let parsedBody = null;
+        try {
+            parsedBody = bodyText ? JSON.parse(bodyText) : null;
+        }
+        catch {
+            parsedBody = bodyText;
+        }
+        return {
+            response,
+            bodyText,
+            parsedBody,
+            payload,
+            endpoint: endpoint.toString()
+        };
+    }
+    catch (error) {
+        if (error.name === "AbortError") {
+            throw new Error(`LinkedIn enrichment workflow timed out after ${params.timeoutMs}ms.`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function fetchSalesNavLookupCandidates(params) {
+    const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL?.trim();
+    const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY?.trim();
+    if (!supabaseUrl || !serviceRoleKey || !params.companyName.trim()) {
+        return [];
+    }
+    const supabase = createClient(supabaseUrl, serviceRoleKey, {
+        auth: {
+            autoRefreshToken: false,
+            persistSession: false
+        }
+    });
+    const mapRows = (rows) => rows.map((row) => ({
+        orgId: row.org_id == null ? null : String(row.org_id),
+        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),
+        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")
+            .limit(10);
+        if (params.orgId?.trim()) {
+            query = query.eq("org_id", params.orgId.trim());
+        }
+        query = operator === "eq" ? query.eq("company_name", value) : query.ilike("company_name", value);
+        const response = await query;
+        if (response.error) {
+            throw new Error(`Sales Nav people lookup failed with ${response.error.message}`);
+        }
+        return mapRows((response.data ?? []));
+    };
+    const exactRows = await fetchRows("eq", params.companyName);
+    if (exactRows.length > 0) {
+        return exactRows;
+    }
+    return await fetchRows("ilike", `%${params.companyName}%`);
+}
+async function resolveLinkedInUrlsFromSalesNavRows(params) {
+    const results = [];
+    for (const [index, row] of params.rows.entries()) {
+        const candidates = await fetchSalesNavLookupCandidates({
+            companyName: row.companyName,
+            orgId: params.orgId
+        });
+        const normalizedName = normalizeLooseMatchText(row.fullName);
+        const normalizedCompany = normalizeLooseMatchText(row.companyName);
+        const ranked = candidates
+            .map((candidate) => {
+            const candidateName = normalizeLooseMatchText(candidate.fullName);
+            const candidateCompany = normalizeLooseMatchText(candidate.companyName);
+            let score = 0;
+            if (normalizedCompany && candidateCompany === normalizedCompany)
+                score += 100;
+            else if (normalizedCompany &&
+                (candidateCompany.includes(normalizedCompany) || normalizedCompany.includes(candidateCompany))) {
+                score += 60;
+            }
+            if (normalizedName && candidateName === normalizedName)
+                score += 100;
+            else if (normalizedName &&
+                (candidateName.includes(normalizedName) || normalizedName.includes(candidateName))) {
+                score += 50;
+            }
+            if (!normalizedName && candidateCompany) {
+                score += 5;
+            }
+            return { candidate, score };
+        })
+            .filter((entry) => entry.score >= (normalizedName ? 120 : 60))
+            .sort((left, right) => {
+            const leftUrl = left.candidate.linkedInProfileUrl ?? left.candidate.salesNavProfileUrl;
+            const rightUrl = right.candidate.linkedInProfileUrl ?? right.candidate.salesNavProfileUrl;
+            return right.score - left.score || Number(Boolean(rightUrl)) - Number(Boolean(leftUrl));
+        });
+        const best = ranked[0]?.candidate;
+        const linkedinUrl = best?.linkedInProfileUrl ?? best?.salesNavProfileUrl ?? null;
+        results.push({
+            clientId: row.clientId,
+            fullName: row.fullName,
+            companyName: row.companyName,
+            linkedinUrl,
+            found: Boolean(linkedinUrl),
+            contactId: String(index + 1),
+            source: linkedinUrl ? "salesnav-supabase" : null,
+            matchedFullName: best?.fullName ?? null,
+            matchedCompanyName: best?.companyName ?? null,
+            matchedTitle: best?.title ?? null,
+            matchedOrgId: best?.orgId ?? null
+        });
+    }
+    return results;
+}
 function buildCommandLine(args) {
     return args.map((arg) => shellQuote(arg)).join(" ");
 }
@@ -359,6 +962,24 @@ function slugify(value) {
         .replace(/^-+|-+$/g, "")
         .replace(/-{2,}/g, "-");
 }
+function resolveSalesNavigatorSupabaseConfig(env = process.env) {
+    const supabaseUrl = env.SALESPROMPTER_SUPABASE_URL?.trim() || env.NEXT_PUBLIC_SUPABASE_URL?.trim() || "";
+    const supabaseServiceRoleKey = env.SUPABASE_SERVICE_ROLE_KEY?.trim() || "";
+    const missing = [];
+    if (supabaseUrl.length === 0) {
+        missing.push("SALESPROMPTER_SUPABASE_URL or NEXT_PUBLIC_SUPABASE_URL");
+    }
+    if (supabaseServiceRoleKey.length === 0) {
+        missing.push("SUPABASE_SERVICE_ROLE_KEY");
+    }
+    if (missing.length > 0) {
+        throw new Error(`Missing required environment variables for Sales Navigator Supabase export: ${missing.join(", ")}`);
+    }
+    return {
+        supabaseUrl,
+        supabaseServiceRoleKey
+    };
+}
 function normalizeDomainInput(value) {
     return value
         .trim()
@@ -441,6 +1062,26 @@ function parseCompanyReference(value) {
         })
     };
 }
+function chunkArray(values, size) {
+    const chunks = [];
+    for (let index = 0; index < values.length; index += size) {
+        chunks.push(values.slice(index, index + size));
+    }
+    return chunks;
+}
+function extractSalesNavContactId(url) {
+    if (!url) {
+        return null;
+    }
+    try {
+        const parsed = new URL(url);
+        const segments = parsed.pathname.split("/").filter((segment) => segment.length > 0);
+        return segments.length > 0 ? segments[segments.length - 1] : null;
+    }
+    catch {
+        return null;
+    }
+}
 function writeWizardLine(message = "") {
     process.stdout.write(`${message}\n`);
 }
@@ -461,6 +1102,10 @@ function getOrgLabel(session) {
     }
     return label;
 }
+function resolveSessionOrgId(session) {
+    const orgId = session.user.orgId?.trim();
+    return orgId && orgId.length > 0 ? orgId : null;
+}
 function writeSessionSummary(session) {
     const identity = session.user.name?.trim()
         ? `${session.user.name} (${session.user.email})`
@@ -702,6 +1347,50 @@ async function ensureWizardSession(options) {
     writeWizardLine();
     return result.session;
 }
+async function resolveLlmAuthReadiness() {
+    const apiBaseUrl = process.env.SALESPROMPTER_API_BASE_URL?.trim() || "https://salesprompter.ai";
+    const envToken = resolveNonInteractiveAuthToken(process.env);
+    if (envToken) {
+        try {
+            const session = await loginWithToken(envToken, apiBaseUrl);
+            return {
+                ready: true,
+                mode: "env_token",
+                apiBaseUrl: session.apiBaseUrl,
+                user: session.user,
+                reason: null
+            };
+        }
+        catch (error) {
+            return {
+                ready: false,
+                mode: "env_token",
+                apiBaseUrl,
+                user: null,
+                reason: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    try {
+        const session = await requireAuthSession();
+        return {
+            ready: true,
+            mode: "session",
+            apiBaseUrl: session.apiBaseUrl,
+            user: session.user,
+            reason: null
+        };
+    }
+    catch (error) {
+        return {
+            ready: false,
+            mode: "none",
+            apiBaseUrl,
+            user: null,
+            reason: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
 async function fetchWorkspaceLeadSearch(session, requestBody) {
     const response = await fetch(`${session.apiBaseUrl}/api/cli/leads/search`, {
         method: "POST",
@@ -762,10 +1451,14 @@ function decodeSalesNavigatorQueryParam(url) {
 async function createWorkflowLogger(options) {
     const traceId = options.traceId ?? buildWorkflowTraceId("salesprompter-cli");
     const logPath = options.logPath;
+    let eventStore = options.eventStore ?? null;
     await mkdir(path.dirname(logPath), { recursive: true });
     return {
         traceId,
         logPath,
+        setEventStore: (nextEventStore) => {
+            eventStore = nextEventStore;
+        },
         log: async (event, metadata = {}) => {
             const entry = {
                 timestamp: new Date().toISOString(),
@@ -774,10 +1467,111 @@ async function createWorkflowLogger(options) {
                 metadata
             };
             await appendFile(logPath, `${JSON.stringify(entry)}\n`, "utf8");
+            if (eventStore) {
+                try {
+                    await eventStore.append({
+                        jobId: typeof metadata.jobId === "string" ? metadata.jobId : null,
+                        event,
+                        timestamp: entry.timestamp,
+                        traceId,
+                        source: "cli",
+                        metadata
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    writeProgress(`[${entry.timestamp}] salesnav.event_store.write_failed: ${message}`);
+                }
+            }
             writeProgress(`[${entry.timestamp}] ${event}`);
         }
     };
 }
+function resolveSalesNavigatorRunEventsTable(env = process.env) {
+    return env.SALESPROMPTER_SALESNAV_RUN_EVENTS_TABLE?.trim() || "salesnav_crawl_run_events";
+}
+function resolveSalesNavigatorPhantomLaneLimit(env = process.env) {
+    const raw = env.SALESPROMPTER_SALESNAV_PHANTOM_LANES?.trim();
+    const parsed = raw ? Number(raw) : Number.NaN;
+    if (!Number.isFinite(parsed) || parsed < 1) {
+        return 3;
+    }
+    return Math.max(1, Math.floor(parsed));
+}
+function isMissingSupabaseTableError(code, message) {
+    const normalized = message.toLowerCase();
+    return code === "42P01" || normalized.includes("does not exist");
+}
+async function createSalesNavigatorCrawlEventStore(options) {
+    const config = (() => {
+        try {
+            return resolveSalesNavigatorSupabaseConfig(process.env);
+        }
+        catch {
+            return null;
+        }
+    })();
+    if (!config) {
+        return null;
+    }
+    const table = resolveSalesNavigatorRunEventsTable(process.env);
+    const client = createClient(config.supabaseUrl, config.supabaseServiceRoleKey, {
+        auth: {
+            persistSession: false,
+            autoRefreshToken: false
+        }
+    });
+    let writable = true;
+    return {
+        append: async (entry) => {
+            if (!writable) {
+                return;
+            }
+            const { error } = await client.from(table).insert({
+                org_id: options.orgId,
+                job_id: entry.jobId,
+                event: entry.event,
+                event_time: entry.timestamp,
+                trace_id: entry.traceId,
+                source: entry.source,
+                payload: entry.metadata
+            });
+            if (!error) {
+                return;
+            }
+            if (isMissingSupabaseTableError(error.code, error.message)) {
+                writable = false;
+                return;
+            }
+            throw new Error(`Failed to write crawl event to Supabase: ${error.message}`);
+        },
+        listRecentForJob: async (jobId, limit) => {
+            const { data, error } = await client
+                .from(table)
+                .select("job_id,event,event_time,trace_id,source,payload")
+                .eq("org_id", options.orgId)
+                .eq("job_id", jobId)
+                .order("event_time", { ascending: false })
+                .limit(limit);
+            if (error) {
+                if (isMissingSupabaseTableError(error.code, error.message)) {
+                    return [];
+                }
+                throw new Error(`Failed to fetch crawl events from Supabase: ${error.message}`);
+            }
+            return (data ?? []).map((row) => ({
+                jobId: typeof row.job_id === "string" ? row.job_id : null,
+                event: typeof row.event === "string" ? row.event : "unknown",
+                timestamp: typeof row.event_time === "string" ? row.event_time : new Date().toISOString(),
+                traceId: typeof row.trace_id === "string" ? row.trace_id : null,
+                source: "cli",
+                metadata: row.payload && typeof row.payload === "object" && !Array.isArray(row.payload)
+                    ? row.payload
+                    : {}
+            }));
+        }
+    };
+}
 function summarizeSalesNavigatorQuery(url, appliedFilters) {
     return {
         url,
@@ -1001,6 +1795,13 @@ async function runSalesNavigatorFromProductCategoryWorkflow(options) {
             return { outPath, payload };
         }
         let session = await requireAuthSession();
+        const sessionOrgId = resolveSessionOrgId(session);
+        if (sessionOrgId) {
+            const eventStore = await createSalesNavigatorCrawlEventStore({
+                orgId: sessionOrgId
+            });
+            logger.setEventStore(eventStore);
+        }
         let uploaded = null;
         if (!options.skipProductUpload) {
             await logger.log("linkedin.catalog.upload.started", {
@@ -1115,7 +1916,57 @@ async function runSalesNavigatorFromProductCategoryWorkflow(options) {
                 summary: crawlSummary
             });
         }
-        const summary = buildSalesNavigatorWorkflowSummary(crawls);
+        let summary = buildSalesNavigatorWorkflowSummary(crawls);
+        const sessionPoolBlocked = crawls.some((crawl) => crawl.lastOutcome?.errorCode === "blocked_no_valid_salesnav_session");
+        if (sessionPoolBlocked && sessionOrgId) {
+            try {
+                await logger.log("salesnav.bigquery-fallback.started", {
+                    orgId: sessionOrgId,
+                    scope: "all-sales-people",
+                    reason: "blocked_no_valid_salesnav_session",
+                    mode: "silent"
+                });
+                const fallbackConfig = resolveSalesNavigatorHistoricalBackfillConfig(process.env);
+                const fallbackSummary = await ensureSalesNavigatorPeopleCount({
+                    config: fallbackConfig,
+                    orgId: sessionOrgId,
+                    targetCount: Number.MAX_SAFE_INTEGER,
+                    scope: "all-sales-people",
+                    startOffset: 0,
+                    resumedFromHistory: false,
+                    windowSize: 2_500,
+                    maxWindows: 1,
+                    pageSize: salesNavigatorHistoricalBackfillDefaults.pageSize,
+                    upsertBatchSize: salesNavigatorHistoricalBackfillDefaults.upsertBatchSize,
+                    minUpsertBatchSize: salesNavigatorHistoricalBackfillDefaults.minUpsertBatchSize,
+                    maxUpsertRetries: salesNavigatorHistoricalBackfillDefaults.maxUpsertRetries,
+                    retryDelayMs: salesNavigatorHistoricalBackfillDefaults.retryDelayMs
+                });
+                const importedDelta = Math.max(0, fallbackSummary.currentCount - fallbackSummary.initialCount);
+                if (importedDelta > 0) {
+                    summary = {
+                        ...summary,
+                        workflowStatus: "completed",
+                        totalImportedPeople: summary.totalImportedPeople + importedDelta
+                    };
+                }
+                await logger.log("salesnav.bigquery-fallback.completed", {
+                    orgId: sessionOrgId,
+                    status: fallbackSummary.status,
+                    completedWindows: fallbackSummary.completedWindows,
+                    initialCount: fallbackSummary.initialCount,
+                    currentCount: fallbackSummary.currentCount,
+                    importedDelta
+                });
+            }
+            catch (fallbackError) {
+                await logger.log("salesnav.bigquery-fallback.failed", {
+                    orgId: sessionOrgId,
+                    message: fallbackError instanceof Error ? fallbackError.message : String(fallbackError),
+                    stack: fallbackError instanceof Error ? fallbackError.stack ?? null : null
+                });
+            }
+        }
         const payload = {
             status: "ok",
             dryRun: false,
@@ -1243,6 +2094,26 @@ async function uploadLinkedInProductsCatalog(session, payload, batchSize = 100,
     }
     return { imported, upserted };
 }
+async function launchLinkedInCompaniesBackfill(session, payload) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/linkedin-companies/backfill`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify(payload)
+    }), LinkedInCompanyBackfillLaunchResponseSchema);
+    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",
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`
+        }
+    }), LinkedInCompanyBackfillStatusResponseSchema);
+    return value;
+}
 function serializeSalesNavigatorFiltersForApi(filters) {
     return filters.map((filter) => ({
         type: filter.type,
@@ -1486,6 +2357,55 @@ function isSalesNavigatorAgentBusyError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /parallel executions limit/i.test(message);
 }
+async function drainLinkedInCompanyBackfill(session, payload) {
+    let batches = 0;
+    let startedCompanies = 0;
+    let remaining = 0;
+    let consecutiveBusyPolls = 0;
+    for (;;) {
+        let launched;
+        try {
+            launched = await launchLinkedInCompaniesBackfill(session, payload);
+        }
+        catch (error) {
+            if (isSalesNavigatorAgentBusyError(error)) {
+                consecutiveBusyPolls += 1;
+                if (consecutiveBusyPolls === 1) {
+                    writeProgress("Company enrichment is already running. Waiting for the current batch to finish...");
+                }
+                await delay(30_000);
+                continue;
+            }
+            throw error;
+        }
+        consecutiveBusyPolls = 0;
+        if (!launched.launched || !launched.containerId) {
+            return {
+                completed: true,
+                batches,
+                startedCompanies,
+                remaining: launched.candidates.length
+            };
+        }
+        batches += 1;
+        startedCompanies += launched.candidates.length;
+        writeProgress(`Started company enrichment batch ${batches} for ${launched.candidates.length} companies.`);
+        for (;;) {
+            const status = await fetchLinkedInCompaniesBackfillStatus(session, {
+                clientId: payload.clientId,
+                containerId: launched.containerId
+            });
+            remaining = status.remaining;
+            if (!status.running && status.processed) {
+                writeProgress(remaining > 0
+                    ? `${remaining} companies still waiting. Starting the next batch...`
+                    : "Company enrichment finished.");
+                break;
+            }
+            await delay(15_000);
+        }
+    }
+}
 function isSalesNavigatorSessionError(error) {
     if (error instanceof SalesNavigatorExportRequestError) {
         if (error.errorCode === "invalid_session") {
@@ -1496,7 +2416,7 @@ function isSalesNavigatorSessionError(error) {
         }
     }
     const message = error instanceof Error ? error.message : String(error);
-    return /can't connect profile|sales navigator account|upsell|linkedin session invalid|linkedin_rate_limited|too many requests|rate.?limit|invalid session cookie/i.test(message);
+    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") {
@@ -2125,7 +3045,23 @@ async function executeSalesNavigatorCrawlJob(session, jobId, options) {
     let job = null;
     let idlePollCount = 0;
     let lastOutcome = null;
-    const parallelExports = Math.max(1, options.parallelExports);
+    const phantomLaneLimit = resolveSalesNavigatorPhantomLaneLimit(process.env);
+    const parallelExports = Math.max(1, Math.min(options.parallelExports, phantomLaneLimit));
+    await options.logger?.log("salesnav.crawl.parallel.config", {
+        requestedParallelExports: options.parallelExports,
+        effectiveParallelExports: parallelExports,
+        phantomLaneLimit
+    });
+    if (!runtimeOutputOptions.json && !runtimeOutputOptions.quiet) {
+        process.stderr.write(`Sales Navigator parallel exports: requested=${options.parallelExports}, lane_limit=${phantomLaneLimit}, effective=${parallelExports}\n`);
+    }
+    if (parallelExports < options.parallelExports) {
+        await options.logger?.log("salesnav.crawl.parallel.capped", {
+            requestedParallelExports: options.parallelExports,
+            effectiveParallelExports: parallelExports,
+            phantomLaneLimit
+        });
+    }
     const inFlight = new Map();
     let nextSlot = 0;
     let noMoreClaimableWork = false;
@@ -2395,13 +3331,13 @@ async function runProductMarketWizard(rl) {
     writeWizardLine(`  ${buildCommandLine(commandArgs)}`);
 }
 async function runVendorShortcutWizard(rl) {
-    writeWizardSection("Built-in Deel shortcut", "Use the built-in Deel ICP template and search your workspace lead data.");
+    writeWizardSection("Built-in vendor shortcut", "Use a built-in vendor ICP template and search your workspace lead data.");
     const reference = parseCompanyReference(await promptText(rl, "Which company shortcut should I use?", {
         required: true
     }));
     writeWizardLine();
     if (reference.vendorTemplate !== "deel") {
-        throw new Error("The built-in shortcut only supports Deel right now. Use deel.com or the Deel LinkedIn company page.");
+        throw new Error("The built-in shortcut currently supports Deel only. Use deel.com or the Deel LinkedIn company page.");
     }
     const market = await promptChoice(rl, "Where do you want to search?", [
         { value: "dach", label: "DACH", description: "Germany, Austria, Switzerland" },
@@ -2538,14 +3474,14 @@ async function runWizard(options) {
             },
             {
                 value: "reference-company",
-                label: "Use the built-in Deel shortcut",
-                description: "Generate the saved Deel ICP and search workspace leads",
-                aliases: ["deel", "shortcut", "vendor template", "quick deel"]
+                label: "Use a built-in vendor shortcut",
+                description: "Generate the saved vendor ICP and search workspace leads",
+                aliases: ["vendor", "shortcut", "vendor template", "quick template"]
             },
             {
                 value: "target-company",
                 label: "Find people at a specific company",
-                description: "Example: find people at deel.com",
+                description: "Example: find people at company.com",
                 aliases: ["target company", "company", "find people", "people at a company", "lead generation"]
             },
             {
@@ -2710,10 +3646,33 @@ async function fetchHistoricalQueryRows(tables) {
 }
 program
     .name("salesprompter")
-    .description("Sales workflow CLI for LinkedIn product discovery, Sales Navigator crawling, lead enrichment, scoring, and sync.")
+    .description("Sales workflow CLI for guided lead generation, enrichment, scoring, and sync.")
     .version(packageVersion)
     .option("--json", "Emit compact machine-readable JSON output", false)
     .option("--quiet", "Suppress successful stdout output", false);
+program.configureHelp({
+    visibleCommands(cmd) {
+        return cmd.commands
+            .filter((subcommand) => {
+            const maybeHidden = subcommand;
+            return !maybeHidden._hidden && helpVisibleCommandNames.has(subcommand.name());
+        })
+            .sort((left, right) => left.name().localeCompare(right.name()));
+    },
+    subcommandTerm(cmd) {
+        const visibleName = helpAliasByCommandName.get(cmd.name()) || cmd.name();
+        const args = cmd.registeredArguments.map((arg) => formatHelpArgumentTerm(arg)).join(" ");
+        return visibleName + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
+    }
+});
+program.addHelpText("after", `
+LLM operator tips:
+  - 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>.
+  - Preview contact enrichment first: contacts:resolve-profiles --in <contacts.tsv> --dry-run.
+  - For bigger runs, start with a small sample before processing the full file.
+`);
 program
     .command("auth:login")
     .description("Authenticate CLI with a Salesprompter app token, or device flow if the app supports it.")
@@ -2766,6 +3725,125 @@ program
         createdAt: verifiedSession.createdAt
     });
 });
+program
+    .command("llm:ready")
+    .description("Return LLM/operator readiness info with recommended next commands.")
+    .option("--icp <path>", "Optional ICP path for lead pipeline examples", "/tmp/deel-icp.json")
+    .option("--domain <domain>", "Optional domain for lead pipeline examples", "deel.com")
+    .action(async (options) => {
+    const readiness = await resolveLlmAuthReadiness();
+    const leadPipelineCommand = [
+        "salesprompter --json leads:pipeline",
+        `--icp ${shellQuote(String(options.icp))}`,
+        `--domain ${shellQuote(String(options.domain))}`,
+        "--count 50",
+        "--out-prefix /tmp/leads-run"
+    ].join(" ");
+    const salesNavCountCommand = [
+        "salesprompter --json salesnav:count",
+        "--query-url \"https://www.linkedin.com/sales/search/people?query=...\"",
+        "--number-of-profiles 1"
+    ].join(" ");
+    printOutput({
+        status: "ok",
+        ready: readiness.ready,
+        auth: {
+            mode: readiness.mode,
+            apiBaseUrl: readiness.apiBaseUrl,
+            user: readiness.user,
+            reason: readiness.reason
+        },
+        recommended: {
+            leadPipeline: leadPipelineCommand,
+            salesNavCount: salesNavCountCommand
+        },
+        tips: [
+            "Use SALESPROMPTER_TOKEN for non-interactive runs.",
+            "Add --json for machine-readable outputs.",
+            "For live crawls, start with --max-slices 1."
+        ]
+    });
+});
+program
+    .command("contacts:find-linkedin-urls")
+    .alias("contacts:resolve-profiles")
+    .description("Resolve profile URLs for a pasted contacts 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("--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("--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 = parseLinkedInUrlLookupInput(inputContent);
+    if (rows.length === 0) {
+        throw new Error("No contact rows found. Provide TSV/CSV/JSON input via --in or stdin.");
+    }
+    let sessionOrgId = "";
+    if (!shouldBypassAuth()) {
+        try {
+            const session = await requireAuthSession();
+            sessionOrgId = session.user.orgId ?? "";
+        }
+        catch {
+            sessionOrgId = "";
+        }
+    }
+    const contacts = toLinkedInUrlLookupContacts(rows);
+    if (options.dryRun) {
+        const payload = {
+            status: "ok",
+            dryRun: true,
+            orgId: String(options.orgId ?? "").trim() || null,
+            contacts: contacts.length,
+            sample: contacts.slice(0, 5)
+        };
+        if (options.out) {
+            await writeJsonFile(options.out, payload);
+        }
+        printOutput(payload);
+        return;
+    }
+    const enrichedRows = await resolveLinkedInUrlsFromSalesNavRows({
+        rows,
+        orgId: String(options.orgId ?? "").trim() || undefined
+    });
+    let directAttempted = false;
+    const missingRows = enrichedRows.filter((row) => !row.found);
+    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 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 payload = {
+        status: "ok",
+        orgId: String(options.orgId ?? "").trim() || null,
+        requested: rows.length,
+        found: enrichedRows.filter((row) => row.found).length,
+        directAttempted,
+        rows: enrichedRows
+    };
+    if (options.out) {
+        await writeJsonFile(options.out, payload);
+    }
+    printOutput(payload);
+});
 program
     .command("auth:logout")
     .description("Remove local CLI auth session.")
@@ -2776,7 +3854,10 @@ program
 program.hook("preAction", async (_thisCommand, actionCommand) => {
     applyGlobalOutputOptions(actionCommand);
     const commandName = actionCommand.name();
-    if (commandName.startsWith("auth:") || commandName === "wizard") {
+    if (commandName.startsWith("auth:") ||
+        commandName === "wizard" ||
+        commandName === "llm:ready" ||
+        commandName === "contacts:find-linkedin-urls") {
         return;
     }
     const commandOptions = actionCommand.opts();
@@ -2789,6 +3870,11 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
     if (shouldBypassAuth()) {
         return;
     }
+    const envToken = resolveNonInteractiveAuthToken(process.env);
+    if (envToken) {
+        await loginWithToken(envToken, process.env.SALESPROMPTER_API_BASE_URL?.trim());
+        return;
+    }
     try {
         const session = await requireAuthSession();
         if (session.expiresAt !== undefined && Date.now() >= Date.parse(session.expiresAt)) {
@@ -2796,7 +3882,7 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
                 await ensureInteractiveAuthSession(session.apiBaseUrl);
                 return;
             }
-            throw new Error("session expired. Run `salesprompter auth:login`.");
+            throw new Error("session expired. Run `salesprompter auth:login` or set SALESPROMPTER_TOKEN for non-interactive runs.");
         }
     }
     catch (error) {
@@ -2812,7 +3898,7 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
 program
     .command("account:resolve")
     .description("Resolve a target company into a normalized account profile.")
-    .requiredOption("--domain <domain>", "Company domain like deel.com")
+    .requiredOption("--domain <domain>", "Company domain like company.com")
     .option("--company-name <name>", "Optional company name override")
     .option("--icp <path>", "Optional path to ICP JSON for industry/region/title hints")
     .requiredOption("--out <path>", "Output file path")
@@ -2871,7 +3957,7 @@ program
 program
     .command("icp:vendor")
     .description("Create a vendor-specific ICP template.")
-    .requiredOption("--vendor <vendor>", "Vendor template name, currently: deel")
+    .requiredOption("--vendor <vendor>", "Vendor template name")
     .option("--market <market>", "global|europe|dach", "dach")
     .option("--out <path>", "Optional output file path")
     .action(async (options) => {
@@ -2886,7 +3972,7 @@ program
 program
     .command("icp:from-historical-queries:bq")
     .description("Build a vendor ICP from historical BigQuery query patterns.")
-    .requiredOption("--vendor <vendor>", "Vendor template name, currently: deel")
+    .requiredOption("--vendor <vendor>", "Vendor template name")
     .option("--market <market>", "global|europe|dach", "dach")
     .option("--tables <items>", "Comma-separated BigQuery tables with a query column", "leadLists_raw,leadLists_unique,linkedinSearchExport_people_unique,salesNavigatorSearchExport_companies_unique,snse_containers_input")
     .option("--search-kind <kind>", "all|people|sales-people|sales-company", "sales-people")
@@ -2926,7 +4012,7 @@ program
     .description("Generate leads for a target account 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 deel.com")
+    .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")
     .requiredOption("--out <path>", "Output file path")
@@ -2975,6 +4061,51 @@ program
     await writeJsonFile(options.out, scored);
     printOutput({ status: "ok", scored: scored.length, out: options.out });
 });
+program
+    .command("leads:pipeline")
+    .description("Run one-shot lead generation pipeline: generate -> enrich -> score.")
+    .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("--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);
+    const count = z.coerce.number().int().min(1).max(1000).parse(options.count);
+    const domain = options.domain ?? options.companyDomain;
+    const target = {
+        companyDomain: domain,
+        companyName: options.companyName
+    };
+    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);
+    await writeJsonFile(leadsOut, generated.leads);
+    const enriched = await enrichmentProvider.enrichLeads(generated.leads);
+    await writeJsonFile(enrichedOut, enriched);
+    const scored = await scoringProvider.scoreLeads(icp, enriched);
+    await writeJsonFile(scoredOut, scored);
+    printOutput({
+        status: "ok",
+        provider: generated.provider,
+        mode: generated.mode,
+        account: generated.account,
+        warnings: generated.warnings,
+        counts: {
+            generated: generated.leads.length,
+            enriched: enriched.length,
+            scored: scored.length
+        },
+        outputs: {
+            leads: leadsOut,
+            enriched: enrichedOut,
+            scored: scoredOut
+        }
+    });
+});
 program
     .command("sync:crm")
     .description("Dry-run sync scored leads into a CRM target.")
@@ -3004,9 +4135,56 @@ program
     });
     printOutput({ status: "ok", ...result });
 });
+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("--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 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();
+        const drained = await drainLinkedInCompanyBackfill(session, {
+            clientId,
+            limit
+        });
+        printOutput({
+            status: "ok",
+            dryRun: false,
+            clientId,
+            completed: drained.completed,
+            batches: drained.batches,
+            started: drained.startedCompanies,
+            remaining: drained.remaining
+        });
+        return;
+    }
+    const result = await backfillLinkedInCompanies({
+        clientId,
+        limit,
+        concurrency,
+        dryRun: true
+    });
+    printOutput({
+        status: "ok",
+        dryRun: true,
+        clientId,
+        discovered: result.candidates.length,
+        unavailable: result.results.filter((row) => row.unavailable).length,
+        stored: 0,
+        results: result.results,
+        mergeSql: result.mergeSql
+    });
+});
 program
     .command("linkedin-products:scrape")
-    .description("Resolve a company or LinkedIn product into a LinkedIn product category, scrape that catalog, and upload it to Salesprompter.")
+    .alias("market:scrape")
+    .description("Turn a company or product input into a reusable market catalog and upload it to Salesprompter.")
     .requiredOption("--input <value>", "Company domain, LinkedIn company URL, LinkedIn product URL, LinkedIn category URL, or LinkedIn product search URL")
     .option("--max-pages <number>", "Maximum LinkedIn category pages to fetch", "25")
     .option("--limit <number>", "Optional cap on the number of products to keep")
@@ -3053,7 +4231,8 @@ program
 });
 program
     .command("salesnav:from-product-category")
-    .description("Crawl a LinkedIn product category, derive intended-role title searches, then run durable Sales Navigator crawls that export through Phantombuster into Salesprompter.")
+    .alias("leads:discover")
+    .description("Start from a market or product input, derive the right buyer searches, and discover leads.")
     .requiredOption("--input <value>", "Company domain, LinkedIn company URL, LinkedIn product URL, LinkedIn category URL, or LinkedIn product search URL")
     .option("--max-pages <number>", "Maximum LinkedIn category pages to fetch", "25")
     .option("--product-limit <number>", "Optional cap on the number of LinkedIn products to inspect")
@@ -3264,9 +4443,373 @@ program
     }
     printOutput(payload);
 });
+program
+    .command("salesnav:deel-locale-export")
+    .alias("salesnav:vendor-locale-export")
+    .description("Export the Supabase Sales Navigator Deel corpus into German-vs-English outreach backlog files.")
+    .option("--org-id <id>", "Workspace org id. Defaults to the active CLI org.")
+    .option("--limit <number>", "Maximum number of Supabase rows to process", "250000")
+    .option("--page-size <number>", "Supabase page size per request", "1000")
+    .option("--title-filter <mode>", "deel-hr|all", "deel-hr")
+    .option("--min-email-score <number>", "Minimum email score when enriching leadPool rows", "70")
+    .option("--enrich", "Join the kept Sales Navigator rows to leadPool_new emails", false)
+    .option("--campaign-id <id>", "Fallback Instantly campaign id for both locales")
+    .option("--campaign-id-de <id>", "Instantly campaign id for German leads")
+    .option("--campaign-id-en <id>", "Instantly campaign id for English leads")
+    .option("--apply", "Create leads in Instantly instead of export-only mode", false)
+    .option("--allow-duplicates", "Do not dedupe leads that already exist in the campaign", false)
+    .requiredOption("--out-dir <path>", "Output directory for summary and locale CSV files")
+    .action(async (options) => {
+    const limit = z.coerce.number().int().min(1).max(500000).parse(options.limit);
+    const pageSize = z.coerce.number().int().min(1).max(1000).parse(options.pageSize);
+    const titleFilter = z.enum(["deel-hr", "all"]).parse(options.titleFilter);
+    const minEmailScore = z.coerce.number().int().min(0).max(100).parse(options.minEmailScore);
+    const enrich = Boolean(options.enrich);
+    const fallbackCampaignId = options.campaignId?.trim();
+    const campaignIdDe = options.campaignIdDe?.trim() ?? fallbackCampaignId;
+    const campaignIdEn = options.campaignIdEn?.trim() ?? fallbackCampaignId;
+    const applySync = Boolean(options.apply);
+    const allowDuplicates = Boolean(options.allowDuplicates);
+    let sessionOrgId = null;
+    if (!shouldBypassAuth()) {
+        const session = await requireAuthSession();
+        sessionOrgId = session.user.orgId ?? null;
+    }
+    const orgId = resolveSalesNavigatorHistoricalBackfillOrgId({
+        explicitOrgId: options.orgId,
+        env: process.env,
+        sessionOrgId
+    });
+    const config = resolveSalesNavigatorSupabaseConfig(process.env);
+    const supabase = createClient(config.supabaseUrl, config.supabaseServiceRoleKey, {
+        auth: { persistSession: false }
+    });
+    const countResponse = await supabase
+        .from("linkedin_sales_nav_people")
+        .select("id", { count: "exact", head: true })
+        .eq("org_id", orgId);
+    if (countResponse.error) {
+        throw new Error(`Failed to count linkedin_sales_nav_people rows: ${countResponse.error.message}`);
+    }
+    const totalInOrg = countResponse.count ?? 0;
+    const totalToProcess = Math.min(totalInOrg, limit);
+    const baseSlug = `deel-salesnav-${slugify(orgId) || "workspace"}`;
+    const deCsvPath = path.join(options.outDir, `${baseSlug}-de.csv`);
+    const enCsvPath = path.join(options.outDir, `${baseSlug}-en.csv`);
+    const summaryPath = path.join(options.outDir, `${baseSlug}-summary.json`);
+    const samplesPath = path.join(options.outDir, `${baseSlug}-samples.json`);
+    await mkdir(options.outDir, { recursive: true });
+    await writeFile(deCsvPath, `${buildDeelSalesNavCsvHeader()}\n`, "utf8");
+    await writeFile(enCsvPath, `${buildDeelSalesNavCsvHeader()}\n`, "utf8");
+    const localeCounts = { de: 0, en: 0 };
+    let titleMatchedCount = 0;
+    let titleFilteredOutCount = 0;
+    const fieldCounts = {
+        firstName: 0,
+        lastName: 0,
+        fullName: 0,
+        companyName: 0,
+        companyNameCleaned: 0,
+        preferredProfileUrl: 0,
+        linkedinProfileUrl: 0,
+        companyLinkedInHandle: 0,
+        location: 0,
+        companyLocation: 0,
+        searchQuery: 0
+    };
+    const signalFieldCounts = {
+        location: 0,
+        companyLocation: 0,
+        searchQuery: 0,
+        none: 0
+    };
+    const titleCounts = new Map();
+    const samples = {
+        de: [],
+        en: []
+    };
+    const keptRows = [];
+    const selectFields = [
+        "id",
+        "org_id",
+        "run_id",
+        "sales_nav_profile_url",
+        "linkedin_profile_url",
+        "default_profile_url",
+        "full_name",
+        "first_name",
+        "last_name",
+        "company_name",
+        "company_url",
+        "regular_company_url",
+        "title",
+        "industry",
+        "location",
+        "company_location",
+        "search_query",
+        "scraped_at"
+    ].join(", ");
+    let processed = 0;
+    let lastSeenId = null;
+    while (processed < totalToProcess) {
+        let query = supabase
+            .from("linkedin_sales_nav_people")
+            .select(selectFields)
+            .eq("org_id", orgId)
+            .order("id", { ascending: true })
+            .limit(Math.min(pageSize, totalToProcess - processed));
+        if (lastSeenId) {
+            query = query.gt("id", lastSeenId);
+        }
+        const response = await query;
+        if (response.error) {
+            throw new Error(`Failed to read linkedin_sales_nav_people rows after ${lastSeenId ?? "start"}: ${response.error.message}`);
+        }
+        const pageRows = (response.data ?? []);
+        if (pageRows.length === 0) {
+            break;
+        }
+        const relevantRows = pageRows.filter((row) => {
+            if (titleFilter === "all") {
+                titleMatchedCount += 1;
+                return true;
+            }
+            const matches = isDeelRelevantSalesNavTitle(row.title);
+            if (matches) {
+                titleMatchedCount += 1;
+                return true;
+            }
+            titleFilteredOutCount += 1;
+            return false;
+        });
+        const preparedRows = relevantRows.map((row) => normalizeDeelSalesNavRow(row));
+        const deRows = preparedRows.filter((row) => row.language === "de");
+        const enRows = preparedRows.filter((row) => row.language === "en");
+        keptRows.push(...preparedRows);
+        if (deRows.length > 0) {
+            await appendFile(deCsvPath, `${buildDeelSalesNavCsvLines(deRows)}\n`, "utf8");
+        }
+        if (enRows.length > 0) {
+            await appendFile(enCsvPath, `${buildDeelSalesNavCsvLines(enRows)}\n`, "utf8");
+        }
+        for (const row of preparedRows) {
+            localeCounts[row.language] += 1;
+            if (row.signalFields.length === 0) {
+                signalFieldCounts.none += 1;
+            }
+            else {
+                for (const field of row.signalFields) {
+                    if (field === "location") {
+                        signalFieldCounts.location += 1;
+                    }
+                    else if (field === "companyLocation") {
+                        signalFieldCounts.companyLocation += 1;
+                    }
+                    else if (field === "searchQuery") {
+                        signalFieldCounts.searchQuery += 1;
+                    }
+                }
+            }
+            if (row.firstName)
+                fieldCounts.firstName += 1;
+            if (row.lastName)
+                fieldCounts.lastName += 1;
+            if (row.fullName)
+                fieldCounts.fullName += 1;
+            if (row.companyName)
+                fieldCounts.companyName += 1;
+            if (row.companyNameCleaned)
+                fieldCounts.companyNameCleaned += 1;
+            if (row.preferredProfileUrl)
+                fieldCounts.preferredProfileUrl += 1;
+            if (row.linkedinProfileUrl)
+                fieldCounts.linkedinProfileUrl += 1;
+            if (row.companyLinkedInHandle)
+                fieldCounts.companyLinkedInHandle += 1;
+            if (row.location)
+                fieldCounts.location += 1;
+            if (row.companyLocation)
+                fieldCounts.companyLocation += 1;
+            if (row.searchQuery)
+                fieldCounts.searchQuery += 1;
+            if (row.title) {
+                titleCounts.set(row.title, (titleCounts.get(row.title) ?? 0) + 1);
+            }
+            if (samples[row.language].length < 25) {
+                samples[row.language].push(row);
+            }
+        }
+        processed += pageRows.length;
+        lastSeenId = pageRows[pageRows.length - 1]?.id ?? lastSeenId;
+        const completedPages = Math.ceil(processed / pageSize);
+        if (completedPages === 1 || processed === totalToProcess || completedPages % 10 === 0) {
+            writeProgress(`Processed ${processed}/${totalToProcess} Deel Sales Navigator rows for org ${orgId}; kept ${titleMatchedCount} after ${titleFilter} title filtering.`);
+        }
+    }
+    const keptTotal = localeCounts.de + localeCounts.en;
+    const percentage = (count, base = keptTotal) => base > 0 ? Number(((count / base) * 100).toFixed(2)) : 0;
+    let enrichmentSummary = null;
+    if (enrich) {
+        const localeByContactId = new Map();
+        for (const row of keptRows) {
+            const contactId = extractSalesNavContactId(row.salesNavProfileUrl);
+            if (contactId) {
+                localeByContactId.set(contactId, row.language);
+            }
+        }
+        const contactIds = Array.from(localeByContactId.keys());
+        if (contactIds.length === 0) {
+            enrichmentSummary = {
+                contactIds: 0,
+                enrichedRows: 0,
+                missingContactIds: [],
+                files: {
+                    all: "",
+                    de: "",
+                    en: ""
+                },
+                syncResults: []
+            };
+        }
+        else {
+            const enrichedRows = [];
+            for (const chunk of chunkArray(contactIds, 400)) {
+                const sql = buildDeelLeadPoolContactSql({ contactIds: chunk, minEmailScore });
+                const rows = await runBigQueryRows(sql, { maxRows: chunk.length * 2 });
+                enrichedRows.push(...rows);
+            }
+            const normalizedRows = normalizeDeelOutreachRows(enrichedRows);
+            const foundContactIds = new Set();
+            for (const row of normalizedRows) {
+                if (row.contactId) {
+                    foundContactIds.add(row.contactId);
+                    const overrideLanguage = localeByContactId.get(row.contactId);
+                    if (overrideLanguage) {
+                        row.language = overrideLanguage;
+                        row.marketSegment = overrideLanguage === "de" ? "dach" : "non-dach";
+                    }
+                }
+            }
+            const missingContactIds = contactIds.filter((id) => !foundContactIds.has(id));
+            const pack = buildDeelOutreachPack("global", normalizedRows);
+            const enrichedAllPath = path.join(options.outDir, `${baseSlug}-enriched-all.json`);
+            const enrichedDePath = path.join(options.outDir, `${baseSlug}-enriched-de.json`);
+            const enrichedEnPath = path.join(options.outDir, `${baseSlug}-enriched-en.json`);
+            await writeJsonFile(enrichedAllPath, normalizedRows);
+            await writeJsonFile(enrichedDePath, pack.locales.de);
+            await writeJsonFile(enrichedEnPath, pack.locales.en);
+            const syncResults = [];
+            const routes = [
+                {
+                    locale: "de",
+                    campaignId: campaignIdDe,
+                    leads: pack.locales.de
+                },
+                {
+                    locale: "en",
+                    campaignId: campaignIdEn,
+                    leads: pack.locales.en
+                }
+            ];
+            for (const route of routes) {
+                if (!route.campaignId || route.leads.length === 0) {
+                    continue;
+                }
+                const result = await syncProvider.sync("instantly", route.leads, {
+                    apply: applySync,
+                    instantlyCampaignId: route.campaignId,
+                    allowDuplicates
+                });
+                syncResults.push({
+                    locale: route.locale,
+                    campaignId: route.campaignId,
+                    synced: result.synced,
+                    skipped: result.skipped ?? 0,
+                    dryRun: result.dryRun,
+                    provider: result.provider ?? "instantly"
+                });
+            }
+            enrichmentSummary = {
+                contactIds: contactIds.length,
+                enrichedRows: normalizedRows.length,
+                missingContactIds,
+                files: {
+                    all: enrichedAllPath,
+                    de: enrichedDePath,
+                    en: enrichedEnPath
+                },
+                syncResults
+            };
+        }
+    }
+    const payload = {
+        status: "ok",
+        vendor: "deel",
+        source: "salesnav-supabase",
+        recommendedRouting: "separate-campaigns-by-language",
+        orgId,
+        totalInOrg,
+        scanned: processed,
+        titleFilter,
+        keptAfterTitleFilter: keptTotal,
+        titleMatchedCount,
+        titleFilteredOutCount,
+        truncatedByLimit: totalInOrg > processed,
+        localeCounts,
+        localePercentages: {
+            de: percentage(localeCounts.de),
+            en: percentage(localeCounts.en)
+        },
+        fieldCoverage: {
+            firstName: { count: fieldCounts.firstName, percentage: percentage(fieldCounts.firstName) },
+            lastName: { count: fieldCounts.lastName, percentage: percentage(fieldCounts.lastName) },
+            fullName: { count: fieldCounts.fullName, percentage: percentage(fieldCounts.fullName) },
+            companyName: { count: fieldCounts.companyName, percentage: percentage(fieldCounts.companyName) },
+            companyNameCleaned: {
+                count: fieldCounts.companyNameCleaned,
+                percentage: percentage(fieldCounts.companyNameCleaned)
+            },
+            preferredProfileUrl: {
+                count: fieldCounts.preferredProfileUrl,
+                percentage: percentage(fieldCounts.preferredProfileUrl)
+            },
+            linkedinProfileUrl: {
+                count: fieldCounts.linkedinProfileUrl,
+                percentage: percentage(fieldCounts.linkedinProfileUrl)
+            },
+            companyLinkedInHandle: {
+                count: fieldCounts.companyLinkedInHandle,
+                percentage: percentage(fieldCounts.companyLinkedInHandle)
+            },
+            location: { count: fieldCounts.location, percentage: percentage(fieldCounts.location) },
+            companyLocation: {
+                count: fieldCounts.companyLocation,
+                percentage: percentage(fieldCounts.companyLocation)
+            },
+            searchQuery: { count: fieldCounts.searchQuery, percentage: percentage(fieldCounts.searchQuery) }
+        },
+        signalFieldCounts,
+        topTitles: [...titleCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20),
+        campaignRecommendation: {
+            de: "Only rows with clear DACH signals should enter the German Deel campaign.",
+            en: "Route everything else to a separate English Deel campaign. English is the safer fallback for ambiguous locales."
+        },
+        files: {
+            deCsv: deCsvPath,
+            enCsv: enCsvPath,
+            summary: summaryPath,
+            samples: samplesPath
+        },
+        enrichment: enrichmentSummary
+    };
+    await writeJsonFile(summaryPath, payload);
+    await writeJsonFile(samplesPath, samples);
+    printOutput(payload);
+});
 program
     .command("salesnav:crawl")
-    .description("Adaptively split broad LinkedIn Sales Navigator people searches into exportable slices and store every finished slice through Salesprompter.")
+    .alias("search:run")
+    .description("Run a saved people search, split broad result sets when needed, and store the finished output.")
     .option("--query-url <url>", "Base LinkedIn Sales Navigator people search URL")
     .option("--job-id <id>", "Resume an existing crawl job by id")
     .option("--max-results-per-search <number>", "Maximum results allowed for a sliced search", "2500")
@@ -3299,6 +4842,7 @@ program
     const idlePollSeconds = z.coerce.number().int().min(0).max(300).parse(options.idlePollSeconds);
     const idleMaxPolls = z.coerce.number().int().min(0).max(10000).parse(options.idleMaxPolls);
     const parallelExports = z.coerce.number().int().min(1).max(10).parse(options.parallelExports);
+    const phantomLaneLimit = resolveSalesNavigatorPhantomLaneLimit(process.env);
     const effectiveDryRun = Boolean(options.dryRun || shouldBypassAuth());
     const logger = await createWorkflowLogger({
         logPath: options.logPath ?? buildSalesNavigatorCrawlLogPath(jobId ?? queryUrl ?? "salesnav-crawl")
@@ -3318,6 +4862,7 @@ program
         idlePollSeconds,
         idleMaxPolls,
         parallelExports,
+        phantomLaneLimit,
         dryRun: effectiveDryRun
     });
     if (effectiveDryRun) {
@@ -3381,6 +4926,13 @@ program
         throw new Error("Provide exactly one of --query-url or --job-id.");
     }
     let session = await requireAuthSession();
+    const sessionOrgId = resolveSessionOrgId(session);
+    if (sessionOrgId) {
+        const eventStore = await createSalesNavigatorCrawlEventStore({
+            orgId: sessionOrgId
+        });
+        logger.setEventStore(eventStore);
+    }
     let createResult = null;
     let resolvedJobId = jobId ?? null;
     if (queryUrl) {
@@ -3508,23 +5060,42 @@ program
 });
 program
     .command("salesnav:crawl:status")
-    .description("Return the current status of a durable Sales Navigator crawl job.")
+    .alias("search:status")
+    .description("Return the current status of a background people-search job.")
     .requiredOption("--job-id <id>", "Sales Navigator crawl job id")
+    .option("--events-limit <number>", "How many recent persisted crawl events to include", "25")
     .action(async (options) => {
     const jobId = z.string().uuid().parse(options.jobId);
+    const eventsLimit = z.coerce.number().int().min(0).max(200).parse(options.eventsLimit);
     let session = await requireAuthSession();
     const status = await getSalesNavigatorCrawlStatus(session, jobId);
     session = status.session;
-    void session;
+    const sessionOrgId = resolveSessionOrgId(session);
+    const eventStore = sessionOrgId
+        ? await createSalesNavigatorCrawlEventStore({
+            orgId: sessionOrgId
+        })
+        : null;
+    let recentEvents = [];
+    if (eventsLimit > 0 && eventStore) {
+        try {
+            recentEvents = await eventStore.listRecentForJob(jobId, eventsLimit);
+        }
+        catch {
+            recentEvents = [];
+        }
+    }
     printOutput({
         status: "ok",
         jobId,
-        job: status.value.job
+        job: status.value.job,
+        recentEvents
     });
 });
 program
     .command("salesnav:export")
-    .description("Apply the default Sales Navigator HR slice filters to one or more people-search URLs, then export and store the results through Salesprompter.")
+    .alias("search:export")
+    .description("Apply the default people-search filters to one or more search URLs, then export and store the results.")
     .requiredOption("--query-url <url>", "Base LinkedIn Sales Navigator people search URL", collectStringOptionValue, [])
     .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")
@@ -3585,6 +5156,71 @@ program
     }
     printOutput(payload);
 });
+program
+    .command("salesnav:count")
+    .alias("search:count")
+    .description("Estimate how many results are available for a people-search URL using a minimal probe.")
+    .requiredOption("--query-url <url>", "LinkedIn Sales Navigator people search URL")
+    .option("--max-results-per-search <number>", "Maximum results allowed for the probe", "2500")
+    .option("--number-of-profiles <number>", "Profiles to scrape for the probe run", "1")
+    .option("--slice-preset <name>", "Slice preset label stored with the probe run", "count-probe")
+    .option("--out <path>", "Optional local JSON output path")
+    .action(async (options) => {
+    const queryUrl = z.string().url().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(25).parse(options.numberOfProfiles);
+    const session = await requireAuthSession();
+    const payloadBase = {
+        sourceQueryUrl: queryUrl,
+        slicedQueryUrl: queryUrl,
+        appliedFilters: [],
+        maxResultsPerSearch,
+        numberOfProfiles,
+        slicePreset: options.slicePreset,
+        rawPayload: {
+            workflow: "salesnav:count",
+            sourceQueryUrl: queryUrl,
+            slicedQueryUrl: queryUrl,
+            probeProfiles: numberOfProfiles
+        }
+    };
+    try {
+        const result = await runSalesNavigatorExport(session, payloadBase);
+        const payload = {
+            status: "ok",
+            queryUrl,
+            estimatedTotalResults: result.totalResults ?? null,
+            probeProfiles: numberOfProfiles,
+            runId: result.runId,
+            agentId: result.agentId,
+            containerId: result.containerId,
+            resultJsonUrl: result.resultJsonUrl ?? null,
+            resultCsvUrl: result.resultCsvUrl ?? null
+        };
+        if (options.out) {
+            await writeJsonFile(options.out, payload);
+        }
+        printOutput(payload);
+        return;
+    }
+    catch (error) {
+        if (error instanceof SalesNavigatorSliceTooBroadError) {
+            const payload = {
+                status: "ok",
+                queryUrl,
+                estimatedTotalResults: error.totalResults ?? null,
+                tooBroad: true,
+                probeProfiles: numberOfProfiles
+            };
+            if (options.out) {
+                await writeJsonFile(options.out, payload);
+            }
+            printOutput(payload);
+            return;
+        }
+        throw error;
+    }
+});
 program
     .command("leads:lookup:bq")
     .description("Build a BigQuery lead lookup from an ICP and optionally execute it with the bq CLI.")
@@ -3689,7 +5325,7 @@ program
 program
     .command("leadlists:direct-export:bq")
     .description("Export upstream leads directly from leadLists -> linkedin_contacts -> linkedin_companies and segment them.")
-    .requiredOption("--vendor <vendor>", "Vendor template name, currently: deel")
+    .requiredOption("--vendor <vendor>", "Vendor template name")
     .option("--market <market>", "global|europe|dach", "dach")
     .option("--limit <number>", "Max rows to export", "20000")
     .requiredOption("--out-dir <path>", "Output directory for raw and segmented files")
@@ -3733,10 +5369,99 @@ program
         sqlOut: options.sqlOut ?? null
     });
 });
+program
+    .command("leadlists:deel-outreach:bq")
+    .alias("leadlists:vendor-outreach:bq")
+    .description("Build Instantly-ready Deel outreach batches from leadPool_new with lead-list provenance, split into German vs English.")
+    .option("--market <market>", "global|europe|dach", "global")
+    .option("--limit <number>", "Max rows to export", "200000")
+    .option("--min-email-score <number>", "Minimum email score to keep", "70")
+    .requiredOption("--out-dir <path>", "Output directory for raw rows, packs, and locale batches")
+    .option("--sql-out <path>", "Optional file path for the generated SQL")
+    .option("--campaign-id <id>", "Fallback Instantly campaign id for all locales")
+    .option("--campaign-id-de <id>", "Instantly campaign id for German/DACH leads")
+    .option("--campaign-id-en <id>", "Instantly campaign id for English/non-DACH leads")
+    .option("--apply", "Create leads in Instantly instead of export-only mode", false)
+    .option("--allow-duplicates", "Do not skip emails already present in the Instantly campaign", false)
+    .action(async (options) => {
+    const market = z.enum(["global", "europe", "dach"]).parse(options.market);
+    const limit = z.coerce.number().int().min(1).max(500000).parse(options.limit);
+    const minEmailScore = z.coerce.number().int().min(0).max(100).parse(options.minEmailScore);
+    const sql = buildDeelOutreachExportSql({ market, limit, minEmailScore });
+    if (options.sqlOut) {
+        await writeTextFile(options.sqlOut, `${sql}\n`);
+    }
+    const rows = await runBigQueryRows(sql, { maxRows: limit });
+    const normalizedRows = normalizeDeelOutreachRows(rows);
+    const pack = buildDeelOutreachPack(market, normalizedRows);
+    const baseSlug = `deel-outreach-${market}`;
+    const rawPath = path.join(options.outDir, `${baseSlug}-raw.json`);
+    const packPath = path.join(options.outDir, `${baseSlug}-pack.json`);
+    const allPath = path.join(options.outDir, `${baseSlug}-all.json`);
+    const dePath = path.join(options.outDir, `${baseSlug}-de.json`);
+    const enPath = path.join(options.outDir, `${baseSlug}-en.json`);
+    await writeJsonFile(rawPath, normalizedRows);
+    await writeJsonFile(packPath, pack);
+    await writeJsonFile(allPath, [...pack.locales.de, ...pack.locales.en]);
+    await writeJsonFile(dePath, pack.locales.de);
+    await writeJsonFile(enPath, pack.locales.en);
+    const syncResults = [];
+    const routes = [
+        {
+            locale: "de",
+            campaignId: options.campaignIdDe ?? options.campaignId,
+            leads: pack.locales.de
+        },
+        {
+            locale: "en",
+            campaignId: options.campaignIdEn ?? options.campaignId,
+            leads: pack.locales.en
+        }
+    ];
+    for (const route of routes) {
+        if (!route.campaignId || route.leads.length === 0) {
+            continue;
+        }
+        const result = await syncProvider.sync("instantly", route.leads, {
+            apply: Boolean(options.apply),
+            instantlyCampaignId: route.campaignId,
+            allowDuplicates: Boolean(options.allowDuplicates)
+        });
+        syncResults.push({
+            locale: route.locale,
+            campaignId: route.campaignId,
+            synced: result.synced,
+            skipped: result.skipped ?? 0,
+            dryRun: result.dryRun,
+            provider: result.provider ?? "instantly"
+        });
+    }
+    printOutput({
+        status: "ok",
+        vendor: "deel",
+        market,
+        limit,
+        minEmailScore,
+        rowCount: normalizedRows.length,
+        hitLimit: normalizedRows.length === limit,
+        localeCounts: pack.summary.localeCounts,
+        segmentCounts: pack.summary.segmentCounts,
+        averageEmailScoreByLocale: pack.summary.averageEmailScoreByLocale,
+        recommendedRouting: "separate-campaigns-by-language",
+        outDir: options.outDir,
+        raw: rawPath,
+        pack: packPath,
+        all: allPath,
+        german: dePath,
+        english: enPath,
+        syncResults,
+        sqlOut: options.sqlOut ?? null
+    });
+});
 program
     .command("leadlists:funnel:bq")
     .description("Build an upstream lead-list funnel report for a vendor/market.")
-    .requiredOption("--vendor <vendor>", "Vendor template name, currently: deel")
+    .requiredOption("--vendor <vendor>", "Vendor template name")
     .option("--market <market>", "global|europe|dach", "dach")
     .requiredOption("--out <path>", "Output report path")
     .action(async (options) => {