salesprompter-cli 0.1.38 → 0.1.40

package/README.md

@@ -60,6 +60,9 @@ salesprompter contacts:find-linkedin-urls --in ./contacts.tsv --out ./contacts.e
 # Resolve LinkedIn company URLs for a pasted company list
 salesprompter companies:resolve-linkedin-urls --in ./companies.txt --out ./companies.enriched.json
 
+# Import authorized local Sales Navigator people-search results into Salesprompter
+salesprompter search:local-import --query-url '<sales navigator people search URL>' --number-of-profiles all
+
 # Build and start email enrichment from pasted company/contact rows
 # When authenticated, Salesprompter first enriches company domains in the app, then the CLI builds the email batch.
 salesprompter contacts:resolve-emails --in ./contacts.tsv --out-dir ./email-run --dry-run
@@ -80,6 +83,7 @@ salesprompter --help
 
 - Use your own authorized data access and workspace credentials.
 - Respect provider terms and customer data boundaries.
+- Local Sales Navigator import requires an authorized Sales Navigator session captured from the user's own browser context.
 - The CLI is designed for interactive users and agent-assisted workflows.
 - A repo-local Chrome extension compatibility copy is available in `chrome-extension/` for local LinkedIn session sync and popup copy/debug flows.
 

package/dist/cli.js

@@ -124,9 +124,74 @@ const LinkedInCompanyBackfillStatusResponseSchema = z.object({
     failureCode: z.string().nullable().optional(),
     failureMessage: z.string().nullable().optional()
 });
+const SalesNavigatorLocalImportResponseSchema = z.object({
+    status: z.literal("ok"),
+    runId: z.string().min(1),
+    containerId: z.string().min(1),
+    imported: z.number().int().nonnegative(),
+    upserted: z.number().int().nonnegative()
+});
+const LeadPoolAutoProcessResponseSchema = z.object({
+    success: z.boolean(),
+    clientIds: z.array(z.number().int().positive()),
+    steps: z.array(z.record(z.string(), z.unknown())),
+    startedAt: z.string(),
+    finishedAt: z.string()
+});
+const AffiliateCampaignLaunchResponseSchema = z
+    .object({
+    status: z.string().min(1),
+    dryRun: z.boolean(),
+    product: z.object({
+        domain: z.string().min(1),
+        affiliateLink: z.string().url()
+    }),
+    audience: z.object({
+        sourceType: z.string().min(1),
+        linkedInUrl: z.string().url(),
+        maxResults: z.number().int().positive()
+    }),
+    extraction: z
+        .object({
+        provider: z.string().min(1),
+        agentId: z.string().min(1).optional(),
+        containerId: z.string().min(1).optional(),
+        eventTypes: z.array(z.string()).optional(),
+        monitorId: z.string().min(1).optional(),
+        postsDiscoveredCount: z.number().int().nonnegative().optional(),
+        engagementEventsCount: z.number().int().nonnegative().optional(),
+        peopleDiscoveredCount: z.number().int().nonnegative().optional(),
+        people: z.array(z.unknown()).optional(),
+        posts: z.array(z.unknown()).optional(),
+        run: z.unknown().nullable().optional(),
+        summary: z.unknown().nullable().optional(),
+        selectedSessionCookieSha256: z.string().nullable().optional(),
+        selectedSessionUserEmail: z.string().nullable().optional(),
+        selectedSessionUserHandle: z.string().nullable().optional()
+    })
+        .optional(),
+    previewUrl: z.string().min(1).nullable().optional(),
+    next: z.string().optional()
+})
+    .passthrough();
+const LeadPoolEmailFinderProcessResponseSchema = z.object({
+    success: z.boolean(),
+    provider: z.string().optional(),
+    selected: z.number().int().nonnegative(),
+    found: z.number().int().nonnegative(),
+    notFound: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    durationMs: z.number().nonnegative(),
+    launched: z.boolean().optional(),
+    agentId: z.string().nullable().optional(),
+    containerId: z.string().nullable().optional(),
+    csvInputUrl: z.string().nullable().optional(),
+    processedAt: z.string()
+});
 const PhantombusterContainersSyncResponseSchema = z.object({
     status: z.literal("ok"),
     agentIds: z.array(z.string().min(1)),
+    containerIds: z.array(z.string().min(1)).optional(),
     agents: z.array(z.object({
         agentId: z.string().min(1),
         fetched: z.number().int().nonnegative(),
@@ -326,21 +391,21 @@ const cliPacks = [
         slug: "research",
         title: "Research",
         summary: "Scrape markets and enrich companies before outreach.",
-        commands: ["market:scrape", "companies:enrich"],
+        commands: ["market:scrape", "companies:enrich", "leads:process"],
         installStatus: "included"
     },
     {
         slug: "discovery",
         title: "Discovery",
         summary: "Find leads from product and market inputs.",
-        commands: ["leads:discover", "search:run", "search:status", "search:export", "search:count"],
+        commands: ["leads:discover", "search:run", "search:status", "search:export", "search:local-import", "search:count"],
         installStatus: "included"
     },
     {
         slug: "outreach",
         title: "Outreach",
         summary: "Prepare and sync qualified leads into downstream systems.",
-        commands: ["sync:outreach", "sync:crm"],
+        commands: ["affiliate:launch", "sync:outreach", "sync:crm"],
         installStatus: "included"
     }
 ];
@@ -354,6 +419,7 @@ const helpAliasByCommandName = new Map([
     ["salesnav:crawl", "search:run"],
     ["salesnav:crawl:status", "search:status"],
     ["salesnav:export", "search:export"],
+    ["salesnav:local-import", "search:local-import"],
     ["salesnav:count", "search:count"]
 ]);
 const helpVisibleCommandNames = new Set([
@@ -377,7 +443,9 @@ const helpVisibleCommandNames = new Set([
     "leads:generate",
     "leads:enrich",
     "leads:score",
+    "leads:process",
     "leads:pipeline",
+    "affiliate:launch",
     "sync:crm",
     "sync:outreach",
     "linkedin-companies:backfill",
@@ -386,6 +454,7 @@ const helpVisibleCommandNames = new Set([
     "salesnav:crawl",
     "salesnav:crawl:status",
     "salesnav:export",
+    "salesnav:local-import",
     "salesnav:count"
 ]);
 function printOutput(value) {
@@ -1313,12 +1382,22 @@ async function listChromeExtensionTokenLogCandidates() {
                     if (!file.endsWith(".log")) {
                         continue;
                     }
-                    paths.push(path.join(extensionDir, file));
+                    const filePath = path.join(extensionDir, file);
+                    let mtimeMs = 0;
+                    try {
+                        mtimeMs = (await stat(filePath)).mtimeMs;
+                    }
+                    catch {
+                        mtimeMs = 0;
+                    }
+                    paths.push({ path: filePath, mtimeMs });
                 }
             }
         }
     }
-    return paths.sort().reverse();
+    return paths
+        .sort((left, right) => right.mtimeMs - left.mtimeMs || right.path.localeCompare(left.path))
+        .map((entry) => entry.path);
 }
 async function readLocalLinkedInExtensionDirectLookupConfig() {
     const candidates = await listChromeExtensionTokenLogCandidates();
@@ -1416,6 +1495,9 @@ async function readLinkedInDirectLookupConfig() {
         cachedLinkedInDirectLookupConfig = envConfig;
         return envConfig;
     }
+    if (process.env.SALESPROMPTER_DISABLE_LINKEDIN_DIRECT_LOOKUP_AUTODISCOVERY === "1") {
+        throw new Error("Missing LinkedIn direct lookup session. Set LINKEDIN_CSRF_TOKEN, LINKEDIN_X_LI_IDENTITY, and LINKEDIN_SALES_NAV_COOKIE, or connect the Salesprompter Chrome extension to sync your LinkedIn session to salesprompter.ai.");
+    }
     const localExtensionConfig = await readLocalLinkedInExtensionDirectLookupConfig();
     if (localExtensionConfig) {
         cachedLinkedInDirectLookupConfig = localExtensionConfig;
@@ -5708,6 +5790,567 @@ async function fetchLinkedInCompaniesBackfillStatus(session, payload) {
     }), LinkedInCompanyBackfillStatusResponseSchema);
     return value;
 }
+class LocalSalesNavigatorRateLimitError extends Error {
+    constructor(status, bodyPreview) {
+        super(`Sales Navigator request stopped because LinkedIn returned HTTP ${status}. ` +
+            "Use LinkedIn directly in a supported browser and wait before trying again. " +
+            `Response preview: ${bodyPreview}`);
+        this.name = "LocalSalesNavigatorRateLimitError";
+    }
+}
+function stripShellQuotes(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2) {
+        const quote = trimmed[0];
+        if ((quote === "'" || quote === '"') && trimmed.at(-1) === quote) {
+            return trimmed.slice(1, -1);
+        }
+    }
+    return trimmed;
+}
+function parseCurlHeaderValue(value) {
+    const separatorIndex = value.indexOf(":");
+    if (separatorIndex <= 0) {
+        return null;
+    }
+    const name = value.slice(0, separatorIndex).trim().toLowerCase();
+    const headerValue = value.slice(separatorIndex + 1).trim();
+    if (!name || name === "cookie") {
+        return null;
+    }
+    return [name, headerValue];
+}
+function parseSalesNavigatorCurlRequest(curlText) {
+    const urlMatch = curlText.match(/\bcurl\s+(?:--location\s+|-L\s+)?(['"])(https?:\/\/[\s\S]*?)\1/);
+    const fallbackUrlMatch = curlText.match(/\bcurl\s+(https?:\/\/\S+)/);
+    const url = stripShellQuotes(urlMatch?.[2] ?? fallbackUrlMatch?.[1] ?? "");
+    if (!url) {
+        throw new Error("Could not find a URL in the curl request.");
+    }
+    const headers = {};
+    for (const match of curlText.matchAll(/(?:-H|--header)\s+(['"])([\s\S]*?)\1/g)) {
+        const parsed = parseCurlHeaderValue(match[2] ?? "");
+        if (parsed) {
+            headers[parsed[0]] = parsed[1];
+        }
+    }
+    const cookieMatch = curlText.match(/(?:-b|--cookie)\s+(['"])([\s\S]*?)\1/) ??
+        curlText.match(/(?:-b|--cookie)\s+([^\s\\]+)/);
+    const cookie = stripShellQuotes(cookieMatch?.[2] ?? cookieMatch?.[1] ?? "");
+    if (cookie) {
+        headers.cookie = cookie;
+    }
+    return { url, headers };
+}
+function extractRawUrlSearchParam(url, key) {
+    const search = url.search.startsWith("?") ? url.search.slice(1) : url.search;
+    for (const part of search.split("&")) {
+        const separatorIndex = part.indexOf("=");
+        const name = separatorIndex >= 0 ? part.slice(0, separatorIndex) : part;
+        if (decodeURIComponent(name.replace(/\+/g, " ")) === key) {
+            const value = separatorIndex >= 0 ? part.slice(separatorIndex + 1) : "";
+            return value.length > 0 ? value : null;
+        }
+    }
+    return null;
+}
+function decodeRawSalesNavigatorQueryParam(rawQuery) {
+    try {
+        return decodeURIComponent(rawQuery.replace(/\+/g, "%20"));
+    }
+    catch {
+        return rawQuery;
+    }
+}
+function normalizeSalesNavigatorApiQueryValue(rawQuery) {
+    const decoded = decodeRawSalesNavigatorQueryParam(rawQuery);
+    const withRecentSearchId = decoded.replace(/recentSearchParam:\((?![^)]*\bid:)([^)]*)\)/, (_match, inner) => `recentSearchParam:(id:${Date.now()},${inner})`);
+    return withRecentSearchId.includes("spellCorrectionEnabled:")
+        ? withRecentSearchId
+        : withRecentSearchId.replace(/^\(/, "(spellCorrectionEnabled:true,");
+}
+function buildSalesNavigatorApiRequestFromSearchUrl(searchUrl, config, count) {
+    const source = new URL(searchUrl);
+    if (source.pathname.includes("/sales-api/salesApiLeadSearch")) {
+        return {
+            url: source.toString(),
+            headers: buildLinkedInSalesNavigatorLocalImportHeaders(config)
+        };
+    }
+    if (!source.pathname.includes("/sales/search/people")) {
+        throw new Error("Automatic Sales Navigator import requires a /sales/search/people URL.");
+    }
+    const rawQuery = extractRawUrlSearchParam(source, "query");
+    if (!rawQuery) {
+        throw new Error("Sales Navigator search URL is missing the query parameter.");
+    }
+    const baseUrl = process.env.SALESPROMPTER_LINKEDIN_SALES_API_BASE_URL?.trim() ||
+        `${source.protocol}//${source.host}`;
+    const rawSessionId = extractRawUrlSearchParam(source, "sessionId") ?? encodeURIComponent(generateLinkedInSessionId());
+    const apiQuery = normalizeSalesNavigatorApiQueryValue(rawQuery);
+    const normalizedCount = Math.max(1, Math.min(100, Math.trunc(count)));
+    const apiUrl = `${baseUrl.replace(/\/+$/, "")}/sales-api/salesApiLeadSearch` +
+        `?q=searchQuery&query=${apiQuery}&start=0&count=${normalizedCount}` +
+        `&trackingParam=(sessionId:${rawSessionId})` +
+        "&decorationId=com.linkedin.sales.deco.desktop.searchv2.LeadSearchResult-14";
+    return {
+        url: apiUrl,
+        headers: buildLinkedInSalesNavigatorLocalImportHeaders(config)
+    };
+}
+function withSalesNavigatorPaging(url, start, count) {
+    const normalizedStart = String(Math.max(0, Math.trunc(start)));
+    const normalizedCount = String(Math.max(1, Math.min(100, Math.trunc(count))));
+    const hashIndex = url.indexOf("#");
+    const withoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+    const hash = hashIndex >= 0 ? url.slice(hashIndex) : "";
+    const queryIndex = withoutHash.indexOf("?");
+    if (queryIndex < 0) {
+        return `${withoutHash}?start=${normalizedStart}&count=${normalizedCount}${hash}`;
+    }
+    const base = withoutHash.slice(0, queryIndex);
+    const search = withoutHash.slice(queryIndex + 1);
+    const params = search
+        .split("&")
+        .filter((part) => {
+        const key = part.split("=", 1)[0]?.toLowerCase();
+        return key !== "start" && key !== "count";
+    });
+    params.push(`start=${normalizedStart}`, `count=${normalizedCount}`);
+    return `${base}?${params.join("&")}${hash}`;
+}
+function buildLinkedInSalesNavigatorLocalImportHeaders(config) {
+    return {
+        accept: "*/*",
+        "csrf-token": config.csrfToken,
+        cookie: config.cookie,
+        "user-agent": config.userAgent,
+        "x-li-identity": config.identity,
+        "x-restli-protocol-version": "2.0.0"
+    };
+}
+function getNestedValue(record, pathParts) {
+    let current = record;
+    for (const part of pathParts) {
+        if (typeof current !== "object" || current === null || Array.isArray(current)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function firstLocalString(record, paths) {
+    for (const pathName of paths) {
+        const value = getNestedValue(record, pathName.split("."));
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function flattenSalesNavigatorRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return {};
+    }
+    const record = value;
+    const entity = (record.entityResult ?? record.lead ?? record.profile ?? record.person ?? record);
+    return typeof entity === "object" && entity !== null && !Array.isArray(entity) ? { ...record, ...entity } : record;
+}
+function deriveLocalSalesNavigatorProfileUrl(record) {
+    const direct = firstLocalString(record, [
+        "profileUrl",
+        "defaultProfileUrl",
+        "linkedInProfileUrl",
+        "navigationUrl",
+        "url",
+        "profilePicture.profileUrl"
+    ]);
+    if (direct) {
+        try {
+            const parsed = new URL(direct, "https://www.linkedin.com");
+            return parsed.toString();
+        }
+        catch {
+            return direct;
+        }
+    }
+    const publicIdentifier = firstLocalString(record, [
+        "publicIdentifier",
+        "public_id",
+        "miniProfile.publicIdentifier",
+        "member.publicIdentifier"
+    ]);
+    if (publicIdentifier) {
+        return `https://www.linkedin.com/in/${encodeURIComponent(publicIdentifier)}`;
+    }
+    const urn = firstLocalString(record, ["entityUrn", "profileUrn", "objectUrn", "memberUrn", "urn"]);
+    const urnId = urn?.match(/fs_salesProfile:\(([^,)]+)/i)?.[1] ?? urn?.match(/(?:profile|member|lead):([^,)]+)/i)?.[1];
+    return urnId ? `https://www.linkedin.com/sales/lead/${encodeURIComponent(urnId)}` : null;
+}
+function firstLocalArrayRecord(record, key) {
+    const value = record[key];
+    if (!Array.isArray(value)) {
+        return {};
+    }
+    const first = value.find((item) => typeof item === "object" && item !== null && !Array.isArray(item));
+    return first ? first : {};
+}
+function firstLocalNestedRecord(record, key) {
+    const value = record[key];
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function deriveLocalCompanyId(record, currentPosition, company) {
+    const direct = firstLocalString(record, ["companyId", "currentCompanyId", "company.id"]);
+    if (direct) {
+        return direct;
+    }
+    const urn = firstLocalString(currentPosition, ["companyUrn"]) ?? firstLocalString(company, ["entityUrn"]);
+    return urn?.match(/:(\d+)$/)?.[1] ?? null;
+}
+function formatSalesNavigatorTenure(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    const years = typeof record.numYears === "number" && Number.isFinite(record.numYears) ? `${record.numYears}y` : null;
+    const months = typeof record.numMonths === "number" && Number.isFinite(record.numMonths) ? `${record.numMonths}m` : null;
+    return [years, months].filter(Boolean).join(" ") || null;
+}
+function buildLinkedInImageUrl(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    const rootUrl = typeof record.rootUrl === "string" ? record.rootUrl : null;
+    if (!rootUrl || !Array.isArray(record.artifacts)) {
+        return null;
+    }
+    const artifact = record.artifacts
+        .filter((item) => typeof item === "object" && item !== null && !Array.isArray(item))
+        .sort((left, right) => Number(right.width ?? 0) - Number(left.width ?? 0))[0];
+    const pathSegment = typeof artifact?.fileIdentifyingUrlPathSegment === "string" ? artifact.fileIdentifyingUrlPathSegment : null;
+    return pathSegment ? `${rootUrl}${pathSegment}` : null;
+}
+function deriveSharedConnectionsCount(record) {
+    const badges = Array.isArray(record.spotlightBadges) ? record.spotlightBadges : [];
+    for (const badge of badges) {
+        if (typeof badge !== "object" || badge === null || Array.isArray(badge)) {
+            continue;
+        }
+        const displayValue = firstLocalString(badge, ["displayValue"]);
+        const match = displayValue?.match(/(\d+)\s+mutual connection/i);
+        if (match) {
+            return Number(match[1]);
+        }
+    }
+    return null;
+}
+function deriveLocalSalesNavigatorFullName(record) {
+    const direct = firstLocalString(record, [
+        "fullName",
+        "name",
+        "title.text",
+        "profileName",
+        "miniProfile.fullName"
+    ]);
+    if (direct) {
+        return direct;
+    }
+    const firstName = firstLocalString(record, ["firstName", "miniProfile.firstName"]);
+    const lastName = firstLocalString(record, ["lastName", "miniProfile.lastName"]);
+    return [firstName, lastName].filter(Boolean).join(" ").trim() || null;
+}
+function collectPotentialSalesNavigatorRows(value, rows = []) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectPotentialSalesNavigatorRows(item, rows);
+        }
+        return rows;
+    }
+    if (typeof value !== "object" || value === null) {
+        return rows;
+    }
+    const record = flattenSalesNavigatorRecord(value);
+    if (deriveLocalSalesNavigatorProfileUrl(record) &&
+        (deriveLocalSalesNavigatorFullName(record) ||
+            firstLocalString(record, ["occupation", "title", "headline", "currentPositions.0.title"]))) {
+        rows.push(record);
+    }
+    for (const nested of Object.values(value)) {
+        if (typeof nested === "object" && nested !== null) {
+            collectPotentialSalesNavigatorRows(nested, rows);
+        }
+    }
+    return rows;
+}
+function normalizeLocalSalesNavigatorPeople(responseBody, queryUrl) {
+    const seen = new Set();
+    const rows = [];
+    for (const record of collectPotentialSalesNavigatorRows(responseBody)) {
+        const currentPosition = firstLocalArrayRecord(record, "currentPositions");
+        const company = firstLocalNestedRecord(currentPosition, "companyUrnResolutionResult");
+        const profileUrl = deriveLocalSalesNavigatorProfileUrl(record);
+        if (!profileUrl || seen.has(profileUrl)) {
+            continue;
+        }
+        seen.add(profileUrl);
+        const fullName = deriveLocalSalesNavigatorFullName(record);
+        const companyId = deriveLocalCompanyId(record, currentPosition, company);
+        rows.push({
+            profileUrl,
+            defaultProfileUrl: profileUrl,
+            linkedInProfileUrl: profileUrl.includes("/in/") ? profileUrl : null,
+            fullName,
+            firstName: firstLocalString(record, ["firstName", "miniProfile.firstName"]),
+            lastName: firstLocalString(record, ["lastName", "miniProfile.lastName"]),
+            title: firstLocalString(record, ["occupation", "title", "headline"]) ?? firstLocalString(currentPosition, ["title"]),
+            companyName: firstLocalString(record, [
+                "companyName",
+                "currentCompanyName"
+            ]) ?? firstLocalString(currentPosition, ["companyName"]) ?? firstLocalString(company, ["name"]),
+            companyId,
+            companyUrl: firstLocalString(record, ["companyUrl", "company.url"]) ?? (companyId ? `https://www.linkedin.com/sales/company/${companyId}` : null),
+            regularCompanyUrl: companyId ? `https://www.linkedin.com/company/${companyId}` : null,
+            location: firstLocalString(record, ["location", "geoRegion", "locationName"]),
+            industry: firstLocalString(record, ["industry"]) ?? firstLocalString(company, ["industry"]),
+            summary: firstLocalString(record, ["summary", "description"]),
+            titleDescription: firstLocalString(record, ["titleDescription"]) ?? firstLocalString(currentPosition, ["description"]),
+            companyLocation: firstLocalString(record, ["companyLocation"]) ?? firstLocalString(company, ["location"]),
+            durationInRole: firstLocalString(record, ["durationInRole"]) ?? formatSalesNavigatorTenure(currentPosition.tenureAtPosition),
+            durationInCompany: firstLocalString(record, ["durationInCompany"]) ?? formatSalesNavigatorTenure(currentPosition.tenureAtCompany),
+            connectionDegree: firstLocalString(record, ["connectionDegree"]) ?? (record.degree != null ? String(record.degree) : null),
+            sharedConnectionsCount: deriveSharedConnectionsCount(record),
+            profileImageUrl: firstLocalString(record, ["profileImageUrl", "pictureUrl", "profilePicture.displayImage"]) ?? buildLinkedInImageUrl(record.profilePictureDisplayImage),
+            vmid: firstLocalString(record, ["vmid", "memberId", "profileId"]),
+            isPremium: typeof record.premium === "boolean" ? record.premium : null,
+            isOpenLink: typeof record.openLink === "boolean" ? record.openLink : null,
+            query: queryUrl,
+            timestamp: new Date().toISOString(),
+            rawLocalSalesNavigatorResult: record
+        });
+    }
+    return rows;
+}
+function extractLocalSalesNavigatorTotalResults(responseBody) {
+    if (typeof responseBody !== "object" || responseBody === null || Array.isArray(responseBody)) {
+        return null;
+    }
+    const record = responseBody;
+    const candidates = [record.paging, record.metadata, record.searchResultsMetadata, record];
+    for (const candidate of candidates) {
+        if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) {
+            continue;
+        }
+        for (const key of ["total", "totalResults", "resultCount", "count"]) {
+            const value = candidate[key];
+            if (typeof value === "number" && Number.isFinite(value)) {
+                return Math.trunc(value);
+            }
+        }
+    }
+    return null;
+}
+function randomIntegerBetween(min, max) {
+    const lower = Math.max(0, Math.trunc(min));
+    const upper = Math.max(lower, Math.trunc(max));
+    return lower + Math.floor(Math.random() * (upper - lower + 1));
+}
+function isSalesNavigatorRateLimitStatus(status, text) {
+    return (status === 429 ||
+        status === 999 ||
+        /too many requests|rate limit|unusual activity|automated activity|temporarily restricted/i.test(text));
+}
+function isRetryableLocalSalesNavigatorStatus(status) {
+    return status === 408 || status === 425 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+async function waitWithFullJitter(baseDelayMs, maxDelayMs, attempt) {
+    const exponentialCap = Math.min(Math.max(0, Math.trunc(maxDelayMs)), Math.max(0, Math.trunc(baseDelayMs)) * 2 ** Math.max(0, attempt));
+    const delayMs = randomIntegerBetween(0, exponentialCap);
+    if (delayMs > 0) {
+        await delay(delayMs);
+    }
+    return delayMs;
+}
+async function fetchLocalSalesNavigatorRequest(parsedRequest, retryOptions) {
+    let retryCount = 0;
+    let retryDelayMs = 0;
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            const response = await fetch(parsedRequest.url, {
+                method: "GET",
+                headers: parsedRequest.headers
+            });
+            const text = await response.text();
+            if (!response.ok) {
+                const preview = text.slice(0, 300);
+                if (isSalesNavigatorRateLimitStatus(response.status, text)) {
+                    throw new LocalSalesNavigatorRateLimitError(response.status, preview);
+                }
+                if (isRetryableLocalSalesNavigatorStatus(response.status) && attempt < retryOptions.maxRetries) {
+                    retryCount += 1;
+                    retryDelayMs += await waitWithFullJitter(retryOptions.retryBaseDelayMs, retryOptions.retryMaxDelayMs, attempt);
+                    continue;
+                }
+                throw new Error(`Sales Navigator request failed with HTTP ${response.status}: ${preview}`);
+            }
+            try {
+                return { body: JSON.parse(text), retryCount, retryDelayMs };
+            }
+            catch {
+                throw new Error("Sales Navigator response was not valid JSON.");
+            }
+        }
+        catch (error) {
+            if (error instanceof LocalSalesNavigatorRateLimitError) {
+                throw error;
+            }
+            if (attempt < retryOptions.maxRetries) {
+                retryCount += 1;
+                retryDelayMs += await waitWithFullJitter(retryOptions.retryBaseDelayMs, retryOptions.retryMaxDelayMs, attempt);
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+async function fetchAllLocalSalesNavigatorPeople(parsedRequest, options) {
+    const people = [];
+    const seen = new Set();
+    let totalResults = null;
+    let fetchedPages = 0;
+    let totalDelayMs = 0;
+    let retryCount = 0;
+    const pageSize = Math.max(1, Math.min(100, Math.trunc(options.pageSize)));
+    const requestedProfiles = options.requestedProfiles == null ? null : Math.max(1, Math.trunc(options.requestedProfiles));
+    const pageDelayMinMs = Math.max(0, Math.trunc(options.pageDelayMinMs));
+    const pageDelayMaxMs = Math.max(pageDelayMinMs, Math.trunc(options.pageDelayMaxMs));
+    for (let start = 0;; start += pageSize) {
+        const remainingRequested = requestedProfiles == null ? pageSize : requestedProfiles - people.length;
+        if (remainingRequested <= 0) {
+            break;
+        }
+        const currentCount = Math.min(pageSize, remainingRequested);
+        const pageRequest = {
+            ...parsedRequest,
+            url: withSalesNavigatorPaging(parsedRequest.url, start, currentCount)
+        };
+        const response = await fetchLocalSalesNavigatorRequest(pageRequest, options.retry);
+        retryCount += response.retryCount;
+        totalDelayMs += response.retryDelayMs;
+        const responseBody = response.body;
+        fetchedPages += 1;
+        totalResults = totalResults ?? extractLocalSalesNavigatorTotalResults(responseBody);
+        const pagePeople = normalizeLocalSalesNavigatorPeople(responseBody, pageRequest.url);
+        let added = 0;
+        for (const person of pagePeople) {
+            if (seen.has(person.profileUrl)) {
+                continue;
+            }
+            seen.add(person.profileUrl);
+            people.push(person);
+            added += 1;
+            if (requestedProfiles != null && people.length >= requestedProfiles) {
+                break;
+            }
+        }
+        const reportedTotalReached = totalResults != null && start + currentCount >= totalResults;
+        if (pagePeople.length === 0 || added === 0 || reportedTotalReached) {
+            break;
+        }
+        const pageDelayMs = randomIntegerBetween(pageDelayMinMs, pageDelayMaxMs);
+        if (pageDelayMs > 0) {
+            totalDelayMs += pageDelayMs;
+            await delay(pageDelayMs);
+        }
+    }
+    return {
+        people,
+        totalResults,
+        fetchedPages,
+        sourceQueryUrl: parsedRequest.url,
+        pacing: {
+            delayMinMs: pageDelayMinMs,
+            delayMaxMs: pageDelayMaxMs,
+            totalDelayMs,
+            retryCount
+        }
+    };
+}
+async function importLocalSalesNavigatorPeopleViaApp(session, payload) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/local-import`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify({
+            sourceQueryUrl: payload.sourceQueryUrl,
+            slicedQueryUrl: payload.sourceQueryUrl,
+            appliedFilters: [],
+            maxResultsPerSearch: payload.maxResultsPerSearch,
+            numberOfProfiles: payload.numberOfProfiles,
+            slicePreset: payload.slicePreset,
+            totalResults: payload.totalResults,
+            fetchedPages: payload.fetchedPages,
+            people: payload.people,
+            rawPayload: {
+                workflow: "salesnav:local-import",
+                localPeopleCount: payload.people.length,
+                fetchedPages: payload.fetchedPages,
+                pacing: payload.pacing
+            }
+        })
+    }), SalesNavigatorLocalImportResponseSchema);
+    return value;
+}
+async function runLeadPoolAutoProcessViaApp(session, payload) {
+    const url = new URL('/api/leadpool/auto-process', session.apiBaseUrl);
+    if (payload.clientId)
+        url.searchParams.set('clientId', String(payload.clientId));
+    url.searchParams.set('companyLimit', String(payload.companyLimit));
+    url.searchParams.set('contactCountryLimit', String(payload.contactCountryLimit));
+    url.searchParams.set('contactNameLimit', String(payload.contactNameLimit));
+    url.searchParams.set('hunterLimit', String(payload.hunterLimit));
+    url.searchParams.set('hunterConcurrency', String(payload.hunterConcurrency));
+    url.searchParams.set('refresh', payload.refresh ? 'true' : 'false');
+    url.searchParams.set('qualifiedLeads', payload.qualifiedLeads ? 'true' : 'false');
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(url.toString(), {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`
+        }
+    }), LeadPoolAutoProcessResponseSchema);
+    return value;
+}
+async function launchAffiliateCampaignViaApp(session, payload) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-campaigns`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify(payload)
+    }), AffiliateCampaignLaunchResponseSchema);
+    return value;
+}
+async function runLeadPoolEmailFinderViaApp(session, payload) {
+    const url = new URL('/api/leadpool/process-hunter-emails', session.apiBaseUrl);
+    url.searchParams.set('provider', payload.provider);
+    url.searchParams.set('limit', String(payload.limit));
+    if (payload.concurrency != null) {
+        url.searchParams.set('concurrency', String(payload.concurrency));
+    }
+    if (payload.retryNotFoundAfterDays != null) {
+        url.searchParams.set('retryNotFoundAfterDays', String(payload.retryNotFoundAfterDays));
+    }
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(url.toString(), {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`
+        }
+    }), LeadPoolEmailFinderProcessResponseSchema);
+    return value;
+}
 async function syncPhantombusterContainersViaApp(session, payload) {
     const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/phantombuster/containers/sync`, {
         method: "POST",
@@ -5877,7 +6520,8 @@ async function startSalesNavigatorExport(session, payload, traceId) {
     const sessionOverridePayload = exportSession
         ? {
             sessionCookie: exportSession.sessionCookie,
-            selectedSessionCookieSha256: exportSession.selectedSessionCookieSha256
+            selectedSessionCookieSha256: exportSession.selectedSessionCookieSha256,
+            selectedSessionUserAgent: exportSession.selectedSessionUserAgent
         }
         : {};
     return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/export`, {
@@ -6706,9 +7350,6 @@ function hashSalesNavigatorSessionCookieForPhantombuster(sessionCookie) {
     }
     return createHash("sha256").update(liAt).digest("hex");
 }
-function normalizeSalesNavigatorSessionCookieForPhantombuster(sessionCookie) {
-    return extractLiAtCookieValue(sessionCookie) ?? sessionCookie;
-}
 function cacheSalesNavigatorExportSessionOverride(queryUrl, value) {
     cachedSalesNavigatorExportSessionOverride = {
         queryUrl,
@@ -6728,8 +7369,9 @@ async function resolveSalesNavigatorExportSessionOverride(queryUrl, options) {
         const selectedSessionCookieSha256 = hashSalesNavigatorSessionCookieForPhantombuster(localExtensionConfig.cookie);
         if (process.env.SALESPROMPTER_SALESNAV_EXPORT_SKIP_EXTENSION_PREFLIGHT === "1") {
             return cacheSalesNavigatorExportSessionOverride(queryUrl, {
-                sessionCookie: normalizeSalesNavigatorSessionCookieForPhantombuster(localExtensionConfig.cookie),
+                sessionCookie: localExtensionConfig.cookie,
                 selectedSessionCookieSha256,
+                selectedSessionUserAgent: localExtensionConfig.userAgent,
                 source: "chrome_extension"
             });
         }
@@ -6746,8 +7388,9 @@ async function resolveSalesNavigatorExportSessionOverride(queryUrl, options) {
         });
         if (probe.status === "ok") {
             return cacheSalesNavigatorExportSessionOverride(queryUrl, {
-                sessionCookie: normalizeSalesNavigatorSessionCookieForPhantombuster(localExtensionConfig.cookie),
+                sessionCookie: localExtensionConfig.cookie,
                 selectedSessionCookieSha256,
+                selectedSessionUserAgent: localExtensionConfig.userAgent,
                 source: "chrome_extension"
             });
         }
@@ -6759,9 +7402,10 @@ async function resolveSalesNavigatorExportSessionOverride(queryUrl, options) {
     });
     if (claimed?.sessionCookie) {
         return cacheSalesNavigatorExportSessionOverride(queryUrl, {
-            sessionCookie: normalizeSalesNavigatorSessionCookieForPhantombuster(claimed.sessionCookie),
+            sessionCookie: claimed.sessionCookie,
             selectedSessionCookieSha256: claimed.sessionCookieSha256 ??
                 hashSalesNavigatorSessionCookieForPhantombuster(claimed.sessionCookie),
+            selectedSessionUserAgent: null,
             source: "session_vault"
         });
     }
@@ -9140,7 +9784,7 @@ program
     const titleLimit = options.titleLimit === undefined
         ? undefined
         : z.coerce.number().int().min(1).max(1000).parse(options.titleLimit);
-    const maxResultsPerSearch = z.coerce.number().int().min(1).max(2500).parse(options.maxResultsPerSearch);
+    const maxResultsPerSearch = z.coerce.number().int().min(1).max(100000).parse(options.maxResultsPerSearch);
     const numberOfProfiles = z.coerce.number().int().min(1).max(2500).parse(options.numberOfProfiles);
     const maxSplitDepth = z.coerce.number().int().min(1).max(6).parse(options.maxSplitDepth);
     const maxSlicesPerTitle = z.coerce.number().int().min(1).max(10000).parse(options.maxSlicesPerTitle);
@@ -9981,6 +10625,7 @@ program
     .alias("pb:containers:sync")
     .description("Fetch Phantombuster containers for configured agents and store them in Neon.")
     .option("--agent-id <id>", "Phantombuster agent id to sync. Repeat to sync multiple agents.", collectStringOptionValue, [])
+    .option("--container-id <id>", "Specific Phantombuster container id to sync. Repeat to sync multiple containers.", collectStringOptionValue, [])
     .option("--limit <number>", "Maximum containers to fetch per Phantombuster page", "100")
     .option("--max-pages <number>", "Maximum Phantombuster pages to fetch per agent", "50")
     .option("--mode <mode>", "Phantombuster container mode: all or finalized", "all")
@@ -9990,6 +10635,7 @@ program
     .option("--out <path>", "Optional local JSON output path")
     .action(async (options) => {
     const agentIds = z.array(z.string().min(1)).parse(options.agentId);
+    const containerIds = z.array(z.string().min(1)).parse(options.containerId);
     const limit = z.coerce.number().int().min(1).max(500).parse(options.limit);
     const maxPages = z.coerce.number().int().min(1).max(500).parse(options.maxPages);
     const mode = z.enum(["all", "finalized"]).parse(options.mode);
@@ -9999,6 +10645,7 @@ program
     const session = await requireAuthSession();
     const result = await syncPhantombusterContainersViaApp(session, {
         agentIds: agentIds.length > 0 ? agentIds : undefined,
+        containerIds: containerIds.length > 0 ? containerIds : undefined,
         limit,
         maxPages,
         mode,
@@ -10090,6 +10737,100 @@ program
     }
     printOutput(payload);
 });
+program
+    .command("salesnav:local-import")
+    .alias("search:local-import")
+    .description("Run a saved Sales Navigator API request locally and store the people in Salesprompter.")
+    .option("--curl-file <path>", "Path to a saved curl request copied from the Sales Navigator network panel")
+    .option("--query-url <url>", "Sales Navigator people search URL. Uses the locally captured extension session automatically.")
+    .option("--max-results-per-search <number>", "Maximum expected results for this local request", "100")
+    .option("--number-of-profiles <number>", "Total profiles to import, or 'all' for the full reported result set", "all")
+    .option("--page-size <number>", "Profiles requested per local Sales Navigator API page", "25")
+    .option("--page-delay-min-ms <number>", "Minimum randomized delay between Sales Navigator result pages", "1500")
+    .option("--page-delay-max-ms <number>", "Maximum randomized delay between Sales Navigator result pages", "6000")
+    .option("--max-retries <number>", "Bounded retries for transient network/5xx failures. Rate limits still stop immediately.", "2")
+    .option("--retry-base-delay-ms <number>", "Base delay for full-jitter retry backoff", "2000")
+    .option("--retry-max-delay-ms <number>", "Maximum delay for full-jitter retry backoff", "30000")
+    .option("--slice-preset <name>", "Slice preset label stored with the import run", "local-salesnav")
+    .option("--out <path>", "Optional local JSON output path")
+    .option("--dry-run", "Run and normalize the local request without writing to Salesprompter", false)
+    .action(async (options) => {
+    const maxResultsPerSearch = z.coerce.number().int().min(1).max(100000).parse(options.maxResultsPerSearch);
+    const numberOfProfilesOption = String(options.numberOfProfiles ?? "all").trim().toLowerCase();
+    const requestedProfiles = numberOfProfilesOption === "all" ? null : z.coerce.number().int().min(1).max(100000).parse(options.numberOfProfiles);
+    const pageSize = z.coerce.number().int().min(1).max(100).parse(options.pageSize);
+    const pageDelayMinMs = z.coerce.number().int().min(0).max(300000).parse(options.pageDelayMinMs);
+    const pageDelayMaxMs = z.coerce.number().int().min(0).max(300000).parse(options.pageDelayMaxMs);
+    if (pageDelayMaxMs < pageDelayMinMs) {
+        throw new Error("--page-delay-max-ms must be greater than or equal to --page-delay-min-ms.");
+    }
+    const retry = {
+        maxRetries: z.coerce.number().int().min(0).max(5).parse(options.maxRetries),
+        retryBaseDelayMs: z.coerce.number().int().min(0).max(300000).parse(options.retryBaseDelayMs),
+        retryMaxDelayMs: z.coerce.number().int().min(0).max(300000).parse(options.retryMaxDelayMs)
+    };
+    const curlFile = typeof options.curlFile === "string" && options.curlFile.trim().length > 0 ? options.curlFile.trim() : null;
+    const queryUrl = typeof options.queryUrl === "string" && options.queryUrl.trim().length > 0 ? z.string().url().parse(options.queryUrl.trim()) : null;
+    if (Boolean(curlFile) === Boolean(queryUrl)) {
+        throw new Error("Provide exactly one of --curl-file or --query-url.");
+    }
+    const parsedRequest = curlFile
+        ? parseSalesNavigatorCurlRequest(await readFile(curlFile, "utf8"))
+        : buildSalesNavigatorApiRequestFromSearchUrl(queryUrl, await readLinkedInDirectLookupConfig(), pageSize);
+    const localFetch = await fetchAllLocalSalesNavigatorPeople(parsedRequest, {
+        requestedProfiles,
+        pageSize,
+        pageDelayMinMs,
+        pageDelayMaxMs,
+        retry
+    });
+    const people = localFetch.people;
+    const totalResults = localFetch.totalResults;
+    const dryRun = Boolean(options.dryRun);
+    if (people.length === 0) {
+        throw new Error("The local Sales Navigator response did not contain any importable people rows.");
+    }
+    const basePayload = {
+        status: "ok",
+        dryRun,
+        sourceQueryUrl: localFetch.sourceQueryUrl,
+        totalResults,
+        discovered: people.length,
+        fetchedPages: localFetch.fetchedPages,
+        requestedProfiles: requestedProfiles ?? "all",
+        pacing: localFetch.pacing,
+        people
+    };
+    if (dryRun) {
+        if (options.out) {
+            await writeJsonFile(options.out, basePayload);
+        }
+        printOutput(basePayload);
+        return;
+    }
+    const session = await requireAuthSession();
+    const imported = await importLocalSalesNavigatorPeopleViaApp(session, {
+        sourceQueryUrl: localFetch.sourceQueryUrl,
+        people,
+        totalResults,
+        fetchedPages: localFetch.fetchedPages,
+        pacing: localFetch.pacing,
+        maxResultsPerSearch,
+        numberOfProfiles: requestedProfiles ?? people.length,
+        slicePreset: options.slicePreset
+    });
+    const payload = {
+        ...basePayload,
+        runId: imported.runId,
+        containerId: imported.containerId,
+        imported: imported.imported,
+        upserted: imported.upserted
+    };
+    if (options.out) {
+        await writeJsonFile(options.out, payload);
+    }
+    printOutput(payload);
+});
 program
     .command("salesnav:count")
     .alias("search:count")
@@ -10752,6 +11493,54 @@ program
         execution
     });
 });
+program
+    .command("affiliate:launch")
+    .description("Turn an affiliate link and LinkedIn audience URL into a ready-to-review outreach campaign.")
+    .requiredOption("--affiliate-link <url>", "Affiliate landing URL, including the tracking/referral parameter")
+    .requiredOption("--linkedin-url <url>", "LinkedIn content/search URL for the audience")
+    .option("--max-results <number>", "Maximum audience profiles to extract", "1000")
+    .option("--dry-run", "Validate inputs and show the planned campaign without launching extraction", false)
+    .action(async (options) => {
+    const session = await requireAuthSession();
+    const result = await launchAffiliateCampaignViaApp(session, {
+        affiliateLink: z.string().url().parse(options.affiliateLink),
+        linkedInUrl: z.string().url().parse(options.linkedinUrl),
+        maxResults: z.coerce.number().int().min(1).max(1000).parse(options.maxResults),
+        dryRun: Boolean(options.dryRun)
+    });
+    printOutput(result);
+});
+program
+    .command("leads:process")
+    .description("Automatically process the lead pool: companies, contact cleanup, email finding, and qualified leads.")
+    .option("--client-id <number>", "Limit processing to one Salesprompter clientId")
+    .option("--company-limit <number>", "Max companies to start per enrichment batch", "10")
+    .option("--contact-country-limit <number>", "Max contact country-code rows to process", "500")
+    .option("--contact-name-limit <number>", "Max contact name rows to clean", "250")
+    .option("--hunter-limit <number>", "Max Hunter email-finder rows to process", "500")
+    .option("--hunter-concurrency <number>", "Hunter email-finder concurrency", "6")
+    .option("--refresh", "Run a full lead-pool refresh after processing", false)
+    .option("--no-qualified-leads", "Skip rebuilding the qualified lead snapshot")
+    .action(async (options) => {
+    const session = await requireAuthSession();
+    const clientId = options.clientId == null || String(options.clientId).trim() === ''
+        ? null
+        : parsePositiveClientIdValue(options.clientId);
+    const result = await runLeadPoolAutoProcessViaApp(session, {
+        clientId,
+        companyLimit: z.coerce.number().int().min(1).max(50).parse(options.companyLimit),
+        contactCountryLimit: z.coerce.number().int().min(1).max(5000).parse(options.contactCountryLimit),
+        contactNameLimit: z.coerce.number().int().min(1).max(250).parse(options.contactNameLimit),
+        hunterLimit: z.coerce.number().int().min(1).max(10000).parse(options.hunterLimit),
+        hunterConcurrency: z.coerce.number().int().min(1).max(12).parse(options.hunterConcurrency),
+        refresh: Boolean(options.refresh),
+        qualifiedLeads: options.qualifiedLeads !== false,
+    });
+    printOutput({
+        status: result.success ? "ok" : "partial",
+        ...result,
+    });
+});
 program
     .command("contacts:process-emails")
     .alias("contacts:resolve-emails")
@@ -10763,6 +11552,8 @@ program
     .requiredOption("--out-dir <path>", "Output directory for artifacts")
     .option("--trace-id <traceId>", "Trace id for this batch")
     .option("--endpoint-url <url>", "Override the enrichment workflow endpoint")
+    .option("--provider <provider>", "Email finder provider for workspace queue: hunter or phantombuster", "hunter")
+    .option("--retry-not-found-after-days <number>", "Retry stale Email not found rows after this many days", "1")
     .option("--timeout-ms <number>", "Workflow trigger timeout in milliseconds", "30000")
     .option("--company-cleaning <mode>", "Company cleaning mode for direct input: off, basic, or ai", "basic")
     .option("--dry-run", "Preview the next batch without starting background processing", false)
@@ -10771,7 +11562,69 @@ program
     const outDir = z.string().min(1).parse(options.outDir);
     const timeoutMs = z.coerce.number().int().min(1000).max(300000).parse(options.timeoutMs);
     const usingDirectInput = typeof options.in === "string" && options.in.trim().length > 0;
+    const provider = z.enum(["hunter", "phantombuster"]).parse(String(options.provider ?? "hunter").trim().toLowerCase());
+    const retryNotFoundAfterDays = z.coerce.number().int().min(0).max(30).parse(options.retryNotFoundAfterDays);
     const companyCleaningMode = resolveCompanyCleaningMode(String(options.companyCleaning ?? process.env.SALESPROMPTER_COMPANY_CLEANING_MODE ?? "basic"));
+    if (provider === "phantombuster" && !usingDirectInput) {
+        await mkdir(outDir, { recursive: true });
+        const traceId = z.string().min(1).parse(options.traceId ?? `salesprompter-cli-email-phantombuster-${Date.now()}`);
+        const requestPath = `${outDir}/email-enrichment-request-phantombuster.json`;
+        const responsePath = `${outDir}/email-enrichment-response-phantombuster.json`;
+        const requestPayload = {
+            traceId,
+            provider,
+            limit,
+            retryNotFoundAfterDays
+        };
+        await writeJsonFile(requestPath, requestPayload);
+        if (options.dryRun) {
+            printOutput({
+                status: "ok",
+                provider,
+                limit,
+                traceId,
+                dryRun: true,
+                mode: "workspace-queue",
+                contactsQueued: null,
+                started: false,
+                artifacts: {
+                    inputSqlPath: null,
+                    inputRowsPath: null,
+                    directReportPath: null,
+                    requestPath,
+                    responsePath: null
+                }
+            });
+            return;
+        }
+        const session = await requireAuthSession();
+        const result = await runLeadPoolEmailFinderViaApp(session, {
+            provider,
+            limit,
+            retryNotFoundAfterDays
+        });
+        await writeJsonFile(responsePath, result);
+        printOutput({
+            status: result.success ? "ok" : "partial",
+            provider,
+            limit,
+            traceId,
+            dryRun: false,
+            mode: "workspace-queue",
+            contactsQueued: result.selected,
+            started: Boolean(result.launched),
+            agentId: result.agentId ?? null,
+            containerId: result.containerId ?? null,
+            artifacts: {
+                inputSqlPath: null,
+                inputRowsPath: null,
+                directReportPath: null,
+                requestPath,
+                responsePath
+            }
+        });
+        return;
+    }
     let clientId;
     let queueRows;
     let directReportRows = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salesprompter-cli",
-  "version": "0.1.38",
+  "version": "0.1.40",
   "description": "Sales workflow CLI for guided lead generation, enrichment, scoring, and sync.",
   "author": "Daniel Sinewe <hello@danielsinewe.com>",
   "type": "module",