salesprompter-cli 0.1.17 → 0.1.19

package/dist/cli.js

@@ -2,20 +2,25 @@
 import { spawn } from "node:child_process";
 import { access } from "node:fs/promises";
 import { createRequire } from "node:module";
+import path from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import { createInterface } from "node:readline/promises";
+import { setTimeout as delay } from "node:timers/promises";
 import { Command } from "commander";
 import { z } from "zod";
 import { clearAuthSession, loginWithBrowserConnect, loginWithDeviceFlow, loginWithToken, requireAuthSession, shouldBypassAuth, verifySession } from "./auth.js";
 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 { 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 { crawlLinkedInProductCategory } from "./linkedin-products.js";
 import { buildLeadlistsFunnelQueries } from "./leadlists-funnel.js";
 import { readJsonFile, splitCsv, writeJsonFile, writeTextFile } from "./io.js";
+import { buildSalesNavigatorCrawlPreview, createSalesNavigatorCrawlSeed, DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS, buildSalesNavigatorPeopleSlice, expandSalesNavigatorCrawlAttempt, SalesNavigatorSliceTooBroadError } from "./sales-navigator.js";
 const require = createRequire(import.meta.url);
 const { version: packageVersion } = require("../package.json");
 const program = new Command();
@@ -27,6 +32,155 @@ const runtimeOutputOptions = {
     json: false,
     quiet: false
 };
+const nullableOptionalString = z.string().min(1).nullish().transform((value) => value ?? undefined);
+const WorkspaceLeadSchema = LeadSchema.extend({
+    companySize: nullableOptionalString.optional(),
+    country: nullableOptionalString.optional()
+});
+const WorkspaceLeadSearchResponseSchema = z.object({
+    leads: z.array(WorkspaceLeadSchema),
+    stats: z
+        .object({
+        count: z.number().int().nonnegative()
+    })
+        .optional()
+});
+const LinkedInProductIngestResponseSchema = z.object({
+    imported: z.number().int().nonnegative(),
+    upserted: z.number().int().nonnegative(),
+    totalInCatalog: z.number().int().nonnegative().optional()
+});
+const SalesNavigatorExportStartResponseSchema = z.object({
+    status: z.literal("accepted"),
+    runId: z.string().min(1),
+    exportStatus: z.literal("pending"),
+    agentId: z.string().min(1),
+    containerId: z.string().min(1),
+    sourceQueryUrl: z.string().url(),
+    slicedQueryUrl: z.string().url(),
+    previousContainerId: z.string().min(1).nullable().optional()
+});
+const SalesNavigatorExportRunSchema = z.object({
+    id: z.string().min(1),
+    status: z.enum(["pending", "finished", "failed"]),
+    resultClassification: z.enum([
+        "pending",
+        "success",
+        "too_broad",
+        "invalid_session",
+        "invalid_result_artifact",
+        "transient_failure"
+    ]),
+    errorMessage: z.string().nullable(),
+    totalResults: z.number().int().nonnegative().nullable().optional(),
+    imported: z.number().int().nonnegative(),
+    upserted: z.number().int().nonnegative(),
+    resultJsonUrl: z.string().url().nullable().optional(),
+    resultCsvUrl: z.string().url().nullable().optional(),
+    agentId: z.string().min(1),
+    containerId: z.string().min(1),
+    sourceQueryUrl: z.string().url(),
+    slicedQueryUrl: z.string().url(),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+    finishedAt: z.string().datetime().nullable()
+});
+const SalesNavigatorExportRunStatusResponseSchema = z.object({
+    status: z.literal("ok"),
+    run: SalesNavigatorExportRunSchema
+});
+const SalesNavigatorExportResponseSchema = z.object({
+    status: z.literal("ok"),
+    runId: z.string().min(1),
+    imported: z.number().int().nonnegative(),
+    upserted: z.number().int().nonnegative(),
+    totalResults: z.number().int().nonnegative().nullable().optional(),
+    resultJsonUrl: z.string().url().nullable().optional(),
+    resultCsvUrl: z.string().url().nullable().optional(),
+    agentId: z.string().min(1),
+    containerId: z.string().min(1),
+    sourceQueryUrl: z.string().url(),
+    slicedQueryUrl: z.string().url()
+});
+const SalesNavigatorCrawlSplitTrailEntrySchema = z.object({
+    key: z.string().min(1),
+    filterType: z.string().min(1),
+    value: z.object({
+        id: z.string().min(1).optional(),
+        text: z.string().min(1),
+        selectionType: z.enum(["INCLUDED", "EXCLUDED"]).optional()
+    })
+});
+const SalesNavigatorCrawlJobSummarySchema = z.object({
+    id: z.string().uuid(),
+    orgId: z.string().min(1),
+    sourceQueryUrl: z.string().url(),
+    slicePreset: z.string().min(1),
+    maxResultsPerSearch: z.number().int().min(1).max(2500),
+    numberOfProfiles: z.number().int().min(1).max(2500),
+    status: z.enum(["queued", "running", "completed", "completed_with_failures"]),
+    queuedSlices: z.number().int().nonnegative(),
+    runningSlices: z.number().int().nonnegative(),
+    exportedSlices: z.number().int().nonnegative(),
+    failedSlices: z.number().int().nonnegative(),
+    importedPeople: z.number().int().nonnegative(),
+    startedAt: z.string().datetime().nullable(),
+    finishedAt: z.string().datetime().nullable(),
+    lastError: z.string().nullable(),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+    sliceStatusCounts: z.object({
+        queued: z.number().int().nonnegative(),
+        running: z.number().int().nonnegative(),
+        split: z.number().int().nonnegative(),
+        exported: z.number().int().nonnegative(),
+        retryableFailed: z.number().int().nonnegative(),
+        terminalFailed: z.number().int().nonnegative()
+    })
+});
+const SalesNavigatorClaimedCrawlSliceSchema = z.object({
+    id: z.string().uuid(),
+    jobId: z.string().uuid(),
+    sourceQueryUrl: z.string().url(),
+    slicedQueryUrl: z.string().url(),
+    appliedFilters: z.array(z.object({
+        type: z.string().min(1),
+        values: z.array(z.object({
+            id: z.string().min(1).optional(),
+            text: z.string().min(1),
+            selectionType: z.enum(["INCLUDED", "EXCLUDED"]).optional()
+        })).min(1)
+    })),
+    depth: z.number().int().min(0),
+    splitTrail: z.array(SalesNavigatorCrawlSplitTrailEntrySchema),
+    retryCount: z.number().int().nonnegative(),
+    cookieRetryCount: z.number().int().nonnegative(),
+    resultRetryCount: z.number().int().nonnegative(),
+    lastError: z.string().nullable(),
+    lastErrorCode: z.string().nullable(),
+    totalResults: z.number().int().nonnegative().nullable(),
+    slicePreset: z.string().min(1),
+    maxResultsPerSearch: z.number().int().min(1).max(2500),
+    numberOfProfiles: z.number().int().min(1).max(2500)
+});
+const SalesNavigatorCrawlCreateResponseSchema = z.object({
+    status: z.literal("ok"),
+    resumed: z.boolean(),
+    job: SalesNavigatorCrawlJobSummarySchema
+});
+const SalesNavigatorCrawlStatusResponseSchema = z.object({
+    status: z.literal("ok"),
+    job: SalesNavigatorCrawlJobSummarySchema
+});
+const SalesNavigatorCrawlClaimResponseSchema = z.object({
+    status: z.literal("ok"),
+    job: SalesNavigatorCrawlJobSummarySchema,
+    slice: SalesNavigatorClaimedCrawlSliceSchema.nullable()
+});
+const SalesNavigatorCrawlReportResponseSchema = z.object({
+    status: z.literal("ok"),
+    job: SalesNavigatorCrawlJobSummarySchema
+});
 function printOutput(value) {
     if (runtimeOutputOptions.quiet) {
         return;
@@ -68,9 +222,6 @@ function openUrlInBrowser(url) {
     }
 }
 function writeDeviceLoginInstructions(info) {
-    if (runtimeOutputOptions.json || runtimeOutputOptions.quiet) {
-        return;
-    }
     process.stderr.write("Starting device login flow. Complete login in the browser.\n");
     process.stderr.write(`Open this URL: ${info.verificationUrl}\n`);
     process.stderr.write(`Enter this code if prompted: ${info.userCode}\n`);
@@ -83,9 +234,6 @@ function writeDeviceLoginInstructions(info) {
     }
 }
 function writeBrowserLoginInstructions(info) {
-    if (runtimeOutputOptions.json || runtimeOutputOptions.quiet) {
-        return;
-    }
     process.stderr.write("Starting browser login flow. Complete login in the browser.\n");
     process.stderr.write(`Open this URL: ${info.browserUrl}\n`);
     if (openUrlInBrowser(info.browserUrl)) {
@@ -138,6 +286,22 @@ async function performLogin(options) {
         session: result.session
     };
 }
+function canPromptForInteractiveLogin() {
+    if (process.env.SALESPROMPTER_FORCE_INTERACTIVE_LOGIN === "1") {
+        return true;
+    }
+    return Boolean(process.stdin.isTTY && process.stderr.isTTY);
+}
+async function ensureInteractiveAuthSession(apiUrl) {
+    if (!canPromptForInteractiveLogin()) {
+        return;
+    }
+    process.stderr.write("No active Salesprompter session found. Starting login...\n\n");
+    await performLogin({
+        apiUrl: process.env.SALESPROMPTER_API_BASE_URL?.trim() || apiUrl,
+        timeoutSeconds: 180
+    });
+}
 function shellQuote(value) {
     if (/^[A-Za-z0-9_./:@=-]+$/.test(value)) {
         return value;
@@ -174,6 +338,72 @@ function deriveCompanyNameFromDomain(domain) {
         .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
         .join(" ");
 }
+function normalizeLinkedInCompanyHandle(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    try {
+        const url = new URL(trimmed);
+        if (!/(^|\.)linkedin\.com$/i.test(url.hostname)) {
+            return null;
+        }
+        const segments = url.pathname.split("/").filter((segment) => segment.length > 0);
+        const companyIndex = segments.findIndex((segment) => segment.toLowerCase() === "company");
+        if (companyIndex === -1) {
+            return null;
+        }
+        const handle = segments[companyIndex + 1]?.trim().toLowerCase() ?? "";
+        return handle.length > 0 ? handle : null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeLinkedInCompanyPage(handle) {
+    return `https://www.linkedin.com/company/${handle}`;
+}
+function titleCaseSlug(value) {
+    return value
+        .split(/[-_]/)
+        .filter((part) => part.length > 0)
+        .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
+        .join(" ");
+}
+function inferVendorTemplate(reference) {
+    if (reference.domain === "deel.com" || reference.linkedinHandle === "deel") {
+        return "deel";
+    }
+    return undefined;
+}
+function parseCompanyReference(value) {
+    const rawInput = value.trim();
+    if (rawInput.length === 0) {
+        throw new Error("Company website or LinkedIn page is required.");
+    }
+    const linkedinHandle = normalizeLinkedInCompanyHandle(rawInput) ?? undefined;
+    const domain = linkedinHandle ? undefined : normalizeDomainInput(rawInput);
+    const companyName = domain
+        ? deriveCompanyNameFromDomain(domain)
+        : linkedinHandle
+            ? titleCaseSlug(linkedinHandle)
+            : rawInput;
+    const slug = slugify(companyName) || slugify(domain ?? linkedinHandle ?? companyName) || "company";
+    const label = domain ?? (linkedinHandle ? normalizeLinkedInCompanyPage(linkedinHandle) : rawInput);
+    return {
+        rawInput,
+        companyName,
+        slug,
+        label,
+        domain: domain && domain.length > 0 ? domain : undefined,
+        linkedinCompanyPage: linkedinHandle ? normalizeLinkedInCompanyPage(linkedinHandle) : undefined,
+        linkedinHandle,
+        vendorTemplate: inferVendorTemplate({
+            domain: domain && domain.length > 0 ? domain : undefined,
+            linkedinHandle
+        })
+    };
+}
 function writeWizardLine(message = "") {
     process.stdout.write(`${message}\n`);
 }
@@ -220,6 +450,9 @@ function buildLeadOutputPaths(baseSlug) {
         scoredPath: `./data/${baseSlug}-scored.json`
     };
 }
+function buildQualifiedLeadsPath(baseSlug) {
+    return `./data/${baseSlug}-qualified-leads.json`;
+}
 function normalizeChoiceText(value) {
     return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -273,11 +506,8 @@ async function promptChoiceInteractive(prompt, options, defaultIndex) {
         if (!selected) {
             throw new Error("wizard selection invariant violated");
         }
-        const summary = `${prompt} ${selected.label}`;
-        redrawInteractiveChoice([summary], renderedLineCount);
-        renderedLineCount = 1;
-        process.stdout.write("\n");
         cleanup();
+        process.stdout.write("\n");
         resolve(selected.value);
     };
     const cancel = (reject) => {
@@ -409,46 +639,6 @@ async function promptYesNo(rl, prompt, defaultValue) {
         writeWizardLine("Please answer yes or no.");
     }
 }
-async function maybeSearchLeadDataNow(rl, options) {
-    const shouldSearch = await promptYesNo(rl, "Do you want to search your lead data for matches now?", false);
-    writeWizardLine();
-    if (!shouldSearch) {
-        return;
-    }
-    writeWizardSection("Search your lead data", "I will use the ICP you just saved.");
-    await runVendorLookupWizard(rl, { icpPath: options.icpPath });
-}
-async function maybePrepareLeadsForOutreach(rl, options) {
-    const shouldScore = await promptYesNo(rl, "Do you want me to score these leads for outreach?", false);
-    writeWizardLine();
-    if (!shouldScore) {
-        return;
-    }
-    writeWizardSection("Prepare for outreach", "I will enrich and score the leads you just saved.");
-    const { enrichedPath, scoredPath } = buildLeadOutputPaths(options.baseSlug);
-    const enriched = await enrichmentProvider.enrichLeads(options.leads);
-    const scored = await scoringProvider.scoreLeads(options.icp, enriched);
-    await writeJsonFile(enrichedPath, enriched);
-    await writeJsonFile(scoredPath, scored);
-    writeWizardLine(`Saved enriched leads to ${enrichedPath}.`);
-    writeWizardLine(`Saved scored leads to ${scoredPath}.`);
-    writeWizardLine();
-    writeWizardLine("Equivalent raw commands:");
-    writeWizardLine(`  ${buildCommandLine(["salesprompter", "leads:enrich", "--in", options.leadPath, "--out", enrichedPath])}`);
-    writeWizardLine(`  ${buildCommandLine(["salesprompter", "leads:score", "--icp", options.icpPath, "--in", enrichedPath, "--out", scoredPath])}`);
-    if (!process.env.INSTANTLY_API_KEY || process.env.INSTANTLY_API_KEY.trim().length === 0) {
-        writeWizardLine();
-        writeWizardLine("You can send the scored leads to Instantly later from the main menu.");
-        return;
-    }
-    writeWizardLine();
-    const shouldSync = await promptYesNo(rl, "Do you want to send these leads to Instantly now?", false);
-    writeWizardLine();
-    if (!shouldSync) {
-        return;
-    }
-    await runOutreachSyncWizard(rl, { inputPath: scoredPath });
-}
 async function ensureWizardSession(options) {
     if (shouldBypassAuth()) {
         return null;
@@ -465,7 +655,7 @@ async function ensureWizardSession(options) {
             throw error;
         }
     }
-    writeWizardLine("First, sign in to Salesprompter.");
+    writeWizardLine("First, sign in to continue.");
     writeWizardLine();
     const result = await performLogin({
         apiUrl: options?.apiUrl,
@@ -475,269 +665,620 @@ async function ensureWizardSession(options) {
     writeWizardLine();
     return result.session;
 }
-async function runVendorIcpWizard(rl) {
-    const startPoint = await promptChoice(rl, "How do you want to build your ICP?", [
-        {
-            value: "custom",
-            label: "Start from scratch",
-            description: "Answer a few questions about the companies you want to sell to",
-            aliases: ["custom", "from scratch", "new profile"]
+async function fetchWorkspaceLeadSearch(session, requestBody) {
+    const response = await fetch(`${session.apiBaseUrl}/api/cli/leads/search`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${session.accessToken}`
         },
-        {
-            value: "template",
-            label: "Use the Deel template",
-            description: "Quick start from the current built-in template",
-            aliases: ["template", "deel", "use template"]
-        }
-    ], "custom");
-    writeWizardLine();
-    if (startPoint === "custom") {
-        writeWizardSection("Define your ICP", "Start with the basics. You can add more filters if you want.");
-        const productName = await promptText(rl, "What do you sell?", { required: true });
-        const description = await promptText(rl, "Short description (optional)");
-        writeWizardLine();
-        let industries = "";
-        let companySizes = "";
-        let regions = "";
-        let countries = "";
-        let titles = "";
-        let keywords = "";
-        const addDetails = await promptYesNo(rl, "Do you want to add industries, company size, region, or title filters?", false);
-        writeWizardLine();
-        if (addDetails) {
-            industries = await promptText(rl, "Industries to target (optional, comma-separated)");
-            companySizes = await promptText(rl, "Company sizes to target (optional, comma-separated)");
-            regions = await promptText(rl, "Regions to target (optional, comma-separated)");
-            countries = await promptText(rl, "Countries to target (optional, comma-separated)");
-            titles = await promptText(rl, "Job titles to target (optional, comma-separated)");
-            keywords = await promptText(rl, "Keywords or buying signals (optional, comma-separated)");
-            writeWizardLine();
+        body: JSON.stringify(requestBody)
+    });
+    const text = await response.text();
+    const payload = text.length > 0 ? JSON.parse(text) : {};
+    if (!response.ok) {
+        const errorMessage = typeof payload === "object" && payload !== null && "error" in payload && typeof payload.error === "string"
+            ? payload.error
+            : `request failed (${response.status})`;
+        throw new Error(errorMessage);
+    }
+    return WorkspaceLeadSearchResponseSchema.parse(payload).leads;
+}
+function buildLinkedInProductsOutputPath(categorySlug) {
+    return `./data/linkedin-products-${categorySlug}.json`;
+}
+function collectStringOptionValue(value, previous = []) {
+    return [...previous, value];
+}
+class SalesNavigatorExportRequestError extends Error {
+    errorCode;
+    totalResults;
+    runId;
+    agentId;
+    containerId;
+    statusCode;
+    constructor(message, options) {
+        super(message);
+        this.name = "SalesNavigatorExportRequestError";
+        this.statusCode = options.statusCode;
+        this.errorCode = options.errorCode;
+        this.totalResults = options.totalResults ?? null;
+        this.runId = options.runId;
+        this.agentId = options.agentId;
+        this.containerId = options.containerId;
+    }
+}
+async function withRefreshableAuthSession(session, run, contextLabel = "Salesprompter session expired during crawl. Refreshing login...") {
+    let currentSession = session;
+    let authRefreshCount = 0;
+    while (true) {
+        try {
+            return {
+                session: currentSession,
+                value: await run(currentSession)
+            };
         }
-        const slug = slugify(productName) || "icp";
-        const outPath = `./data/${slug}-icp.json`;
-        const icp = IcpSchema.parse({
-            name: `${productName} ICP`,
-            description,
-            industries: splitCsv(industries),
-            companySizes: splitCsv(companySizes),
-            regions: splitCsv(regions),
-            countries: splitCsv(countries),
-            titles: splitCsv(titles),
-            keywords: splitCsv(keywords)
-        });
-        await writeJsonFile(outPath, icp);
-        writeWizardLine(`Created ${icp.name}.`);
-        writeWizardLine(`Saved profile to ${outPath}.`);
-        writeWizardLine();
-        writeWizardLine("Equivalent raw command:");
-        const defineArgs = ["salesprompter", "icp:define", "--name", icp.name];
-        if (description.trim().length > 0) {
-            defineArgs.push("--description", description);
+        catch (error) {
+            if (!isRefreshableAuthError(error) || !canPromptForInteractiveLogin() || authRefreshCount >= 2) {
+                throw error;
+            }
+            authRefreshCount += 1;
+            if (!runtimeOutputOptions.quiet) {
+                process.stderr.write(`${contextLabel}\n`);
+            }
+            await ensureInteractiveAuthSession(currentSession.apiBaseUrl);
+            currentSession = await requireAuthSession();
         }
-        if (industries.trim().length > 0) {
-            defineArgs.push("--industries", industries);
+    }
+}
+async function fetchCliJson(session, request, schema) {
+    return await withRefreshableAuthSession(session, async (currentSession) => {
+        const response = await request(currentSession);
+        const text = await response.text();
+        const parsed = text.length > 0 ? JSON.parse(text) : {};
+        if (!response.ok) {
+            const errorMessage = typeof parsed === "object" &&
+                parsed !== null &&
+                "error" in parsed &&
+                typeof parsed.error === "string"
+                ? parsed.error
+                : `request failed (${response.status})`;
+            throw new Error(errorMessage);
         }
-        if (companySizes.trim().length > 0) {
-            defineArgs.push("--company-sizes", companySizes);
+        return schema.parse(parsed);
+    });
+}
+async function uploadLinkedInProductsCatalog(session, payload, batchSize = 100) {
+    let imported = 0;
+    let upserted = 0;
+    for (let startIndex = 0; startIndex < payload.items.length; startIndex += batchSize) {
+        const batch = payload.items.slice(startIndex, startIndex + batchSize);
+        const response = await fetch(`${session.apiBaseUrl}/api/cli/linkedin-products/ingest`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${session.accessToken}`
+            },
+            body: JSON.stringify({
+                source: payload.source,
+                items: batch
+            })
+        });
+        const text = await response.text();
+        const parsed = text.length > 0 ? JSON.parse(text) : {};
+        if (!response.ok) {
+            const errorMessage = typeof parsed === "object" && parsed !== null && "error" in parsed && typeof parsed.error === "string"
+                ? parsed.error
+                : `request failed (${response.status})`;
+            throw new Error(errorMessage);
         }
-        if (regions.trim().length > 0) {
-            defineArgs.push("--regions", regions);
+        const result = LinkedInProductIngestResponseSchema.parse(parsed);
+        imported += result.imported;
+        upserted += result.upserted;
+    }
+    return { imported, upserted };
+}
+function serializeSalesNavigatorFiltersForApi(filters) {
+    return filters.map((filter) => ({
+        type: filter.type,
+        values: filter.values.map((value) => ({
+            id: value.id ?? value.text,
+            text: value.text,
+            selectionType: value.selectionType
+        }))
+    }));
+}
+async function runSalesNavigatorExport(session, payload) {
+    const started = await startSalesNavigatorExport(session, payload);
+    const completed = await waitForSalesNavigatorExportRunCompletion(started.session, started.value.runId);
+    return mapCompletedSalesNavigatorExportRun(completed.value.run);
+}
+async function startSalesNavigatorExport(session, payload) {
+    return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/export`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify({
+            ...payload,
+            appliedFilters: serializeSalesNavigatorFiltersForApi(payload.appliedFilters)
+        })
+    }), SalesNavigatorExportStartResponseSchema);
+}
+async function getSalesNavigatorExportRunStatus(session, runId) {
+    return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/export-runs/${runId}?refresh=1`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`
         }
-        if (countries.trim().length > 0) {
-            defineArgs.push("--countries", countries);
+    }), SalesNavigatorExportRunStatusResponseSchema);
+}
+function mapCompletedSalesNavigatorExportRun(run) {
+    if (run.status === "pending") {
+        throw new Error(`Sales Navigator export run ${run.id} is still pending`);
+    }
+    if (run.resultClassification === "too_broad") {
+        throw new SalesNavigatorSliceTooBroadError(run.errorMessage ?? "Sliced Sales Navigator query is still too broad.", {
+            totalResults: run.totalResults ?? null,
+            details: run
+        });
+    }
+    if (run.resultClassification !== "success") {
+        throw new SalesNavigatorExportRequestError(run.errorMessage ?? "Sales Navigator export failed", {
+            statusCode: 502,
+            errorCode: run.resultClassification,
+            totalResults: run.totalResults ?? null,
+            runId: run.id,
+            agentId: run.agentId,
+            containerId: run.containerId
+        });
+    }
+    return SalesNavigatorExportResponseSchema.parse({
+        status: "ok",
+        runId: run.id,
+        imported: run.imported,
+        upserted: run.upserted,
+        totalResults: run.totalResults ?? null,
+        resultJsonUrl: run.resultJsonUrl ?? null,
+        resultCsvUrl: run.resultCsvUrl ?? null,
+        agentId: run.agentId,
+        containerId: run.containerId,
+        sourceQueryUrl: run.sourceQueryUrl,
+        slicedQueryUrl: run.slicedQueryUrl
+    });
+}
+async function waitForSalesNavigatorExportRunCompletion(session, runId, options = {}) {
+    const timeoutSeconds = options.timeoutSeconds ?? 960;
+    const pollIntervalMs = options.pollIntervalMs ?? 5000;
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    let currentSession = session;
+    while (Date.now() < deadline) {
+        const status = await getSalesNavigatorExportRunStatus(currentSession, runId);
+        currentSession = status.session;
+        if (status.value.run.status !== "pending") {
+            return status;
         }
-        if (titles.trim().length > 0) {
-            defineArgs.push("--titles", titles);
+        await delay(pollIntervalMs);
+    }
+    throw new SalesNavigatorExportRequestError(`Timed out waiting for Sales Navigator export run ${runId}`, {
+        statusCode: 504,
+        runId
+    });
+}
+function isSalesNavigatorAgentBusyError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /parallel executions limit/i.test(message);
+}
+function isSalesNavigatorSessionError(error) {
+    if (error instanceof SalesNavigatorExportRequestError &&
+        ["phantombuster_cant_connect_profile", "salesnav_upsell_detected", "linkedin_session_invalid"].includes(error.errorCode ?? "")) {
+        return true;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return /can't connect profile|sales navigator account|upsell|linkedin session invalid/i.test(message);
+}
+function isSalesNavigatorResultArtifactError(error) {
+    if (error instanceof SalesNavigatorExportRequestError && error.errorCode === "phantombuster_result_invalid") {
+        return true;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return /page has crashed|no valid sales navigator people rows/i.test(message);
+}
+function isSalesNavigatorTransientExportError(error) {
+    if (isSalesNavigatorSessionError(error) || isSalesNavigatorResultArtifactError(error)) {
+        return false;
+    }
+    if (error instanceof SalesNavigatorExportRequestError) {
+        return error.statusCode >= 500;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return /enotfound|fetch failed|network|timed out|socket hang up/i.test(message);
+}
+function isRefreshableAuthError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /token expired|session expired|not logged in|missing bearer token/i.test(message);
+}
+async function runSalesNavigatorExportWithAgentWait(session, payload, options) {
+    let busyWaitCount = 0;
+    let currentSession = session;
+    let authRefreshCount = 0;
+    while (true) {
+        try {
+            return await runSalesNavigatorExport(currentSession, payload);
         }
-        if (keywords.trim().length > 0) {
-            defineArgs.push("--keywords", keywords);
+        catch (error) {
+            if (isRefreshableAuthError(error)) {
+                if (!canPromptForInteractiveLogin() || authRefreshCount >= 2) {
+                    throw error;
+                }
+                authRefreshCount += 1;
+                if (!runtimeOutputOptions.quiet) {
+                    process.stderr.write("Salesprompter session expired during crawl. Refreshing login...\n");
+                }
+                await ensureInteractiveAuthSession(currentSession.apiBaseUrl);
+                currentSession = await requireAuthSession();
+                continue;
+            }
+            if (isSalesNavigatorAgentBusyError(error)) {
+                if (busyWaitCount === options.maxWaits) {
+                    throw error;
+                }
+                busyWaitCount += 1;
+                if (!runtimeOutputOptions.json && !runtimeOutputOptions.quiet) {
+                    process.stderr.write(`Sales Navigator export agent is busy. Waiting ${options.waitSeconds}s before retrying...\n`);
+                }
+                await delay(options.waitSeconds * 1000);
+                continue;
+            }
+            throw error;
         }
-        defineArgs.push("--out", outPath);
-        writeWizardLine(`  ${buildCommandLine(defineArgs)}`);
-        writeWizardLine();
-        await maybeSearchLeadDataNow(rl, { icpPath: outPath });
-        return;
     }
-    const vendor = "deel";
-    writeWizardSection("Define your ICP", "Use the built-in Deel template and choose a market.");
-    writeWizardLine("Using the built-in Deel ICP template.");
-    writeWizardLine();
-    const market = await promptChoice(rl, "Which market do you want to focus on?", [
-        { value: "dach", label: "DACH", description: "Germany, Austria, Switzerland" },
-        { value: "europe", label: "Europe" },
-        { value: "global", label: "Global" }
-    ], "dach");
-    writeWizardLine();
-    const outPath = `./data/${slugify(vendor)}-icp-${market}.json`;
-    const icp = buildVendorIcp(vendor, market);
-    await writeJsonFile(outPath, icp);
-    writeWizardLine(`Created ${icp.name}.`);
-    writeWizardLine(`Saved profile to ${outPath}.`);
-    writeWizardLine();
-    writeWizardLine("Equivalent raw command:");
-    writeWizardLine(`  ${buildCommandLine(["salesprompter", "icp:vendor", "--vendor", vendor, "--market", market, "--out", outPath])}`);
-    writeWizardLine();
-    await maybeSearchLeadDataNow(rl, { icpPath: outPath });
 }
-async function runTargetAccountWizard(rl) {
-    writeWizardSection("Pick a company", "Start with the company and how many people you want.");
-    const domain = normalizeDomainInput(await promptText(rl, "Which company do you want leads from? Enter the domain", { required: true }));
-    writeWizardLine();
-    const displayName = deriveCompanyNameFromDomain(domain);
-    const leadCount = z.coerce.number().int().min(1).max(1000).parse(await promptText(rl, "How many people do you want?", { defaultValue: "5", required: true }));
-    writeWizardLine();
-    let region = "Global";
-    let industries = "";
-    let titles = "";
-    const narrowResults = await promptYesNo(rl, "Do you want to narrow the results by region, industry, or title?", false);
-    writeWizardLine();
-    if (narrowResults) {
-        region = await promptText(rl, "Region", { defaultValue: "Global", required: true });
-        industries = await promptText(rl, "Industries (optional, comma-separated)");
-        titles = await promptText(rl, "Job titles (optional, comma-separated)");
-        writeWizardLine();
-    }
-    const slug = slugify(domain);
-    const icpPath = `./data/${slug}-target-icp.json`;
-    const { leadsPath } = buildLeadOutputPaths(slug);
-    const icp = IcpSchema.parse({
-        name: `${displayName} target account`,
-        regions: region.length > 0 ? [region] : [],
-        industries: splitCsv(industries),
-        titles: splitCsv(titles)
+async function runSalesNavigatorCrawlAttempt(session, attempt, options, context) {
+    const shouldProbe = options.probeProfiles > 0 &&
+        options.probeProfiles < attempt.numberOfProfiles &&
+        attempt.depth < options.maxSplitDepth;
+    const probeProfiles = shouldProbe ? Math.max(1, options.probeProfiles) : attempt.numberOfProfiles;
+    const probeResult = await runSalesNavigatorExportWithAgentWait(session, {
+        sourceQueryUrl: attempt.sourceQueryUrl,
+        slicedQueryUrl: attempt.slicedQueryUrl,
+        appliedFilters: attempt.appliedFilters,
+        maxResultsPerSearch: attempt.maxResultsPerSearch,
+        numberOfProfiles: probeProfiles,
+        slicePreset: attempt.slicePreset,
+        crawlJobId: context?.crawlJobId,
+        crawlSliceId: context?.crawlSliceId
+    }, {
+        waitSeconds: options.agentBusyWaitSeconds,
+        maxWaits: options.agentBusyMaxWaits
     });
-    await writeJsonFile(icpPath, icp);
-    const result = await leadProvider.generateLeads(icp, leadCount, {
-        companyDomain: domain
-    });
-    await writeJsonFile(leadsPath, result.leads);
-    writeWizardLine(`Generated ${result.leads.length} leads for ${result.account.companyName} (${result.account.domain}).`);
-    writeWizardLine(`Saved profile to ${icpPath}.`);
-    writeWizardLine(`Saved leads to ${leadsPath}.`);
-    if (result.warnings.length > 0) {
-        writeWizardLine();
-        writeWizardLine(`Warning: ${result.warnings.join(" ")}`);
-    }
-    writeWizardLine();
-    writeWizardLine("Equivalent raw commands:");
-    const defineArgs = ["salesprompter", "icp:define", "--name", icp.name];
-    if (region.length > 0) {
-        defineArgs.push("--regions", region);
-    }
-    if (industries.trim().length > 0) {
-        defineArgs.push("--industries", industries);
-    }
-    if (titles.trim().length > 0) {
-        defineArgs.push("--titles", titles);
-    }
-    defineArgs.push("--out", icpPath);
-    writeWizardLine(`  ${buildCommandLine(defineArgs)}`);
-    const leadArgs = ["salesprompter", "leads:generate", "--icp", icpPath, "--count", String(leadCount), "--domain", domain];
-    leadArgs.push("--out", leadsPath);
-    writeWizardLine(`  ${buildCommandLine(leadArgs)}`);
-    writeWizardLine();
-    await maybePrepareLeadsForOutreach(rl, {
-        baseSlug: slug,
-        icp,
-        icpPath,
-        leadPath: leadsPath,
-        leads: result.leads
+    if (!shouldProbe) {
+        return probeResult;
+    }
+    const totalResults = probeResult.totalResults ?? null;
+    if (totalResults === null || totalResults > attempt.maxResultsPerSearch) {
+        return probeResult;
+    }
+    return await runSalesNavigatorExportWithAgentWait(session, {
+        sourceQueryUrl: attempt.sourceQueryUrl,
+        slicedQueryUrl: attempt.slicedQueryUrl,
+        appliedFilters: attempt.appliedFilters,
+        maxResultsPerSearch: attempt.maxResultsPerSearch,
+        numberOfProfiles: attempt.numberOfProfiles,
+        slicePreset: attempt.slicePreset,
+        crawlJobId: context?.crawlJobId,
+        crawlSliceId: context?.crawlSliceId
+    }, {
+        waitSeconds: options.agentBusyWaitSeconds,
+        maxWaits: options.agentBusyMaxWaits
     });
 }
-async function runLeadGenerationWizard(rl) {
-    const source = await promptChoice(rl, "How do you want to generate leads?", [
-        {
-            value: "target-account",
-            label: "At one company",
-            description: "Example: find people at acme.com",
-            aliases: ["company", "one company", "specific company", "account"]
+function buildSalesNavigatorCrawlAttemptFromClaimedSlice(slice) {
+    return {
+        sourceQueryUrl: slice.sourceQueryUrl,
+        slicedQueryUrl: slice.slicedQueryUrl,
+        appliedFilters: slice.appliedFilters,
+        depth: slice.depth,
+        retryCount: slice.retryCount,
+        maxResultsPerSearch: slice.maxResultsPerSearch,
+        numberOfProfiles: slice.numberOfProfiles,
+        slicePreset: slice.slicePreset,
+        splitTrail: slice.splitTrail
+    };
+}
+async function createOrResumeSalesNavigatorCrawlJob(session, payload) {
+    return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/crawls`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
         },
-        {
-            value: "vendor-lookup",
-            label: "From my own lead data",
-            description: "Search leads you already have in BigQuery",
-            aliases: ["bigquery", "warehouse", "my data", "from bigquery"]
+        body: JSON.stringify({
+            ...payload,
+            rootSlice: {
+                ...payload.rootSlice,
+                appliedFilters: serializeSalesNavigatorFiltersForApi(payload.rootSlice.appliedFilters)
+            }
+        })
+    }), SalesNavigatorCrawlCreateResponseSchema);
+}
+async function getSalesNavigatorCrawlStatus(session, jobId) {
+    return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/crawls/${jobId}`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`
         }
-    ], "target-account");
-    writeWizardLine();
-    if (source === "target-account") {
-        await runTargetAccountWizard(rl);
-        return;
+    }), SalesNavigatorCrawlStatusResponseSchema);
+}
+async function claimNextSalesNavigatorCrawlSlice(session, jobId) {
+    return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/crawls/${jobId}/claim-next`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`
+        }
+    }), SalesNavigatorCrawlClaimResponseSchema);
+}
+async function reportSalesNavigatorCrawlSlice(session, jobId, payload) {
+    return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/crawls/${jobId}/report`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify({
+            ...payload,
+            children: payload.children?.map((child) => ({
+                ...child,
+                appliedFilters: serializeSalesNavigatorFiltersForApi(child.appliedFilters)
+            }))
+        })
+    }), SalesNavigatorCrawlReportResponseSchema);
+}
+function nextSalesNavigatorSplitDimension(slice, maxSplitDepth) {
+    if (slice.depth >= maxSplitDepth) {
+        return null;
     }
-    await runVendorLookupWizard(rl);
+    return DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS[slice.depth] ?? null;
+}
+const SALES_NAVIGATOR_COOKIE_RETRY_LIMIT = 8;
+const SALES_NAVIGATOR_RESULT_RETRY_LIMIT = 3;
+function buildSalesNavigatorSplitChildren(slice, dimension) {
+    const attempt = buildSalesNavigatorCrawlAttemptFromClaimedSlice(slice);
+    return expandSalesNavigatorCrawlAttempt(attempt, dimension).map((child) => ({
+        slicedQueryUrl: child.slicedQueryUrl,
+        appliedFilters: child.appliedFilters,
+        depth: child.depth,
+        splitTrail: child.splitTrail
+    }));
 }
-async function runVendorLookupWizard(rl, options) {
-    if (!options?.icpPath) {
-        writeWizardSection("Search your lead data", "Use a saved ICP to build the lookup.");
+function buildSalesNavigatorSliceFailureReport(slice, error, options) {
+    const message = error instanceof Error ? error.message : String(error);
+    const exportError = error instanceof SalesNavigatorExportRequestError ? error : null;
+    if (error instanceof SalesNavigatorSliceTooBroadError) {
+        const nextDimension = nextSalesNavigatorSplitDimension(slice, options.maxSplitDepth);
+        if (nextDimension) {
+            return {
+                sliceId: slice.id,
+                outcome: "split",
+                totalResults: error.totalResults,
+                error: message,
+                errorCode: "too_broad",
+                children: buildSalesNavigatorSplitChildren(slice, nextDimension)
+            };
+        }
+        return {
+            sliceId: slice.id,
+            outcome: "terminal_failed",
+            totalResults: error.totalResults,
+            error: message,
+            errorCode: "too_broad_no_remaining_dimensions"
+        };
     }
-    const icpPath = options?.icpPath
-        ? options.icpPath
-        : await promptText(rl, "Which saved ICP should I use?", {
-            defaultValue: "./data/icp.json",
-            required: true
+    if (isSalesNavigatorSessionError(error)) {
+        return {
+            sliceId: slice.id,
+            outcome: slice.cookieRetryCount + 1 <= SALES_NAVIGATOR_COOKIE_RETRY_LIMIT
+                ? "retryable_failed"
+                : "terminal_failed",
+            totalResults: exportError?.totalResults,
+            error: message,
+            errorCode: exportError?.errorCode ?? "invalid_session",
+            exportRunId: exportError?.runId,
+            incrementCookieRetryCount: 1
+        };
+    }
+    if (isSalesNavigatorResultArtifactError(error)) {
+        return {
+            sliceId: slice.id,
+            outcome: slice.resultRetryCount + 1 <= SALES_NAVIGATOR_RESULT_RETRY_LIMIT
+                ? "retryable_failed"
+                : "terminal_failed",
+            totalResults: exportError?.totalResults,
+            error: message,
+            errorCode: exportError?.errorCode ?? "invalid_result_artifact",
+            exportRunId: exportError?.runId,
+            incrementResultRetryCount: 1
+        };
+    }
+    return {
+        sliceId: slice.id,
+        outcome: slice.retryCount + 1 <= options.maxRetries ? "retryable_failed" : "terminal_failed",
+        totalResults: exportError?.totalResults,
+        error: message,
+        errorCode: exportError?.errorCode ?? (isSalesNavigatorTransientExportError(error) ? "transient_failure" : "runtime_error"),
+        exportRunId: exportError?.runId,
+        incrementRetryCount: 1
+    };
+}
+function formatSalesNavigatorSplitTrail(splitTrail) {
+    return splitTrail.map((entry) => `${entry.key}:${entry.value.text}`);
+}
+async function executeSalesNavigatorCrawlJob(session, jobId, options) {
+    let currentSession = session;
+    let claimedSlices = 0;
+    const seenSliceIds = new Set();
+    let activeSlice = null;
+    let job = null;
+    let lastOutcome = null;
+    while (true) {
+        if (claimedSlices >= options.maxSlices && lastOutcome?.outcome !== "retryable_failed") {
+            break;
+        }
+        const claimed = await claimNextSalesNavigatorCrawlSlice(currentSession, jobId);
+        currentSession = claimed.session;
+        job = claimed.value.job;
+        if (!claimed.value.slice) {
+            break;
+        }
+        const slice = claimed.value.slice;
+        activeSlice = slice;
+        const isNewSlice = !seenSliceIds.has(slice.id);
+        if (isNewSlice) {
+            seenSliceIds.add(slice.id);
+            claimedSlices += 1;
+        }
+        if (!runtimeOutputOptions.json && !runtimeOutputOptions.quiet) {
+            process.stderr.write(`Processing Sales Navigator slice ${claimedSlices}/${options.maxSlices}: ${slice.slicedQueryUrl}\n`);
+        }
+        try {
+            const result = await runSalesNavigatorCrawlAttempt(currentSession, buildSalesNavigatorCrawlAttemptFromClaimedSlice(slice), {
+                maxSplitDepth: options.maxSplitDepth,
+                probeProfiles: options.probeProfiles,
+                agentBusyWaitSeconds: options.agentBusyWaitSeconds,
+                agentBusyMaxWaits: options.agentBusyMaxWaits
+            }, {
+                crawlJobId: jobId,
+                crawlSliceId: slice.id
+            });
+            const reported = await reportSalesNavigatorCrawlSlice(currentSession, jobId, {
+                sliceId: slice.id,
+                outcome: "exported",
+                totalResults: result.totalResults ?? null,
+                exportRunId: result.runId,
+                importedPeople: result.imported,
+                upsertedPeople: result.upserted
+            });
+            currentSession = reported.session;
+            job = reported.value.job;
+            lastOutcome = {
+                outcome: "exported",
+                runId: result.runId,
+                totalResults: result.totalResults ?? null
+            };
+        }
+        catch (error) {
+            const payload = buildSalesNavigatorSliceFailureReport(slice, error, {
+                maxSplitDepth: options.maxSplitDepth,
+                maxRetries: options.maxRetries
+            });
+            const reported = await reportSalesNavigatorCrawlSlice(currentSession, jobId, payload);
+            currentSession = reported.session;
+            job = reported.value.job;
+            lastOutcome = {
+                outcome: payload.outcome,
+                runId: payload.exportRunId,
+                error: payload.error,
+                errorCode: payload.errorCode,
+                totalResults: payload.totalResults
+            };
+        }
+    }
+    if (!job) {
+        const status = await getSalesNavigatorCrawlStatus(currentSession, jobId);
+        currentSession = status.session;
+        job = status.value.job;
+    }
+    return {
+        session: currentSession,
+        job,
+        claimedSlices,
+        truncated: claimedSlices >= options.maxSlices && (job.queuedSlices > 0 || job.runningSlices > 0),
+        activeSlice,
+        lastOutcome
+    };
+}
+async function searchReferenceCompanyLeads(reference, icp, limit) {
+    if (shouldBypassAuth()) {
+        const fallbackTargetDomain = reference.domain ?? `${reference.slug}.com`;
+        const result = await leadProvider.generateLeads(icp, limit, {
+            companyDomain: fallbackTargetDomain,
+            companyName: reference.companyName
         });
-    if (options?.icpPath) {
-        writeWizardLine(`Using profile from ${icpPath}.`);
+        return result.leads;
     }
-    const limit = z.coerce.number().int().min(1).max(5000).parse(await promptText(rl, "How many leads do you want?", { defaultValue: "100", required: true }));
-    const execute = await promptYesNo(rl, "Do you want me to run the BigQuery search now?", false);
-    writeWizardLine();
-    const icp = await readJsonFile(icpPath, IcpSchema);
-    const slug = slugify(icp.name) || "icp";
-    const sqlPath = `./data/${slug}-lookup.sql`;
-    const rawPath = `./data/${slug}-leads-raw.json`;
-    const { leadsPath: leadPath } = buildLeadOutputPaths(slug);
-    const sql = buildBigQueryLeadLookupSql(icp, {
-        table: "icpidentifier.SalesGPT.leadPool_new",
-        companyField: "companyName",
-        domainField: "domain",
-        regionField: undefined,
-        keywordFields: splitCsv("companyName,industry,description,tagline,specialties"),
-        titleField: "jobTitle",
-        industryField: "industry",
-        companySizeField: "companySize",
-        countryField: "company_countryCode",
-        firstNameField: "firstName",
-        lastNameField: "lastName",
-        emailField: "email",
-        limit,
-        additionalWhere: undefined,
-        useSalesprompterGuards: true
+    const session = await requireAuthSession();
+    return await fetchWorkspaceLeadSearch(session, {
+        mode: "reference-company",
+        icp,
+        limit
     });
-    await writeTextFile(sqlPath, `${sql}\n`);
-    let executedRowCount = null;
-    let normalizedLeads = [];
-    if (execute) {
-        const rows = await runBigQueryQuery(sql, { maxRows: limit });
-        const parsedRows = z.array(z.record(z.string(), z.unknown())).parse(rows);
-        await writeJsonFile(rawPath, parsedRows);
-        normalizedLeads = normalizeBigQueryLeadRows(parsedRows);
-        await writeJsonFile(leadPath, normalizedLeads);
-        executedRowCount = parsedRows.length;
-    }
-    writeWizardLine(`Saved search SQL to ${sqlPath}.`);
-    if (execute) {
-        writeWizardLine(`Saved ${executedRowCount ?? 0} raw rows to ${rawPath}.`);
-        writeWizardLine(`Saved leads to ${leadPath}.`);
+}
+async function searchTargetCompanyLeads(reference, limit) {
+    if (shouldBypassAuth()) {
+        const fallbackTargetDomain = reference.domain ?? `${reference.slug}.com`;
+        const result = await leadProvider.generateLeads(IcpSchema.parse({ name: `${reference.companyName} qualified leads` }), limit, {
+            companyDomain: fallbackTargetDomain,
+            companyName: reference.companyName
+        });
+        return result.leads;
     }
+    const session = await requireAuthSession();
+    return await fetchWorkspaceLeadSearch(session, {
+        mode: "target-company",
+        domain: reference.domain,
+        linkedinCompanyPage: reference.linkedinCompanyPage,
+        limit
+    });
+}
+async function runReferenceCompanyWizard(rl) {
+    writeWizardSection("Reference company", "Paste the website or LinkedIn company page for the company you sell for.");
+    const reference = parseCompanyReference(await promptText(rl, "Which company are you selling for?", {
+        required: true
+    }));
     writeWizardLine();
-    writeWizardLine("Equivalent raw command:");
-    const lookupArgs = ["salesprompter", "leads:lookup:bq", "--icp", icpPath, "--limit", String(limit), "--sql-out", sqlPath];
-    if (execute) {
-        lookupArgs.push("--execute", "--out", rawPath, "--lead-out", leadPath);
+    if (reference.vendorTemplate !== "deel") {
+        throw new Error("Automatic company-to-ICP matching is available for Deel right now. Try deel.com or the Deel LinkedIn company page.");
     }
-    writeWizardLine(`  ${buildCommandLine(lookupArgs)}`);
-    if (!execute) {
+    writeWizardSection("Find matching leads", `Using the built-in ${reference.companyName} profile to search your workspace data.`);
+    const market = await promptChoice(rl, "Where do you want to search?", [
+        { value: "dach", label: "DACH", description: "Germany, Austria, Switzerland" },
+        { value: "europe", label: "Europe" },
+        { value: "global", label: "Global" }
+    ], "dach");
+    const leadCount = z.coerce.number().int().min(1).max(5000).parse(await promptText(rl, "How many leads do you want?", { defaultValue: "100", required: true }));
+    writeWizardLine();
+    const icp = buildVendorIcp(reference.vendorTemplate, market);
+    const icpPath = `./data/${reference.slug}-icp-${market}.json`;
+    const leadPath = buildQualifiedLeadsPath(`${reference.slug}-${market}`);
+    await writeJsonFile(icpPath, icp);
+    const leads = await searchReferenceCompanyLeads(reference, icp, leadCount);
+    await writeJsonFile(leadPath, leads);
+    writeWizardLine(`Saved ICP to ${icpPath}.`);
+    if (leads.length === 0) {
+        writeWizardLine(`No matching leads found for ${reference.companyName} in this workspace.`);
         return;
     }
+    writeWizardLine(`Found ${leads.length} matching lead${leads.length === 1 ? "" : "s"}.`);
+    writeWizardLine(`Saved leads to ${leadPath}.`);
+}
+async function runTargetCompanyWizard(rl) {
+    writeWizardSection("Target company", "Paste the website or LinkedIn company page for the company you want people from.");
+    const reference = parseCompanyReference(await promptText(rl, "Which company do you want people from?", {
+        required: true
+    }));
     writeWizardLine();
-    await maybePrepareLeadsForOutreach(rl, {
-        baseSlug: slug,
-        icp,
-        icpPath,
-        leadPath,
-        leads: normalizedLeads
-    });
+    const leadCount = z.coerce.number().int().min(1).max(1000).parse(await promptText(rl, "How many people do you want?", { defaultValue: "25", required: true }));
+    writeWizardLine();
+    const leadPath = buildQualifiedLeadsPath(reference.slug);
+    const leads = await searchTargetCompanyLeads(reference, leadCount);
+    await writeJsonFile(leadPath, leads);
+    if (leads.length === 0) {
+        writeWizardLine(`No qualified leads found for ${reference.label} in this workspace.`);
+        return;
+    }
+    writeWizardLine(`Found ${leads.length} qualified lead${leads.length === 1 ? "" : "s"} at ${reference.companyName}.`);
+    writeWizardLine(`Saved leads to ${leadPath}.`);
 }
 async function runOutreachSyncWizard(rl, options) {
     const target = "instantly";
@@ -809,7 +1350,7 @@ async function runWizard(options) {
         throw new Error("wizard does not support --json or --quiet.");
     }
     writeWizardLine("Salesprompter");
-    writeWizardLine("Tell me what you want to do, and I will guide you through it.");
+    writeWizardLine("Start with a company website or LinkedIn page. I will guide you from there.");
     writeWizardLine();
     await ensureWizardSession(options);
     const rl = createInterface({
@@ -819,31 +1360,31 @@ async function runWizard(options) {
     try {
         const flow = await promptChoice(rl, "What do you want help with?", [
             {
-                value: "vendor-icp",
-                label: "Define my ICP",
-                description: "Build the company profile you want to sell to",
-                aliases: ["icp", "ideal customer", "who to target", "targeting", "profile"]
+                value: "reference-company",
+                label: "Find leads like one of my customers",
+                description: "Example: I sell for Deel and want similar companies and people",
+                aliases: ["customer", "reference company", "similar companies", "icp", "who to target"]
             },
             {
-                value: "lead-generation",
-                label: "Generate leads",
-                description: "Find people at one company or from your own lead data",
-                aliases: ["leads", "find leads", "lead generation", "find people"]
+                value: "target-company",
+                label: "Find people at a specific company",
+                description: "Example: find people at deel.com",
+                aliases: ["target company", "company", "find people", "people at a company", "lead generation"]
             },
             {
                 value: "outreach-sync",
-                label: "Send leads to Instantly",
-                description: "Use a scored leads file to fill an Instantly campaign",
+                label: "Push qualified leads to Instantly",
+                description: "Use a saved leads file to fill an Instantly campaign",
                 aliases: ["instantly", "outreach", "send leads", "campaign"]
             }
-        ], "vendor-icp");
+        ], "reference-company");
         writeWizardLine();
-        if (flow === "vendor-icp") {
-            await runVendorIcpWizard(rl);
+        if (flow === "reference-company") {
+            await runReferenceCompanyWizard(rl);
             return;
         }
-        if (flow === "lead-generation") {
-            await runLeadGenerationWizard(rl);
+        if (flow === "target-company") {
+            await runTargetCompanyWizard(rl);
             return;
         }
         await runOutreachSyncWizard(rl);
@@ -1057,12 +1598,34 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
     if (commandName.startsWith("auth:") || commandName === "wizard") {
         return;
     }
+    const commandOptions = actionCommand.opts();
+    if (typeof commandOptions === "object" &&
+        commandOptions !== null &&
+        "dryRun" in commandOptions &&
+        Boolean(commandOptions.dryRun)) {
+        return;
+    }
     if (shouldBypassAuth()) {
         return;
     }
-    const session = await requireAuthSession();
-    if (session.expiresAt !== undefined && Date.now() >= Date.parse(session.expiresAt)) {
-        throw new Error("session expired. Run `salesprompter auth:login`.");
+    try {
+        const session = await requireAuthSession();
+        if (session.expiresAt !== undefined && Date.now() >= Date.parse(session.expiresAt)) {
+            if (canPromptForInteractiveLogin()) {
+                await ensureInteractiveAuthSession(session.apiBaseUrl);
+                return;
+            }
+            throw new Error("session expired. Run `salesprompter auth:login`.");
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if ((message.includes("not logged in") || message.includes("session expired")) &&
+            canPromptForInteractiveLogin()) {
+            await ensureInteractiveAuthSession();
+            return;
+        }
+        throw error;
     }
 });
 program
@@ -1260,6 +1823,278 @@ program
     });
     printOutput({ status: "ok", ...result });
 });
+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.")
+    .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")
+    .option("--out <path>", "Optional local JSON output path")
+    .option("--skip-details", "Skip product-page enrichment and only keep category-card data", false)
+    .action(async (options) => {
+    const maxPages = z.coerce.number().int().min(1).max(500).parse(options.maxPages);
+    const limit = options.limit === undefined ? undefined : z.coerce.number().int().min(1).max(5000).parse(options.limit);
+    const scrape = await crawlLinkedInProductCategory({
+        input: options.input,
+        maxPages,
+        limit,
+        enrichDetails: !options.skipDetails
+    });
+    const outPath = options.out ?? buildLinkedInProductsOutputPath(scrape.source.category.slug);
+    await writeJsonFile(outPath, {
+        source: scrape.source,
+        items: scrape.items,
+        totalPagesFetched: scrape.totalPagesFetched
+    });
+    let uploaded = null;
+    if (!shouldBypassAuth()) {
+        const session = await requireAuthSession();
+        uploaded = await uploadLinkedInProductsCatalog(session, {
+            source: {
+                input: scrape.source.input,
+                kind: scrape.source.kind,
+                query: scrape.source.query,
+                companyUrl: scrape.source.companyUrl,
+                productUrl: scrape.source.productUrl,
+                category: scrape.source.category
+            },
+            items: scrape.items
+        });
+    }
+    printOutput({
+        status: "ok",
+        source: scrape.source,
+        totalPagesFetched: scrape.totalPagesFetched,
+        discovered: scrape.items.length,
+        out: outPath,
+        uploaded
+    });
+});
+program
+    .command("salesnav:crawl")
+    .description("Adaptively split broad LinkedIn Sales Navigator people searches into exportable slices and store every finished slice through Salesprompter.")
+    .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")
+    .option("--number-of-profiles <number>", "Profiles to export per sliced query", "2500")
+    .option("--slice-preset <name>", "Slice preset label stored with the export runs", "human-resources-crawl")
+    .option("--max-split-depth <number>", "Maximum number of adaptive split dimensions to use", "6")
+    .option("--max-slices <number>", "Safety cap for total claimed slices in this invocation", "1000")
+    .option("--max-retries <number>", "Retries for non-splitting export failures", "3")
+    .option("--probe-profiles <number>", "Profiles to scrape while probing whether a slice is still too broad", "100")
+    .option("--agent-busy-wait-seconds <number>", "Seconds to wait before retrying when the export agent is already busy", "30")
+    .option("--agent-busy-max-waits <number>", "How many busy-agent waits to tolerate before failing the slice", "20")
+    .option("--out <path>", "Optional local JSON output path")
+    .option("--dry-run", "Preview the adaptive crawl plan without exporting anything", false)
+    .action(async (options) => {
+    const queryUrl = z.string().url().optional().parse(options.queryUrl);
+    const jobId = z.string().uuid().optional().parse(options.jobId);
+    const maxResultsPerSearch = z.coerce.number().int().min(1).max(2500).parse(options.maxResultsPerSearch);
+    const numberOfProfiles = z.coerce.number().int().min(1).max(2500).parse(options.numberOfProfiles);
+    const maxSplitDepth = z.coerce.number().int().min(1).max(6).parse(options.maxSplitDepth);
+    const maxSlices = z.coerce.number().int().min(1).max(10000).parse(options.maxSlices);
+    const maxRetries = z.coerce.number().int().min(0).max(5).parse(options.maxRetries);
+    const probeProfiles = z.coerce.number().int().min(1).max(2500).parse(options.probeProfiles);
+    const agentBusyWaitSeconds = z.coerce.number().int().min(1).max(300).parse(options.agentBusyWaitSeconds);
+    const agentBusyMaxWaits = z.coerce.number().int().min(0).max(120).parse(options.agentBusyMaxWaits);
+    const effectiveDryRun = Boolean(options.dryRun || shouldBypassAuth());
+    if (effectiveDryRun) {
+        if (jobId) {
+            throw new Error("--dry-run does not support --job-id. Use --query-url instead.");
+        }
+        if (!queryUrl) {
+            throw new Error("Provide --query-url for --dry-run.");
+        }
+        const payload = {
+            status: "ok",
+            dryRun: true,
+            mode: "adaptive",
+            dimensionPreset: "human-resources-adaptive",
+            query: (() => {
+                const preview = buildSalesNavigatorCrawlPreview({
+                    sourceQueryUrl: queryUrl,
+                    maxResultsPerSearch,
+                    numberOfProfiles,
+                    slicePreset: options.slicePreset
+                });
+                return {
+                    sourceQueryUrl: queryUrl,
+                    rootQueryUrl: preview.root.slicedQueryUrl,
+                    rootAppliedFilters: preview.root.appliedFilters,
+                    dimensionOrder: preview.dimensions.map((dimension) => ({
+                        key: dimension.key,
+                        filterType: dimension.filterType,
+                        valueCount: dimension.values.length
+                    })),
+                    firstSplitQueries: preview.firstSplit.map((attempt) => ({
+                        slicedQueryUrl: attempt.slicedQueryUrl,
+                        appliedFilters: attempt.appliedFilters,
+                        splitTrail: attempt.splitTrail.map((entry) => ({
+                            key: entry.key,
+                            filterType: entry.filterType,
+                            valueText: entry.value.text
+                        }))
+                    }))
+                };
+            })()
+        };
+        if (options.out) {
+            await writeJsonFile(options.out, payload);
+        }
+        printOutput(payload);
+        return;
+    }
+    if (Boolean(queryUrl) === Boolean(jobId)) {
+        throw new Error("Provide exactly one of --query-url or --job-id.");
+    }
+    let session = await requireAuthSession();
+    let createResult = null;
+    let resolvedJobId = jobId ?? null;
+    if (queryUrl) {
+        const seed = createSalesNavigatorCrawlSeed({
+            sourceQueryUrl: queryUrl,
+            maxResultsPerSearch,
+            numberOfProfiles,
+            slicePreset: options.slicePreset
+        });
+        const created = await createOrResumeSalesNavigatorCrawlJob(session, {
+            sourceQueryUrl: queryUrl,
+            slicePreset: options.slicePreset,
+            maxResultsPerSearch,
+            numberOfProfiles,
+            rootSlice: {
+                slicedQueryUrl: seed.slicedQueryUrl,
+                appliedFilters: seed.appliedFilters,
+                depth: seed.depth,
+                splitTrail: seed.splitTrail
+            }
+        });
+        session = created.session;
+        createResult = {
+            resumed: created.value.resumed,
+            job: created.value.job
+        };
+        resolvedJobId = created.value.job.id;
+    }
+    else {
+        const status = await getSalesNavigatorCrawlStatus(session, resolvedJobId);
+        session = status.session;
+    }
+    if (!resolvedJobId) {
+        throw new Error("Failed to determine Sales Navigator crawl job id.");
+    }
+    const crawl = await executeSalesNavigatorCrawlJob(session, resolvedJobId, {
+        maxSplitDepth,
+        maxSlices,
+        maxRetries,
+        probeProfiles,
+        agentBusyWaitSeconds,
+        agentBusyMaxWaits
+    });
+    const payload = {
+        status: "ok",
+        dryRun: false,
+        mode: "durable",
+        jobId: resolvedJobId,
+        resumed: createResult?.resumed ?? true,
+        sourceQueryUrl: crawl.job.sourceQueryUrl,
+        slicePreset: crawl.job.slicePreset,
+        maxResultsPerSearch: crawl.job.maxResultsPerSearch,
+        numberOfProfiles: crawl.job.numberOfProfiles,
+        claimedSlices: crawl.claimedSlices,
+        truncated: crawl.truncated,
+        job: crawl.job,
+        activeSlice: crawl.activeSlice
+            ? {
+                id: crawl.activeSlice.id,
+                slicedQueryUrl: crawl.activeSlice.slicedQueryUrl,
+                depth: crawl.activeSlice.depth,
+                splitTrail: formatSalesNavigatorSplitTrail(crawl.activeSlice.splitTrail),
+                retryCount: crawl.activeSlice.retryCount,
+                cookieRetryCount: crawl.activeSlice.cookieRetryCount,
+                resultRetryCount: crawl.activeSlice.resultRetryCount
+            }
+            : null,
+        lastOutcome: crawl.lastOutcome
+    };
+    if (options.out) {
+        await writeJsonFile(options.out, payload);
+    }
+    printOutput(payload);
+});
+program
+    .command("salesnav:crawl:status")
+    .description("Return the current status of a durable Sales Navigator crawl job.")
+    .requiredOption("--job-id <id>", "Sales Navigator crawl job id")
+    .action(async (options) => {
+    const jobId = z.string().uuid().parse(options.jobId);
+    let session = await requireAuthSession();
+    const status = await getSalesNavigatorCrawlStatus(session, jobId);
+    session = status.session;
+    void session;
+    printOutput({
+        status: "ok",
+        jobId,
+        job: status.value.job
+    });
+});
+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.")
+    .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")
+    .option("--slice-preset <name>", "Slice preset label stored with the export run", "human-resources-default")
+    .option("--out <path>", "Optional local JSON output path")
+    .option("--dry-run", "Only generate sliced query URLs without exporting them", false)
+    .action(async (options) => {
+    const queryUrls = z.array(z.string().url()).min(1).parse(options.queryUrl);
+    const maxResultsPerSearch = z.coerce.number().int().min(1).max(2500).parse(options.maxResultsPerSearch);
+    const numberOfProfiles = z.coerce.number().int().min(1).max(2500).parse(options.numberOfProfiles);
+    const prepared = queryUrls.map((queryUrl) => buildSalesNavigatorPeopleSlice(queryUrl));
+    const effectiveDryRun = Boolean(options.dryRun || shouldBypassAuth());
+    if (effectiveDryRun) {
+        const payload = {
+            status: "ok",
+            dryRun: true,
+            queries: prepared.map((item) => ({
+                sourceQueryUrl: item.sourceQueryUrl,
+                slicedQueryUrl: item.slicedQueryUrl,
+                appliedFilters: item.appliedFilters,
+                maxResultsPerSearch,
+                numberOfProfiles,
+                slicePreset: options.slicePreset
+            }))
+        };
+        if (options.out) {
+            await writeJsonFile(options.out, payload);
+        }
+        printOutput(payload);
+        return;
+    }
+    const session = await requireAuthSession();
+    const exported = [];
+    for (const item of prepared) {
+        const result = await runSalesNavigatorExport(session, {
+            sourceQueryUrl: item.sourceQueryUrl,
+            slicedQueryUrl: item.slicedQueryUrl,
+            appliedFilters: item.appliedFilters,
+            maxResultsPerSearch,
+            numberOfProfiles,
+            slicePreset: options.slicePreset
+        });
+        exported.push(result);
+    }
+    const payload = {
+        status: "ok",
+        dryRun: false,
+        queries: exported
+    };
+    if (options.out) {
+        await writeJsonFile(options.out, payload);
+    }
+    printOutput(payload);
+});
 program
     .command("leads:lookup:bq")
     .description("Build a BigQuery lead lookup from an ICP and optionally execute it with the bq CLI.")
@@ -1361,6 +2196,53 @@ program
         sourceTables: report.sourceTables
     });
 });
+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")
+    .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")
+    .option("--sql-out <path>", "Optional file path for the generated SQL")
+    .action(async (options) => {
+    const vendor = z.enum(["deel"]).parse(options.vendor);
+    const market = z.enum(["global", "europe", "dach"]).parse(options.market);
+    const limit = z.coerce.number().int().min(1).max(100000).parse(options.limit);
+    const sql = buildDirectPathLeadExportSql(vendor, market, limit);
+    if (options.sqlOut) {
+        await writeTextFile(options.sqlOut, `${sql}\n`);
+    }
+    const rows = await runBigQueryRows(sql, { maxRows: limit });
+    const normalizedRows = normalizeDirectPathRows(rows);
+    const pack = segmentDirectPathRows(vendor, market, normalizedRows);
+    const baseSlug = `${slugify(vendor)}-direct-${market}`;
+    const rawPath = path.join(options.outDir, `${baseSlug}-raw.json`);
+    const packPath = path.join(options.outDir, `${baseSlug}-segments.json`);
+    const leadershipPath = path.join(options.outDir, `${baseSlug}-leadership.json`);
+    const payrollPath = path.join(options.outDir, `${baseSlug}-payroll-people-services.json`);
+    const broaderPath = path.join(options.outDir, `${baseSlug}-broader-hr.json`);
+    await writeJsonFile(rawPath, normalizedRows);
+    await writeJsonFile(packPath, pack);
+    await writeJsonFile(leadershipPath, pack.segments.leadership);
+    await writeJsonFile(payrollPath, pack.segments["payroll-people-services"]);
+    await writeJsonFile(broaderPath, pack.segments["broader-hr"]);
+    printOutput({
+        status: "ok",
+        vendor,
+        market,
+        rowCount: normalizedRows.length,
+        distinctContacts: pack.distinctContacts,
+        distinctCompanies: pack.distinctCompanies,
+        segmentCounts: pack.summary.segmentCounts,
+        outDir: options.outDir,
+        raw: rawPath,
+        pack: packPath,
+        leadership: leadershipPath,
+        payrollPeopleServices: payrollPath,
+        broaderHr: broaderPath,
+        sqlOut: options.sqlOut ?? null
+    });
+});
 program
     .command("leadlists:funnel:bq")
     .description("Build an upstream lead-list funnel report for a vendor/market.")