salesprompter-cli 0.1.18 → 0.1.20

package/dist/cli.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
-import { access } from "node:fs/promises";
+import { access, appendFile, mkdir } 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 { createClient } from "@supabase/supabase-js";
 import { Command } from "commander";
 import { z } from "zod";
 import { clearAuthSession, loginWithBrowserConnect, loginWithDeviceFlow, loginWithToken, requireAuthSession, shouldBypassAuth, verifySession } from "./auth.js";
@@ -20,7 +21,8 @@ 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";
+import { buildSalesNavigatorCrawlPreview, createSalesNavigatorCrawlSeed, DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS, buildSalesNavigatorPeopleSlice, deriveSalesNavigatorTitleQuerySeeds, expandSalesNavigatorCrawlAttempt, SalesNavigatorSliceTooBroadError } from "./sales-navigator.js";
+import { buildSalesNavigatorHistoricalBackfillPlan, ensureSalesNavigatorPeopleCount, resolveSalesNavigatorHistoricalBackfillConfig, resolveSalesNavigatorHistoricalBackfillResumeState, resolveSalesNavigatorHistoricalBackfillOrgId, salesNavigatorHistoricalBackfillDefaults } from "./salesnav-backfill.js";
 const require = createRequire(import.meta.url);
 const { version: packageVersion } = require("../package.json");
 const program = new Command();
@@ -50,12 +52,31 @@ const LinkedInProductIngestResponseSchema = z.object({
     upserted: z.number().int().nonnegative(),
     totalInCatalog: z.number().int().nonnegative().optional()
 });
+const SalesNavigatorLaunchDiagnosticsSchema = z.object({
+    orderedCandidateAgentIds: z.array(z.string().min(1)),
+    runningAgentIds: z.array(z.string().min(1)),
+    busyAgentIds: z.array(z.string().min(1)),
+    selectedAgent: z.object({
+        id: z.string().min(1),
+        name: z.string().min(1),
+        maxParallelism: z.number().int().nullable(),
+        fileMgmt: z.string().min(1).nullable(),
+        hasWebhook: z.boolean(),
+        hasStoredSessionCookie: z.boolean(),
+        storedIdentityCount: z.number().int().nonnegative(),
+        supportsDirectSessionInjection: z.boolean()
+    })
+});
 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),
+    selectedSessionCookieSha256: z.string().min(1).nullable().optional(),
+    selectedSessionUserEmail: z.string().min(1).nullable().optional(),
+    selectedSessionUserHandle: z.string().min(1).nullable().optional(),
+    launchDiagnostics: SalesNavigatorLaunchDiagnosticsSchema.nullable().optional(),
     sourceQueryUrl: z.string().url(),
     slicedQueryUrl: z.string().url(),
     previousContainerId: z.string().min(1).nullable().optional()
@@ -79,6 +100,10 @@ const SalesNavigatorExportRunSchema = z.object({
     resultCsvUrl: z.string().url().nullable().optional(),
     agentId: z.string().min(1),
     containerId: z.string().min(1),
+    selectedSessionCookieSha256: z.string().min(1).nullable().optional(),
+    selectedSessionUserEmail: z.string().min(1).nullable().optional(),
+    selectedSessionUserHandle: z.string().min(1).nullable().optional(),
+    launchDiagnostics: SalesNavigatorLaunchDiagnosticsSchema.nullable().optional(),
     sourceQueryUrl: z.string().url(),
     slicedQueryUrl: z.string().url(),
     createdAt: z.string().datetime(),
@@ -99,6 +124,10 @@ const SalesNavigatorExportResponseSchema = z.object({
     resultCsvUrl: z.string().url().nullable().optional(),
     agentId: z.string().min(1),
     containerId: z.string().min(1),
+    selectedSessionCookieSha256: z.string().min(1).nullable().optional(),
+    selectedSessionUserEmail: z.string().min(1).nullable().optional(),
+    selectedSessionUserHandle: z.string().min(1).nullable().optional(),
+    launchDiagnostics: SalesNavigatorLaunchDiagnosticsSchema.nullable().optional(),
     sourceQueryUrl: z.string().url(),
     slicedQueryUrl: z.string().url()
 });
@@ -188,6 +217,12 @@ function printOutput(value) {
     const space = runtimeOutputOptions.json ? undefined : 2;
     process.stdout.write(`${JSON.stringify(value, null, space)}\n`);
 }
+function writeProgress(message) {
+    if (runtimeOutputOptions.json || runtimeOutputOptions.quiet) {
+        return;
+    }
+    process.stderr.write(`${message}\n`);
+}
 function applyGlobalOutputOptions(actionCommand) {
     const globalOptions = actionCommand.optsWithGlobals();
     runtimeOutputOptions.json = Boolean(globalOptions.json);
@@ -687,6 +722,449 @@ async function fetchWorkspaceLeadSearch(session, requestBody) {
 function buildLinkedInProductsOutputPath(categorySlug) {
     return `./data/linkedin-products-${categorySlug}.json`;
 }
+function buildLinkedInProductCategorySalesNavigatorOutputPath(categorySlug) {
+    return `./data/salesnav-product-category-${categorySlug}.json`;
+}
+const SALES_NAVIGATOR_TERMINAL_JOB_STATUSES = new Set(["completed", "completed_with_failures"]);
+function isSalesNavigatorCrawlJobTerminal(status) {
+    return SALES_NAVIGATOR_TERMINAL_JOB_STATUSES.has(status);
+}
+function buildWorkflowTraceId(prefix) {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function buildSalesNavigatorWorkflowLogPath(input) {
+    const slug = slugify(input) || "salesnav-product-category";
+    return `./data/${slug}-salesnav.log.jsonl`;
+}
+function buildSalesNavigatorCrawlLogPath(input) {
+    const slug = slugify(input) || "salesnav-crawl";
+    return `./data/${slug}-crawl.log.jsonl`;
+}
+function decodeSalesNavigatorQueryParam(url) {
+    try {
+        const encoded = new URL(url).searchParams.get("query");
+        if (!encoded) {
+            return null;
+        }
+        try {
+            return decodeURIComponent(encoded);
+        }
+        catch {
+            return encoded;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+async function createWorkflowLogger(options) {
+    const traceId = options.traceId ?? buildWorkflowTraceId("salesprompter-cli");
+    const logPath = options.logPath;
+    await mkdir(path.dirname(logPath), { recursive: true });
+    return {
+        traceId,
+        logPath,
+        log: async (event, metadata = {}) => {
+            const entry = {
+                timestamp: new Date().toISOString(),
+                traceId,
+                event,
+                metadata
+            };
+            await appendFile(logPath, `${JSON.stringify(entry)}\n`, "utf8");
+            writeProgress(`[${entry.timestamp}] ${event}`);
+        }
+    };
+}
+function summarizeSalesNavigatorQuery(url, appliedFilters) {
+    return {
+        url,
+        decodedQuery: decodeSalesNavigatorQueryParam(url),
+        appliedFilters
+    };
+}
+function extractSalesNavigatorFilterTypes(url, appliedFilters) {
+    const filterTypes = new Set(appliedFilters.map((filter) => filter.type));
+    const decodedQuery = decodeSalesNavigatorQueryParam(url) ?? "";
+    for (const match of decodedQuery.matchAll(/type:([A-Z_]+)/g)) {
+        const value = match[1]?.trim();
+        if (value) {
+            filterTypes.add(value);
+        }
+    }
+    return [...filterTypes];
+}
+function shouldPreSplitSalesNavigatorRootSlice(slice, maxSplitDepth) {
+    if (slice.depth !== 0 || slice.splitTrail.length > 0) {
+        return false;
+    }
+    if (!nextSalesNavigatorSplitDimension(slice, maxSplitDepth)) {
+        return false;
+    }
+    const filterTypes = new Set(extractSalesNavigatorFilterTypes(slice.slicedQueryUrl, slice.appliedFilters));
+    if (!filterTypes.has("CURRENT_TITLE")) {
+        return false;
+    }
+    return !DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS.some((dimension) => filterTypes.has(dimension.filterType));
+}
+function buildTraceHeaders(traceId) {
+    return traceId ? { "X-Salesprompter-Trace-Id": traceId } : {};
+}
+function buildSalesNavigatorWorkflowCrawlSummary(crawl) {
+    const successful = crawl.job.status === "completed" && !crawl.truncated;
+    return {
+        jobStatus: crawl.job.status,
+        importedPeople: crawl.job.importedPeople,
+        exportedSlices: crawl.job.exportedSlices,
+        failedSlices: crawl.job.failedSlices,
+        queuedSlices: crawl.job.queuedSlices,
+        runningSlices: crawl.job.runningSlices,
+        truncated: crawl.truncated,
+        successful
+    };
+}
+function buildSalesNavigatorWorkflowSummary(crawls) {
+    return crawls.reduce((summary, crawl) => {
+        summary.totalImportedPeople += crawl.summary.importedPeople;
+        summary.totalExportedSlices += crawl.summary.exportedSlices;
+        summary.totalFailedSlices += crawl.summary.failedSlices;
+        if (crawl.summary.truncated) {
+            summary.truncatedTitles += 1;
+        }
+        if (crawl.summary.jobStatus === "completed") {
+            summary.completedTitles += 1;
+        }
+        else if (crawl.summary.jobStatus === "completed_with_failures") {
+            summary.completedWithFailuresTitles += 1;
+        }
+        else {
+            summary.runningTitles += 1;
+        }
+        if (!crawl.summary.successful) {
+            summary.workflowStatus = "completed_with_failures";
+        }
+        return summary;
+    }, {
+        workflowStatus: "completed",
+        totalImportedPeople: 0,
+        totalExportedSlices: 0,
+        totalFailedSlices: 0,
+        completedTitles: 0,
+        completedWithFailuresTitles: 0,
+        runningTitles: 0,
+        truncatedTitles: 0
+    });
+}
+function buildSalesNavigatorWorkflowFailureMessage(summary) {
+    return [
+        "Sales Navigator workflow completed with failures.",
+        `completedTitles=${summary.completedTitles}`,
+        `completedWithFailuresTitles=${summary.completedWithFailuresTitles}`,
+        `runningTitles=${summary.runningTitles}`,
+        `truncatedTitles=${summary.truncatedTitles}`,
+        `totalFailedSlices=${summary.totalFailedSlices}`
+    ].join(" ");
+}
+function validateSalesNavigatorSeedQuery(seed) {
+    const decodedQuery = decodeSalesNavigatorQueryParam(seed.queryUrl);
+    const haystack = decodedQuery?.toLowerCase() ?? "";
+    const missingFilters = seed.appliedFilters.flatMap((filter) => {
+        const missingValues = filter.values.filter((value) => !haystack.includes(value.text.toLowerCase()));
+        if (!haystack.includes(filter.type.toLowerCase()) || missingValues.length > 0) {
+            return `${filter.type}:${missingValues.map((value) => value.text).join(",") || "*"}`;
+        }
+        return [];
+    });
+    return {
+        valid: missingFilters.length === 0,
+        missingFilters,
+        decodedQuery
+    };
+}
+async function runSalesNavigatorFromProductCategoryWorkflow(options) {
+    const logger = await createWorkflowLogger({
+        logPath: options.logPath ?? buildSalesNavigatorWorkflowLogPath(options.input)
+    });
+    await logger.log("workflow.started", {
+        input: options.input,
+        maxPages: options.maxPages,
+        productLimit: options.productLimit ?? null,
+        titleLimit: options.titleLimit ?? null,
+        maxResultsPerSearch: options.maxResultsPerSearch,
+        numberOfProfiles: options.numberOfProfiles,
+        slicePreset: options.slicePreset,
+        maxSplitDepth: options.maxSplitDepth,
+        maxSlicesPerTitle: options.maxSlicesPerTitle,
+        maxRetries: options.maxRetries,
+        probeProfiles: options.probeProfiles,
+        agentBusyWaitSeconds: options.agentBusyWaitSeconds,
+        agentBusyMaxWaits: options.agentBusyMaxWaits,
+        idlePollSeconds: options.idlePollSeconds,
+        idleMaxPolls: options.idleMaxPolls,
+        parallelExports: options.parallelExports,
+        skipProductUpload: options.skipProductUpload,
+        dryRun: options.dryRun
+    });
+    try {
+        const scrape = await crawlLinkedInProductCategory({
+            input: options.input,
+            maxPages: options.maxPages,
+            limit: options.productLimit
+        });
+        await logger.log("linkedin.category.scraped", {
+            source: scrape.source,
+            totalPagesFetched: scrape.totalPagesFetched,
+            discoveredProducts: scrape.items.length,
+            productNames: scrape.items.map((item) => item.productName)
+        });
+        const titleSeeds = deriveSalesNavigatorTitleQuerySeeds({
+            sourceProductUrl: scrape.source.productUrl,
+            items: scrape.items,
+            titleLimit: options.titleLimit
+        });
+        if (titleSeeds.length === 0) {
+            throw new Error(`No intended-role job titles were found while crawling the LinkedIn product category ${scrape.source.category.name}.`);
+        }
+        const outPath = options.outPath ?? buildLinkedInProductCategorySalesNavigatorOutputPath(scrape.source.category.slug);
+        const previewQueries = titleSeeds.map((seed) => {
+            const preview = buildSalesNavigatorCrawlPreview({
+                sourceQueryUrl: seed.queryUrl,
+                maxResultsPerSearch: options.maxResultsPerSearch,
+                numberOfProfiles: options.numberOfProfiles,
+                slicePreset: options.slicePreset
+            });
+            return {
+                title: seed.title,
+                queryUrl: seed.queryUrl,
+                appliedFilters: seed.appliedFilters,
+                sourceProduct: seed.sourceProduct,
+                matchedProductCount: seed.matchedProductCount,
+                firstSplitQueries: preview.firstSplit.map((attempt) => ({
+                    slicedQueryUrl: attempt.slicedQueryUrl,
+                    appliedFilters: attempt.appliedFilters,
+                    splitTrail: formatSalesNavigatorSplitTrail(attempt.splitTrail.map((entry) => ({
+                        ...entry,
+                        value: {
+                            id: entry.value.id,
+                            text: entry.value.text,
+                            selectionType: entry.value.selectionType
+                        }
+                    })))
+                }))
+            };
+        });
+        await logger.log("salesnav.title-seeds.derived", {
+            titleCount: titleSeeds.length,
+            titles: titleSeeds.map((seed) => ({
+                title: seed.title,
+                sourceProduct: seed.sourceProduct,
+                matchedProductCount: seed.matchedProductCount,
+                ...summarizeSalesNavigatorQuery(seed.queryUrl, seed.appliedFilters)
+            }))
+        });
+        const firstSeedValidation = validateSalesNavigatorSeedQuery(titleSeeds[0]);
+        await logger.log("salesnav.first-query.validated", {
+            title: titleSeeds[0]?.title ?? null,
+            valid: firstSeedValidation.valid,
+            missingFilters: firstSeedValidation.missingFilters,
+            decodedQuery: firstSeedValidation.decodedQuery
+        });
+        if (!firstSeedValidation.valid) {
+            throw new Error(`Generated Sales Navigator seed query for "${titleSeeds[0]?.title ?? "unknown"}" is missing expected filters: ${firstSeedValidation.missingFilters.join(", ")}.`);
+        }
+        await logger.log("salesnav.first-split.preview", {
+            titles: previewQueries.map((query) => ({
+                title: query.title,
+                sourceProduct: query.sourceProduct,
+                matchedProductCount: query.matchedProductCount,
+                ...summarizeSalesNavigatorQuery(query.queryUrl, query.appliedFilters),
+                firstSplitQueries: query.firstSplitQueries.map((split) => ({
+                    splitTrail: split.splitTrail,
+                    ...summarizeSalesNavigatorQuery(split.slicedQueryUrl, split.appliedFilters)
+                }))
+            }))
+        });
+        if (options.dryRun) {
+            const payload = {
+                status: "ok",
+                dryRun: true,
+                mode: "linkedin-product-category-to-salesnav",
+                traceId: logger.traceId,
+                logPath: logger.logPath,
+                source: scrape.source,
+                totalPagesFetched: scrape.totalPagesFetched,
+                discoveredProducts: scrape.items.length,
+                titleCount: titleSeeds.length,
+                summary: {
+                    workflowStatus: "completed",
+                    totalImportedPeople: 0,
+                    totalExportedSlices: 0,
+                    totalFailedSlices: 0,
+                    completedTitles: 0,
+                    completedWithFailuresTitles: 0,
+                    runningTitles: 0,
+                    truncatedTitles: 0
+                },
+                uploaded: null,
+                queries: previewQueries
+            };
+            await writeJsonFile(outPath, payload);
+            await logger.log("workflow.completed", {
+                outPath,
+                dryRun: true,
+                discoveredProducts: payload.discoveredProducts,
+                titleCount: payload.titleCount
+            });
+            return { outPath, payload };
+        }
+        let session = await requireAuthSession();
+        let uploaded = null;
+        if (!options.skipProductUpload) {
+            await logger.log("linkedin.catalog.upload.started", {
+                itemCount: scrape.items.length
+            });
+            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
+            }, 100, logger.traceId);
+            await logger.log("linkedin.catalog.upload.completed", uploaded);
+        }
+        const crawls = [];
+        for (const seed of titleSeeds) {
+            writeProgress(`Starting durable Sales Navigator crawl for intended role "${seed.title}".`);
+            const rootSlice = createSalesNavigatorCrawlSeed({
+                sourceQueryUrl: seed.queryUrl,
+                maxResultsPerSearch: options.maxResultsPerSearch,
+                numberOfProfiles: options.numberOfProfiles,
+                slicePreset: options.slicePreset
+            });
+            const created = await createOrResumeSalesNavigatorCrawlJob(session, {
+                sourceQueryUrl: seed.queryUrl,
+                slicePreset: options.slicePreset,
+                maxResultsPerSearch: options.maxResultsPerSearch,
+                numberOfProfiles: options.numberOfProfiles,
+                rawPayload: {
+                    workflow: "linkedin-product-category-to-salesnav",
+                    traceId: logger.traceId,
+                    source: scrape.source,
+                    titleSeed: {
+                        title: seed.title,
+                        queryUrl: seed.queryUrl,
+                        appliedFilters: seed.appliedFilters,
+                        sourceProduct: seed.sourceProduct,
+                        matchedProductCount: seed.matchedProductCount
+                    }
+                },
+                rootSlice: {
+                    slicedQueryUrl: rootSlice.slicedQueryUrl,
+                    appliedFilters: rootSlice.appliedFilters,
+                    depth: rootSlice.depth,
+                    splitTrail: rootSlice.splitTrail,
+                    rawPayload: {
+                        traceId: logger.traceId,
+                        title: seed.title,
+                        sourceProduct: seed.sourceProduct,
+                        matchedProductCount: seed.matchedProductCount,
+                        source: scrape.source
+                    }
+                }
+            }, logger.traceId);
+            session = created.session;
+            await logger.log("salesnav.crawl.job.ready", {
+                title: seed.title,
+                sourceProduct: seed.sourceProduct,
+                matchedProductCount: seed.matchedProductCount,
+                resumed: created.value.resumed,
+                jobId: created.value.job.id,
+                rootSlice: {
+                    depth: rootSlice.depth,
+                    splitTrail: formatSalesNavigatorSplitTrail(rootSlice.splitTrail),
+                    ...summarizeSalesNavigatorQuery(rootSlice.slicedQueryUrl, rootSlice.appliedFilters)
+                }
+            });
+            const crawl = await executeSalesNavigatorCrawlJob(session, created.value.job.id, {
+                maxSplitDepth: options.maxSplitDepth,
+                maxSlices: options.maxSlicesPerTitle,
+                maxRetries: options.maxRetries,
+                probeProfiles: options.probeProfiles,
+                agentBusyWaitSeconds: options.agentBusyWaitSeconds,
+                agentBusyMaxWaits: options.agentBusyMaxWaits,
+                idlePollSeconds: options.idlePollSeconds,
+                idleMaxPolls: options.idleMaxPolls,
+                parallelExports: options.parallelExports,
+                traceId: logger.traceId,
+                logger
+            });
+            session = crawl.session;
+            const crawlSummary = buildSalesNavigatorWorkflowCrawlSummary(crawl);
+            await logger.log("salesnav.crawl.job.finished", {
+                title: seed.title,
+                jobId: created.value.job.id,
+                summary: crawlSummary,
+                lastOutcome: crawl.lastOutcome
+            });
+            crawls.push({
+                title: seed.title,
+                sourceProduct: seed.sourceProduct,
+                matchedProductCount: seed.matchedProductCount,
+                queryUrl: seed.queryUrl,
+                jobId: created.value.job.id,
+                resumed: created.value.resumed,
+                claimedSlices: crawl.claimedSlices,
+                truncated: crawl.truncated,
+                activeSlice: crawl.activeSlice
+                    ? {
+                        id: crawl.activeSlice.id,
+                        slicedQueryUrl: crawl.activeSlice.slicedQueryUrl,
+                        depth: crawl.activeSlice.depth,
+                        splitTrail: formatSalesNavigatorSplitTrail(crawl.activeSlice.splitTrail)
+                    }
+                    : null,
+                lastOutcome: crawl.lastOutcome,
+                job: crawl.job,
+                summary: crawlSummary
+            });
+        }
+        const summary = buildSalesNavigatorWorkflowSummary(crawls);
+        const payload = {
+            status: "ok",
+            dryRun: false,
+            mode: "linkedin-product-category-to-salesnav",
+            traceId: logger.traceId,
+            logPath: logger.logPath,
+            source: scrape.source,
+            totalPagesFetched: scrape.totalPagesFetched,
+            discoveredProducts: scrape.items.length,
+            titleCount: titleSeeds.length,
+            summary,
+            uploaded,
+            crawls
+        };
+        await writeJsonFile(outPath, payload);
+        await logger.log("workflow.completed", {
+            outPath,
+            dryRun: false,
+            uploaded,
+            crawlCount: crawls.length,
+            summary
+        });
+        return { outPath, payload };
+    }
+    catch (error) {
+        await logger.log("workflow.failed", {
+            message: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack ?? null : null
+        });
+        throw error;
+    }
+}
 function collectStringOptionValue(value, previous = []) {
     return [...previous, value];
 }
@@ -696,6 +1174,7 @@ class SalesNavigatorExportRequestError extends Error {
     runId;
     agentId;
     containerId;
+    launchDiagnostics;
     statusCode;
     constructor(message, options) {
         super(message);
@@ -706,8 +1185,10 @@ class SalesNavigatorExportRequestError extends Error {
         this.runId = options.runId;
         this.agentId = options.agentId;
         this.containerId = options.containerId;
+        this.launchDiagnostics = options.launchDiagnostics ?? null;
     }
 }
+const SALES_NAVIGATOR_EXPORT_START_TIMEOUT_MS = 90_000;
 async function withRefreshableAuthSession(session, run, contextLabel = "Salesprompter session expired during crawl. Refreshing login...") {
     let currentSession = session;
     let authRefreshCount = 0;
@@ -748,7 +1229,7 @@ async function fetchCliJson(session, request, schema) {
         return schema.parse(parsed);
     });
 }
-async function uploadLinkedInProductsCatalog(session, payload, batchSize = 100) {
+async function uploadLinkedInProductsCatalog(session, payload, batchSize = 100, traceId) {
     let imported = 0;
     let upserted = 0;
     for (let startIndex = 0; startIndex < payload.items.length; startIndex += batchSize) {
@@ -757,7 +1238,8 @@ async function uploadLinkedInProductsCatalog(session, payload, batchSize = 100)
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
-                Authorization: `Bearer ${session.accessToken}`
+                Authorization: `Bearer ${session.accessToken}`,
+                ...buildTraceHeaders(traceId)
             },
             body: JSON.stringify({
                 source: payload.source,
@@ -788,17 +1270,149 @@ function serializeSalesNavigatorFiltersForApi(filters) {
         }))
     }));
 }
-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);
+function buildSalesNavigatorSliceRawPayload(slice, extra = {}) {
+    return {
+        ...extra,
+        sourceQueryUrl: slice.sourceQueryUrl,
+        slicedQueryUrl: slice.slicedQueryUrl,
+        appliedFilters: slice.appliedFilters,
+        depth: slice.depth,
+        splitTrail: slice.splitTrail,
+        slicePreset: slice.slicePreset,
+        maxResultsPerSearch: slice.maxResultsPerSearch,
+        numberOfProfiles: slice.numberOfProfiles,
+        retryCount: slice.retryCount ?? null,
+        cookieRetryCount: slice.cookieRetryCount ?? null,
+        resultRetryCount: slice.resultRetryCount ?? null
+    };
 }
-async function startSalesNavigatorExport(session, payload) {
+function buildSalesNavigatorCrawlReportRawPayload(slice, traceId, extra = {}) {
+    return buildSalesNavigatorSliceRawPayload({
+        sourceQueryUrl: slice.sourceQueryUrl,
+        slicedQueryUrl: slice.slicedQueryUrl,
+        appliedFilters: slice.appliedFilters,
+        depth: slice.depth,
+        splitTrail: slice.splitTrail,
+        slicePreset: slice.slicePreset,
+        maxResultsPerSearch: slice.maxResultsPerSearch,
+        numberOfProfiles: slice.numberOfProfiles,
+        retryCount: slice.retryCount,
+        cookieRetryCount: slice.cookieRetryCount,
+        resultRetryCount: slice.resultRetryCount
+    }, {
+        traceId: traceId ?? null,
+        sliceId: slice.id,
+        jobId: slice.jobId,
+        ...extra
+    });
+}
+function describeSalesNavigatorLaunchDiagnostics(diagnostics) {
+    if (!diagnostics) {
+        return null;
+    }
+    const parts = [
+        `agent ${diagnostics.selectedAgent.name} (${diagnostics.selectedAgent.id})`,
+        diagnostics.runningAgentIds.length > 0
+            ? `running: ${diagnostics.runningAgentIds.join(", ")}`
+            : null,
+        diagnostics.busyAgentIds.length > 0
+            ? `busy fallback: ${diagnostics.busyAgentIds.join(", ")}`
+            : null,
+        diagnostics.selectedAgent.maxParallelism !== null
+            ? `parallelism ${diagnostics.selectedAgent.maxParallelism}`
+            : null,
+        diagnostics.selectedAgent.fileMgmt
+            ? `file mgmt ${diagnostics.selectedAgent.fileMgmt}`
+            : null,
+        diagnostics.selectedAgent.hasWebhook ? "webhook on" : "webhook off",
+        diagnostics.selectedAgent.hasStoredSessionCookie
+            ? "stored phantom cookie present"
+            : "stored phantom cookie cleared at launch",
+    ].filter((value) => Boolean(value));
+    return parts.join("; ");
+}
+function writeSalesNavigatorLaunchDiagnosticsProgress(diagnostics, selectedSessionUserEmail) {
+    if (runtimeOutputOptions.json || runtimeOutputOptions.quiet || !diagnostics) {
+        return;
+    }
+    const details = describeSalesNavigatorLaunchDiagnostics(diagnostics);
+    const operator = selectedSessionUserEmail ? ` using ${selectedSessionUserEmail}` : "";
+    process.stderr.write(`Phantombuster launch selected ${diagnostics.selectedAgent.id}${operator}.${details ? ` ${details}` : ""}\n`);
+}
+async function runSalesNavigatorExport(session, payload, traceId, logOptions = {}) {
+    const baseMetadata = {
+        sourceQueryUrl: payload.sourceQueryUrl,
+        slicedQueryUrl: payload.slicedQueryUrl,
+        slicePreset: payload.slicePreset,
+        maxResultsPerSearch: payload.maxResultsPerSearch,
+        numberOfProfiles: payload.numberOfProfiles,
+        filterTypes: payload.appliedFilters.map((filter) => filter.type),
+        ...logOptions.metadata
+    };
+    await logOptions.logger?.log("salesnav.export.started", baseMetadata);
+    try {
+        const started = await startSalesNavigatorExport(session, payload, traceId);
+        await logOptions.logger?.log("salesnav.export.accepted", {
+            ...baseMetadata,
+            runId: started.value.runId,
+            agentId: started.value.agentId,
+            containerId: started.value.containerId,
+            previousContainerId: started.value.previousContainerId ?? null,
+            selectedSessionCookieSha256: started.value.selectedSessionCookieSha256 ?? null,
+            selectedSessionUserEmail: started.value.selectedSessionUserEmail ?? null,
+            selectedSessionUserHandle: started.value.selectedSessionUserHandle ?? null,
+            launchDiagnostics: started.value.launchDiagnostics ?? null
+        });
+        writeSalesNavigatorLaunchDiagnosticsProgress(started.value.launchDiagnostics ?? null, started.value.selectedSessionUserEmail ?? null);
+        const completed = await waitForSalesNavigatorExportRunCompletion(started.session, started.value.runId, {}, traceId, {
+            logger: logOptions.logger,
+            metadata: baseMetadata
+        });
+        await logOptions.logger?.log("salesnav.export.completed", {
+            ...baseMetadata,
+            runId: completed.value.run.id,
+            status: completed.value.run.status,
+            resultClassification: completed.value.run.resultClassification,
+            totalResults: completed.value.run.totalResults ?? null,
+            imported: completed.value.run.imported,
+            upserted: completed.value.run.upserted,
+            updatedAt: completed.value.run.updatedAt,
+            finishedAt: completed.value.run.finishedAt ?? null
+        });
+        const mapped = mapCompletedSalesNavigatorExportRun(completed.value.run);
+        return SalesNavigatorExportResponseSchema.parse({
+            ...mapped,
+            launchDiagnostics: mapped.launchDiagnostics ?? started.value.launchDiagnostics ?? null,
+        });
+    }
+    catch (error) {
+        await logOptions.logger?.log("salesnav.export.failed", {
+            ...baseMetadata,
+            name: error instanceof Error ? error.name : "Error",
+            message: error instanceof Error ? error.message : String(error),
+            ...(error instanceof SalesNavigatorExportRequestError
+                ? {
+                    runId: error.runId ?? null,
+                    agentId: error.agentId ?? null,
+                    containerId: error.containerId ?? null,
+                    errorCode: error.errorCode ?? null,
+                    totalResults: error.totalResults ?? null,
+                    launchDiagnostics: error.launchDiagnostics ?? null,
+                    statusCode: error.statusCode
+                }
+                : {})
+        });
+        throw error;
+    }
+}
+async function startSalesNavigatorExport(session, payload, traceId) {
     return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/export`, {
         method: "POST",
+        signal: AbortSignal.timeout(SALES_NAVIGATOR_EXPORT_START_TIMEOUT_MS),
         headers: {
             "Content-Type": "application/json",
-            Authorization: `Bearer ${currentSession.accessToken}`
+            Authorization: `Bearer ${currentSession.accessToken}`,
+            ...buildTraceHeaders(traceId)
         },
         body: JSON.stringify({
             ...payload,
@@ -806,11 +1420,12 @@ async function startSalesNavigatorExport(session, payload) {
         })
     }), SalesNavigatorExportStartResponseSchema);
 }
-async function getSalesNavigatorExportRunStatus(session, runId) {
+async function getSalesNavigatorExportRunStatus(session, runId, traceId) {
     return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/export-runs/${runId}?refresh=1`, {
         method: "GET",
         headers: {
-            Authorization: `Bearer ${currentSession.accessToken}`
+            Authorization: `Bearer ${currentSession.accessToken}`,
+            ...buildTraceHeaders(traceId)
         }
     }), SalesNavigatorExportRunStatusResponseSchema);
 }
@@ -831,7 +1446,8 @@ function mapCompletedSalesNavigatorExportRun(run) {
             totalResults: run.totalResults ?? null,
             runId: run.id,
             agentId: run.agentId,
-            containerId: run.containerId
+            containerId: run.containerId,
+            launchDiagnostics: run.launchDiagnostics ?? null
         });
     }
     return SalesNavigatorExportResponseSchema.parse({
@@ -844,18 +1460,35 @@ function mapCompletedSalesNavigatorExportRun(run) {
         resultCsvUrl: run.resultCsvUrl ?? null,
         agentId: run.agentId,
         containerId: run.containerId,
+        selectedSessionCookieSha256: run.selectedSessionCookieSha256 ?? null,
+        selectedSessionUserEmail: run.selectedSessionUserEmail ?? null,
+        selectedSessionUserHandle: run.selectedSessionUserHandle ?? null,
+        launchDiagnostics: run.launchDiagnostics ?? null,
         sourceQueryUrl: run.sourceQueryUrl,
         slicedQueryUrl: run.slicedQueryUrl
     });
 }
-async function waitForSalesNavigatorExportRunCompletion(session, runId, options = {}) {
+async function waitForSalesNavigatorExportRunCompletion(session, runId, options = {}, traceId, logOptions = {}) {
     const timeoutSeconds = options.timeoutSeconds ?? 960;
     const pollIntervalMs = options.pollIntervalMs ?? 5000;
     const deadline = Date.now() + timeoutSeconds * 1000;
     let currentSession = session;
+    let pollCount = 0;
     while (Date.now() < deadline) {
-        const status = await getSalesNavigatorExportRunStatus(currentSession, runId);
+        const status = await getSalesNavigatorExportRunStatus(currentSession, runId, traceId);
         currentSession = status.session;
+        pollCount += 1;
+        await logOptions.logger?.log("salesnav.export.polled", {
+            runId,
+            pollCount,
+            status: status.value.run.status,
+            resultClassification: status.value.run.resultClassification,
+            totalResults: status.value.run.totalResults ?? null,
+            imported: status.value.run.imported,
+            upserted: status.value.run.upserted,
+            updatedAt: status.value.run.updatedAt,
+            ...logOptions.metadata
+        });
         if (status.value.run.status !== "pending") {
             return status;
         }
@@ -871,12 +1504,16 @@ function isSalesNavigatorAgentBusyError(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;
+    if (error instanceof SalesNavigatorExportRequestError) {
+        if (error.errorCode === "invalid_session") {
+            return true;
+        }
+        if (["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);
+    return /can't connect profile|sales navigator account|upsell|linkedin session invalid|linkedin_rate_limited|too many requests|rate.?limit|invalid session cookie/i.test(message);
 }
 function isSalesNavigatorResultArtifactError(error) {
     if (error instanceof SalesNavigatorExportRequestError && error.errorCode === "phantombuster_result_invalid") {
@@ -899,13 +1536,16 @@ 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) {
+async function runSalesNavigatorExportWithAgentWait(session, payload, options, traceId) {
     let busyWaitCount = 0;
     let currentSession = session;
     let authRefreshCount = 0;
     while (true) {
         try {
-            return await runSalesNavigatorExport(currentSession, payload);
+            return await runSalesNavigatorExport(currentSession, payload, traceId, {
+                logger: options.logger,
+                metadata: options.logMetadata
+            });
         }
         catch (error) {
             if (isRefreshableAuthError(error)) {
@@ -916,6 +1556,12 @@ async function runSalesNavigatorExportWithAgentWait(session, payload, options) {
                 if (!runtimeOutputOptions.quiet) {
                     process.stderr.write("Salesprompter session expired during crawl. Refreshing login...\n");
                 }
+                await options.logger?.log("salesnav.export.auth.refresh", {
+                    authRefreshCount,
+                    waitSeconds: options.waitSeconds,
+                    maxWaits: options.maxWaits,
+                    ...options.logMetadata
+                });
                 await ensureInteractiveAuthSession(currentSession.apiBaseUrl);
                 currentSession = await requireAuthSession();
                 continue;
@@ -928,6 +1574,12 @@ async function runSalesNavigatorExportWithAgentWait(session, payload, options) {
                 if (!runtimeOutputOptions.json && !runtimeOutputOptions.quiet) {
                     process.stderr.write(`Sales Navigator export agent is busy. Waiting ${options.waitSeconds}s before retrying...\n`);
                 }
+                await options.logger?.log("salesnav.export.agent.busy", {
+                    busyWaitCount,
+                    waitSeconds: options.waitSeconds,
+                    maxWaits: options.maxWaits,
+                    ...options.logMetadata
+                });
                 await delay(options.waitSeconds * 1000);
                 continue;
             }
@@ -940,6 +1592,14 @@ async function runSalesNavigatorCrawlAttempt(session, attempt, options, context)
         options.probeProfiles < attempt.numberOfProfiles &&
         attempt.depth < options.maxSplitDepth;
     const probeProfiles = shouldProbe ? Math.max(1, options.probeProfiles) : attempt.numberOfProfiles;
+    const logMetadata = {
+        crawlJobId: context?.crawlJobId ?? null,
+        crawlSliceId: context?.crawlSliceId ?? null,
+        sliceDepth: attempt.depth,
+        splitTrail: formatSalesNavigatorSplitTrail(attempt.splitTrail),
+        sourceQueryUrl: attempt.sourceQueryUrl,
+        slicedQueryUrl: attempt.slicedQueryUrl
+    };
     const probeResult = await runSalesNavigatorExportWithAgentWait(session, {
         sourceQueryUrl: attempt.sourceQueryUrl,
         slicedQueryUrl: attempt.slicedQueryUrl,
@@ -948,11 +1608,23 @@ async function runSalesNavigatorCrawlAttempt(session, attempt, options, context)
         numberOfProfiles: probeProfiles,
         slicePreset: attempt.slicePreset,
         crawlJobId: context?.crawlJobId,
-        crawlSliceId: context?.crawlSliceId
+        crawlSliceId: context?.crawlSliceId,
+        rawPayload: buildSalesNavigatorSliceRawPayload(attempt, {
+            traceId: context?.traceId ?? null,
+            phase: shouldProbe ? "probe" : "full_export",
+            requestedProfiles: probeProfiles,
+            crawlJobId: context?.crawlJobId ?? null,
+            crawlSliceId: context?.crawlSliceId ?? null
+        })
     }, {
         waitSeconds: options.agentBusyWaitSeconds,
-        maxWaits: options.agentBusyMaxWaits
-    });
+        maxWaits: options.agentBusyMaxWaits,
+        logger: options.logger,
+        logMetadata: {
+            ...logMetadata,
+            phase: shouldProbe ? "probe" : "full_export"
+        }
+    }, context?.traceId);
     if (!shouldProbe) {
         return probeResult;
     }
@@ -968,11 +1640,27 @@ async function runSalesNavigatorCrawlAttempt(session, attempt, options, context)
         numberOfProfiles: attempt.numberOfProfiles,
         slicePreset: attempt.slicePreset,
         crawlJobId: context?.crawlJobId,
-        crawlSliceId: context?.crawlSliceId
+        crawlSliceId: context?.crawlSliceId,
+        rawPayload: buildSalesNavigatorSliceRawPayload(attempt, {
+            traceId: context?.traceId ?? null,
+            phase: "full_export_after_probe",
+            requestedProfiles: attempt.numberOfProfiles,
+            crawlJobId: context?.crawlJobId ?? null,
+            crawlSliceId: context?.crawlSliceId ?? null,
+            probeProfiles,
+            probeTotalResults: totalResults
+        })
     }, {
         waitSeconds: options.agentBusyWaitSeconds,
-        maxWaits: options.agentBusyMaxWaits
-    });
+        maxWaits: options.agentBusyMaxWaits,
+        logger: options.logger,
+        logMetadata: {
+            ...logMetadata,
+            phase: "full_export_after_probe",
+            probeProfiles,
+            probeTotalResults: totalResults
+        }
+    }, context?.traceId);
 }
 function buildSalesNavigatorCrawlAttemptFromClaimedSlice(slice) {
     return {
@@ -987,12 +1675,13 @@ function buildSalesNavigatorCrawlAttemptFromClaimedSlice(slice) {
         splitTrail: slice.splitTrail
     };
 }
-async function createOrResumeSalesNavigatorCrawlJob(session, payload) {
+async function createOrResumeSalesNavigatorCrawlJob(session, payload, traceId) {
     return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/crawls`, {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
-            Authorization: `Bearer ${currentSession.accessToken}`
+            Authorization: `Bearer ${currentSession.accessToken}`,
+            ...buildTraceHeaders(traceId)
         },
         body: JSON.stringify({
             ...payload,
@@ -1003,28 +1692,31 @@ async function createOrResumeSalesNavigatorCrawlJob(session, payload) {
         })
     }), SalesNavigatorCrawlCreateResponseSchema);
 }
-async function getSalesNavigatorCrawlStatus(session, jobId) {
+async function getSalesNavigatorCrawlStatus(session, jobId, traceId) {
     return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/crawls/${jobId}`, {
         method: "GET",
         headers: {
-            Authorization: `Bearer ${currentSession.accessToken}`
+            Authorization: `Bearer ${currentSession.accessToken}`,
+            ...buildTraceHeaders(traceId)
         }
     }), SalesNavigatorCrawlStatusResponseSchema);
 }
-async function claimNextSalesNavigatorCrawlSlice(session, jobId) {
+async function claimNextSalesNavigatorCrawlSlice(session, jobId, traceId) {
     return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/crawls/${jobId}/claim-next`, {
         method: "POST",
         headers: {
-            Authorization: `Bearer ${currentSession.accessToken}`
+            Authorization: `Bearer ${currentSession.accessToken}`,
+            ...buildTraceHeaders(traceId)
         }
     }), SalesNavigatorCrawlClaimResponseSchema);
 }
-async function reportSalesNavigatorCrawlSlice(session, jobId, payload) {
+async function reportSalesNavigatorCrawlSlice(session, jobId, payload, traceId) {
     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}`
+            Authorization: `Bearer ${currentSession.accessToken}`,
+            ...buildTraceHeaders(traceId)
         },
         body: JSON.stringify({
             ...payload,
@@ -1049,7 +1741,13 @@ function buildSalesNavigatorSplitChildren(slice, dimension) {
         slicedQueryUrl: child.slicedQueryUrl,
         appliedFilters: child.appliedFilters,
         depth: child.depth,
-        splitTrail: child.splitTrail
+        splitTrail: child.splitTrail,
+        rawPayload: buildSalesNavigatorSliceRawPayload(child, {
+            parentSliceId: slice.id,
+            parentSlicedQueryUrl: slice.slicedQueryUrl,
+            splitDimensionKey: child.splitTrail.at(-1)?.key ?? null,
+            splitDimensionFilterType: child.splitTrail.at(-1)?.filterType ?? null
+        })
     }));
 }
 function buildSalesNavigatorSliceFailureReport(slice, error, options) {
@@ -1114,73 +1812,301 @@ function buildSalesNavigatorSliceFailureReport(slice, error, options) {
 function formatSalesNavigatorSplitTrail(splitTrail) {
     return splitTrail.map((entry) => `${entry.key}:${entry.value.text}`);
 }
-async function executeSalesNavigatorCrawlJob(session, jobId, options) {
+async function processSalesNavigatorClaimedCrawlSlice(session, jobId, slice, options) {
     let currentSession = session;
-    let claimedSlices = 0;
-    let activeSlice = null;
-    let job = null;
-    let lastOutcome = null;
-    while (claimedSlices < options.maxSlices) {
-        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;
-        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
-            });
+    await options.logger?.log("salesnav.crawl.slice.claimed", {
+        jobId,
+        sliceId: slice.id,
+        isNewSlice: true,
+        claimedSlices: options.claimedSlices,
+        depth: slice.depth,
+        retryCount: slice.retryCount,
+        cookieRetryCount: slice.cookieRetryCount,
+        resultRetryCount: slice.resultRetryCount,
+        splitTrail: formatSalesNavigatorSplitTrail(slice.splitTrail),
+        ...summarizeSalesNavigatorQuery(slice.slicedQueryUrl, slice.appliedFilters)
+    });
+    if (!runtimeOutputOptions.json && !runtimeOutputOptions.quiet) {
+        process.stderr.write(`Processing Sales Navigator slice ${options.claimedSlices}: ${slice.slicedQueryUrl}\n`);
+    }
+    if (shouldPreSplitSalesNavigatorRootSlice(slice, options.maxSplitDepth)) {
+        const nextDimension = nextSalesNavigatorSplitDimension(slice, options.maxSplitDepth);
+        if (nextDimension) {
+            const children = buildSalesNavigatorSplitChildren(slice, nextDimension);
             const reported = await reportSalesNavigatorCrawlSlice(currentSession, jobId, {
                 sliceId: slice.id,
-                outcome: "exported",
-                totalResults: result.totalResults ?? null,
-                exportRunId: result.runId,
-                importedPeople: result.imported,
-                upsertedPeople: result.upserted
-            });
+                outcome: "split",
+                error: `Pre-splitting broad Sales Navigator title query by ${nextDimension.key} before the first export attempt.`,
+                errorCode: "presplit_root_title_query",
+                children,
+                rawPayload: buildSalesNavigatorCrawlReportRawPayload(slice, options.traceId, {
+                    phase: "presplit",
+                    reason: "broad_root_title_query",
+                    nextDimensionKey: nextDimension.key,
+                    nextDimensionFilterType: nextDimension.filterType,
+                    childCount: children.length
+                })
+            }, options.traceId);
             currentSession = reported.session;
-            job = reported.value.job;
-            lastOutcome = {
+            await options.logger?.log("salesnav.crawl.slice.presplit", {
+                jobId,
+                sliceId: slice.id,
+                nextDimension: nextDimension.key,
+                childCount: children.length,
+                splitTrail: formatSalesNavigatorSplitTrail(slice.splitTrail),
+                ...summarizeSalesNavigatorQuery(slice.slicedQueryUrl, slice.appliedFilters),
+                childQueries: children.map((child) => ({
+                    splitTrail: formatSalesNavigatorSplitTrail(child.splitTrail),
+                    ...summarizeSalesNavigatorQuery(child.slicedQueryUrl, child.appliedFilters)
+                }))
+            });
+            return {
+                session: currentSession,
+                job: reported.value.job,
+                activeSlice: slice,
+                lastOutcome: {
+                    outcome: "split",
+                    error: `Pre-split by ${nextDimension.key}`,
+                    errorCode: "presplit_root_title_query",
+                    totalResults: null
+                }
+            };
+        }
+    }
+    try {
+        const result = await runSalesNavigatorCrawlAttempt(currentSession, buildSalesNavigatorCrawlAttemptFromClaimedSlice(slice), {
+            maxSplitDepth: options.maxSplitDepth,
+            probeProfiles: options.probeProfiles,
+            agentBusyWaitSeconds: options.agentBusyWaitSeconds,
+            agentBusyMaxWaits: options.agentBusyMaxWaits,
+            logger: options.logger
+        }, {
+            crawlJobId: jobId,
+            crawlSliceId: slice.id,
+            traceId: options.traceId
+        });
+        const reported = await reportSalesNavigatorCrawlSlice(currentSession, jobId, {
+            sliceId: slice.id,
+            outcome: "exported",
+            totalResults: result.totalResults ?? null,
+            exportRunId: result.runId,
+            importedPeople: result.imported,
+            upsertedPeople: result.upserted,
+            rawPayload: buildSalesNavigatorCrawlReportRawPayload(slice, options.traceId, {
+                phase: "exported",
+                export: {
+                    runId: result.runId,
+                    totalResults: result.totalResults ?? null,
+                    imported: result.imported,
+                    upserted: result.upserted,
+                    resultJsonUrl: result.resultJsonUrl ?? null,
+                    resultCsvUrl: result.resultCsvUrl ?? null,
+                    selectedSessionCookieSha256: result.selectedSessionCookieSha256 ?? null,
+                    selectedSessionUserEmail: result.selectedSessionUserEmail ?? null,
+                    selectedSessionUserHandle: result.selectedSessionUserHandle ?? null,
+                    launchDiagnostics: result.launchDiagnostics ?? null
+                }
+            })
+        }, options.traceId);
+        currentSession = reported.session;
+        await options.logger?.log("salesnav.crawl.slice.exported", {
+            jobId,
+            sliceId: slice.id,
+            exportRunId: result.runId,
+            totalResults: result.totalResults ?? null,
+            imported: result.imported,
+            upserted: result.upserted,
+            selectedAgentId: result.launchDiagnostics?.selectedAgent.id ?? result.agentId,
+            selectedSessionUserEmail: result.selectedSessionUserEmail ?? null
+        });
+        return {
+            session: currentSession,
+            job: reported.value.job,
+            activeSlice: slice,
+            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 = {
+            }
+        };
+    }
+    catch (error) {
+        const payload = buildSalesNavigatorSliceFailureReport(slice, error, {
+            maxSplitDepth: options.maxSplitDepth,
+            maxRetries: options.maxRetries
+        });
+        payload.rawPayload = buildSalesNavigatorCrawlReportRawPayload(slice, options.traceId, {
+            phase: payload.outcome,
+            error: error instanceof Error
+                ? {
+                    name: error.name,
+                    message: error.message,
+                    ...(error instanceof SalesNavigatorExportRequestError
+                        ? {
+                            launchDiagnostics: error.launchDiagnostics ?? null,
+                            agentId: error.agentId ?? null,
+                            containerId: error.containerId ?? null
+                        }
+                        : {})
+                }
+                : {
+                    name: "Error",
+                    message: String(error)
+                }
+        });
+        const reported = await reportSalesNavigatorCrawlSlice(currentSession, jobId, payload, options.traceId);
+        currentSession = reported.session;
+        await options.logger?.log("salesnav.crawl.slice.reported", {
+            jobId,
+            sliceId: slice.id,
+            outcome: payload.outcome,
+            error: payload.error ?? null,
+            errorCode: payload.errorCode ?? null,
+            totalResults: payload.totalResults ?? null,
+            exportRunId: payload.exportRunId ?? null,
+            childCount: payload.children?.length ?? 0
+        });
+        return {
+            session: currentSession,
+            job: reported.value.job,
+            activeSlice: slice,
+            lastOutcome: {
                 outcome: payload.outcome,
                 runId: payload.exportRunId,
                 error: payload.error,
                 errorCode: payload.errorCode,
                 totalResults: payload.totalResults
-            };
+            }
+        };
+    }
+}
+async function executeSalesNavigatorCrawlJob(session, jobId, options) {
+    let currentSession = session;
+    let claimedSlices = 0;
+    const seenSliceIds = new Set();
+    let activeSlice = null;
+    let job = null;
+    let idlePollCount = 0;
+    let lastOutcome = null;
+    const parallelExports = Math.max(1, options.parallelExports);
+    const inFlight = new Map();
+    let nextSlot = 0;
+    let noMoreClaimableWork = false;
+    while (true) {
+        while (!noMoreClaimableWork && inFlight.size < parallelExports) {
+            if (claimedSlices >= options.maxSlices) {
+                break;
+            }
+            const claimed = await claimNextSalesNavigatorCrawlSlice(currentSession, jobId, options.traceId);
+            currentSession = claimed.session;
+            job = claimed.value.job;
+            if (!claimed.value.slice) {
+                const shouldWaitForRemoteWork = !isSalesNavigatorCrawlJobTerminal(job.status) &&
+                    options.idleMaxPolls > 0 &&
+                    job.runningSlices > 0;
+                if (shouldWaitForRemoteWork && inFlight.size === 0) {
+                    if (idlePollCount >= options.idleMaxPolls) {
+                        lastOutcome = {
+                            outcome: "terminal_failed",
+                            error: `Sales Navigator crawl job ${jobId} stayed non-terminal without a claimable slice after ${options.idleMaxPolls} polls.`,
+                            errorCode: "crawl_idle_timeout"
+                        };
+                        await options.logger?.log("salesnav.crawl.job.stalled", {
+                            jobId,
+                            status: job.status,
+                            queuedSlices: job.queuedSlices,
+                            runningSlices: job.runningSlices,
+                            idlePollCount,
+                            idleMaxPolls: options.idleMaxPolls
+                        });
+                        noMoreClaimableWork = true;
+                        break;
+                    }
+                    idlePollCount += 1;
+                    await options.logger?.log("salesnav.crawl.job.waiting", {
+                        jobId,
+                        status: job.status,
+                        queuedSlices: job.queuedSlices,
+                        runningSlices: job.runningSlices,
+                        idlePollCount,
+                        idlePollSeconds: options.idlePollSeconds
+                    });
+                    if (!runtimeOutputOptions.json && !runtimeOutputOptions.quiet) {
+                        process.stderr.write(`Sales Navigator crawl job ${jobId} has no claimable slice yet. Waiting ${options.idlePollSeconds}s for remote work to settle...\n`);
+                    }
+                    await delay(options.idlePollSeconds * 1000);
+                    const status = await getSalesNavigatorCrawlStatus(currentSession, jobId, options.traceId);
+                    currentSession = status.session;
+                    job = status.value.job;
+                    await options.logger?.log("salesnav.crawl.job.status.polled", {
+                        jobId,
+                        status: job.status,
+                        queuedSlices: job.queuedSlices,
+                        runningSlices: job.runningSlices,
+                        exportedSlices: job.exportedSlices,
+                        failedSlices: job.failedSlices,
+                        importedPeople: job.importedPeople,
+                        idlePollCount
+                    });
+                    if (isSalesNavigatorCrawlJobTerminal(job.status)) {
+                        noMoreClaimableWork = true;
+                        break;
+                    }
+                    continue;
+                }
+                if (!shouldWaitForRemoteWork) {
+                    noMoreClaimableWork = true;
+                }
+                break;
+            }
+            const slice = claimed.value.slice;
+            idlePollCount = 0;
+            activeSlice = slice;
+            const isNewSlice = !seenSliceIds.has(slice.id);
+            if (isNewSlice) {
+                seenSliceIds.add(slice.id);
+                claimedSlices += 1;
+            }
+            const claimedSliceNumber = claimedSlices;
+            const slot = nextSlot++;
+            inFlight.set(slot, processSalesNavigatorClaimedCrawlSlice(currentSession, jobId, slice, {
+                maxSplitDepth: options.maxSplitDepth,
+                maxRetries: options.maxRetries,
+                probeProfiles: options.probeProfiles,
+                agentBusyWaitSeconds: options.agentBusyWaitSeconds,
+                agentBusyMaxWaits: options.agentBusyMaxWaits,
+                claimedSlices: claimedSliceNumber,
+                traceId: options.traceId,
+                logger: options.logger
+            }).then((value) => ({ slot, value })));
         }
+        if (inFlight.size === 0) {
+            break;
+        }
+        const completed = await Promise.race(inFlight.values());
+        inFlight.delete(completed.slot);
+        currentSession = completed.value.session;
+        job = completed.value.job;
+        activeSlice = completed.value.activeSlice;
+        lastOutcome = completed.value.lastOutcome;
     }
     if (!job) {
-        const status = await getSalesNavigatorCrawlStatus(currentSession, jobId);
+        const status = await getSalesNavigatorCrawlStatus(currentSession, jobId, options.traceId);
         currentSession = status.session;
         job = status.value.job;
     }
+    await options.logger?.log("salesnav.crawl.job.completed", {
+        jobId,
+        status: job.status,
+        queuedSlices: job.queuedSlices,
+        runningSlices: job.runningSlices,
+        exportedSlices: job.exportedSlices,
+        failedSlices: job.failedSlices,
+        importedPeople: job.importedPeople,
+        claimedSlices,
+        truncated: claimedSlices >= options.maxSlices && (job.queuedSlices > 0 || job.runningSlices > 0),
+        lastOutcome
+    });
     return {
         session: currentSession,
         job,
@@ -1190,22 +2116,6 @@ async function executeSalesNavigatorCrawlJob(session, jobId, options) {
         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
-        });
-        return result.leads;
-    }
-    const session = await requireAuthSession();
-    return await fetchWorkspaceLeadSearch(session, {
-        mode: "reference-company",
-        icp,
-        limit
-    });
-}
 async function searchTargetCompanyLeads(reference, limit) {
     if (shouldBypassAuth()) {
         const fallbackTargetDomain = reference.domain ?? `${reference.slug}.com`;
@@ -1223,16 +2133,90 @@ async function searchTargetCompanyLeads(reference, limit) {
         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?", {
+async function runProductMarketWizard(rl) {
+    writeWizardSection("Find leads from a product market", "Start from a company website, LinkedIn company page, product page, or category page. I will turn that into intended job titles and durable Sales Navigator crawls.");
+    const input = await promptText(rl, "What company website or LinkedIn page should I start from?", {
+        required: true
+    });
+    const productLimit = z.coerce.number().int().min(1).max(5000).parse(await promptText(rl, "How many products should I inspect?", { defaultValue: "25", required: true }));
+    const titleLimit = z.coerce.number().int().min(1).max(1000).parse(await promptText(rl, "How many job titles should I turn into Sales Navigator crawls?", {
+        defaultValue: "5",
+        required: true
+    }));
+    writeWizardLine();
+    const dryRun = shouldBypassAuth();
+    if (dryRun) {
+        writeWizardLine("Auth bypass is enabled, so I will preview the crawl plan instead of launching Phantombuster.");
+        writeWizardLine();
+    }
+    const result = await runSalesNavigatorFromProductCategoryWorkflow({
+        input,
+        maxPages: 25,
+        productLimit,
+        titleLimit,
+        maxResultsPerSearch: 2500,
+        numberOfProfiles: 2500,
+        slicePreset: "wizard-linkedin-product-category",
+        maxSplitDepth: DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS.length,
+        maxSlicesPerTitle: 1000,
+        maxRetries: 3,
+        probeProfiles: 100,
+        agentBusyWaitSeconds: 30,
+        agentBusyMaxWaits: 20,
+        idlePollSeconds: 10,
+        idleMaxPolls: 180,
+        parallelExports: 3,
+        skipProductUpload: false,
+        dryRun
+    });
+    writeWizardLine(`LinkedIn product category: ${result.payload.source.category.name}.`);
+    writeWizardLine(`Inspected ${result.payload.discoveredProducts} product${result.payload.discoveredProducts === 1 ? "" : "s"} and derived ${result.payload.titleCount} intended job title${result.payload.titleCount === 1 ? "" : "s"}.`);
+    if (result.payload.dryRun) {
+        const firstQuery = result.payload.queries?.[0];
+        writeWizardLine(`Saved preview to ${result.outPath}.`);
+        writeWizardLine(`Saved logs to ${result.payload.logPath}.`);
+        if (firstQuery) {
+            writeWizardLine(`First Sales Navigator title search: ${firstQuery.title}.`);
+        }
+    }
+    else {
+        if (result.payload.uploaded) {
+            writeWizardLine(`Uploaded ${result.payload.uploaded.upserted} LinkedIn product record${result.payload.uploaded.upserted === 1 ? "" : "s"} to Salesprompter.`);
+        }
+        writeWizardLine(`Finished ${result.payload.crawls?.length ?? 0} durable Sales Navigator crawl${result.payload.crawls?.length === 1 ? "" : "s"}.`);
+        writeWizardLine(`Imported ${result.payload.summary.totalImportedPeople} people across ${result.payload.summary.totalExportedSlices} exported slice${result.payload.summary.totalExportedSlices === 1 ? "" : "s"}.`);
+        if (result.payload.summary.workflowStatus !== "completed") {
+            writeWizardLine(`Some title crawls still failed: ${result.payload.summary.completedWithFailuresTitles} completed with failures, ${result.payload.summary.runningTitles} still non-terminal, ${result.payload.summary.truncatedTitles} truncated.`);
+        }
+        writeWizardLine(`Saved crawl summary to ${result.outPath}.`);
+        writeWizardLine(`Saved logs to ${result.payload.logPath}.`);
+    }
+    writeWizardLine();
+    writeWizardLine("Equivalent raw command:");
+    const commandArgs = [
+        "salesprompter",
+        "salesnav:from-product-category",
+        "--input",
+        input,
+        "--product-limit",
+        String(productLimit),
+        "--title-limit",
+        String(titleLimit)
+    ];
+    if (dryRun) {
+        commandArgs.push("--dry-run");
+    }
+    writeWizardLine(`  ${buildCommandLine(commandArgs)}`);
+}
+async function runVendorShortcutWizard(rl) {
+    writeWizardSection("Built-in Deel shortcut", "Use the built-in Deel ICP template and search your workspace lead data.");
+    const reference = parseCompanyReference(await promptText(rl, "Which company shortcut should I use?", {
         required: true
     }));
     writeWizardLine();
     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.");
+        throw new Error("The built-in shortcut only supports Deel right now. Use deel.com or the Deel LinkedIn company page.");
     }
-    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" },
@@ -1244,7 +2228,16 @@ async function runReferenceCompanyWizard(rl) {
     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);
+    const leads = shouldBypassAuth()
+        ? (await leadProvider.generateLeads(icp, leadCount, {
+            companyDomain: reference.domain ?? `${reference.slug}.com`,
+            companyName: reference.companyName
+        })).leads
+        : await fetchWorkspaceLeadSearch(await requireAuthSession(), {
+            mode: "reference-company",
+            icp,
+            limit: leadCount
+        });
     await writeJsonFile(leadPath, leads);
     writeWizardLine(`Saved ICP to ${icpPath}.`);
     if (leads.length === 0) {
@@ -1342,7 +2335,7 @@ async function runWizard(options) {
         throw new Error("wizard does not support --json or --quiet.");
     }
     writeWizardLine("Salesprompter");
-    writeWizardLine("Start with a company website or LinkedIn page. I will guide you from there.");
+    writeWizardLine("Start with a company website, LinkedIn product page, or category URL. I will guide you from there.");
     writeWizardLine();
     await ensureWizardSession(options);
     const rl = createInterface({
@@ -1351,11 +2344,17 @@ async function runWizard(options) {
     });
     try {
         const flow = await promptChoice(rl, "What do you want help with?", [
+            {
+                value: "product-market",
+                label: "Find leads from a product market",
+                description: "Start from a company, product, or LinkedIn category and crawl Sales Navigator",
+                aliases: ["product market", "linkedin products", "category", "sales navigator", "crawl"]
+            },
             {
                 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"]
+                label: "Use the built-in Deel shortcut",
+                description: "Generate the saved Deel ICP and search workspace leads",
+                aliases: ["deel", "shortcut", "vendor template", "quick deel"]
             },
             {
                 value: "target-company",
@@ -1369,10 +2368,14 @@ async function runWizard(options) {
                 description: "Use a saved leads file to fill an Instantly campaign",
                 aliases: ["instantly", "outreach", "send leads", "campaign"]
             }
-        ], "reference-company");
+        ], "product-market");
         writeWizardLine();
+        if (flow === "product-market") {
+            await runProductMarketWizard(rl);
+            return;
+        }
         if (flow === "reference-company") {
-            await runReferenceCompanyWizard(rl);
+            await runVendorShortcutWizard(rl);
             return;
         }
         if (flow === "target-company") {
@@ -1521,7 +2524,7 @@ async function fetchHistoricalQueryRows(tables) {
 }
 program
     .name("salesprompter")
-    .description("Sales workflow CLI for ICP definition, lead generation, enrichment, scoring, and sync.")
+    .description("Sales workflow CLI for LinkedIn product discovery, Sales Navigator crawling, lead enrichment, scoring, and sync.")
     .version(packageVersion)
     .option("--json", "Emit compact machine-readable JSON output", false)
     .option("--quiet", "Suppress successful stdout output", false);
@@ -1862,6 +2865,219 @@ program
         uploaded
     });
 });
+program
+    .command("salesnav:from-product-category")
+    .description("Crawl a LinkedIn product category, derive intended-role title searches, then run durable Sales Navigator crawls that export through Phantombuster into Salesprompter.")
+    .requiredOption("--input <value>", "Company domain, LinkedIn company URL, LinkedIn product URL, LinkedIn category URL, or LinkedIn product search URL")
+    .option("--max-pages <number>", "Maximum LinkedIn category pages to fetch", "25")
+    .option("--product-limit <number>", "Optional cap on the number of LinkedIn products to inspect")
+    .option("--title-limit <number>", "Optional cap on the number of intended-role titles to crawl")
+    .option("--max-results-per-search <number>", "Maximum Sales Navigator results allowed for one slice before splitting again. Current live export cap is 2500.", "2500")
+    .option("--number-of-profiles <number>", "Profiles to request from Phantombuster per finished Sales Navigator slice. Current live export cap is 2500.", "2500")
+    .option("--slice-preset <name>", "Slice preset label stored with every durable crawl job", "linkedin-product-category")
+    .option("--max-split-depth <number>", "Maximum number of adaptive split dimensions to use", "6")
+    .option("--max-slices-per-title <number>", "Safety cap for total claimed slices per intended-role title", "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("--idle-poll-seconds <number>", "Seconds to wait before polling durable crawl status when remote slices are still running", "10")
+    .option("--idle-max-polls <number>", "How many no-claim status polls to tolerate before the crawl is considered stalled", "180")
+    .option("--parallel-exports <number>", "How many Sales Navigator slices to export concurrently per title crawl", "3")
+    .option("--allow-partial-success", "Exit 0 even when one or more durable title crawls finish with failures", false)
+    .option("--skip-product-upload", "Do not upload the crawled LinkedIn product catalog before starting Sales Navigator crawls", false)
+    .option("--out <path>", "Optional local JSON output path")
+    .option("--log-path <path>", "Optional JSONL log path with timestamps, trace id, and Sales Navigator query metadata")
+    .option("--dry-run", "Preview the derived intended-role title queries without creating crawl jobs", false)
+    .action(async (options) => {
+    const maxPages = z.coerce.number().int().min(1).max(500).parse(options.maxPages);
+    const productLimit = options.productLimit === undefined
+        ? undefined
+        : z.coerce.number().int().min(1).max(5000).parse(options.productLimit);
+    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 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);
+    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 idlePollSeconds = z.coerce.number().int().min(0).max(300).parse(options.idlePollSeconds);
+    const idleMaxPolls = z.coerce.number().int().min(0).max(10000).parse(options.idleMaxPolls);
+    const parallelExports = z.coerce.number().int().min(1).max(10).parse(options.parallelExports);
+    const result = await runSalesNavigatorFromProductCategoryWorkflow({
+        input: options.input,
+        maxPages,
+        productLimit,
+        titleLimit,
+        maxResultsPerSearch,
+        numberOfProfiles,
+        slicePreset: options.slicePreset,
+        maxSplitDepth,
+        maxSlicesPerTitle,
+        maxRetries,
+        probeProfiles,
+        agentBusyWaitSeconds,
+        agentBusyMaxWaits,
+        idlePollSeconds,
+        idleMaxPolls,
+        parallelExports,
+        skipProductUpload: Boolean(options.skipProductUpload),
+        outPath: options.out,
+        logPath: options.logPath,
+        dryRun: Boolean(options.dryRun || shouldBypassAuth())
+    });
+    printOutput({
+        ...result.payload,
+        out: result.outPath
+    });
+    if (!result.payload.dryRun && result.payload.summary.workflowStatus !== "completed" && !options.allowPartialSuccess) {
+        throw new Error(buildSalesNavigatorWorkflowFailureMessage(result.payload.summary));
+    }
+});
+program
+    .command("salesnav:ensure-count")
+    .description("Ensure the workspace has at least the target number of Sales Navigator people rows by importing historical BigQuery windows directly.")
+    .option("--target-count <number>", "Minimum linkedin_sales_nav_people rows to guarantee", "200000")
+    .option("--scope <scope>", "Historical scope: all-sales-people|hr-function-included", "all-sales-people")
+    .option("--org-id <id>", "Workspace org id. Defaults to the active CLI org.")
+    .option("--start-offset <number>", "BigQuery offset override. By default the CLI resumes from prior historical backfill runs.")
+    .option("--window-size <number>", "How many historical contacts to request from BigQuery per window", String(salesNavigatorHistoricalBackfillDefaults.windowSize))
+    .option("--max-windows <number>", "Maximum number of BigQuery windows to import in this invocation", "10")
+    .option("--page-size <number>", "BigQuery page size per API read", String(salesNavigatorHistoricalBackfillDefaults.pageSize))
+    .option("--upsert-batch-size <number>", "Supabase upsert batch size", String(salesNavigatorHistoricalBackfillDefaults.upsertBatchSize))
+    .option("--min-upsert-batch-size <number>", "Smallest batch size allowed after timeout-driven splitting", String(salesNavigatorHistoricalBackfillDefaults.minUpsertBatchSize))
+    .option("--max-upsert-retries <number>", "How many retry rounds to tolerate for timeout-prone writes", String(salesNavigatorHistoricalBackfillDefaults.maxUpsertRetries))
+    .option("--retry-delay-ms <number>", "Base retry delay in milliseconds for write retries", String(salesNavigatorHistoricalBackfillDefaults.retryDelayMs))
+    .option("--out <path>", "Optional local JSON output path")
+    .option("--dry-run", "Preview the historical import plan without touching BigQuery or Supabase", false)
+    .action(async (options) => {
+    const targetCount = z.coerce.number().int().min(1).parse(options.targetCount);
+    const scope = z.enum(["all-sales-people", "hr-function-included"]).parse(options.scope);
+    const explicitStartOffset = typeof options.startOffset === "string" && options.startOffset.trim().length > 0
+        ? z.coerce.number().int().min(0).parse(options.startOffset)
+        : null;
+    const windowSize = z.coerce.number().int().min(1).parse(options.windowSize);
+    const maxWindows = z.coerce.number().int().min(1).max(100).parse(options.maxWindows);
+    const pageSize = z.coerce.number().int().min(1).parse(options.pageSize);
+    const upsertBatchSize = z.coerce.number().int().min(1).parse(options.upsertBatchSize);
+    const minUpsertBatchSize = z.coerce.number().int().min(1).parse(options.minUpsertBatchSize);
+    const maxUpsertRetries = z.coerce.number().int().min(0).parse(options.maxUpsertRetries);
+    const retryDelayMs = z.coerce.number().int().min(0).parse(options.retryDelayMs);
+    if (minUpsertBatchSize > upsertBatchSize) {
+        throw new Error("--min-upsert-batch-size must be less than or equal to --upsert-batch-size.");
+    }
+    if (Boolean(options.dryRun)) {
+        const plan = buildSalesNavigatorHistoricalBackfillPlan({
+            targetCount,
+            currentCount: null,
+            startOffset: explicitStartOffset ?? 0,
+            windowSize,
+            maxWindows
+        });
+        const payload = {
+            status: "ok",
+            dryRun: true,
+            mode: "historical-bigquery-backfill",
+            orgId: options.orgId ?? null,
+            scope,
+            targetCount,
+            resumedFromHistory: false,
+            plan
+        };
+        if (options.out) {
+            await writeJsonFile(options.out, payload);
+        }
+        printOutput(payload);
+        return;
+    }
+    let sessionOrgId = null;
+    if (!shouldBypassAuth()) {
+        const session = await requireAuthSession();
+        sessionOrgId = session.user.orgId ?? null;
+    }
+    const orgId = resolveSalesNavigatorHistoricalBackfillOrgId({
+        explicitOrgId: options.orgId,
+        env: process.env,
+        sessionOrgId
+    });
+    const config = resolveSalesNavigatorHistoricalBackfillConfig(process.env);
+    const supabase = createClient(config.supabaseUrl, config.supabaseServiceRoleKey, {
+        auth: { persistSession: false }
+    });
+    const resumeState = explicitStartOffset === null
+        ? await resolveSalesNavigatorHistoricalBackfillResumeState({
+            supabase,
+            orgId,
+            scope,
+            windowSize,
+            fallbackOffset: 0
+        })
+        : {
+            startOffset: explicitStartOffset,
+            resumedFromHistory: false,
+            matchedHistoryRows: 0,
+            reason: "fallback"
+        };
+    if (resumeState.resumedFromHistory) {
+        writeProgress(`Resuming historical Sales Navigator backfill from offset ${resumeState.startOffset} based on prior CLI runs.`);
+    }
+    else if (explicitStartOffset !== null) {
+        writeProgress(`Using explicit historical Sales Navigator backfill offset ${explicitStartOffset}.`);
+    }
+    const summary = await ensureSalesNavigatorPeopleCount({
+        config,
+        orgId,
+        targetCount,
+        scope,
+        startOffset: resumeState.startOffset,
+        resumedFromHistory: resumeState.resumedFromHistory,
+        windowSize,
+        maxWindows,
+        pageSize,
+        upsertBatchSize,
+        minUpsertBatchSize,
+        maxUpsertRetries,
+        retryDelayMs,
+        onProgress: (event) => {
+            if (event.type === "window-start") {
+                writeProgress(`Starting historical Sales Navigator backfill window ${event.windowIndex + 1}: offset ${event.offset}, limit ${event.limit}.`);
+                return;
+            }
+            if (event.type === "window-progress") {
+                writeProgress(`Historical window ${event.windowIndex + 1}: ${event.processed}/${event.totalResults} rows imported (${event.percent}%).`);
+                return;
+            }
+            writeProgress(`Historical window ${event.windowIndex + 1} complete: count ${event.countBefore} -> ${event.countAfter} (delta ${event.countDelta}).`);
+        }
+    });
+    const payload = {
+        status: summary.status,
+        dryRun: false,
+        mode: "historical-bigquery-backfill",
+        orgId: summary.orgId,
+        scope: summary.scope,
+        targetCount: summary.targetCount,
+        initialCount: summary.initialCount,
+        currentCount: summary.currentCount,
+        resumedFromHistory: summary.resumedFromHistory,
+        startOffset: summary.startOffset,
+        nextOffset: summary.nextOffset,
+        exhausted: summary.exhausted,
+        completedWindows: summary.completedWindows,
+        windows: summary.windows
+    };
+    if (options.out) {
+        await writeJsonFile(options.out, payload);
+    }
+    if (summary.status !== "ok") {
+        throw new Error(`Historical Sales Navigator backfill stopped at ${summary.currentCount} rows before reaching the target ${summary.targetCount}.`);
+    }
+    printOutput(payload);
+});
 program
     .command("salesnav:crawl")
     .description("Adaptively split broad LinkedIn Sales Navigator people searches into exportable slices and store every finished slice through Salesprompter.")
@@ -1876,7 +3092,12 @@ program
     .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("--idle-poll-seconds <number>", "Seconds to wait before polling durable crawl status when remote slices are still running", "10")
+    .option("--idle-max-polls <number>", "How many no-claim status polls to tolerate before the crawl is considered stalled", "180")
+    .option("--parallel-exports <number>", "How many Sales Navigator slices to export concurrently in this invocation", "3")
+    .option("--allow-partial-success", "Exit 0 even when the durable crawl finishes with failures or remains non-terminal", false)
     .option("--out <path>", "Optional local JSON output path")
+    .option("--log-path <path>", "Optional JSONL log path with timestamps, trace id, and Sales Navigator slice metadata")
     .option("--dry-run", "Preview the adaptive crawl plan without exporting anything", false)
     .action(async (options) => {
     const queryUrl = z.string().url().optional().parse(options.queryUrl);
@@ -1889,7 +3110,30 @@ program
     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 idlePollSeconds = z.coerce.number().int().min(0).max(300).parse(options.idlePollSeconds);
+    const idleMaxPolls = z.coerce.number().int().min(0).max(10000).parse(options.idleMaxPolls);
+    const parallelExports = z.coerce.number().int().min(1).max(10).parse(options.parallelExports);
     const effectiveDryRun = Boolean(options.dryRun || shouldBypassAuth());
+    const logger = await createWorkflowLogger({
+        logPath: options.logPath ?? buildSalesNavigatorCrawlLogPath(jobId ?? queryUrl ?? "salesnav-crawl")
+    });
+    await logger.log("salesnav.crawl.command.started", {
+        queryUrl: queryUrl ?? null,
+        jobId: jobId ?? null,
+        maxResultsPerSearch,
+        numberOfProfiles,
+        slicePreset: options.slicePreset,
+        maxSplitDepth,
+        maxSlices,
+        maxRetries,
+        probeProfiles,
+        agentBusyWaitSeconds,
+        agentBusyMaxWaits,
+        idlePollSeconds,
+        idleMaxPolls,
+        parallelExports,
+        dryRun: effectiveDryRun
+    });
     if (effectiveDryRun) {
         if (jobId) {
             throw new Error("--dry-run does not support --job-id. Use --query-url instead.");
@@ -1901,6 +3145,8 @@ program
             status: "ok",
             dryRun: true,
             mode: "adaptive",
+            traceId: logger.traceId,
+            logPath: logger.logPath,
             dimensionPreset: "human-resources-adaptive",
             query: (() => {
                 const preview = buildSalesNavigatorCrawlPreview({
@@ -1930,6 +3176,15 @@ program
                 };
             })()
         };
+        await logger.log("salesnav.crawl.dry-run.preview", {
+            sourceQueryUrl: payload.query.sourceQueryUrl,
+            root: summarizeSalesNavigatorQuery(payload.query.rootQueryUrl, payload.query.rootAppliedFilters),
+            dimensionOrder: payload.query.dimensionOrder,
+            firstSplitQueries: payload.query.firstSplitQueries.map((attempt) => ({
+                splitTrail: attempt.splitTrail,
+                ...summarizeSalesNavigatorQuery(attempt.slicedQueryUrl, attempt.appliedFilters)
+            }))
+        });
         if (options.out) {
             await writeJsonFile(options.out, payload);
         }
@@ -1954,23 +3209,57 @@ program
             slicePreset: options.slicePreset,
             maxResultsPerSearch,
             numberOfProfiles,
+            rawPayload: {
+                workflow: "salesnav:crawl",
+                traceId: logger.traceId,
+                command: {
+                    sourceQueryUrl: queryUrl,
+                    slicePreset: options.slicePreset,
+                    maxResultsPerSearch,
+                    numberOfProfiles,
+                    maxSplitDepth,
+                    maxSlices,
+                    maxRetries,
+                    probeProfiles,
+                    agentBusyWaitSeconds,
+                    agentBusyMaxWaits,
+                    idlePollSeconds,
+                    idleMaxPolls,
+                    parallelExports
+                }
+            },
             rootSlice: {
                 slicedQueryUrl: seed.slicedQueryUrl,
                 appliedFilters: seed.appliedFilters,
                 depth: seed.depth,
-                splitTrail: seed.splitTrail
+                splitTrail: seed.splitTrail,
+                rawPayload: {
+                    workflow: "salesnav:crawl",
+                    traceId: logger.traceId
+                }
             }
-        });
+        }, logger.traceId);
         session = created.session;
         createResult = {
             resumed: created.value.resumed,
             job: created.value.job
         };
         resolvedJobId = created.value.job.id;
+        await logger.log("salesnav.crawl.job.ready", {
+            jobId: resolvedJobId,
+            resumed: created.value.resumed,
+            sourceQueryUrl: queryUrl,
+            rootSlice: summarizeSalesNavigatorQuery(seed.slicedQueryUrl, seed.appliedFilters)
+        });
     }
     else {
-        const status = await getSalesNavigatorCrawlStatus(session, resolvedJobId);
+        const status = await getSalesNavigatorCrawlStatus(session, resolvedJobId, logger.traceId);
         session = status.session;
+        await logger.log("salesnav.crawl.job.resumed", {
+            jobId: resolvedJobId,
+            sourceQueryUrl: status.value.job.sourceQueryUrl,
+            status: status.value.job.status
+        });
     }
     if (!resolvedJobId) {
         throw new Error("Failed to determine Sales Navigator crawl job id.");
@@ -1981,12 +3270,19 @@ program
         maxRetries,
         probeProfiles,
         agentBusyWaitSeconds,
-        agentBusyMaxWaits
+        agentBusyMaxWaits,
+        idlePollSeconds,
+        idleMaxPolls,
+        parallelExports,
+        traceId: logger.traceId,
+        logger
     });
     const payload = {
         status: "ok",
         dryRun: false,
         mode: "durable",
+        traceId: logger.traceId,
+        logPath: logger.logPath,
         jobId: resolvedJobId,
         resumed: createResult?.resumed ?? true,
         sourceQueryUrl: crawl.job.sourceQueryUrl,
@@ -2009,10 +3305,20 @@ program
             : null,
         lastOutcome: crawl.lastOutcome
     };
+    await logger.log("salesnav.crawl.command.completed", {
+        jobId: resolvedJobId,
+        status: crawl.job.status,
+        claimedSlices: crawl.claimedSlices,
+        truncated: crawl.truncated,
+        lastOutcome: crawl.lastOutcome
+    });
     if (options.out) {
         await writeJsonFile(options.out, payload);
     }
     printOutput(payload);
+    if ((crawl.job.status !== "completed" || crawl.truncated) && !options.allowPartialSuccess) {
+        throw new Error(`Sales Navigator crawl did not finish cleanly. status=${crawl.job.status} truncated=${crawl.truncated} failedSlices=${crawl.job.failedSlices} runningSlices=${crawl.job.runningSlices} queuedSlices=${crawl.job.queuedSlices}`);
+    }
 });
 program
     .command("salesnav:crawl:status")
@@ -2073,7 +3379,13 @@ program
             appliedFilters: item.appliedFilters,
             maxResultsPerSearch,
             numberOfProfiles,
-            slicePreset: options.slicePreset
+            slicePreset: options.slicePreset,
+            rawPayload: {
+                workflow: "salesnav:export",
+                sourceQueryUrl: item.sourceQueryUrl,
+                slicedQueryUrl: item.slicedQueryUrl,
+                appliedFilters: item.appliedFilters
+            }
         });
         exported.push(result);
     }