salesprompter-cli 0.1.40 → 0.1.42

package/dist/cli.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
 import { access, appendFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import os from "node:os";
@@ -9,9 +8,10 @@ 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 pg from "pg";
 import { Command } from "commander";
 import { z } from "zod";
-import { clearAuthSession, loginWithBrowserConnect, loginWithDeviceFlow, loginWithToken, requireAuthSession, shouldBypassAuth, verifySession, writeAuthSession } from "./auth.js";
+import { clearAuthSession, loginWithBrowserConnect, loginWithDeviceFlow, loginWithToken, readAuthSession, requireAuthSession, shouldBypassAuth, verifySession, writeAuthSession } from "./auth.js";
 import { buildBigQueryLeadLookupSql, executeBigQuerySql, normalizeBigQueryLeadRows, runBigQueryQuery, runBigQueryRows } from "./bigquery.js";
 import { AccountProfileSchema, EnrichedLeadSchema, IcpSchema, LeadSchema, ScoredLeadSchema, SyncTargetSchema } from "./domain.js";
 import { auditDomainDecisions, buildDomainfinderBacklogQueries, buildDomainfinderCandidatesSql, buildDomainfinderInputSql, buildDomainfinderWritebackSql, buildExistingDomainRepairSql, buildExistingDomainAuditQueries, compareDomainSelectionStrategies, selectBestDomains } from "./domainfinder.js";
@@ -26,11 +26,10 @@ import { InstantlySyncProvider } from "./instantly.js";
 import { backfillLinkedInCompanies } from "./linkedin-companies.js";
 import { parseLinkedInCompanyPage } from "./linkedin-companies.js";
 import { crawlLinkedInProductCategory } from "./linkedin-products.js";
-import { claimValidatedSalesNavigatorSessionCookieForCli, createLinkedInSessionSupabaseClient, probeSalesNavigatorSearchSession, resolveConfiguredEnvValue } from "./linkedin-session.js";
-import { extractLiAtCookieValue } from "./linkedin-session-contracts.js";
+import { claimValidatedSalesNavigatorSessionCookieForCli, createLinkedInSessionSupabaseClient, resolveConfiguredEnvValue } from "./linkedin-session.js";
 import { buildLeadlistsFunnelQueries } from "./leadlists-funnel.js";
 import { readJsonFile, splitCsv, writeJsonFile, writeTextFile } from "./io.js";
-import { buildSalesNavigatorCrawlPreview, createSalesNavigatorCrawlSeed, DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS, buildSalesNavigatorPeopleSlice, deriveSalesNavigatorTitleQuerySeeds, expandSalesNavigatorCrawlAttempt, SalesNavigatorSliceTooBroadError } from "./sales-navigator.js";
+import { buildSalesNavigatorCrawlPreview, createSalesNavigatorCrawlSeed, DEFAULT_SALES_NAVIGATOR_ACCOUNT_CRAWL_DIMENSIONS, DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS, buildSalesNavigatorPeopleSearchUrl, buildSalesNavigatorPeopleSlice, deriveSalesNavigatorTitleQuerySeeds, executeSalesNavigatorAdaptiveCrawl, expandSalesNavigatorCrawlAttempt, SalesNavigatorCrawlStopError, 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");
@@ -129,69 +128,17 @@ const SalesNavigatorLocalImportResponseSchema = z.object({
     runId: z.string().min(1),
     containerId: z.string().min(1),
     imported: z.number().int().nonnegative(),
-    upserted: z.number().int().nonnegative()
-});
-const LeadPoolAutoProcessResponseSchema = z.object({
-    success: z.boolean(),
-    clientIds: z.array(z.number().int().positive()),
-    steps: z.array(z.record(z.string(), z.unknown())),
-    startedAt: z.string(),
-    finishedAt: z.string()
-});
-const AffiliateCampaignLaunchResponseSchema = z
-    .object({
-    status: z.string().min(1),
-    dryRun: z.boolean(),
-    product: z.object({
-        domain: z.string().min(1),
-        affiliateLink: z.string().url()
-    }),
-    audience: z.object({
-        sourceType: z.string().min(1),
-        linkedInUrl: z.string().url(),
-        maxResults: z.number().int().positive()
-    }),
-    extraction: z
+    upserted: z.number().int().nonnegative(),
+    leadPoolRefresh: z
         .object({
-        provider: z.string().min(1),
-        agentId: z.string().min(1).optional(),
-        containerId: z.string().min(1).optional(),
-        eventTypes: z.array(z.string()).optional(),
-        monitorId: z.string().min(1).optional(),
-        postsDiscoveredCount: z.number().int().nonnegative().optional(),
-        engagementEventsCount: z.number().int().nonnegative().optional(),
-        peopleDiscoveredCount: z.number().int().nonnegative().optional(),
-        people: z.array(z.unknown()).optional(),
-        posts: z.array(z.unknown()).optional(),
-        run: z.unknown().nullable().optional(),
-        summary: z.unknown().nullable().optional(),
-        selectedSessionCookieSha256: z.string().nullable().optional(),
-        selectedSessionUserEmail: z.string().nullable().optional(),
-        selectedSessionUserHandle: z.string().nullable().optional()
+        scheduled: z.literal(true),
     })
+        .nullable()
         .optional(),
-    previewUrl: z.string().min(1).nullable().optional(),
-    next: z.string().optional()
-})
-    .passthrough();
-const LeadPoolEmailFinderProcessResponseSchema = z.object({
-    success: z.boolean(),
-    provider: z.string().optional(),
-    selected: z.number().int().nonnegative(),
-    found: z.number().int().nonnegative(),
-    notFound: z.number().int().nonnegative(),
-    failed: z.number().int().nonnegative(),
-    durationMs: z.number().nonnegative(),
-    launched: z.boolean().optional(),
-    agentId: z.string().nullable().optional(),
-    containerId: z.string().nullable().optional(),
-    csvInputUrl: z.string().nullable().optional(),
-    processedAt: z.string()
 });
 const PhantombusterContainersSyncResponseSchema = z.object({
     status: z.literal("ok"),
     agentIds: z.array(z.string().min(1)),
-    containerIds: z.array(z.string().min(1)).optional(),
     agents: z.array(z.object({
         agentId: z.string().min(1),
         fetched: z.number().int().nonnegative(),
@@ -203,13 +150,7 @@ const PhantombusterContainersSyncResponseSchema = z.object({
     resultsSynced: z.number().int().nonnegative(),
     outputsStored: z.number().int().nonnegative(),
     resultObjectsStored: z.number().int().nonnegative(),
-    resultRowsStored: z.number().int().nonnegative(),
-    leadListsProjected: z.number().int().nonnegative().optional(),
-    leadListContactsProjected: z.number().int().nonnegative().optional(),
-    contactsProjected: z.number().int().nonnegative().optional(),
-    leadPoolRows: z.number().int().nonnegative().nullable().optional(),
-    qualifiedContacts: z.number().int().nonnegative().nullable().optional(),
-    qualifiedCompanies: z.number().int().nonnegative().nullable().optional()
+    resultRowsStored: z.number().int().nonnegative()
 });
 const CliEmailEnrichmentCompaniesResponseSchema = z.object({
     clientId: z.number().int().positive(),
@@ -379,6 +320,47 @@ const SalesNavigatorCrawlReportResponseSchema = z.object({
     status: z.literal("ok"),
     job: SalesNavigatorCrawlJobSummarySchema
 });
+const SalesNavigatorAccountRunStatusSchema = z.object({
+    runId: z.string().uuid(),
+    orgId: z.string().min(1),
+    sourceQueryUrl: z.string().url(),
+    status: z.string().min(1),
+    storedAccounts: z.number().int().nonnegative(),
+    reportedRootTotal: z.number().int().nonnegative().nullable(),
+    missingStoredFromRoot: z.number().int().nonnegative().nullable(),
+    lastError: z.string().nullable(),
+    updatedAt: z.string().datetime(),
+    sliceCounts: z.record(z.string(), z.number().int().nonnegative()),
+    workflow: z.object({
+        latestRunId: z.string().min(1).nullable(),
+        latestStartedAt: z.string().datetime().nullable(),
+    }).default({
+        latestRunId: null,
+        latestStartedAt: null,
+    }),
+    nextAction: z.enum(["complete", "cooldown", "resume_cli", "inspect"]),
+    cooldownUntil: z.string().datetime().nullable(),
+    problemSlices: z.array(z.object({
+        sliceId: z.string().uuid(),
+        status: z.string().min(1),
+        totalResults: z.number().int().nonnegative().nullable(),
+        storedAccounts: z.number().int().nonnegative(),
+        lastError: z.string().nullable(),
+        slicedQueryUrl: z.string().url(),
+        stopReason: z.string().nullable(),
+        nextStart: z.number().int().nonnegative().nullable(),
+        missingFromReported: z.number().int().nonnegative().nullable()
+    }))
+});
+const SalesNavigatorAccountRunStatusResponseSchema = z.object({
+    status: z.literal("ok"),
+    run: SalesNavigatorAccountRunStatusSchema
+});
+const SalesNavigatorAccountWorkflowStartResponseSchema = z.object({
+    status: z.literal("accepted"),
+    workflowRunId: z.string().min(1),
+    accountRunId: z.string().uuid()
+});
 const cliPacks = [
     {
         slug: "contacts",
@@ -391,21 +373,32 @@ const cliPacks = [
         slug: "research",
         title: "Research",
         summary: "Scrape markets and enrich companies before outreach.",
-        commands: ["market:scrape", "companies:enrich", "leads:process"],
+        commands: ["market:scrape", "companies:enrich"],
         installStatus: "included"
     },
     {
         slug: "discovery",
         title: "Discovery",
         summary: "Find leads from product and market inputs.",
-        commands: ["leads:discover", "search:run", "search:status", "search:export", "search:local-import", "search:count"],
+        commands: [
+            "leads:discover",
+            "search:run",
+            "search:status",
+            "search:export",
+            "search:count",
+            "accounts:split",
+            "accounts:local-import",
+            "accounts:status",
+            "accounts:resume",
+            "accounts:repair"
+        ],
         installStatus: "included"
     },
     {
         slug: "outreach",
         title: "Outreach",
         summary: "Prepare and sync qualified leads into downstream systems.",
-        commands: ["affiliate:launch", "sync:outreach", "sync:crm"],
+        commands: ["sync:outreach", "sync:crm"],
         installStatus: "included"
     }
 ];
@@ -419,8 +412,12 @@ const helpAliasByCommandName = new Map([
     ["salesnav:crawl", "search:run"],
     ["salesnav:crawl:status", "search:status"],
     ["salesnav:export", "search:export"],
-    ["salesnav:local-import", "search:local-import"],
-    ["salesnav:count", "search:count"]
+    ["salesnav:count", "search:count"],
+    ["salesnav:accounts:split", "accounts:split"],
+    ["salesnav:accounts:local-import", "accounts:local-import"],
+    ["salesnav:accounts:status", "accounts:status"],
+    ["salesnav:accounts:resume", "accounts:resume"],
+    ["salesnav:accounts:repair", "accounts:repair"]
 ]);
 const helpVisibleCommandNames = new Set([
     "setup",
@@ -443,9 +440,7 @@ const helpVisibleCommandNames = new Set([
     "leads:generate",
     "leads:enrich",
     "leads:score",
-    "leads:process",
     "leads:pipeline",
-    "affiliate:launch",
     "sync:crm",
     "sync:outreach",
     "linkedin-companies:backfill",
@@ -454,8 +449,12 @@ const helpVisibleCommandNames = new Set([
     "salesnav:crawl",
     "salesnav:crawl:status",
     "salesnav:export",
-    "salesnav:local-import",
-    "salesnav:count"
+    "salesnav:count",
+    "salesnav:accounts:split",
+    "salesnav:accounts:local-import",
+    "salesnav:accounts:status",
+    "salesnav:accounts:resume",
+    "salesnav:accounts:repair"
 ]);
 function printOutput(value) {
     if (runtimeOutputOptions.quiet) {
@@ -1382,22 +1381,12 @@ async function listChromeExtensionTokenLogCandidates() {
                     if (!file.endsWith(".log")) {
                         continue;
                     }
-                    const filePath = path.join(extensionDir, file);
-                    let mtimeMs = 0;
-                    try {
-                        mtimeMs = (await stat(filePath)).mtimeMs;
-                    }
-                    catch {
-                        mtimeMs = 0;
-                    }
-                    paths.push({ path: filePath, mtimeMs });
+                    paths.push(path.join(extensionDir, file));
                 }
             }
         }
     }
-    return paths
-        .sort((left, right) => right.mtimeMs - left.mtimeMs || right.path.localeCompare(left.path))
-        .map((entry) => entry.path);
+    return paths.sort().reverse();
 }
 async function readLocalLinkedInExtensionDirectLookupConfig() {
     const candidates = await listChromeExtensionTokenLogCandidates();
@@ -1436,6 +1425,16 @@ function readLinkedInDirectLookupEnvConfig() {
             "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
     };
 }
+function shouldDisableLinkedInDirectLookupAutodiscovery() {
+    const value = process.env.SALESPROMPTER_DISABLE_LINKEDIN_DIRECT_LOOKUP_AUTODISCOVERY ??
+        process.env.LINKEDIN_DISABLE_DIRECT_LOOKUP_AUTODISCOVERY ??
+        "";
+    return ["1", "true", "on", "yes"].includes(value.trim().toLowerCase());
+}
+function isExplicitLinkedInSessionVaultEnabled() {
+    const value = process.env.SALESPROMPTER_CLI_MANAGE_LINKEDIN_SESSIONS ?? "";
+    return ["1", "true", "on", "yes"].includes(value.trim().toLowerCase());
+}
 function extractStoredLinkedInLookupValue(metadata, key) {
     if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
         return "";
@@ -1495,18 +1494,24 @@ async function readLinkedInDirectLookupConfig() {
         cachedLinkedInDirectLookupConfig = envConfig;
         return envConfig;
     }
-    if (process.env.SALESPROMPTER_DISABLE_LINKEDIN_DIRECT_LOOKUP_AUTODISCOVERY === "1") {
-        throw new Error("Missing LinkedIn direct lookup session. Set LINKEDIN_CSRF_TOKEN, LINKEDIN_X_LI_IDENTITY, and LINKEDIN_SALES_NAV_COOKIE, or connect the Salesprompter Chrome extension to sync your LinkedIn session to salesprompter.ai.");
+    try {
+        const storedConfig = await readStoredLinkedInDirectLookupConfig();
+        if (storedConfig) {
+            cachedLinkedInDirectLookupConfig = storedConfig;
+            return storedConfig;
+        }
     }
-    const localExtensionConfig = await readLocalLinkedInExtensionDirectLookupConfig();
-    if (localExtensionConfig) {
-        cachedLinkedInDirectLookupConfig = localExtensionConfig;
-        return localExtensionConfig;
+    catch (error) {
+        if (isExplicitLinkedInSessionVaultEnabled()) {
+            throw error;
+        }
     }
-    const storedConfig = await readStoredLinkedInDirectLookupConfig();
-    if (storedConfig) {
-        cachedLinkedInDirectLookupConfig = storedConfig;
-        return storedConfig;
+    if (!shouldDisableLinkedInDirectLookupAutodiscovery()) {
+        const localExtensionConfig = await readLocalLinkedInExtensionDirectLookupConfig();
+        if (localExtensionConfig) {
+            cachedLinkedInDirectLookupConfig = localExtensionConfig;
+            return localExtensionConfig;
+        }
     }
     throw new Error("Missing LinkedIn direct lookup session. Set LINKEDIN_CSRF_TOKEN, LINKEDIN_X_LI_IDENTITY, and LINKEDIN_SALES_NAV_COOKIE, or connect the Salesprompter Chrome extension to sync your LinkedIn session to salesprompter.ai.");
 }
@@ -1997,25 +2002,198 @@ function scoreLinkedInSalesApiElementMatch(contact, element) {
         companyMatchCount
     };
 }
-function extractLinkedInCompanyEmployeeCountFromSalesApiElement(element) {
+function extractLinkedInCompanyEmployeeCountFromSalesApiElement(element, options = {}) {
+    if (!element) {
+        return null;
+    }
+    for (const key of ["employeeDisplayCount", "employeesOnLinkedInCount"]) {
+        const value = element[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return Math.max(0, Math.trunc(value));
+        }
+        if (typeof value === "string") {
+            const parsed = parseLinkedInCompactNumber(value);
+            if (parsed != null) {
+                return parsed;
+            }
+        }
+    }
+    if (options.allowTextFallback) {
+        for (const value of collectNestedStrings(element)) {
+            const match = value.match(/(\d[\d.,]*)\s+employees\b/i);
+            if (match) {
+                return Number(match[1].replace(/[.,]/g, ""));
+            }
+        }
+    }
+    return null;
+}
+function extractLinkedInCompanyNumericTextFromSalesApiElement(element, directKeys, pattern) {
     if (!element) {
         return null;
     }
-    const numericCandidates = [
-        typeof element.employeeCount === "number" ? element.employeeCount : null,
-        typeof element.employeesOnLinkedInCount === "number" ? element.employeesOnLinkedInCount : null
-    ].filter((value) => Number.isFinite(value));
-    if (numericCandidates.length > 0) {
-        return Math.max(0, Math.trunc(numericCandidates[0] ?? 0));
+    for (const key of directKeys) {
+        const value = element[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return Math.max(0, Math.trunc(value));
+        }
+        if (typeof value === "string") {
+            const parsed = parseLinkedInCompactNumber(value);
+            if (parsed != null) {
+                return parsed;
+            }
+        }
     }
     for (const value of collectNestedStrings(element)) {
-        const match = value.match(/(\d[\d.,]*)\s+employees\b/i);
-        if (match) {
-            return Number(match[1].replace(/[.,]/g, ""));
+        const match = value.match(pattern);
+        if (match?.[1]) {
+            const parsed = parseLinkedInCompactNumber(match[1]);
+            if (parsed != null) {
+                return parsed;
+            }
         }
     }
     return null;
 }
+function parseLinkedInCompactNumber(value) {
+    const normalized = value.trim().replace(/,/g, "");
+    const match = normalized.match(/^(\d+(?:\.\d+)?)\s*([kmb])?\+?$/i);
+    if (!match) {
+        const digits = normalized.match(/\d[\d.]*/)?.[0];
+        return digits ? Number(digits.replace(/\./g, "")) : null;
+    }
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount)) {
+        return null;
+    }
+    const suffix = match[2]?.toLowerCase();
+    const multiplier = suffix === "b" ? 1_000_000_000 : suffix === "m" ? 1_000_000 : suffix === "k" ? 1_000 : 1;
+    return Math.max(0, Math.trunc(amount * multiplier));
+}
+function extractFirstNestedStringByKeys(element, keys) {
+    if (!element) {
+        return null;
+    }
+    for (const key of keys) {
+        const direct = element[key];
+        if (typeof direct === "string" && normalizeLookupWhitespace(direct)) {
+            return normalizeLookupWhitespace(direct);
+        }
+    }
+    const normalizedKeys = new Set(keys.map((key) => key.toLowerCase()));
+    const visit = (value, seen = new Set()) => {
+        if (value == null || seen.has(value) || typeof value !== "object") {
+            return null;
+        }
+        seen.add(value);
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                const found = visit(item, seen);
+                if (found) {
+                    return found;
+                }
+            }
+            return null;
+        }
+        const record = value;
+        for (const [key, candidate] of Object.entries(record)) {
+            if (normalizedKeys.has(key.toLowerCase()) &&
+                typeof candidate === "string" &&
+                normalizeLookupWhitespace(candidate)) {
+                return normalizeLookupWhitespace(candidate);
+            }
+        }
+        for (const candidate of Object.values(record)) {
+            const found = visit(candidate, seen);
+            if (found) {
+                return found;
+            }
+        }
+        return null;
+    };
+    return visit(element);
+}
+function extractLinkedInCompanyIdFromUrl(value) {
+    if (!value) {
+        return null;
+    }
+    const match = value.match(/\/(?:sales\/company|company)\/([^/?#]+)/i);
+    return match?.[1] ? decodeURIComponent(match[1]) : null;
+}
+function extractLinkedInSalesCompanyIdFromUrn(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const directMatch = value.match(/urn:li:fs_salesCompany:(\d+)\b/i);
+    if (directMatch?.[1]) {
+        return directMatch[1];
+    }
+    const tupleMatch = value.match(/urn:li:fs_salesCompany:\((\d+),/i);
+    return tupleMatch?.[1] ?? null;
+}
+function normalizeLocalSalesNavigatorAccount(element, queryUrl) {
+    const urnCompanyId = extractLinkedInSalesCompanyIdFromUrn(element.entityUrn);
+    const explicitSalesNavCompanyUrl = extractLinkedInSalesNavCompanyUrlFromSalesApiElement(element);
+    const explicitLinkedinCompanyUrl = extractLinkedInCompanyUrlFromSalesApiElement(element);
+    const companyName = extractLinkedInCompanyNameFromSalesApiElement(element);
+    const companyId = extractLinkedInCompanyIdFromUrl(explicitSalesNavCompanyUrl) ??
+        extractLinkedInCompanyIdFromUrl(explicitLinkedinCompanyUrl) ??
+        urnCompanyId;
+    const salesNavCompanyUrl = explicitSalesNavCompanyUrl ??
+        (companyId ? `https://www.linkedin.com/sales/company/${companyId}` : null);
+    const linkedinCompanyUrl = explicitLinkedinCompanyUrl ??
+        (companyId ? normalizeLinkedInCompanyPage(companyId) : null);
+    const accountKey = (companyId ? `company-id:${companyId}` : null) ??
+        salesNavCompanyUrl?.toLowerCase() ??
+        linkedinCompanyUrl?.toLowerCase() ??
+        (companyName ? `company-name:${normalizeLooseMatchText(companyName)}` : null);
+    if (!accountKey) {
+        return null;
+    }
+    return {
+        accountKey,
+        salesNavCompanyUrl,
+        linkedinCompanyUrl,
+        companyId,
+        companyName,
+        industry: extractFirstNestedStringByKeys(element, ["industry", "industryName"]),
+        location: extractFirstNestedStringByKeys(element, ["location", "locationName", "geoRegion"]),
+        headquarters: extractFirstNestedStringByKeys(element, ["headquarters", "headquartersLocation"]),
+        employeeCount: extractLinkedInCompanyEmployeeCountFromSalesApiElement(element),
+        followerCount: extractLinkedInCompanyNumericTextFromSalesApiElement(element, ["followerCount", "followersCount", "numFollowers"], /(\d[\d.,kmbKMB+]*)\s+followers?\b/i),
+        companyType: extractFirstNestedStringByKeys(element, ["companyType", "type"]),
+        description: extractFirstNestedStringByKeys(element, ["description", "summary", "tagline"]),
+        website: extractFirstNestedStringByKeys(element, ["website", "websiteUrl", "companyWebsite"]),
+        searchQueryUrl: queryUrl,
+        scrapedAt: new Date().toISOString(),
+        rawLocalSalesNavigatorAccountResult: element,
+    };
+}
+function normalizeLocalSalesNavigatorAccounts(responseBody, queryUrl) {
+    if (typeof responseBody !== "object" ||
+        responseBody === null ||
+        Array.isArray(responseBody)) {
+        return [];
+    }
+    const elements = responseBody.elements;
+    if (!Array.isArray(elements)) {
+        return [];
+    }
+    const accounts = [];
+    const seen = new Set();
+    for (const element of elements) {
+        if (typeof element !== "object" || element === null || Array.isArray(element)) {
+            continue;
+        }
+        const account = normalizeLocalSalesNavigatorAccount(element, queryUrl);
+        if (!account || seen.has(account.accountKey)) {
+            continue;
+        }
+        seen.add(account.accountKey);
+        accounts.push(account);
+    }
+    return accounts;
+}
 function buildLinkedInCompanyLookupVariants(params) {
     const variants = [];
     const seen = new Set();
@@ -2125,7 +2303,9 @@ async function resolveDirectLinkedInCompanyContexts(params) {
                     matchedCompanyUrl = companyUrl ?? matchedCompanyUrl;
                     matchedSalesNavCompanyUrl = salesNavCompanyUrl ?? matchedSalesNavCompanyUrl;
                     matchedCompanyName = companyName ?? matchedCompanyName;
-                    matchedCompanyEmployeeCount = extractLinkedInCompanyEmployeeCountFromSalesApiElement(first);
+                    matchedCompanyEmployeeCount = extractLinkedInCompanyEmployeeCountFromSalesApiElement(first, {
+                        allowTextFallback: true
+                    });
                     addAlias(companyName);
                     addAlias(companyUrl ? normalizeLinkedInCompanyHandle(companyUrl)?.replace(/[-_]+/g, " ") : null);
                     addAlias(salesNavCompanyUrl ? normalizeLookupWhitespace(salesNavCompanyUrl.split("/sales/company/")[1]?.split(/[/?#]/)[0] ?? "") : null);
@@ -3320,7 +3500,9 @@ async function invokeLinkedInCompanyEnrichmentDirect(params) {
                     matchedCompanyUrl = companyUrl;
                     matchedSalesNavCompanyUrl = salesNavCompanyUrl;
                     matchedCompanyName = extractLinkedInCompanyNameFromSalesApiElement(first);
-                    matchedCompanyEmployeeCount = extractLinkedInCompanyEmployeeCountFromSalesApiElement(first);
+                    matchedCompanyEmployeeCount = extractLinkedInCompanyEmployeeCountFromSalesApiElement(first, {
+                        allowTextFallback: true
+                    });
                     break;
                 }
             }
@@ -4233,6 +4415,11 @@ function resolveSessionOrgId(session) {
     const orgId = session.user.orgId?.trim();
     return orgId && orgId.length > 0 ? orgId : null;
 }
+function resolveAccountSearchStorageOrgId(session, explicitOrgId) {
+    return (compactOptionalText(explicitOrgId) ??
+        compactOptionalText(process.env.SALESPROMPTER_ORG_ID) ??
+        (session ? resolveSessionOrgId(session) : null));
+}
 function normalizeCliApiBaseUrl(value) {
     return value.trim().replace(/\/+$/, "");
 }
@@ -5791,11 +5978,18 @@ async function fetchLinkedInCompaniesBackfillStatus(session, payload) {
     return value;
 }
 class LocalSalesNavigatorRateLimitError extends Error {
-    constructor(status, bodyPreview) {
+    status;
+    retryAfterMs;
+    constructor(status, bodyPreview, retryAfterMs) {
         super(`Sales Navigator request stopped because LinkedIn returned HTTP ${status}. ` +
             "Use LinkedIn directly in a supported browser and wait before trying again. " +
+            (retryAfterMs != null
+                ? `Retry after approximately ${Math.ceil(retryAfterMs / 1000)} seconds. `
+                : "") +
             `Response preview: ${bodyPreview}`);
         this.name = "LocalSalesNavigatorRateLimitError";
+        this.status = status;
+        this.retryAfterMs = retryAfterMs;
     }
 }
 function stripShellQuotes(value) {
@@ -5874,7 +6068,7 @@ function buildSalesNavigatorApiRequestFromSearchUrl(searchUrl, config, count) {
     if (source.pathname.includes("/sales-api/salesApiLeadSearch")) {
         return {
             url: source.toString(),
-            headers: buildLinkedInSalesNavigatorLocalImportHeaders(config)
+            headers: buildLinkedInSalesNavigatorLocalImportHeaders(config),
         };
     }
     if (!source.pathname.includes("/sales/search/people")) {
@@ -5886,7 +6080,8 @@ function buildSalesNavigatorApiRequestFromSearchUrl(searchUrl, config, count) {
     }
     const baseUrl = process.env.SALESPROMPTER_LINKEDIN_SALES_API_BASE_URL?.trim() ||
         `${source.protocol}//${source.host}`;
-    const rawSessionId = extractRawUrlSearchParam(source, "sessionId") ?? encodeURIComponent(generateLinkedInSessionId());
+    const rawSessionId = extractRawUrlSearchParam(source, "sessionId") ??
+        encodeURIComponent(generateLinkedInSessionId());
     const apiQuery = normalizeSalesNavigatorApiQueryValue(rawQuery);
     const normalizedCount = Math.max(1, Math.min(100, Math.trunc(count)));
     const apiUrl = `${baseUrl.replace(/\/+$/, "")}/sales-api/salesApiLeadSearch` +
@@ -5895,7 +6090,337 @@ function buildSalesNavigatorApiRequestFromSearchUrl(searchUrl, config, count) {
         "&decorationId=com.linkedin.sales.deco.desktop.searchv2.LeadSearchResult-14";
     return {
         url: apiUrl,
-        headers: buildLinkedInSalesNavigatorLocalImportHeaders(config)
+        headers: buildLinkedInSalesNavigatorLocalImportHeaders(config),
+    };
+}
+function extractSalesNavigatorDecorationId(requestUrl, fallbackDecorationId) {
+    try {
+        const url = new URL(requestUrl);
+        return (extractRawUrlSearchParam(url, "decorationId") ??
+            fallbackDecorationId);
+    }
+    catch {
+        return fallbackDecorationId;
+    }
+}
+function buildSalesNavigatorAccountApiUrlFromSearchUrl(searchUrl, count, options = {}) {
+    const source = new URL(searchUrl);
+    if (source.pathname.includes("/sales-api/salesApiAccountSearch")) {
+        return source.toString();
+    }
+    if (!source.pathname.includes("/sales/search/company")) {
+        throw new Error("Automatic Sales Navigator account splitting requires a /sales/search/company URL.");
+    }
+    const rawQuery = extractRawUrlSearchParam(source, "query");
+    if (!rawQuery) {
+        throw new Error("Sales Navigator account search URL is missing the query parameter.");
+    }
+    const baseUrl = compactOptionalText(options.baseUrl) ??
+        compactOptionalText(process.env.SALESPROMPTER_LINKEDIN_SALES_API_BASE_URL) ??
+        `${source.protocol}//${source.host}`;
+    const rawSessionId = extractRawUrlSearchParam(source, "sessionId") ??
+        encodeURIComponent(generateLinkedInSessionId());
+    const apiQuery = normalizeSalesNavigatorApiQueryValue(rawQuery);
+    const normalizedCount = Math.max(1, Math.min(100, Math.trunc(count)));
+    const decorationId = compactOptionalText(options.decorationId) ??
+        "com.linkedin.sales.deco.desktop.searchv2.AccountSearchResult-14";
+    return (`${baseUrl.replace(/\/+$/, "")}/sales-api/salesApiAccountSearch` +
+        `?q=searchQuery&query=${apiQuery}&start=0&count=${normalizedCount}` +
+        `&trackingParam=(sessionId:${rawSessionId})` +
+        `&decorationId=${decorationId}`);
+}
+function buildSalesNavigatorAccountApiRequestFromSearchUrl(searchUrl, config, count) {
+    const source = new URL(searchUrl);
+    if (source.pathname.includes("/sales-api/salesApiAccountSearch")) {
+        return {
+            url: source.toString(),
+            headers: buildLinkedInSalesNavigatorAccountSearchHeaders(config),
+        };
+    }
+    return {
+        url: buildSalesNavigatorAccountApiUrlFromSearchUrl(searchUrl, count),
+        headers: buildLinkedInSalesNavigatorAccountSearchHeaders(config),
+    };
+}
+function buildSalesNavigatorAccountApiRequestFromSearchUrlWithTemplate(searchUrl, templateRequest, count) {
+    const templateUrl = new URL(templateRequest.url);
+    return {
+        url: buildSalesNavigatorAccountApiUrlFromSearchUrl(searchUrl, count, {
+            baseUrl: `${templateUrl.protocol}//${templateUrl.host}`,
+            decorationId: extractSalesNavigatorDecorationId(templateRequest.url, "com.linkedin.sales.deco.desktop.searchv2.AccountSearchResult-14"),
+        }),
+        headers: { ...templateRequest.headers },
+    };
+}
+const SALES_NAVIGATOR_PROFILE_LANGUAGE_VALUES = new Map([
+    ["de", { id: "de", text: "German", selectionType: "INCLUDED" }],
+    ["german", { id: "de", text: "German", selectionType: "INCLUDED" }],
+    ["en", { id: "en", text: "English", selectionType: "INCLUDED" }],
+    ["english", { id: "en", text: "English", selectionType: "INCLUDED" }],
+]);
+const SALES_NAVIGATOR_SENIORITY_VALUES = new Map([
+    [
+        "owner / partner",
+        { id: "320", text: "Owner / Partner", selectionType: "INCLUDED" },
+    ],
+    ["owner", { id: "320", text: "Owner / Partner", selectionType: "INCLUDED" }],
+    [
+        "partner",
+        { id: "320", text: "Owner / Partner", selectionType: "INCLUDED" },
+    ],
+    ["cxo", { id: "310", text: "CXO", selectionType: "INCLUDED" }],
+    [
+        "vice president",
+        { id: "300", text: "Vice President", selectionType: "INCLUDED" },
+    ],
+    ["vp", { id: "300", text: "Vice President", selectionType: "INCLUDED" }],
+    ["director", { id: "220", text: "Director", selectionType: "INCLUDED" }],
+    [
+        "experienced manager",
+        { id: "210", text: "Experienced Manager", selectionType: "INCLUDED" },
+    ],
+    [
+        "manager",
+        { id: "210", text: "Experienced Manager", selectionType: "INCLUDED" },
+    ],
+    ["senior", { id: "120", text: "Senior", selectionType: "INCLUDED" }],
+    [
+        "entry level",
+        { id: "110", text: "Entry Level", selectionType: "INCLUDED" },
+    ],
+    ["entry", { id: "110", text: "Entry Level", selectionType: "INCLUDED" }],
+]);
+const SALES_NAVIGATOR_FUNCTION_VALUES = new Map([
+    [
+        "human resources",
+        { id: "12", text: "Human Resources", selectionType: "INCLUDED" },
+    ],
+    ["hr", { id: "12", text: "Human Resources", selectionType: "INCLUDED" }],
+]);
+const SALES_NAVIGATOR_COMPANY_TYPE_VALUES = new Map([
+    [
+        "privately held",
+        { id: "P", text: "Privately Held", selectionType: "INCLUDED" },
+    ],
+    ["private", { id: "P", text: "Privately Held", selectionType: "INCLUDED" }],
+    [
+        "public company",
+        { id: "C", text: "Public Company", selectionType: "INCLUDED" },
+    ],
+    ["public", { id: "C", text: "Public Company", selectionType: "INCLUDED" }],
+]);
+const SALES_NAVIGATOR_COMPANY_HEADCOUNT_VALUES = new Map([
+    ["1-10", { id: "B", text: "1-10", selectionType: "INCLUDED" }],
+    ["11-50", { id: "C", text: "11-50", selectionType: "INCLUDED" }],
+    ["51-200", { id: "D", text: "51-200", selectionType: "INCLUDED" }],
+    ["201-500", { id: "E", text: "201-500", selectionType: "INCLUDED" }],
+    ["501-1000", { id: "F", text: "501-1000", selectionType: "INCLUDED" }],
+    ["1001-5000", { id: "G", text: "1001-5000", selectionType: "INCLUDED" }],
+    ["5001-10,000", { id: "H", text: "5001-10,000", selectionType: "INCLUDED" }],
+    ["5001-10000", { id: "H", text: "5001-10,000", selectionType: "INCLUDED" }],
+    ["10,000+", { id: "I", text: "10,000+", selectionType: "INCLUDED" }],
+    ["10000+", { id: "I", text: "10,000+", selectionType: "INCLUDED" }],
+]);
+const SALES_NAVIGATOR_TENURE_VALUES = new Map([
+    [
+        "less than 1 year",
+        { id: "1", text: "Less than 1 year", selectionType: "INCLUDED" },
+    ],
+    [
+        "1 to 2 years",
+        { id: "2", text: "1 to 2 years", selectionType: "INCLUDED" },
+    ],
+    ["1-2 years", { id: "2", text: "1 to 2 years", selectionType: "INCLUDED" }],
+    [
+        "3 to 5 years",
+        { id: "3", text: "3 to 5 years", selectionType: "INCLUDED" },
+    ],
+    ["3-5 years", { id: "3", text: "3 to 5 years", selectionType: "INCLUDED" }],
+    [
+        "6 to 10 years",
+        { id: "4", text: "6 to 10 years", selectionType: "INCLUDED" },
+    ],
+    ["6-10 years", { id: "4", text: "6 to 10 years", selectionType: "INCLUDED" }],
+    [
+        "more than 10 years",
+        { id: "5", text: "More than 10 years", selectionType: "INCLUDED" },
+    ],
+    [
+        "10+ years",
+        { id: "5", text: "More than 10 years", selectionType: "INCLUDED" },
+    ],
+]);
+const SALES_NAVIGATOR_REGION_VALUES = new Map([
+    ["europe", { id: "100506914", text: "Europe", selectionType: "INCLUDED" }],
+    ["germany", { id: "101282230", text: "Germany", selectionType: "INCLUDED" }],
+]);
+const SALES_NAVIGATOR_INDUSTRY_VALUES = new Map([
+    [
+        "architecture and planning",
+        { id: "50", text: "Architecture and Planning", selectionType: "INCLUDED" },
+    ],
+    [
+        "machinery manufacturing",
+        { id: "55", text: "Machinery Manufacturing", selectionType: "INCLUDED" },
+    ],
+]);
+function normalizeLeadParameterKey(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function splitName(fullName) {
+    const parts = fullName.trim().split(/\s+/).filter(Boolean);
+    return {
+        firstName: parts[0] ?? "",
+        lastName: parts.slice(1).join(" "),
+    };
+}
+function buildGermanNameVariants(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const variants = new Set([trimmed]);
+    const replacements = [
+        [/ae/g, "ä"],
+        [/Ae/g, "Ä"],
+        [/oe/g, "ö"],
+        [/Oe/g, "Ö"],
+        [/ue/g, "ü"],
+        [/Ue/g, "Ü"],
+        [/ss/g, "ß"],
+    ];
+    let current = trimmed;
+    for (const [pattern, replacement] of replacements) {
+        current = current.replace(pattern, replacement);
+    }
+    variants.add(current);
+    return [...variants].filter((variant) => variant.length > 0);
+}
+function parseSalesNavigatorValueSpec(spec, lookup) {
+    const trimmed = spec.trim();
+    if (!trimmed) {
+        throw new Error("Filter value cannot be empty.");
+    }
+    const mapped = lookup?.get(normalizeLeadParameterKey(trimmed));
+    if (mapped) {
+        return { ...mapped };
+    }
+    const pipeIndex = trimmed.indexOf("|");
+    if (pipeIndex > 0 && trimmed.slice(pipeIndex + 1).trim()) {
+        return {
+            id: trimmed.slice(0, pipeIndex).trim(),
+            text: trimmed.slice(pipeIndex + 1).trim(),
+            selectionType: "INCLUDED",
+        };
+    }
+    const parts = trimmed.split(":");
+    if (parts.length >= 2 &&
+        parts[0]?.trim() &&
+        parts.slice(1).join(":").trim()) {
+        return {
+            id: parts[0]?.trim(),
+            text: parts.slice(1).join(":").trim(),
+            selectionType: "INCLUDED",
+        };
+    }
+    return {
+        text: trimmed,
+        selectionType: "INCLUDED",
+    };
+}
+function parseGenericLeadParameterFilter(spec) {
+    const separatorIndex = spec.indexOf(":");
+    if (separatorIndex <= 0) {
+        throw new Error(`Invalid --filter value "${spec}". Use TYPE:text or TYPE:id:text.`);
+    }
+    const type = spec.slice(0, separatorIndex).trim().toUpperCase();
+    const valueSpec = spec.slice(separatorIndex + 1).trim();
+    if (!type || !valueSpec) {
+        throw new Error(`Invalid --filter value "${spec}". Use TYPE:text or TYPE:id:text.`);
+    }
+    return {
+        type,
+        values: [parseSalesNavigatorValueSpec(valueSpec)],
+    };
+}
+function buildSingleValueLeadParameterFilter(type, value, lookup) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return {
+        type,
+        values: [parseSalesNavigatorValueSpec(trimmed, lookup)],
+    };
+}
+function appendSalesNavigatorKeywords(searchUrl, keywords) {
+    const trimmed = keywords?.trim();
+    if (!trimmed) {
+        return searchUrl;
+    }
+    const url = new URL(searchUrl);
+    const query = url.searchParams.get("query");
+    if (!query) {
+        return searchUrl;
+    }
+    const withoutClosingParen = query.endsWith(")") ? query.slice(0, -1) : query;
+    url.searchParams.set("query", `${withoutClosingParen},keywords:${trimmed})`);
+    return url.toString();
+}
+function buildLeadParameterSearchUrl(filters, keywords) {
+    const url = new URL(appendSalesNavigatorKeywords(buildSalesNavigatorPeopleSearchUrl(filters), keywords));
+    const query = url.searchParams.get("query");
+    if (query) {
+        const inner = query.startsWith("(") && query.endsWith(")") ? query.slice(1, -1) : query;
+        url.searchParams.set("query", `(spellCorrectionEnabled:true,recentSearchParam:(id:${Date.now()},doLogHistory:true),${inner})`);
+    }
+    url.searchParams.set("sessionId", generateLinkedInSessionId());
+    url.searchParams.set("viewAllFilters", "true");
+    return url.toString();
+}
+function normalizeGermanNameForMatch(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/ä/g, "ae")
+        .replace(/ö/g, "oe")
+        .replace(/ü/g, "ue")
+        .replace(/ß/g, "ss")
+        .replace(/\s+/g, " ");
+}
+function contactMatchesLocalLead(person, target) {
+    const fullName = normalizeGermanNameForMatch(String(person.fullName ?? ""));
+    const firstName = target.firstName
+        ? normalizeGermanNameForMatch(target.firstName)
+        : null;
+    const lastName = target.lastName
+        ? normalizeGermanNameForMatch(target.lastName)
+        : null;
+    const company = target.company?.trim().toLowerCase();
+    const personCompany = String(person.companyName ?? "").toLowerCase();
+    if (firstName && !fullName.includes(firstName)) {
+        return false;
+    }
+    if (lastName && !fullName.includes(lastName)) {
+        return false;
+    }
+    if (company && personCompany && !personCompany.includes(company)) {
+        return false;
+    }
+    return true;
+}
+function summarizeMatchedLeadParameterResult(person) {
+    if (!person) {
+        return null;
+    }
+    return {
+        fullName: typeof person.fullName === "string" ? person.fullName : null,
+        title: typeof person.title === "string" ? person.title : null,
+        companyName: typeof person.companyName === "string" ? person.companyName : null,
+        profileUrl: typeof person.profileUrl === "string" ? person.profileUrl : null,
+        linkedInProfileUrl: typeof person.linkedInProfileUrl === "string"
+            ? person.linkedInProfileUrl
+            : null,
     };
 }
 function withSalesNavigatorPaging(url, start, count) {
@@ -5910,9 +6435,7 @@ function withSalesNavigatorPaging(url, start, count) {
     }
     const base = withoutHash.slice(0, queryIndex);
     const search = withoutHash.slice(queryIndex + 1);
-    const params = search
-        .split("&")
-        .filter((part) => {
+    const params = search.split("&").filter((part) => {
         const key = part.split("=", 1)[0]?.toLowerCase();
         return key !== "start" && key !== "count";
     });
@@ -5926,13 +6449,28 @@ function buildLinkedInSalesNavigatorLocalImportHeaders(config) {
         cookie: config.cookie,
         "user-agent": config.userAgent,
         "x-li-identity": config.identity,
-        "x-restli-protocol-version": "2.0.0"
+        "x-restli-protocol-version": "2.0.0",
+    };
+}
+function buildLinkedInSalesNavigatorAccountSearchHeaders(config) {
+    return {
+        ...buildLinkedInSalesNavigatorLocalImportHeaders(config),
+        accept: "*/*",
+        "accept-language": "en-GB,en-US;q=0.9,en;q=0.8",
+        referer: "https://www.linkedin.com/sales/search/company",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        "x-li-lang": "en_US",
+        "x-li-page-instance": "urn:li:page:d_sales2_search_accounts;13Jvve6kRGCao+iP0wwAag==",
     };
 }
 function getNestedValue(record, pathParts) {
     let current = record;
     for (const part of pathParts) {
-        if (typeof current !== "object" || current === null || Array.isArray(current)) {
+        if (typeof current !== "object" ||
+            current === null ||
+            Array.isArray(current)) {
             return undefined;
         }
         current = current[part];
@@ -5953,8 +6491,14 @@ function flattenSalesNavigatorRecord(value) {
         return {};
     }
     const record = value;
-    const entity = (record.entityResult ?? record.lead ?? record.profile ?? record.person ?? record);
-    return typeof entity === "object" && entity !== null && !Array.isArray(entity) ? { ...record, ...entity } : record;
+    const entity = (record.entityResult ??
+        record.lead ??
+        record.profile ??
+        record.person ??
+        record);
+    return typeof entity === "object" && entity !== null && !Array.isArray(entity)
+        ? { ...record, ...entity }
+        : record;
 }
 function deriveLocalSalesNavigatorProfileUrl(record) {
     const direct = firstLocalString(record, [
@@ -5963,7 +6507,7 @@ function deriveLocalSalesNavigatorProfileUrl(record) {
         "linkedInProfileUrl",
         "navigationUrl",
         "url",
-        "profilePicture.profileUrl"
+        "profilePicture.profileUrl",
     ]);
     if (direct) {
         try {
@@ -5978,14 +6522,23 @@ function deriveLocalSalesNavigatorProfileUrl(record) {
         "publicIdentifier",
         "public_id",
         "miniProfile.publicIdentifier",
-        "member.publicIdentifier"
+        "member.publicIdentifier",
     ]);
     if (publicIdentifier) {
         return `https://www.linkedin.com/in/${encodeURIComponent(publicIdentifier)}`;
     }
-    const urn = firstLocalString(record, ["entityUrn", "profileUrn", "objectUrn", "memberUrn", "urn"]);
-    const urnId = urn?.match(/fs_salesProfile:\(([^,)]+)/i)?.[1] ?? urn?.match(/(?:profile|member|lead):([^,)]+)/i)?.[1];
-    return urnId ? `https://www.linkedin.com/sales/lead/${encodeURIComponent(urnId)}` : null;
+    const urn = firstLocalString(record, [
+        "entityUrn",
+        "profileUrn",
+        "objectUrn",
+        "memberUrn",
+        "urn",
+    ]);
+    const urnId = urn?.match(/fs_salesProfile:\(([^,)]+)/i)?.[1] ??
+        urn?.match(/(?:profile|member|lead):([^,)]+)/i)?.[1];
+    return urnId
+        ? `https://www.linkedin.com/sales/lead/${encodeURIComponent(urnId)}`
+        : null;
 }
 function firstLocalArrayRecord(record, key) {
     const value = record[key];
@@ -5997,14 +6550,21 @@ function firstLocalArrayRecord(record, key) {
 }
 function firstLocalNestedRecord(record, key) {
     const value = record[key];
-    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
 }
 function deriveLocalCompanyId(record, currentPosition, company) {
-    const direct = firstLocalString(record, ["companyId", "currentCompanyId", "company.id"]);
+    const direct = firstLocalString(record, [
+        "companyId",
+        "currentCompanyId",
+        "company.id",
+    ]);
     if (direct) {
         return direct;
     }
-    const urn = firstLocalString(currentPosition, ["companyUrn"]) ?? firstLocalString(company, ["entityUrn"]);
+    const urn = firstLocalString(currentPosition, ["companyUrn"]) ??
+        firstLocalString(company, ["entityUrn"]);
     return urn?.match(/:(\d+)$/)?.[1] ?? null;
 }
 function formatSalesNavigatorTenure(value) {
@@ -6012,8 +6572,12 @@ function formatSalesNavigatorTenure(value) {
         return null;
     }
     const record = value;
-    const years = typeof record.numYears === "number" && Number.isFinite(record.numYears) ? `${record.numYears}y` : null;
-    const months = typeof record.numMonths === "number" && Number.isFinite(record.numMonths) ? `${record.numMonths}m` : null;
+    const years = typeof record.numYears === "number" && Number.isFinite(record.numYears)
+        ? `${record.numYears}y`
+        : null;
+    const months = typeof record.numMonths === "number" && Number.isFinite(record.numMonths)
+        ? `${record.numMonths}m`
+        : null;
     return [years, months].filter(Boolean).join(" ") || null;
 }
 function buildLinkedInImageUrl(value) {
@@ -6028,16 +6592,22 @@ function buildLinkedInImageUrl(value) {
     const artifact = record.artifacts
         .filter((item) => typeof item === "object" && item !== null && !Array.isArray(item))
         .sort((left, right) => Number(right.width ?? 0) - Number(left.width ?? 0))[0];
-    const pathSegment = typeof artifact?.fileIdentifyingUrlPathSegment === "string" ? artifact.fileIdentifyingUrlPathSegment : null;
+    const pathSegment = typeof artifact?.fileIdentifyingUrlPathSegment === "string"
+        ? artifact.fileIdentifyingUrlPathSegment
+        : null;
     return pathSegment ? `${rootUrl}${pathSegment}` : null;
 }
 function deriveSharedConnectionsCount(record) {
-    const badges = Array.isArray(record.spotlightBadges) ? record.spotlightBadges : [];
+    const badges = Array.isArray(record.spotlightBadges)
+        ? record.spotlightBadges
+        : [];
     for (const badge of badges) {
         if (typeof badge !== "object" || badge === null || Array.isArray(badge)) {
             continue;
         }
-        const displayValue = firstLocalString(badge, ["displayValue"]);
+        const displayValue = firstLocalString(badge, [
+            "displayValue",
+        ]);
         const match = displayValue?.match(/(\d+)\s+mutual connection/i);
         if (match) {
             return Number(match[1]);
@@ -6051,13 +6621,19 @@ function deriveLocalSalesNavigatorFullName(record) {
         "name",
         "title.text",
         "profileName",
-        "miniProfile.fullName"
+        "miniProfile.fullName",
     ]);
     if (direct) {
         return direct;
     }
-    const firstName = firstLocalString(record, ["firstName", "miniProfile.firstName"]);
-    const lastName = firstLocalString(record, ["lastName", "miniProfile.lastName"]);
+    const firstName = firstLocalString(record, [
+        "firstName",
+        "miniProfile.firstName",
+    ]);
+    const lastName = firstLocalString(record, [
+        "lastName",
+        "miniProfile.lastName",
+    ]);
     return [firstName, lastName].filter(Boolean).join(" ").trim() || null;
 }
 function collectPotentialSalesNavigatorRows(value, rows = []) {
@@ -6073,7 +6649,12 @@ function collectPotentialSalesNavigatorRows(value, rows = []) {
     const record = flattenSalesNavigatorRecord(value);
     if (deriveLocalSalesNavigatorProfileUrl(record) &&
         (deriveLocalSalesNavigatorFullName(record) ||
-            firstLocalString(record, ["occupation", "title", "headline", "currentPositions.0.title"]))) {
+            firstLocalString(record, [
+                "occupation",
+                "title",
+                "headline",
+                "currentPositions.0.title",
+            ]))) {
         rows.push(record);
     }
     for (const nested of Object.values(value)) {
@@ -6101,44 +6682,75 @@ function normalizeLocalSalesNavigatorPeople(responseBody, queryUrl) {
             defaultProfileUrl: profileUrl,
             linkedInProfileUrl: profileUrl.includes("/in/") ? profileUrl : null,
             fullName,
-            firstName: firstLocalString(record, ["firstName", "miniProfile.firstName"]),
+            firstName: firstLocalString(record, [
+                "firstName",
+                "miniProfile.firstName",
+            ]),
             lastName: firstLocalString(record, ["lastName", "miniProfile.lastName"]),
-            title: firstLocalString(record, ["occupation", "title", "headline"]) ?? firstLocalString(currentPosition, ["title"]),
-            companyName: firstLocalString(record, [
-                "companyName",
-                "currentCompanyName"
-            ]) ?? firstLocalString(currentPosition, ["companyName"]) ?? firstLocalString(company, ["name"]),
+            title: firstLocalString(record, ["occupation", "title", "headline"]) ??
+                firstLocalString(currentPosition, ["title"]),
+            companyName: firstLocalString(record, ["companyName", "currentCompanyName"]) ??
+                firstLocalString(currentPosition, ["companyName"]) ??
+                firstLocalString(company, ["name"]),
             companyId,
-            companyUrl: firstLocalString(record, ["companyUrl", "company.url"]) ?? (companyId ? `https://www.linkedin.com/sales/company/${companyId}` : null),
-            regularCompanyUrl: companyId ? `https://www.linkedin.com/company/${companyId}` : null,
-            location: firstLocalString(record, ["location", "geoRegion", "locationName"]),
-            industry: firstLocalString(record, ["industry"]) ?? firstLocalString(company, ["industry"]),
+            companyUrl: firstLocalString(record, ["companyUrl", "company.url"]) ??
+                (companyId
+                    ? `https://www.linkedin.com/sales/company/${companyId}`
+                    : null),
+            regularCompanyUrl: companyId
+                ? `https://www.linkedin.com/company/${companyId}`
+                : null,
+            location: firstLocalString(record, [
+                "location",
+                "geoRegion",
+                "locationName",
+            ]),
+            industry: firstLocalString(record, ["industry"]) ??
+                firstLocalString(company, ["industry"]),
             summary: firstLocalString(record, ["summary", "description"]),
-            titleDescription: firstLocalString(record, ["titleDescription"]) ?? firstLocalString(currentPosition, ["description"]),
-            companyLocation: firstLocalString(record, ["companyLocation"]) ?? firstLocalString(company, ["location"]),
-            durationInRole: firstLocalString(record, ["durationInRole"]) ?? formatSalesNavigatorTenure(currentPosition.tenureAtPosition),
-            durationInCompany: firstLocalString(record, ["durationInCompany"]) ?? formatSalesNavigatorTenure(currentPosition.tenureAtCompany),
-            connectionDegree: firstLocalString(record, ["connectionDegree"]) ?? (record.degree != null ? String(record.degree) : null),
+            titleDescription: firstLocalString(record, ["titleDescription"]) ??
+                firstLocalString(currentPosition, ["description"]),
+            companyLocation: firstLocalString(record, ["companyLocation"]) ??
+                firstLocalString(company, ["location"]),
+            durationInRole: firstLocalString(record, ["durationInRole"]) ??
+                formatSalesNavigatorTenure(currentPosition.tenureAtPosition),
+            durationInCompany: firstLocalString(record, ["durationInCompany"]) ??
+                formatSalesNavigatorTenure(currentPosition.tenureAtCompany),
+            connectionDegree: firstLocalString(record, ["connectionDegree"]) ??
+                (record.degree != null ? String(record.degree) : null),
             sharedConnectionsCount: deriveSharedConnectionsCount(record),
-            profileImageUrl: firstLocalString(record, ["profileImageUrl", "pictureUrl", "profilePicture.displayImage"]) ?? buildLinkedInImageUrl(record.profilePictureDisplayImage),
+            profileImageUrl: firstLocalString(record, [
+                "profileImageUrl",
+                "pictureUrl",
+                "profilePicture.displayImage",
+            ]) ?? buildLinkedInImageUrl(record.profilePictureDisplayImage),
             vmid: firstLocalString(record, ["vmid", "memberId", "profileId"]),
             isPremium: typeof record.premium === "boolean" ? record.premium : null,
             isOpenLink: typeof record.openLink === "boolean" ? record.openLink : null,
             query: queryUrl,
             timestamp: new Date().toISOString(),
-            rawLocalSalesNavigatorResult: record
+            rawLocalSalesNavigatorResult: record,
         });
     }
     return rows;
 }
 function extractLocalSalesNavigatorTotalResults(responseBody) {
-    if (typeof responseBody !== "object" || responseBody === null || Array.isArray(responseBody)) {
+    if (typeof responseBody !== "object" ||
+        responseBody === null ||
+        Array.isArray(responseBody)) {
         return null;
     }
     const record = responseBody;
-    const candidates = [record.paging, record.metadata, record.searchResultsMetadata, record];
+    const candidates = [
+        record.paging,
+        record.metadata,
+        record.searchResultsMetadata,
+        record,
+    ];
     for (const candidate of candidates) {
-        if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) {
+        if (typeof candidate !== "object" ||
+            candidate === null ||
+            Array.isArray(candidate)) {
             continue;
         }
         for (const key of ["total", "totalResults", "resultCount", "count"]) {
@@ -6161,7 +6773,27 @@ function isSalesNavigatorRateLimitStatus(status, text) {
         /too many requests|rate limit|unusual activity|automated activity|temporarily restricted/i.test(text));
 }
 function isRetryableLocalSalesNavigatorStatus(status) {
-    return status === 408 || status === 425 || status === 500 || status === 502 || status === 503 || status === 504;
+    return (status === 408 ||
+        status === 425 ||
+        status === 500 ||
+        status === 502 ||
+        status === 503 ||
+        status === 504);
+}
+function parseRetryAfterHeader(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const seconds = Number(trimmed);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return Math.trunc(seconds * 1000);
+    }
+    const dateMs = Date.parse(trimmed);
+    if (Number.isFinite(dateMs)) {
+        return Math.max(0, dateMs - Date.now());
+    }
+    return null;
 }
 async function waitWithFullJitter(baseDelayMs, maxDelayMs, attempt) {
     const exponentialCap = Math.min(Math.max(0, Math.trunc(maxDelayMs)), Math.max(0, Math.trunc(baseDelayMs)) * 2 ** Math.max(0, attempt));
@@ -6178,15 +6810,16 @@ async function fetchLocalSalesNavigatorRequest(parsedRequest, retryOptions) {
         try {
             const response = await fetch(parsedRequest.url, {
                 method: "GET",
-                headers: parsedRequest.headers
+                headers: parsedRequest.headers,
             });
             const text = await response.text();
             if (!response.ok) {
                 const preview = text.slice(0, 300);
                 if (isSalesNavigatorRateLimitStatus(response.status, text)) {
-                    throw new LocalSalesNavigatorRateLimitError(response.status, preview);
+                    throw new LocalSalesNavigatorRateLimitError(response.status, preview, parseRetryAfterHeader(response.headers.get("retry-after")));
                 }
-                if (isRetryableLocalSalesNavigatorStatus(response.status) && attempt < retryOptions.maxRetries) {
+                if (isRetryableLocalSalesNavigatorStatus(response.status) &&
+                    attempt < retryOptions.maxRetries) {
                     retryCount += 1;
                     retryDelayMs += await waitWithFullJitter(retryOptions.retryBaseDelayMs, retryOptions.retryMaxDelayMs, attempt);
                     continue;
@@ -6221,7 +6854,9 @@ async function fetchAllLocalSalesNavigatorPeople(parsedRequest, options) {
     let totalDelayMs = 0;
     let retryCount = 0;
     const pageSize = Math.max(1, Math.min(100, Math.trunc(options.pageSize)));
-    const requestedProfiles = options.requestedProfiles == null ? null : Math.max(1, Math.trunc(options.requestedProfiles));
+    const requestedProfiles = options.requestedProfiles == null
+        ? null
+        : Math.max(1, Math.trunc(options.requestedProfiles));
     const pageDelayMinMs = Math.max(0, Math.trunc(options.pageDelayMinMs));
     const pageDelayMaxMs = Math.max(pageDelayMinMs, Math.trunc(options.pageDelayMaxMs));
     for (let start = 0;; start += pageSize) {
@@ -6232,14 +6867,15 @@ async function fetchAllLocalSalesNavigatorPeople(parsedRequest, options) {
         const currentCount = Math.min(pageSize, remainingRequested);
         const pageRequest = {
             ...parsedRequest,
-            url: withSalesNavigatorPaging(parsedRequest.url, start, currentCount)
+            url: withSalesNavigatorPaging(parsedRequest.url, start, currentCount),
         };
         const response = await fetchLocalSalesNavigatorRequest(pageRequest, options.retry);
         retryCount += response.retryCount;
         totalDelayMs += response.retryDelayMs;
         const responseBody = response.body;
         fetchedPages += 1;
-        totalResults = totalResults ?? extractLocalSalesNavigatorTotalResults(responseBody);
+        totalResults =
+            totalResults ?? extractLocalSalesNavigatorTotalResults(responseBody);
         const pagePeople = normalizeLocalSalesNavigatorPeople(responseBody, pageRequest.url);
         let added = 0;
         for (const person of pagePeople) {
@@ -6272,85 +6908,699 @@ async function fetchAllLocalSalesNavigatorPeople(parsedRequest, options) {
             delayMinMs: pageDelayMinMs,
             delayMaxMs: pageDelayMaxMs,
             totalDelayMs,
-            retryCount
-        }
-    };
-}
-async function importLocalSalesNavigatorPeopleViaApp(session, payload) {
-    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/local-import`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${currentSession.accessToken}`
+            retryCount,
         },
-        body: JSON.stringify({
-            sourceQueryUrl: payload.sourceQueryUrl,
-            slicedQueryUrl: payload.sourceQueryUrl,
-            appliedFilters: [],
-            maxResultsPerSearch: payload.maxResultsPerSearch,
-            numberOfProfiles: payload.numberOfProfiles,
-            slicePreset: payload.slicePreset,
-            totalResults: payload.totalResults,
-            fetchedPages: payload.fetchedPages,
-            people: payload.people,
-            rawPayload: {
-                workflow: "salesnav:local-import",
-                localPeopleCount: payload.people.length,
-                fetchedPages: payload.fetchedPages,
-                pacing: payload.pacing
-            }
-        })
-    }), SalesNavigatorLocalImportResponseSchema);
-    return value;
+    };
 }
-async function runLeadPoolAutoProcessViaApp(session, payload) {
-    const url = new URL('/api/leadpool/auto-process', session.apiBaseUrl);
-    if (payload.clientId)
-        url.searchParams.set('clientId', String(payload.clientId));
-    url.searchParams.set('companyLimit', String(payload.companyLimit));
-    url.searchParams.set('contactCountryLimit', String(payload.contactCountryLimit));
-    url.searchParams.set('contactNameLimit', String(payload.contactNameLimit));
-    url.searchParams.set('hunterLimit', String(payload.hunterLimit));
-    url.searchParams.set('hunterConcurrency', String(payload.hunterConcurrency));
-    url.searchParams.set('refresh', payload.refresh ? 'true' : 'false');
-    url.searchParams.set('qualifiedLeads', payload.qualifiedLeads ? 'true' : 'false');
-    const { value } = await fetchCliJson(session, (currentSession) => fetch(url.toString(), {
-        method: "POST",
-        headers: {
-            Authorization: `Bearer ${currentSession.accessToken}`
+async function fetchAllLocalSalesNavigatorAccounts(parsedRequest, options) {
+    const accounts = [];
+    const seen = new Set();
+    let totalResults = null;
+    let fetchedPages = 0;
+    let totalDelayMs = 0;
+    let retryCount = 0;
+    const pageSize = Math.max(1, Math.min(100, Math.trunc(options.pageSize)));
+    const requestedAccounts = options.requestedAccounts == null
+        ? null
+        : Math.max(1, Math.trunc(options.requestedAccounts));
+    const pageDelayMinMs = Math.max(0, Math.trunc(options.pageDelayMinMs));
+    const pageDelayMaxMs = Math.max(pageDelayMinMs, Math.trunc(options.pageDelayMaxMs));
+    const startOffset = Math.max(0, Math.trunc(options.startOffset ?? 0));
+    let rateLimit;
+    let pageError;
+    let stopReason = null;
+    let lastSuccessfulStart = null;
+    let lastSuccessfulCount = 0;
+    let lastSuccessfulAdded = 0;
+    let stoppedAtStart = null;
+    let stoppedAtCount = null;
+    let nextStart = null;
+    for (let start = startOffset;; start += pageSize) {
+        const remainingRequested = requestedAccounts == null ? pageSize : requestedAccounts - accounts.length;
+        if (remainingRequested <= 0) {
+            stopReason = "requested_limit_reached";
+            nextStart = start;
+            break;
         }
-    }), LeadPoolAutoProcessResponseSchema);
-    return value;
-}
-async function launchAffiliateCampaignViaApp(session, payload) {
-    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-campaigns`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${currentSession.accessToken}`
+        const currentCount = Math.min(pageSize, remainingRequested);
+        const pageRequest = {
+            ...parsedRequest,
+            url: withSalesNavigatorPaging(parsedRequest.url, start, currentCount),
+        };
+        let response;
+        try {
+            response = await fetchLocalSalesNavigatorRequest(pageRequest, options.retry);
+        }
+        catch (error) {
+            if (error instanceof LocalSalesNavigatorRateLimitError &&
+                accounts.length > 0) {
+                rateLimit = {
+                    status: error.status,
+                    retryAfterMs: error.retryAfterMs,
+                    message: error.message,
+                };
+                stopReason = "rate_limit";
+                stoppedAtStart = start;
+                stoppedAtCount = currentCount;
+                nextStart = start;
+                break;
+            }
+            if (options.allowPartialPageErrors && accounts.length > 0) {
+                pageError = {
+                    message: error instanceof Error ? error.message : String(error),
+                };
+                stopReason = "page_error";
+                stoppedAtStart = start;
+                stoppedAtCount = currentCount;
+                nextStart = start;
+                break;
+            }
+            throw error;
+        }
+        retryCount += response.retryCount;
+        totalDelayMs += response.retryDelayMs;
+        const responseBody = response.body;
+        fetchedPages += 1;
+        totalResults =
+            totalResults ?? extractLocalSalesNavigatorTotalResults(responseBody);
+        if (totalResults != null &&
+            totalResults > Math.max(1, Math.trunc(options.maxAllowedResults))) {
+            throw new SalesNavigatorSliceTooBroadError(`Account slice has ${totalResults} results, above ${options.maxAllowedResults}.`, { totalResults });
+        }
+        const pageAccounts = normalizeLocalSalesNavigatorAccounts(responseBody, pageRequest.url);
+        let added = 0;
+        for (const account of pageAccounts) {
+            if (seen.has(account.accountKey)) {
+                continue;
+            }
+            seen.add(account.accountKey);
+            accounts.push(account);
+            added += 1;
+            if (requestedAccounts != null && accounts.length >= requestedAccounts) {
+                break;
+            }
+        }
+        if (added > 0) {
+            lastSuccessfulStart = start;
+            lastSuccessfulCount = currentCount;
+            lastSuccessfulAdded = added;
+        }
+        if (requestedAccounts != null && accounts.length >= requestedAccounts) {
+            stopReason = "requested_limit_reached";
+            stoppedAtStart = start;
+            stoppedAtCount = currentCount;
+            nextStart = start + currentCount;
+            break;
+        }
+        const reportedTotalReached = totalResults != null && start + currentCount >= totalResults;
+        if (pageAccounts.length === 0) {
+            stopReason = "empty_page";
+            stoppedAtStart = start;
+            stoppedAtCount = currentCount;
+            nextStart = start;
+            break;
+        }
+        if (added === 0) {
+            stopReason = "duplicate_page";
+            stoppedAtStart = start;
+            stoppedAtCount = currentCount;
+            nextStart = start;
+            break;
+        }
+        if (reportedTotalReached) {
+            stopReason = "reported_total_reached";
+            stoppedAtStart = start;
+            stoppedAtCount = currentCount;
+            nextStart = start + currentCount;
+            break;
+        }
+        const pageDelayMs = randomIntegerBetween(pageDelayMinMs, pageDelayMaxMs);
+        if (pageDelayMs > 0) {
+            totalDelayMs += pageDelayMs;
+            await delay(pageDelayMs);
+        }
+    }
+    const fetchedThrough = nextStart ?? (lastSuccessfulStart == null ? startOffset : lastSuccessfulStart + lastSuccessfulCount);
+    const missingFromReported = totalResults == null ? null : Math.max(0, totalResults - fetchedThrough);
+    return {
+        accounts,
+        totalResults,
+        fetchedPages,
+        sourceQueryUrl: parsedRequest.url,
+        pacing: {
+            startOffset,
+            delayMinMs: pageDelayMinMs,
+            delayMaxMs: pageDelayMaxMs,
+            totalDelayMs,
+            retryCount,
+            ...(rateLimit ? { rateLimit } : {}),
+            ...(pageError ? { pageError } : {}),
+            stop: {
+                reason: stopReason ?? "reported_total_reached",
+                startOffset,
+                pageSize,
+                lastSuccessfulStart,
+                lastSuccessfulCount,
+                lastSuccessfulAdded,
+                stoppedAtStart,
+                stoppedAtCount,
+                nextStart,
+                fetchedAccounts: accounts.length,
+                reportedTotal: totalResults,
+                missingFromReported,
+            },
         },
-        body: JSON.stringify(payload)
-    }), AffiliateCampaignLaunchResponseSchema);
+    };
+}
+function describeLocalSalesNavigatorAccountPartialError(fetchResult) {
+    const rateLimit = fetchResult.pacing.rateLimit;
+    if (rateLimit) {
+        return rateLimit.message;
+    }
+    const pageError = fetchResult.pacing.pageError;
+    if (pageError) {
+        return pageError.message;
+    }
+    const stop = fetchResult.pacing.stop;
+    if (stop.reason === "requested_limit_reached") {
+        return null;
+    }
+    if (stop.missingFromReported != null && stop.missingFromReported > 0) {
+        return `Account slice stopped at offset ${stop.stoppedAtStart ?? stop.nextStart ?? "unknown"} (${stop.reason}) after fetching ${stop.fetchedAccounts} of ${stop.reportedTotal} reported accounts.`;
+    }
+    return null;
+}
+async function importLocalSalesNavigatorPeopleViaApp(session, payload) {
+    const { value } = await fetchCliJson(session, (currentSession) => {
+        const workspaceClientId = currentSession.user.workspaceClientId?.trim() || null;
+        return fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/local-import`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${currentSession.accessToken}`,
+            },
+            body: JSON.stringify({
+                sourceQueryUrl: payload.sourceQueryUrl,
+                slicedQueryUrl: payload.sourceQueryUrl,
+                appliedFilters: [],
+                maxResultsPerSearch: payload.maxResultsPerSearch,
+                numberOfProfiles: payload.numberOfProfiles,
+                slicePreset: payload.slicePreset,
+                totalResults: payload.totalResults,
+                fetchedPages: payload.fetchedPages,
+                people: payload.people,
+                rawPayload: {
+                    clientId: workspaceClientId ?? undefined,
+                    client_id: workspaceClientId ?? undefined,
+                    leadList: workspaceClientId
+                        ? { clientId: workspaceClientId }
+                        : undefined,
+                    workflow: "salesnav:local-import",
+                    localPeopleCount: payload.people.length,
+                    fetchedPages: payload.fetchedPages,
+                    pacing: payload.pacing,
+                },
+            }),
+        });
+    }, SalesNavigatorLocalImportResponseSchema);
     return value;
 }
-async function runLeadPoolEmailFinderViaApp(session, payload) {
-    const url = new URL('/api/leadpool/process-hunter-emails', session.apiBaseUrl);
-    url.searchParams.set('provider', payload.provider);
-    url.searchParams.set('limit', String(payload.limit));
-    if (payload.concurrency != null) {
-        url.searchParams.set('concurrency', String(payload.concurrency));
+async function createSalesNavigatorAccountSearchStore() {
+    const databaseUrl = process.env.SALESPROMPTER_DATABASE_URL?.trim() ||
+        process.env.DATABASE_URL?.trim() ||
+        "";
+    if (databaseUrl) {
+        const client = new pg.Client({
+            connectionString: databaseUrl,
+            ssl: { rejectUnauthorized: false },
+        });
+        await client.connect();
+        return { kind: "postgres", client };
+    }
+    const config = resolveSalesNavigatorSupabaseConfig(process.env);
+    return {
+        kind: "supabase",
+        client: createClient(config.supabaseUrl, config.supabaseServiceRoleKey, {
+            auth: {
+                persistSession: false,
+                autoRefreshToken: false,
+            },
+        }),
+    };
+}
+async function closeSalesNavigatorAccountSearchStore(store) {
+    if (store.kind === "postgres") {
+        await store.client.end();
+    }
+}
+async function createSalesNavigatorAccountSearchRun(params) {
+    if (params.store.kind === "postgres") {
+        const result = await params.store.client.query(`INSERT INTO public.linkedin_sales_nav_account_search_runs (
+        org_id, source_query_url, slice_preset, max_results_per_search, page_size, status, raw_payload
+      )
+      VALUES ($1, $2, $3, $4, $5, 'running', $6::jsonb)
+      RETURNING id`, [
+            params.orgId,
+            params.sourceQueryUrl,
+            params.slicePreset,
+            params.maxResultsPerSearch,
+            params.pageSize,
+            JSON.stringify(params.rawPayload),
+        ]);
+        const id = result.rows[0]?.id ?? "";
+        if (!id) {
+            throw new Error("Failed to create account search run in Neon: missing run id.");
+        }
+        return id;
+    }
+    const { data, error } = await params.store.client
+        .from("linkedin_sales_nav_account_search_runs")
+        .insert({
+        org_id: params.orgId,
+        source_query_url: params.sourceQueryUrl,
+        slice_preset: params.slicePreset,
+        max_results_per_search: params.maxResultsPerSearch,
+        page_size: params.pageSize,
+        status: "running",
+        raw_payload: params.rawPayload,
+    })
+        .select("id")
+        .single();
+    if (error) {
+        throw new Error(`Failed to create account search run in Neon: ${error.message}`);
+    }
+    const id = typeof data?.id === "string" ? data.id : "";
+    if (!id) {
+        throw new Error("Failed to create account search run in Neon: missing run id.");
+    }
+    return id;
+}
+async function updateSalesNavigatorAccountSearchRun(params) {
+    if (params.store.kind === "postgres") {
+        await params.store.client.query(`UPDATE public.linkedin_sales_nav_account_search_runs
+      SET status = $2,
+          total_slices = $3,
+          stored_accounts = $4,
+          attempted_slices = $5,
+          split_events = $6,
+          failed_slices = $7,
+          unresolved_slices = $8,
+          truncated = $9,
+          finished_at = now(),
+          last_error = $10,
+          raw_payload = CASE
+            WHEN $11::jsonb IS NULL THEN raw_payload
+            ELSE COALESCE(raw_payload, '{}'::jsonb) || $11::jsonb
+          END
+      WHERE id = $1`, [
+            params.runId,
+            params.status,
+            params.totalSlices,
+            params.storedAccounts,
+            params.attemptedSlices,
+            params.splitEvents,
+            params.failedSlices,
+            params.unresolvedSlices,
+            params.truncated,
+            params.lastError ?? null,
+            params.rawPayload ? JSON.stringify(params.rawPayload) : null,
+        ]);
+        return;
     }
-    if (payload.retryNotFoundAfterDays != null) {
-        url.searchParams.set('retryNotFoundAfterDays', String(payload.retryNotFoundAfterDays));
+    let mergedRawPayload = null;
+    if (params.rawPayload) {
+        const { data: existing, error: selectError } = await params.store.client
+            .from("linkedin_sales_nav_account_search_runs")
+            .select("raw_payload")
+            .eq("id", params.runId)
+            .maybeSingle();
+        if (selectError) {
+            throw new Error(`Failed to read account search run payload in Neon: ${selectError.message}`);
+        }
+        const existingPayload = typeof existing?.raw_payload === "object" &&
+            existing.raw_payload !== null &&
+            !Array.isArray(existing.raw_payload)
+            ? existing.raw_payload
+            : {};
+        mergedRawPayload = {
+            ...existingPayload,
+            ...params.rawPayload,
+        };
     }
-    const { value } = await fetchCliJson(session, (currentSession) => fetch(url.toString(), {
-        method: "POST",
-        headers: {
-            Authorization: `Bearer ${currentSession.accessToken}`
+    const { error } = await params.store.client
+        .from("linkedin_sales_nav_account_search_runs")
+        .update({
+        status: params.status,
+        total_slices: params.totalSlices,
+        stored_accounts: params.storedAccounts,
+        attempted_slices: params.attemptedSlices,
+        split_events: params.splitEvents,
+        failed_slices: params.failedSlices,
+        unresolved_slices: params.unresolvedSlices,
+        truncated: params.truncated,
+        finished_at: new Date().toISOString(),
+        last_error: params.lastError ?? null,
+        ...(mergedRawPayload
+            ? {
+                raw_payload: mergedRawPayload,
+            }
+            : {}),
+    })
+        .eq("id", params.runId);
+    if (error) {
+        throw new Error(`Failed to update account search run in Neon: ${error.message}`);
+    }
+}
+async function upsertSalesNavigatorAccountSearchSlice(params) {
+    if (params.store.kind === "postgres") {
+        const result = await params.store.client.query(`INSERT INTO public.linkedin_sales_nav_account_search_slices (
+        run_id, org_id, sliced_query_url, applied_filters, split_trail, depth, status,
+        total_results, fetched_pages, stored_accounts, retry_count, retry_delay_ms, last_error, raw_payload
+      )
+      VALUES ($1, $2, $3, $4::jsonb, $5::jsonb, $6, $7, $8, $9, $10, $11, $12, $13, $14::jsonb)
+      ON CONFLICT (run_id, sliced_query_url)
+      DO UPDATE SET
+        applied_filters = excluded.applied_filters,
+        split_trail = excluded.split_trail,
+        depth = excluded.depth,
+        status = excluded.status,
+        total_results = excluded.total_results,
+        fetched_pages = excluded.fetched_pages,
+        stored_accounts = excluded.stored_accounts,
+        retry_count = excluded.retry_count,
+        retry_delay_ms = excluded.retry_delay_ms,
+        last_error = excluded.last_error,
+        raw_payload = excluded.raw_payload
+      RETURNING id`, [
+            params.runId,
+            params.orgId,
+            params.attempt.slicedQueryUrl,
+            JSON.stringify(params.attempt.appliedFilters),
+            JSON.stringify(params.attempt.splitTrail),
+            params.attempt.depth,
+            params.status,
+            params.totalResults,
+            params.fetchedPages,
+            params.storedAccounts,
+            params.retryCount,
+            params.retryDelayMs,
+            params.lastError ?? null,
+            JSON.stringify(params.rawPayload),
+        ]);
+        const id = result.rows[0]?.id ?? "";
+        if (!id) {
+            throw new Error("Failed to upsert account search slice in Neon: missing slice id.");
+        }
+        return id;
+    }
+    const { data, error } = await params.store.client
+        .from("linkedin_sales_nav_account_search_slices")
+        .upsert({
+        run_id: params.runId,
+        org_id: params.orgId,
+        sliced_query_url: params.attempt.slicedQueryUrl,
+        applied_filters: params.attempt.appliedFilters,
+        split_trail: params.attempt.splitTrail,
+        depth: params.attempt.depth,
+        status: params.status,
+        total_results: params.totalResults,
+        fetched_pages: params.fetchedPages,
+        stored_accounts: params.storedAccounts,
+        retry_count: params.retryCount,
+        retry_delay_ms: params.retryDelayMs,
+        last_error: params.lastError ?? null,
+        raw_payload: params.rawPayload,
+    }, { onConflict: "run_id,sliced_query_url" })
+        .select("id")
+        .single();
+    if (error) {
+        throw new Error(`Failed to upsert account search slice in Neon: ${error.message}`);
+    }
+    const id = typeof data?.id === "string" ? data.id : "";
+    if (!id) {
+        throw new Error("Failed to upsert account search slice in Neon: missing slice id.");
+    }
+    return id;
+}
+function stripPostgresUnsafeStringBytes(value) {
+    return value.replace(/\u0000/g, "");
+}
+function sanitizeForPostgresJson(value) {
+    if (typeof value === "string") {
+        return stripPostgresUnsafeStringBytes(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeForPostgresJson(item));
+    }
+    if (typeof value === "object" && value !== null) {
+        const sanitized = {};
+        for (const [key, nested] of Object.entries(value)) {
+            sanitized[stripPostgresUnsafeStringBytes(key)] =
+                sanitizeForPostgresJson(nested);
         }
-    }), LeadPoolEmailFinderProcessResponseSchema);
+        return sanitized;
+    }
     return value;
 }
+function sanitizeOptionalPostgresText(value) {
+    return typeof value === "string" ? stripPostgresUnsafeStringBytes(value) : null;
+}
+async function upsertSalesNavigatorAccounts(params) {
+    if (params.accounts.length === 0) {
+        return 0;
+    }
+    const rows = params.accounts.map((account) => ({
+        org_id: params.orgId,
+        last_run_id: params.runId,
+        last_slice_id: params.sliceId,
+        account_key: stripPostgresUnsafeStringBytes(account.accountKey),
+        sales_nav_company_url: sanitizeOptionalPostgresText(account.salesNavCompanyUrl),
+        linkedin_company_url: sanitizeOptionalPostgresText(account.linkedinCompanyUrl),
+        company_id: sanitizeOptionalPostgresText(account.companyId),
+        company_name: sanitizeOptionalPostgresText(account.companyName),
+        industry: sanitizeOptionalPostgresText(account.industry),
+        location: sanitizeOptionalPostgresText(account.location),
+        headquarters: sanitizeOptionalPostgresText(account.headquarters),
+        employee_count: typeof account.employeeCount === "number" ? account.employeeCount : null,
+        follower_count: typeof account.followerCount === "number" ? account.followerCount : null,
+        company_type: sanitizeOptionalPostgresText(account.companyType),
+        description: sanitizeOptionalPostgresText(account.description),
+        website: sanitizeOptionalPostgresText(account.website),
+        search_query_url: sanitizeOptionalPostgresText(account.searchQueryUrl),
+        scraped_at: typeof account.scrapedAt === "string"
+            ? stripPostgresUnsafeStringBytes(account.scrapedAt)
+            : new Date().toISOString(),
+        raw_payload: sanitizeForPostgresJson(typeof account.rawLocalSalesNavigatorAccountResult === "object" &&
+            account.rawLocalSalesNavigatorAccountResult !== null
+            ? account.rawLocalSalesNavigatorAccountResult
+            : account),
+    }));
+    if (params.store.kind === "postgres") {
+        for (const row of rows) {
+            await params.store.client.query(`INSERT INTO public.linkedin_sales_nav_accounts (
+          org_id, last_run_id, last_slice_id, account_key, sales_nav_company_url,
+          linkedin_company_url, company_id, company_name, industry, location, headquarters,
+          employee_count, follower_count, company_type, description, website, search_query_url,
+          scraped_at, raw_payload
+        )
+        VALUES (
+          $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16,
+          $17, $18, $19::jsonb
+        )
+        ON CONFLICT (org_id, account_key)
+        DO UPDATE SET
+          last_run_id = excluded.last_run_id,
+          last_slice_id = excluded.last_slice_id,
+          sales_nav_company_url = excluded.sales_nav_company_url,
+          linkedin_company_url = excluded.linkedin_company_url,
+          company_id = excluded.company_id,
+          company_name = excluded.company_name,
+          industry = excluded.industry,
+          location = excluded.location,
+          headquarters = excluded.headquarters,
+          employee_count = excluded.employee_count,
+          follower_count = excluded.follower_count,
+          company_type = excluded.company_type,
+          description = excluded.description,
+          website = excluded.website,
+          search_query_url = excluded.search_query_url,
+          scraped_at = excluded.scraped_at,
+          raw_payload = excluded.raw_payload`, [
+                row.org_id,
+                row.last_run_id,
+                row.last_slice_id,
+                row.account_key,
+                row.sales_nav_company_url,
+                row.linkedin_company_url,
+                row.company_id,
+                row.company_name,
+                row.industry,
+                row.location,
+                row.headquarters,
+                row.employee_count,
+                row.follower_count,
+                row.company_type,
+                row.description,
+                row.website,
+                row.search_query_url,
+                row.scraped_at,
+                JSON.stringify(row.raw_payload),
+            ]);
+        }
+        return rows.length;
+    }
+    const { error } = await params.store.client
+        .from("linkedin_sales_nav_accounts")
+        .upsert(rows, { onConflict: "org_id,account_key" });
+    if (error) {
+        throw new Error(`Failed to upsert Sales Navigator accounts in Neon: ${error.message}`);
+    }
+    return rows.length;
+}
+function asJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+function asJsonArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asOptionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function resolveAccountRepairStartOffset(slice) {
+    const rawPayload = asJsonObject(slice.rawPayload);
+    const stop = asJsonObject(rawPayload.stop ?? asJsonObject(rawPayload.pacing).stop);
+    const nextStart = asOptionalNumber(stop.nextStart) ??
+        asOptionalNumber(stop.stoppedAtStart);
+    if (nextStart != null) {
+        return Math.max(0, Math.trunc(nextStart));
+    }
+    return Math.max(0, Math.trunc(slice.storedAccounts));
+}
+function repairSliceToCrawlAttempt(slice) {
+    return {
+        sourceQueryUrl: slice.sourceQueryUrl,
+        slicedQueryUrl: slice.slicedQueryUrl,
+        appliedFilters: slice.appliedFilters,
+        depth: slice.depth,
+        retryCount: slice.retryCount,
+        maxResultsPerSearch: slice.maxResultsPerSearch,
+        numberOfProfiles: slice.pageSize,
+        slicePreset: slice.slicePreset,
+        splitTrail: slice.splitTrail,
+    };
+}
+async function listSalesNavigatorAccountSearchRepairSlices(params) {
+    if (params.store.kind !== "postgres") {
+        throw new Error("Account run repair requires direct Postgres access. Set DATABASE_URL or SALESPROMPTER_DATABASE_URL.");
+    }
+    const result = await params.store.client.query(`SELECT
+        slices.id::text,
+        slices.org_id,
+        slices.run_id::text,
+        runs.source_query_url,
+        slices.sliced_query_url,
+        slices.applied_filters,
+        slices.split_trail,
+        slices.depth,
+        slices.status,
+        slices.total_results,
+        slices.fetched_pages,
+        slices.stored_accounts,
+        slices.retry_count,
+        slices.retry_delay_ms,
+        slices.last_error,
+        slices.raw_payload,
+        runs.slice_preset,
+        runs.max_results_per_search,
+        runs.page_size
+      FROM public.linkedin_sales_nav_account_search_slices AS slices
+      INNER JOIN public.linkedin_sales_nav_account_search_runs AS runs
+        ON runs.id = slices.run_id
+      WHERE slices.run_id = $1
+        AND slices.status IN ('failed', 'unresolved')
+      ORDER BY
+        CASE WHEN slices.stored_accounts > 0 THEN 0 ELSE 1 END,
+        slices.depth ASC,
+        slices.updated_at ASC
+      LIMIT $2`, [params.runId, params.limit]);
+    return result.rows.map((row) => ({
+        id: String(row.id),
+        orgId: String(row.org_id),
+        runId: String(row.run_id),
+        sourceQueryUrl: String(row.source_query_url ?? row.sliced_query_url),
+        slicedQueryUrl: String(row.sliced_query_url),
+        appliedFilters: asJsonArray(row.applied_filters),
+        splitTrail: asJsonArray(row.split_trail),
+        depth: Number(row.depth ?? 0),
+        status: row.status === "unresolved" ? "unresolved" : "failed",
+        totalResults: typeof row.total_results === "number" ? row.total_results : null,
+        fetchedPages: Number(row.fetched_pages ?? 0),
+        storedAccounts: Number(row.stored_accounts ?? 0),
+        retryCount: Number(row.retry_count ?? 0),
+        retryDelayMs: Number(row.retry_delay_ms ?? 0),
+        lastError: typeof row.last_error === "string" ? row.last_error : null,
+        rawPayload: asJsonObject(row.raw_payload),
+        slicePreset: String(row.slice_preset ?? "account-search-split"),
+        maxResultsPerSearch: Number(row.max_results_per_search ?? 1000),
+        pageSize: Number(row.page_size ?? 25),
+    }));
+}
+async function summarizeSalesNavigatorAccountSearchRunFromSlices(params) {
+    if (params.store.kind !== "postgres") {
+        throw new Error("Account run summary requires direct Postgres access. Set DATABASE_URL or SALESPROMPTER_DATABASE_URL.");
+    }
+    const result = await params.store.client.query(`SELECT
+        count(*) FILTER (WHERE status <> 'split')::int AS total_slices,
+        COALESCE(sum(stored_accounts) FILTER (WHERE status <> 'split'), 0)::int AS stored_accounts,
+        count(*) FILTER (WHERE status <> 'split')::int AS attempted_slices,
+        count(*) FILTER (WHERE status = 'split')::int AS split_events,
+        count(*) FILTER (WHERE status = 'failed')::int AS failed_slices,
+        count(*) FILTER (WHERE status = 'unresolved')::int AS unresolved_slices,
+        (
+          SELECT last_error
+          FROM public.linkedin_sales_nav_account_search_slices
+          WHERE run_id = $1
+            AND status IN ('failed', 'unresolved')
+          ORDER BY updated_at DESC
+          LIMIT 1
+        ) AS last_error
+      FROM public.linkedin_sales_nav_account_search_slices
+      WHERE run_id = $1`, [params.runId]);
+    const row = result.rows[0] ?? {};
+    const failedSlices = Number(row.failed_slices ?? 0);
+    const unresolvedSlices = Number(row.unresolved_slices ?? 0);
+    return {
+        totalSlices: Number(row.total_slices ?? 0),
+        storedAccounts: Number(row.stored_accounts ?? 0),
+        attemptedSlices: Number(row.attempted_slices ?? 0),
+        splitEvents: Number(row.split_events ?? 0),
+        failedSlices,
+        unresolvedSlices,
+        truncated: failedSlices > 0 || unresolvedSlices > 0,
+        lastError: typeof row.last_error === "string" ? row.last_error : null,
+    };
+}
+async function resolveOptionalAppSyncSession() {
+    const envToken = resolveNonInteractiveAuthToken(process.env);
+    if (envToken) {
+        return await loginWithToken(envToken, process.env.SALESPROMPTER_API_BASE_URL?.trim());
+    }
+    const session = await readAuthSession();
+    if (!session) {
+        return null;
+    }
+    if (session.expiresAt !== undefined &&
+        Date.now() >= Date.parse(session.expiresAt)) {
+        if (canPromptForInteractiveLogin()) {
+            await ensureInteractiveAuthSession(session.apiBaseUrl);
+            return await readAuthSession();
+        }
+        return null;
+    }
+    return session;
+}
 async function syncPhantombusterContainersViaApp(session, payload) {
     const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/phantombuster/containers/sync`, {
         method: "POST",
@@ -6514,16 +7764,6 @@ async function runSalesNavigatorExport(session, payload, traceId, logOptions = {
     }
 }
 async function startSalesNavigatorExport(session, payload, traceId) {
-    const exportSession = await resolveSalesNavigatorExportSessionOverride(payload.slicedQueryUrl, {
-        source: "cli_salesnav_export_start"
-    });
-    const sessionOverridePayload = exportSession
-        ? {
-            sessionCookie: exportSession.sessionCookie,
-            selectedSessionCookieSha256: exportSession.selectedSessionCookieSha256,
-            selectedSessionUserAgent: exportSession.selectedSessionUserAgent
-        }
-        : {};
     return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/export`, {
         method: "POST",
         signal: AbortSignal.timeout(SALES_NAVIGATOR_EXPORT_START_TIMEOUT_MS),
@@ -6534,8 +7774,7 @@ async function startSalesNavigatorExport(session, payload, traceId) {
         },
         body: JSON.stringify({
             ...payload,
-            appliedFilters: serializeSalesNavigatorFiltersForApi(payload.appliedFilters),
-            ...sessionOverridePayload
+            appliedFilters: serializeSalesNavigatorFiltersForApi(payload.appliedFilters)
         })
     }), SalesNavigatorExportStartResponseSchema);
 }
@@ -7057,6 +8296,73 @@ async function getSalesNavigatorCrawlStatus(session, jobId, traceId) {
         }
     }), SalesNavigatorCrawlStatusResponseSchema);
 }
+async function getSalesNavigatorAccountRunStatus(session, runId, options = {}, traceId) {
+    const params = new URLSearchParams();
+    if (options.cooldownSeconds != null) {
+        params.set("cooldownSeconds", String(options.cooldownSeconds));
+    }
+    const query = params.toString();
+    return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/accounts/runs/${runId}${query ? `?${query}` : ""}`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`,
+            ...buildTraceHeaders(traceId)
+        }
+    }), SalesNavigatorAccountRunStatusResponseSchema);
+}
+async function startSalesNavigatorAccountRunWorkflow(session, runId, options = {}, traceId) {
+    return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/accounts/runs/${runId}/workflow`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`,
+            ...buildTraceHeaders(traceId)
+        },
+        body: JSON.stringify({
+            runId,
+            ...(options.cooldownSeconds != null
+                ? { cooldownSeconds: options.cooldownSeconds }
+                : {})
+        })
+    }), SalesNavigatorAccountWorkflowStartResponseSchema);
+}
+function buildSalesNavigatorAccountRepairCommand(params) {
+    const parts = ["salesprompter", "accounts:repair", "--run-id", params.runId];
+    if (params.curlFile) {
+        parts.push("--curl-file", params.curlFile);
+    }
+    else {
+        parts.push("--curl-file", "<account-search-curl-file>");
+    }
+    return parts.join(" ");
+}
+async function tryStartSalesNavigatorAccountWorkflow(params) {
+    const session = await resolveOptionalAppSyncSession();
+    if (!session) {
+        return {
+            started: false,
+            workflowRunId: null,
+            error: "No saved Salesprompter app auth session is available.",
+        };
+    }
+    try {
+        const workflow = await startSalesNavigatorAccountRunWorkflow(session, params.runId, {
+            cooldownSeconds: params.cooldownSeconds,
+        });
+        return {
+            started: true,
+            workflowRunId: workflow.value.workflowRunId,
+            error: null,
+        };
+    }
+    catch (error) {
+        return {
+            started: false,
+            workflowRunId: null,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
 async function claimNextSalesNavigatorCrawlSlice(session, jobId, traceId) {
     return await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/salesnav/crawls/${jobId}/claim-next`, {
         method: "POST",
@@ -7342,95 +8648,25 @@ function buildSalesNavigatorSliceFailureReport(slice, error, options) {
 function formatSalesNavigatorSplitTrail(splitTrail) {
     return splitTrail.map((entry) => `${entry.key}:${entry.value.text}`);
 }
-let cachedSalesNavigatorExportSessionOverride = null;
-function hashSalesNavigatorSessionCookieForPhantombuster(sessionCookie) {
-    const liAt = extractLiAtCookieValue(sessionCookie);
-    if (!liAt) {
-        return null;
-    }
-    return createHash("sha256").update(liAt).digest("hex");
-}
-function cacheSalesNavigatorExportSessionOverride(queryUrl, value) {
-    cachedSalesNavigatorExportSessionOverride = {
-        queryUrl,
-        expiresAt: Date.now() + 120_000,
-        value
-    };
-    return value;
-}
-async function resolveSalesNavigatorExportSessionOverride(queryUrl, options) {
-    if (cachedSalesNavigatorExportSessionOverride &&
-        cachedSalesNavigatorExportSessionOverride.queryUrl === queryUrl &&
-        cachedSalesNavigatorExportSessionOverride.expiresAt > Date.now()) {
-        return cachedSalesNavigatorExportSessionOverride.value;
-    }
-    const localExtensionConfig = await readLocalLinkedInExtensionDirectLookupConfig();
-    if (localExtensionConfig?.cookie) {
-        const selectedSessionCookieSha256 = hashSalesNavigatorSessionCookieForPhantombuster(localExtensionConfig.cookie);
-        if (process.env.SALESPROMPTER_SALESNAV_EXPORT_SKIP_EXTENSION_PREFLIGHT === "1") {
-            return cacheSalesNavigatorExportSessionOverride(queryUrl, {
-                sessionCookie: localExtensionConfig.cookie,
-                selectedSessionCookieSha256,
-                selectedSessionUserAgent: localExtensionConfig.userAgent,
-                source: "chrome_extension"
-            });
-        }
-        const probe = await probeSalesNavigatorSearchSession(localExtensionConfig.cookie, queryUrl, {
-            timeoutMs: 8000
-        });
-        await options.logger?.log("salesnav.export.session.chrome_extension.preflight", {
-            source: options.source,
-            queryUrl,
-            status: probe.status,
-            selectedSessionCookieSha256,
-            finalUrl: probe.finalUrl,
-            validationError: probe.validationError
-        });
-        if (probe.status === "ok") {
-            return cacheSalesNavigatorExportSessionOverride(queryUrl, {
-                sessionCookie: localExtensionConfig.cookie,
-                selectedSessionCookieSha256,
-                selectedSessionUserAgent: localExtensionConfig.userAgent,
-                source: "chrome_extension"
-            });
-        }
-    }
-    const claimed = await claimValidatedSalesNavigatorSessionCookieForCli({
-        queryUrl,
-        source: options.source,
-        env: process.env
-    });
-    if (claimed?.sessionCookie) {
-        return cacheSalesNavigatorExportSessionOverride(queryUrl, {
-            sessionCookie: claimed.sessionCookie,
-            selectedSessionCookieSha256: claimed.sessionCookieSha256 ??
-                hashSalesNavigatorSessionCookieForPhantombuster(claimed.sessionCookie),
-            selectedSessionUserAgent: null,
-            source: "session_vault"
-        });
-    }
-    if (localExtensionConfig?.cookie &&
-        process.env.SALESPROMPTER_SALESNAV_EXPORT_REQUIRE_FRESH_SESSION === "1") {
-        throw new Error("The local Salesprompter Chrome extension session cookie is not valid for Sales Navigator. Reconnect the extension, then retry the CLI command.");
-    }
-    if (process.env.SALESPROMPTER_CLI_MANAGE_LINKEDIN_SESSIONS === "1") {
-        throw new Error("No validated LinkedIn Sales Navigator session cookie is available from the CLI-managed session pool.");
-    }
-    return null;
-}
 async function ensureSalesNavigatorSessionPoolReady(queryUrl, options) {
     try {
         await options.logger?.log("salesnav.session_pool.preflight.started", {
             source: options.source,
             queryUrl
         });
-        const claimed = await resolveSalesNavigatorExportSessionOverride(queryUrl, options);
+        const claimed = await claimValidatedSalesNavigatorSessionCookieForCli({
+            queryUrl,
+            source: options.source,
+            env: process.env
+        });
         await options.logger?.log("salesnav.session_pool.preflight.completed", {
             source: options.source,
             queryUrl,
             status: claimed ? "ok" : "skipped",
-            selectedSessionSource: claimed?.source ?? "app_managed",
-            selectedSessionCookieSha256: claimed?.selectedSessionCookieSha256 ?? null
+            selectedSessionUserEmail: claimed?.userEmail ?? null,
+            selectedSessionUserHandle: claimed?.userHandle ?? null,
+            selectedSessionCookieSha256: claimed?.sessionCookieSha256 ?? null,
+            selectedSessionLastIngestedSource: claimed?.lastIngestedSource ?? null
         });
         return {
             ready: true
@@ -9357,6 +10593,12 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
         commandName === "llm:ready" ||
         commandName === "contacts:find-linkedin-urls" ||
         commandName === "companies:find-linkedin-urls" ||
+        commandName === "salesnav:accounts:split" ||
+        commandName === "accounts:split" ||
+        commandName === "salesnav:accounts:local-import" ||
+        commandName === "accounts:local-import" ||
+        commandName === "salesnav:accounts:repair" ||
+        commandName === "accounts:repair" ||
         commandName.startsWith("packs:") ||
         ((commandName === "list" || commandName === "add") && parentCommandName === "packs")) {
         return;
@@ -9784,7 +11026,7 @@ program
     const titleLimit = options.titleLimit === undefined
         ? undefined
         : z.coerce.number().int().min(1).max(1000).parse(options.titleLimit);
-    const maxResultsPerSearch = z.coerce.number().int().min(1).max(100000).parse(options.maxResultsPerSearch);
+    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);
@@ -10329,62 +11571,1061 @@ program
     printOutput(payload);
 });
 program
-    .command("salesnav:crawl")
-    .alias("search:run")
-    .description("Run a saved people search, split broad result sets when needed, and store the finished output.")
-    .option("--query-url <url>", "Base LinkedIn Sales Navigator people search URL")
-    .option("--job-id <id>", "Resume an existing crawl job by id")
-    .option("--max-results-per-search <number>", "Maximum results allowed for a sliced search", "2500")
-    .option("--number-of-profiles <number>", "Profiles to export per sliced query", "2500")
-    .option("--slice-preset <name>", "Slice preset label stored with the export runs", "human-resources-crawl")
-    .option("--client-id <number>", "Client id used to generate and store the legacy Neon lead list projection")
-    .option("--max-split-depth <number>", "Maximum number of adaptive split dimensions to use", "6")
-    .option("--max-slices <number>", "Safety cap for total claimed slices in this invocation", "1000")
-    .option("--max-retries <number>", "Retries for non-splitting export failures", "3")
-    .option("--probe-profiles <number>", "Profiles to scrape while probing whether a slice is still too broad", "100")
-    .option("--agent-busy-wait-seconds <number>", "Seconds to wait before retrying when the export agent is already busy", "30")
-    .option("--agent-busy-max-waits <number>", "How many busy-agent waits to tolerate before failing the slice", "20")
-    .option("--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)
+    .command("salesnav:accounts:split")
+    .alias("accounts:split")
+    .description("Split a Sales Navigator account search into account slices below the result cap.")
+    .requiredOption("--query-url <url>", "LinkedIn Sales Navigator account search URL")
+    .option("--curl-file <path>", "Path to a saved account-search curl request used as the local request template")
+    .option("--org-id <id>", "Salesprompter workspace org id for Neon storage. Defaults to SALESPROMPTER_ORG_ID or saved auth session org.")
+    .option("--max-results-per-search <number>", "Maximum account results allowed for each final slice", "1000")
+    .option("--max-windowed-final-results <number>", "Bounded fallback fetch for an oversized final account slice when no split dimensions remain", "1000")
+    .option("--no-windowed-final-slices", "Do not fetch pageable rows for oversized final account slices after adaptive splitting is exhausted")
+    .option("--max-split-depth <number>", "Maximum number of adaptive account split dimensions to use", "3")
+    .option("--max-slices <number>", "Safety cap for total account slices probed in this invocation", "1000")
+    .option("--probe-count <number>", "Accounts to request while probing each slice count", "1")
+    .option("--number-of-accounts <number>", "Maximum accounts to fetch per final slice, or 'all' for the full reported slice", "all")
+    .option("--page-size <number>", "Accounts requested per Sales Navigator account-search API page", "25")
+    .option("--page-delay-min-ms <number>", "Minimum randomized delay between account-search result pages", "1500")
+    .option("--page-delay-max-ms <number>", "Maximum randomized delay between account-search result pages", "6000")
+    .option("--max-retries <number>", "Bounded retries for transient LinkedIn probe failures", "1")
+    .option("--retry-base-delay-ms <number>", "Base delay for full-jitter retry backoff", "1500")
+    .option("--retry-max-delay-ms <number>", "Maximum delay for full-jitter retry backoff", "10000")
     .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)
+    .option("--dry-run", "Preview static account split candidates without calling LinkedIn", false)
+    .option("--plan-only", "Probe account-search counts and print adaptive final batches without storing rows", false)
+    .option("--no-start-workflow", "Do not start the durable app workflow when the account run needs cooldown/repair")
+    .option("--workflow-cooldown-seconds <number>", "Seconds the app workflow should wait after a rate-limit before asking the CLI to repair", "3600")
     .action(async (options) => {
-    const queryUrl = z.string().url().optional().parse(options.queryUrl);
-    const jobId = z.string().uuid().optional().parse(options.jobId);
-    const maxResultsPerSearch = z.coerce.number().int().min(1).max(2500).parse(options.maxResultsPerSearch);
-    const numberOfProfiles = z.coerce.number().int().min(1).max(2500).parse(options.numberOfProfiles);
-    const clientId = parseOptionalSalesNavigatorClientId(options.clientId);
-    const maxSplitDepth = z.coerce.number().int().min(1).max(6).parse(options.maxSplitDepth);
-    const maxSlices = z.coerce.number().int().min(1).max(10000).parse(options.maxSlices);
-    const maxRetries = z.coerce.number().int().min(0).max(5).parse(options.maxRetries);
-    const probeProfiles = z.coerce.number().int().min(1).max(2500).parse(options.probeProfiles);
-    const agentBusyWaitSeconds = z.coerce.number().int().min(1).max(300).parse(options.agentBusyWaitSeconds);
-    const agentBusyMaxWaits = z.coerce.number().int().min(0).max(120).parse(options.agentBusyMaxWaits);
-    const idlePollSeconds = z.coerce.number().int().min(0).max(300).parse(options.idlePollSeconds);
-    const idleMaxPolls = z.coerce.number().int().min(0).max(10000).parse(options.idleMaxPolls);
-    const parallelExports = z.coerce.number().int().min(1).max(10).parse(options.parallelExports);
-    const phantomLaneLimit = resolveSalesNavigatorPhantomLaneLimit(process.env);
-    const effectiveDryRun = Boolean(options.dryRun || shouldBypassAuth());
-    const logger = await createWorkflowLogger({
-        logPath: options.logPath ?? buildSalesNavigatorCrawlLogPath(jobId ?? queryUrl ?? "salesnav-crawl")
-    });
-    await logger.log("salesnav.crawl.command.started", {
-        queryUrl: queryUrl ?? null,
-        jobId: jobId ?? null,
-        maxResultsPerSearch,
-        numberOfProfiles,
-        clientId,
-        slicePreset: options.slicePreset,
-        maxSplitDepth,
-        maxSlices,
-        maxRetries,
-        probeProfiles,
-        agentBusyWaitSeconds,
-        agentBusyMaxWaits,
-        idlePollSeconds,
+    const queryUrl = z.string().url().parse(options.queryUrl);
+    const maxResultsPerSearch = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(1000)
+        .parse(options.maxResultsPerSearch);
+    const maxWindowedFinalResults = z.coerce
+        .number()
+        .int()
+        .min(maxResultsPerSearch)
+        .max(1000)
+        .parse(options.maxWindowedFinalResults);
+    const maxSplitDepth = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(DEFAULT_SALES_NAVIGATOR_ACCOUNT_CRAWL_DIMENSIONS.length)
+        .parse(options.maxSplitDepth);
+    const maxSlices = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(10000)
+        .parse(options.maxSlices);
+    const workflowCooldownSeconds = z.coerce
+        .number()
+        .int()
+        .min(60)
+        .max(86_400)
+        .parse(options.workflowCooldownSeconds);
+    const probeCount = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .parse(options.probeCount);
+    const numberOfAccountsOption = String(options.numberOfAccounts ?? "all")
+        .trim()
+        .toLowerCase();
+    const requestedAccounts = numberOfAccountsOption === "all"
+        ? null
+        : z.coerce
+            .number()
+            .int()
+            .min(1)
+            .max(100000)
+            .parse(options.numberOfAccounts);
+    const pageSize = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .parse(options.pageSize);
+    const pageDelayMinMs = z.coerce
+        .number()
+        .int()
+        .min(0)
+        .max(300000)
+        .parse(options.pageDelayMinMs);
+    const pageDelayMaxMs = z.coerce
+        .number()
+        .int()
+        .min(0)
+        .max(300000)
+        .parse(options.pageDelayMaxMs);
+    if (pageDelayMaxMs < pageDelayMinMs) {
+        throw new Error("--page-delay-max-ms must be greater than or equal to --page-delay-min-ms.");
+    }
+    const retry = {
+        maxRetries: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(5)
+            .parse(options.maxRetries),
+        retryBaseDelayMs: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(300000)
+            .parse(options.retryBaseDelayMs),
+        retryMaxDelayMs: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(300000)
+            .parse(options.retryMaxDelayMs),
+    };
+    const curlFile = typeof options.curlFile === "string" && options.curlFile.trim().length > 0
+        ? options.curlFile.trim()
+        : null;
+    const effectiveDryRun = Boolean(options.dryRun || shouldBypassAuth());
+    const preview = buildSalesNavigatorCrawlPreview({
+        sourceQueryUrl: queryUrl,
+        dimensions: DEFAULT_SALES_NAVIGATOR_ACCOUNT_CRAWL_DIMENSIONS,
+        maxResultsPerSearch,
+        numberOfProfiles: probeCount,
+        slicePreset: "account-search-split",
+        searchType: "account",
+    });
+    if (effectiveDryRun) {
+        const payload = {
+            status: "ok",
+            dryRun: true,
+            mode: "account-split-static-preview",
+            finalBatchesAvailable: false,
+            finalBatchesRequire: "Run with --plan-only or without --dry-run so the CLI can probe Sales Navigator result counts.",
+            maxResultsPerSearch,
+            maxWindowedFinalResults,
+            windowedFinalSlices: options.windowedFinalSlices !== false,
+            probeCount,
+            requestedAccounts: requestedAccounts ?? "all",
+            pageSize,
+            sourceQueryUrl: queryUrl,
+            rootQueryUrl: preview.root.slicedQueryUrl,
+            rootAppliedFilters: preview.root.appliedFilters,
+            dimensionOrder: preview.dimensions.map((dimension) => ({
+                key: dimension.key,
+                filterType: dimension.filterType,
+                valueCount: dimension.values.length,
+            })),
+            firstSplitQueries: preview.firstSplit.map((attempt) => ({
+                kind: "split-candidate",
+                isFinalBatch: false,
+                countStatus: "not_probed",
+                warning: "This URL is a coarse split candidate, not a final batch. It may exceed maxResultsPerSearch until --plan-only probes counts and recursively splits it.",
+                slicedQueryUrl: attempt.slicedQueryUrl,
+                appliedFilters: attempt.appliedFilters,
+                splitTrail: attempt.splitTrail.map((entry) => ({
+                    key: entry.key,
+                    filterType: entry.filterType,
+                    valueText: entry.value.text,
+                })),
+            })),
+        };
+        if (options.out) {
+            await writeJsonFile(options.out, payload);
+        }
+        printOutput(payload);
+        return;
+    }
+    const templateRequest = curlFile
+        ? parseSalesNavigatorCurlRequest(await readFile(curlFile, "utf8"))
+        : null;
+    if (templateRequest &&
+        !new URL(templateRequest.url).pathname.includes("/sales-api/salesApiAccountSearch")) {
+        throw new Error("Account split --curl-file must contain a /sales-api/salesApiAccountSearch request.");
+    }
+    const config = templateRequest ? null : await readLinkedInDirectLookupConfig();
+    const buildAccountApiRequest = (slicedQueryUrl) => templateRequest
+        ? buildSalesNavigatorAccountApiRequestFromSearchUrlWithTemplate(slicedQueryUrl, templateRequest, pageSize)
+        : buildSalesNavigatorAccountApiRequestFromSearchUrl(slicedQueryUrl, config, pageSize);
+    const probeAccountSlice = async (attempt) => {
+        const parsedRequest = buildAccountApiRequest(attempt.slicedQueryUrl);
+        const probeResult = await fetchAllLocalSalesNavigatorAccounts(parsedRequest, {
+            requestedAccounts: probeCount,
+            pageSize,
+            pageDelayMinMs,
+            pageDelayMaxMs,
+            maxAllowedResults: Number.MAX_SAFE_INTEGER,
+            retry,
+        });
+        return { totalResults: probeResult.totalResults };
+    };
+    if (Boolean(options.planOnly)) {
+        const crawl = await executeSalesNavigatorAdaptiveCrawl({
+            sourceQueryUrl: queryUrl,
+            dimensions: DEFAULT_SALES_NAVIGATOR_ACCOUNT_CRAWL_DIMENSIONS,
+            maxResultsPerSearch,
+            numberOfProfiles: probeCount,
+            slicePreset: "account-search-split",
+            searchType: "account",
+            maxSplitDepth,
+            maxSlices,
+            maxRetries: 0,
+            includeResidualExclusionSlices: true,
+            adaptiveSplitProbing: true,
+            probeSlice: probeAccountSlice,
+            exportSlice: async (attempt) => {
+                const probeResult = await probeAccountSlice(attempt);
+                if (probeResult.totalResults == null ||
+                    probeResult.totalResults > attempt.maxResultsPerSearch) {
+                    throw new SalesNavigatorSliceTooBroadError(`Account slice has ${probeResult.totalResults ?? "unknown"} results, above ${attempt.maxResultsPerSearch}.`, { totalResults: probeResult.totalResults });
+                }
+                return probeResult;
+            },
+        });
+        const payload = {
+            status: "ok",
+            dryRun: false,
+            planOnly: true,
+            mode: "account-split-plan",
+            maxResultsPerSearch,
+            probeCount,
+            pageSize,
+            sourceQueryUrl: queryUrl,
+            finalSlices: crawl.exported.map(({ attempt, result }) => ({
+                slicedQueryUrl: attempt.slicedQueryUrl,
+                totalResults: result.totalResults,
+                splitTrail: attempt.splitTrail.map((entry) => ({
+                    key: entry.key,
+                    filterType: entry.filterType,
+                    valueText: entry.value.text,
+                })),
+            })),
+            splitEvents: crawl.splitEvents.map((event) => ({
+                slicedQueryUrl: event.attempt.slicedQueryUrl,
+                totalResults: event.totalResults,
+                nextDimension: event.nextDimension,
+                childCount: event.childCount,
+                strategy: event.strategy ?? "fixed-order",
+                probeSummary: event.probeSummary ?? [],
+            })),
+            unresolved: crawl.unresolved.map((failure) => ({
+                slicedQueryUrl: failure.attempt.slicedQueryUrl,
+                totalResults: failure.totalResults ?? null,
+                splitTrail: failure.attempt.splitTrail.map((entry) => ({
+                    key: entry.key,
+                    filterType: entry.filterType,
+                    valueText: entry.value.text,
+                })),
+                error: failure.error,
+            })),
+            failed: crawl.failed.map((failure) => ({
+                slicedQueryUrl: failure.attempt.slicedQueryUrl,
+                totalResults: failure.totalResults ?? null,
+                splitTrail: failure.attempt.splitTrail.map((entry) => ({
+                    key: entry.key,
+                    filterType: entry.filterType,
+                    valueText: entry.value.text,
+                })),
+                error: failure.error,
+            })),
+            attempted: crawl.attempted,
+            truncated: crawl.truncated,
+            remainingQueue: crawl.remainingQueue,
+        };
+        if (options.out) {
+            await writeJsonFile(options.out, payload);
+        }
+        printOutput(payload);
+        return;
+    }
+    const storedSession = await readAuthSession();
+    const orgId = resolveAccountSearchStorageOrgId(storedSession, options.orgId);
+    if (!orgId) {
+        throw new Error("Account search storage requires --org-id, SALESPROMPTER_ORG_ID, or a saved Salesprompter workspace org. Run `salesprompter auth:login` once, or pass the workspace org id explicitly.");
+    }
+    const store = await createSalesNavigatorAccountSearchStore();
+    const runId = await createSalesNavigatorAccountSearchRun({
+        store,
+        orgId,
+        sourceQueryUrl: queryUrl,
+        slicePreset: "account-search-split",
+        maxResultsPerSearch,
+        pageSize,
+        rawPayload: {
+            workflow: "salesnav:accounts:split",
+            sourceQueryUrl: queryUrl,
+            maxResultsPerSearch,
+            maxWindowedFinalResults,
+            windowedFinalSlices: options.windowedFinalSlices !== false,
+            maxSplitDepth,
+            maxSlices,
+            probeCount,
+            requestedAccounts: requestedAccounts ?? "all",
+            pageSize,
+            pageDelayMinMs,
+            pageDelayMaxMs,
+            workflowCooldownSeconds,
+        },
+    });
+    let storedAccountCount = 0;
+    let crawl;
+    try {
+        crawl = await executeSalesNavigatorAdaptiveCrawl({
+            sourceQueryUrl: queryUrl,
+            dimensions: DEFAULT_SALES_NAVIGATOR_ACCOUNT_CRAWL_DIMENSIONS,
+            maxResultsPerSearch,
+            numberOfProfiles: probeCount,
+            slicePreset: "account-search-split",
+            searchType: "account",
+            maxSplitDepth,
+            maxSlices,
+            maxRetries: 0,
+            includeResidualExclusionSlices: true,
+            adaptiveSplitProbing: true,
+            probeSlice: async (attempt) => {
+                const parsedRequest = buildAccountApiRequest(attempt.slicedQueryUrl);
+                const probeResult = await fetchAllLocalSalesNavigatorAccounts(parsedRequest, {
+                    requestedAccounts: probeCount,
+                    pageSize,
+                    pageDelayMinMs,
+                    pageDelayMaxMs,
+                    maxAllowedResults: Number.MAX_SAFE_INTEGER,
+                    retry,
+                });
+                return { totalResults: probeResult.totalResults };
+            },
+            exportSlice: async (attempt) => {
+                const parsedRequest = buildAccountApiRequest(attempt.slicedQueryUrl);
+                try {
+                    const fetchResult = await fetchAllLocalSalesNavigatorAccounts(parsedRequest, {
+                        requestedAccounts,
+                        pageSize,
+                        pageDelayMinMs,
+                        pageDelayMaxMs,
+                        maxAllowedResults: attempt.maxResultsPerSearch,
+                        retry,
+                    });
+                    const stop = fetchResult.pacing.stop;
+                    const partialError = describeLocalSalesNavigatorAccountPartialError(fetchResult);
+                    const sliceId = await upsertSalesNavigatorAccountSearchSlice({
+                        store,
+                        runId,
+                        orgId,
+                        attempt,
+                        status: partialError ? "failed" : "finished",
+                        totalResults: fetchResult.totalResults,
+                        fetchedPages: fetchResult.fetchedPages,
+                        storedAccounts: fetchResult.accounts.length,
+                        retryCount: fetchResult.pacing.retryCount,
+                        retryDelayMs: fetchResult.pacing.totalDelayMs,
+                        lastError: partialError,
+                        rawPayload: {
+                            sourceQueryUrl: attempt.sourceQueryUrl,
+                            slicedQueryUrl: attempt.slicedQueryUrl,
+                            pacing: fetchResult.pacing,
+                            stop,
+                        },
+                    });
+                    const storedAccounts = await upsertSalesNavigatorAccounts({
+                        store,
+                        orgId,
+                        runId,
+                        sliceId,
+                        accounts: fetchResult.accounts,
+                    });
+                    storedAccountCount += storedAccounts;
+                    if (fetchResult.pacing.rateLimit) {
+                        throw new SalesNavigatorCrawlStopError(fetchResult.pacing.rateLimit.message, {
+                            totalResults: fetchResult.totalResults,
+                            details: {
+                                stop,
+                                slicedQueryUrl: attempt.slicedQueryUrl,
+                            },
+                        });
+                    }
+                    return {
+                        estimatedTotalResults: fetchResult.totalResults,
+                        fetchedPages: fetchResult.fetchedPages,
+                        storedAccounts,
+                        retryCount: fetchResult.pacing.retryCount,
+                        retryDelayMs: fetchResult.pacing.totalDelayMs,
+                        stop,
+                        truncated: Boolean(partialError),
+                        error: partialError,
+                    };
+                }
+                catch (error) {
+                    if (error instanceof SalesNavigatorSliceTooBroadError) {
+                        throw error;
+                    }
+                    if (error instanceof SalesNavigatorCrawlStopError) {
+                        throw error;
+                    }
+                    await upsertSalesNavigatorAccountSearchSlice({
+                        store,
+                        runId,
+                        orgId,
+                        attempt,
+                        status: "failed",
+                        totalResults: null,
+                        fetchedPages: 0,
+                        storedAccounts: 0,
+                        retryCount: 0,
+                        retryDelayMs: 0,
+                        lastError: error instanceof Error ? error.message : String(error),
+                        rawPayload: {
+                            sourceQueryUrl: attempt.sourceQueryUrl,
+                            slicedQueryUrl: attempt.slicedQueryUrl,
+                        },
+                    });
+                    throw error;
+                }
+            },
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        await updateSalesNavigatorAccountSearchRun({
+            store,
+            runId,
+            status: "failed",
+            totalSlices: 0,
+            storedAccounts: storedAccountCount,
+            attemptedSlices: 0,
+            splitEvents: 0,
+            failedSlices: 1,
+            unresolvedSlices: 0,
+            truncated: false,
+            lastError: errorMessage,
+        });
+        await closeSalesNavigatorAccountSearchStore(store);
+        if (Boolean(options.startWorkflow) &&
+            /\b(429|rate[-\s]?limit|too many requests)\b/i.test(errorMessage)) {
+            const workflow = await tryStartSalesNavigatorAccountWorkflow({
+                runId,
+                cooldownSeconds: workflowCooldownSeconds,
+            });
+            printOutput({
+                status: "rate_limited",
+                mode: "account-split",
+                runId,
+                error: errorMessage,
+                workflow: {
+                    ...workflow,
+                    nextAction: "cooldown",
+                    cooldownSeconds: workflowCooldownSeconds,
+                    repairCommand: buildSalesNavigatorAccountRepairCommand({
+                        runId,
+                        curlFile,
+                    }),
+                },
+            });
+        }
+        throw error;
+    }
+    const windowedFinalSlices = [];
+    const additionalFailed = [];
+    const remainingUnresolved = [];
+    for (const failure of crawl.unresolved) {
+        const canFetchWindowedFinalSlice = options.windowedFinalSlices !== false &&
+            failure.totalResults != null &&
+            failure.totalResults <= maxWindowedFinalResults;
+        if (canFetchWindowedFinalSlice) {
+            try {
+                const parsedRequest = buildAccountApiRequest(failure.attempt.slicedQueryUrl);
+                const fetchResult = await fetchAllLocalSalesNavigatorAccounts(parsedRequest, {
+                    requestedAccounts,
+                    pageSize,
+                    pageDelayMinMs,
+                    pageDelayMaxMs,
+                    maxAllowedResults: maxWindowedFinalResults,
+                    retry,
+                    allowPartialPageErrors: true,
+                });
+                const windowedError = describeLocalSalesNavigatorAccountPartialError(fetchResult);
+                const sliceId = await upsertSalesNavigatorAccountSearchSlice({
+                    store,
+                    runId,
+                    orgId,
+                    attempt: failure.attempt,
+                    status: windowedError ? "failed" : "finished",
+                    totalResults: fetchResult.totalResults,
+                    fetchedPages: fetchResult.fetchedPages,
+                    storedAccounts: fetchResult.accounts.length,
+                    retryCount: fetchResult.pacing.retryCount,
+                    retryDelayMs: fetchResult.pacing.totalDelayMs,
+                    lastError: windowedError,
+                    rawPayload: {
+                        sourceQueryUrl: failure.attempt.sourceQueryUrl,
+                        slicedQueryUrl: failure.attempt.slicedQueryUrl,
+                        oversizedFinalSlice: true,
+                        originalError: failure.error,
+                        pacing: fetchResult.pacing,
+                        stop: fetchResult.pacing.stop,
+                    },
+                });
+                const storedAccounts = await upsertSalesNavigatorAccounts({
+                    store,
+                    orgId,
+                    runId,
+                    sliceId,
+                    accounts: fetchResult.accounts,
+                });
+                storedAccountCount += storedAccounts;
+                windowedFinalSlices.push({
+                    slicedQueryUrl: failure.attempt.slicedQueryUrl,
+                    appliedFilters: failure.attempt.appliedFilters,
+                    splitTrail: failure.attempt.splitTrail.map((entry) => ({
+                        key: entry.key,
+                        filterType: entry.filterType,
+                        valueText: entry.value.text,
+                    })),
+                    estimatedTotalResults: fetchResult.totalResults,
+                    fetchedPages: fetchResult.fetchedPages,
+                    storedAccounts,
+                    retryCount: fetchResult.pacing.retryCount,
+                    retryDelayMs: fetchResult.pacing.totalDelayMs,
+                    windowedFinal: true,
+                    truncated: Boolean(windowedError),
+                    error: windowedError,
+                    stop: fetchResult.pacing.stop,
+                });
+                continue;
+            }
+            catch (error) {
+                additionalFailed.push({
+                    attempt: failure.attempt,
+                    totalResults: failure.totalResults ?? null,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                await upsertSalesNavigatorAccountSearchSlice({
+                    store,
+                    runId,
+                    orgId,
+                    attempt: failure.attempt,
+                    status: "failed",
+                    totalResults: failure.totalResults ?? null,
+                    fetchedPages: 0,
+                    storedAccounts: 0,
+                    retryCount: 0,
+                    retryDelayMs: 0,
+                    lastError: error instanceof Error ? error.message : String(error),
+                    rawPayload: {
+                        sourceQueryUrl: failure.attempt.sourceQueryUrl,
+                        slicedQueryUrl: failure.attempt.slicedQueryUrl,
+                        oversizedFinalSlice: true,
+                        originalError: failure.error,
+                    },
+                });
+                continue;
+            }
+        }
+        remainingUnresolved.push(failure);
+    }
+    for (const failure of remainingUnresolved) {
+        await upsertSalesNavigatorAccountSearchSlice({
+            store,
+            runId,
+            orgId,
+            attempt: failure.attempt,
+            status: "unresolved",
+            totalResults: failure.totalResults ?? null,
+            fetchedPages: 0,
+            storedAccounts: 0,
+            retryCount: 0,
+            retryDelayMs: 0,
+            lastError: failure.error,
+            rawPayload: {
+                sourceQueryUrl: failure.attempt.sourceQueryUrl,
+                slicedQueryUrl: failure.attempt.slicedQueryUrl,
+            },
+        });
+    }
+    for (const event of crawl.splitEvents) {
+        await upsertSalesNavigatorAccountSearchSlice({
+            store,
+            runId,
+            orgId,
+            attempt: event.attempt,
+            status: "split",
+            totalResults: event.totalResults,
+            fetchedPages: 1,
+            storedAccounts: 0,
+            retryCount: 0,
+            retryDelayMs: 0,
+            rawPayload: {
+                sourceQueryUrl: event.attempt.sourceQueryUrl,
+                slicedQueryUrl: event.attempt.slicedQueryUrl,
+                nextDimension: event.nextDimension,
+                childCount: event.childCount,
+            },
+        });
+    }
+    const finalSlices = crawl.exported.map(({ attempt, result }) => ({
+        slicedQueryUrl: attempt.slicedQueryUrl,
+        appliedFilters: attempt.appliedFilters,
+        splitTrail: attempt.splitTrail.map((entry) => ({
+            key: entry.key,
+            filterType: entry.filterType,
+            valueText: entry.value.text,
+        })),
+        estimatedTotalResults: result.estimatedTotalResults,
+        fetchedPages: result.fetchedPages,
+        storedAccounts: result.storedAccounts,
+        retryCount: result.retryCount,
+        retryDelayMs: result.retryDelayMs,
+        stop: result.stop,
+        truncated: result.truncated,
+        error: result.error,
+    })).concat(windowedFinalSlices);
+    const failed = crawl.failed.concat(additionalFailed);
+    const rootReportedTotal = crawl.splitEvents.find((event) => event.attempt.depth === 0)?.totalResults ?? null;
+    const finalSliceReportedTotalSum = finalSlices.reduce((sum, slice) => sum + (slice.estimatedTotalResults ?? 0), 0);
+    const missingReportedFromFinalSlices = rootReportedTotal == null
+        ? null
+        : Math.max(0, rootReportedTotal - finalSliceReportedTotalSum);
+    const missingStoredFromRoot = rootReportedTotal == null
+        ? null
+        : Math.max(0, rootReportedTotal - storedAccountCount);
+    const truncated = crawl.truncated ||
+        finalSlices.some((slice) => slice.truncated) ||
+        (missingReportedFromFinalSlices != null && missingReportedFromFinalSlices > 0) ||
+        (missingStoredFromRoot != null && missingStoredFromRoot > 0);
+    const coverageError = missingReportedFromFinalSlices != null && missingReportedFromFinalSlices > 0
+        ? `Final account slices explain ${finalSliceReportedTotalSum} of ${rootReportedTotal} root reported results; missing reported total ${missingReportedFromFinalSlices}.`
+        : missingStoredFromRoot != null && missingStoredFromRoot > 0
+            ? `Stored ${storedAccountCount} of ${rootReportedTotal} root reported accounts; missing stored total ${missingStoredFromRoot}.`
+            : null;
+    const payload = {
+        status: "ok",
+        dryRun: false,
+        mode: "account-split",
+        maxResultsPerSearch,
+        probeCount,
+        requestedAccounts: requestedAccounts ?? "all",
+        pageSize,
+        sourceQueryUrl: queryUrl,
+        runId,
+        finalSlices,
+        splitEvents: crawl.splitEvents.map((event) => ({
+            slicedQueryUrl: event.attempt.slicedQueryUrl,
+            totalResults: event.totalResults,
+            nextDimension: event.nextDimension,
+            childCount: event.childCount,
+            strategy: event.strategy ?? "fixed-order",
+            probeSummary: event.probeSummary ?? [],
+        })),
+        unresolved: remainingUnresolved.map((failure) => ({
+            slicedQueryUrl: failure.attempt.slicedQueryUrl,
+            splitTrail: failure.attempt.splitTrail.map((entry) => ({
+                key: entry.key,
+                filterType: entry.filterType,
+                valueText: entry.value.text,
+            })),
+            totalResults: failure.totalResults ?? null,
+            error: failure.error,
+        })),
+        failed: failed.map((failure) => ({
+            slicedQueryUrl: failure.attempt.slicedQueryUrl,
+            splitTrail: failure.attempt.splitTrail.map((entry) => ({
+                key: entry.key,
+                filterType: entry.filterType,
+                valueText: entry.value.text,
+            })),
+            totalResults: failure.totalResults ?? null,
+            error: failure.error,
+        })),
+        attempted: crawl.attempted,
+        truncated,
+        remainingQueue: crawl.remainingQueue,
+        storedAccounts: storedAccountCount,
+        reportedCoverage: {
+            rootReportedTotal,
+            finalSliceReportedTotalSum,
+            missingReportedFromFinalSlices,
+            storedAccounts: storedAccountCount,
+            missingStoredFromRoot,
+        },
+    };
+    await updateSalesNavigatorAccountSearchRun({
+        store,
+        runId,
+        status: payload.unresolved.length > 0 || payload.failed.length > 0 || payload.truncated
+            ? "failed"
+            : "finished",
+        totalSlices: payload.finalSlices.length,
+        storedAccounts: storedAccountCount,
+        attemptedSlices: crawl.attempted,
+        splitEvents: crawl.splitEvents.length,
+        failedSlices: payload.failed.length +
+            finalSlices.filter((slice) => slice.error).length,
+        unresolvedSlices: payload.unresolved.length,
+        truncated: payload.truncated,
+        lastError: payload.unresolved[0]?.error ??
+            payload.failed[0]?.error ??
+            windowedFinalSlices.find((slice) => slice.error)?.error ??
+            finalSlices.find((slice) => slice.error)?.error ??
+            coverageError ??
+            (payload.truncated ? "Account search split truncated before completion." : null),
+        rawPayload: {
+            reportedCoverage: payload.reportedCoverage,
+        },
+    });
+    const needsWorkflow = payload.unresolved.length > 0 || payload.failed.length > 0 || payload.truncated;
+    const workflow = needsWorkflow
+        ? Boolean(options.startWorkflow)
+            ? await tryStartSalesNavigatorAccountWorkflow({
+                runId,
+                cooldownSeconds: workflowCooldownSeconds,
+            })
+            : {
+                started: false,
+                workflowRunId: null,
+                error: "Workflow start disabled by --no-start-workflow.",
+            }
+        : {
+            started: false,
+            workflowRunId: null,
+            error: null,
+        };
+    const outputPayload = {
+        ...payload,
+        workflow: {
+            ...workflow,
+            nextAction: needsWorkflow ? "cooldown" : "complete",
+            cooldownSeconds: needsWorkflow ? workflowCooldownSeconds : null,
+            repairCommand: needsWorkflow
+                ? buildSalesNavigatorAccountRepairCommand({
+                    runId,
+                    curlFile,
+                })
+                : null,
+        },
+    };
+    if (options.out) {
+        await writeJsonFile(options.out, outputPayload);
+    }
+    printOutput(outputPayload);
+    await closeSalesNavigatorAccountSearchStore(store);
+    if (needsWorkflow) {
+        throw new Error(`Account search split did not finish cleanly. finalSlices=${payload.finalSlices.length} unresolved=${payload.unresolved.length} failed=${payload.failed.length} truncated=${payload.truncated}`);
+    }
+});
+program
+    .command("salesnav:accounts:local-import")
+    .alias("accounts:local-import")
+    .description("Run a saved Sales Navigator account request locally and store the accounts in Neon.")
+    .option("--curl-file <path>", "Path to a saved account-search curl request copied from the Sales Navigator network panel")
+    .option("--query-url <url>", "Sales Navigator account search URL. Uses the locally captured extension session automatically.")
+    .option("--org-id <id>", "Salesprompter workspace org id for Neon storage. Defaults to SALESPROMPTER_ORG_ID or saved auth session org.")
+    .option("--max-results-per-search <number>", "Maximum expected account results for this local request", "1000")
+    .option("--number-of-accounts <number>", "Total accounts to import, or 'all' for the full reported result set", "all")
+    .option("--page-size <number>", "Accounts requested per local Sales Navigator API page", "25")
+    .option("--start-offset <number>", "Account-search result offset to start from when resuming a local import", "0")
+    .option("--page-delay-min-ms <number>", "Minimum randomized delay between account-search result pages", "20000")
+    .option("--page-delay-max-ms <number>", "Maximum randomized delay between account-search result pages", "35000")
+    .option("--max-retries <number>", "Bounded retries for transient network/5xx failures. Rate limits still stop immediately.", "2")
+    .option("--retry-base-delay-ms <number>", "Base delay for full-jitter retry backoff", "2000")
+    .option("--retry-max-delay-ms <number>", "Maximum delay for full-jitter retry backoff", "30000")
+    .option("--slice-preset <name>", "Slice preset label stored with the import run", "local-account-search")
+    .option("--allow-partial-page-errors", "Persist rows fetched before a later non-rate-limit page error", false)
+    .option("--out <path>", "Optional local JSON output path")
+    .option("--dry-run", "Run and normalize the local account request without writing to Neon", false)
+    .action(async (options) => {
+    const maxResultsPerSearch = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(1000)
+        .parse(options.maxResultsPerSearch);
+    const numberOfAccountsOption = String(options.numberOfAccounts ?? "all")
+        .trim()
+        .toLowerCase();
+    const requestedAccounts = numberOfAccountsOption === "all"
+        ? null
+        : z.coerce
+            .number()
+            .int()
+            .min(1)
+            .max(100000)
+            .parse(options.numberOfAccounts);
+    const pageSize = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .parse(options.pageSize);
+    const startOffset = z.coerce
+        .number()
+        .int()
+        .min(0)
+        .max(100000)
+        .parse(options.startOffset);
+    const pageDelayMinMs = z.coerce
+        .number()
+        .int()
+        .min(0)
+        .max(300000)
+        .parse(options.pageDelayMinMs);
+    const pageDelayMaxMs = z.coerce
+        .number()
+        .int()
+        .min(0)
+        .max(300000)
+        .parse(options.pageDelayMaxMs);
+    if (pageDelayMaxMs < pageDelayMinMs) {
+        throw new Error("--page-delay-max-ms must be greater than or equal to --page-delay-min-ms.");
+    }
+    const retry = {
+        maxRetries: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(5)
+            .parse(options.maxRetries),
+        retryBaseDelayMs: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(300000)
+            .parse(options.retryBaseDelayMs),
+        retryMaxDelayMs: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(300000)
+            .parse(options.retryMaxDelayMs),
+    };
+    const curlFile = typeof options.curlFile === "string" && options.curlFile.trim().length > 0
+        ? options.curlFile.trim()
+        : null;
+    const queryUrl = typeof options.queryUrl === "string" && options.queryUrl.trim().length > 0
+        ? z.string().url().parse(options.queryUrl.trim())
+        : null;
+    if (Boolean(curlFile) === Boolean(queryUrl)) {
+        throw new Error("Provide exactly one of --curl-file or --query-url.");
+    }
+    const parsedRequest = curlFile
+        ? parseSalesNavigatorCurlRequest(await readFile(curlFile, "utf8"))
+        : buildSalesNavigatorAccountApiRequestFromSearchUrl(queryUrl, await readLinkedInDirectLookupConfig(), pageSize);
+    if (!new URL(parsedRequest.url).pathname.includes("/sales-api/salesApiAccountSearch")) {
+        throw new Error("Account local import requires a /sales-api/salesApiAccountSearch request.");
+    }
+    const localFetch = await fetchAllLocalSalesNavigatorAccounts(parsedRequest, {
+        requestedAccounts,
+        startOffset,
+        pageSize,
+        pageDelayMinMs,
+        pageDelayMaxMs,
+        maxAllowedResults: maxResultsPerSearch,
+        retry,
+        allowPartialPageErrors: Boolean(options.allowPartialPageErrors),
+    });
+    const accounts = localFetch.accounts;
+    const totalResults = localFetch.totalResults;
+    const dryRun = Boolean(options.dryRun);
+    const rateLimit = localFetch.pacing.rateLimit;
+    const pageError = localFetch.pacing.pageError;
+    const partialError = describeLocalSalesNavigatorAccountPartialError(localFetch);
+    if (accounts.length === 0) {
+        throw new Error("The local Sales Navigator account response did not contain any importable account rows.");
+    }
+    const sourceQueryUrl = queryUrl ?? localFetch.sourceQueryUrl;
+    const basePayload = {
+        status: "ok",
+        dryRun,
+        mode: "account-local-import",
+        sourceQueryUrl,
+        totalResults,
+        discovered: accounts.length,
+        fetchedPages: localFetch.fetchedPages,
+        requestedAccounts: requestedAccounts ?? "all",
+        maxResultsPerSearch,
+        startOffset,
+        pageSize,
+        pacing: localFetch.pacing,
+        rateLimit: rateLimit ?? null,
+        pageError: pageError ?? null,
+        stop: localFetch.pacing.stop,
+        accounts,
+    };
+    if (dryRun) {
+        if (options.out) {
+            await writeJsonFile(options.out, basePayload);
+        }
+        printOutput(basePayload);
+        return;
+    }
+    const storedSession = await readAuthSession();
+    const orgId = resolveAccountSearchStorageOrgId(storedSession, options.orgId);
+    if (!orgId) {
+        throw new Error("Account local import storage requires --org-id, SALESPROMPTER_ORG_ID, or a saved Salesprompter workspace org. Run `salesprompter auth:login` once, or pass the workspace org id explicitly.");
+    }
+    const store = await createSalesNavigatorAccountSearchStore();
+    const runId = await createSalesNavigatorAccountSearchRun({
+        store,
+        orgId,
+        sourceQueryUrl,
+        slicePreset: options.slicePreset,
+        maxResultsPerSearch,
+        pageSize,
+        rawPayload: {
+            workflow: "salesnav:accounts:local-import",
+            sourceQueryUrl,
+            requestUrl: localFetch.sourceQueryUrl,
+            maxResultsPerSearch,
+            requestedAccounts: requestedAccounts ?? "all",
+            startOffset,
+            pageSize,
+            pageDelayMinMs,
+            pageDelayMaxMs,
+            rateLimit: rateLimit ?? null,
+            pageError: pageError ?? null,
+            stop: localFetch.pacing.stop,
+        },
+    });
+    const attempt = {
+        sourceQueryUrl,
+        slicedQueryUrl: sourceQueryUrl,
+        appliedFilters: [],
+        depth: 0,
+        retryCount: 0,
+        maxResultsPerSearch,
+        numberOfProfiles: requestedAccounts ?? accounts.length,
+        slicePreset: options.slicePreset,
+        splitTrail: [],
+    };
+    try {
+        const sliceId = await upsertSalesNavigatorAccountSearchSlice({
+            store,
+            runId,
+            orgId,
+            attempt,
+            status: partialError ? "failed" : "finished",
+            totalResults,
+            fetchedPages: localFetch.fetchedPages,
+            storedAccounts: accounts.length,
+            retryCount: localFetch.pacing.retryCount,
+            retryDelayMs: localFetch.pacing.totalDelayMs,
+            lastError: partialError,
+            rawPayload: {
+                sourceQueryUrl,
+                requestUrl: localFetch.sourceQueryUrl,
+                startOffset,
+                pacing: localFetch.pacing,
+                stop: localFetch.pacing.stop,
+            },
+        });
+        const storedAccounts = await upsertSalesNavigatorAccounts({
+            store,
+            orgId,
+            runId,
+            sliceId,
+            accounts,
+        });
+        await updateSalesNavigatorAccountSearchRun({
+            store,
+            runId,
+            status: partialError ? "failed" : "finished",
+            totalSlices: 1,
+            storedAccounts,
+            attemptedSlices: 1,
+            splitEvents: 0,
+            failedSlices: partialError ? 1 : 0,
+            unresolvedSlices: 0,
+            truncated: Boolean(partialError),
+            lastError: partialError,
+        });
+        const payload = {
+            ...basePayload,
+            runId,
+            sliceId,
+            storedAccounts,
+        };
+        if (options.out) {
+            await writeJsonFile(options.out, payload);
+        }
+        printOutput(payload);
+    }
+    catch (error) {
+        await updateSalesNavigatorAccountSearchRun({
+            store,
+            runId,
+            status: "failed",
+            totalSlices: 0,
+            storedAccounts: 0,
+            attemptedSlices: 1,
+            splitEvents: 0,
+            failedSlices: 1,
+            unresolvedSlices: 0,
+            truncated: false,
+            lastError: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+    finally {
+        await closeSalesNavigatorAccountSearchStore(store);
+    }
+});
+program
+    .command("salesnav:crawl")
+    .alias("search:run")
+    .description("Run a saved people search, split broad result sets when needed, and store the finished output.")
+    .option("--query-url <url>", "Base LinkedIn Sales Navigator people search URL")
+    .option("--job-id <id>", "Resume an existing crawl job by id")
+    .option("--max-results-per-search <number>", "Maximum results allowed for a sliced search", "2500")
+    .option("--number-of-profiles <number>", "Profiles to export per sliced query", "2500")
+    .option("--slice-preset <name>", "Slice preset label stored with the export runs", "human-resources-crawl")
+    .option("--client-id <number>", "Client id used to generate and store the legacy Neon lead list projection")
+    .option("--max-split-depth <number>", "Maximum number of adaptive split dimensions to use", "6")
+    .option("--max-slices <number>", "Safety cap for total claimed slices in this invocation", "1000")
+    .option("--max-retries <number>", "Retries for non-splitting export failures", "3")
+    .option("--probe-profiles <number>", "Profiles to scrape while probing whether a slice is still too broad", "100")
+    .option("--agent-busy-wait-seconds <number>", "Seconds to wait before retrying when the export agent is already busy", "30")
+    .option("--agent-busy-max-waits <number>", "How many busy-agent waits to tolerate before failing the slice", "20")
+    .option("--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);
+    const jobId = z.string().uuid().optional().parse(options.jobId);
+    const maxResultsPerSearch = z.coerce.number().int().min(1).max(2500).parse(options.maxResultsPerSearch);
+    const numberOfProfiles = z.coerce.number().int().min(1).max(2500).parse(options.numberOfProfiles);
+    const clientId = parseOptionalSalesNavigatorClientId(options.clientId);
+    const maxSplitDepth = z.coerce.number().int().min(1).max(6).parse(options.maxSplitDepth);
+    const maxSlices = z.coerce.number().int().min(1).max(10000).parse(options.maxSlices);
+    const maxRetries = z.coerce.number().int().min(0).max(5).parse(options.maxRetries);
+    const probeProfiles = z.coerce.number().int().min(1).max(2500).parse(options.probeProfiles);
+    const agentBusyWaitSeconds = z.coerce.number().int().min(1).max(300).parse(options.agentBusyWaitSeconds);
+    const agentBusyMaxWaits = z.coerce.number().int().min(0).max(120).parse(options.agentBusyMaxWaits);
+    const idlePollSeconds = z.coerce.number().int().min(0).max(300).parse(options.idlePollSeconds);
+    const idleMaxPolls = z.coerce.number().int().min(0).max(10000).parse(options.idleMaxPolls);
+    const parallelExports = z.coerce.number().int().min(1).max(10).parse(options.parallelExports);
+    const phantomLaneLimit = resolveSalesNavigatorPhantomLaneLimit(process.env);
+    const effectiveDryRun = Boolean(options.dryRun || shouldBypassAuth());
+    const logger = await createWorkflowLogger({
+        logPath: options.logPath ?? buildSalesNavigatorCrawlLogPath(jobId ?? queryUrl ?? "salesnav-crawl")
+    });
+    await logger.log("salesnav.crawl.command.started", {
+        queryUrl: queryUrl ?? null,
+        jobId: jobId ?? null,
+        maxResultsPerSearch,
+        numberOfProfiles,
+        clientId,
+        slicePreset: options.slicePreset,
+        maxSplitDepth,
+        maxSlices,
+        maxRetries,
+        probeProfiles,
+        agentBusyWaitSeconds,
+        agentBusyMaxWaits,
+        idlePollSeconds,
         idleMaxPolls,
         parallelExports,
         phantomLaneLimit,
@@ -10620,22 +12861,362 @@ program
         recentEvents
     });
 });
+program
+    .command("salesnav:accounts:repair")
+    .alias("accounts:repair")
+    .description("Locally resume failed account-search slices from their stored offsets.")
+    .requiredOption("--run-id <id>", "Sales Navigator account-search run id")
+    .requiredOption("--curl-file <path>", "Path to a saved account-search curl request used as the local request template")
+    .option("--max-slices <number>", "Maximum failed slices to repair in this invocation", "100")
+    .option("--number-of-accounts <number>", "Maximum accounts to fetch per repair slice, or 'all' for each slice remainder", "all")
+    .option("--max-repair-results <number>", "Skip zero-progress failed slices above this reported result count; those still need splitting", "1000")
+    .option("--page-size <number>", "Accounts requested per Sales Navigator account-search API page", "25")
+    .option("--page-delay-min-ms <number>", "Minimum randomized delay between account-search result pages", "20000")
+    .option("--page-delay-max-ms <number>", "Maximum randomized delay between account-search result pages", "35000")
+    .option("--max-retries <number>", "Bounded retries for transient network/5xx failures. Rate limits still stop immediately.", "1")
+    .option("--retry-base-delay-ms <number>", "Base delay for full-jitter retry backoff", "2000")
+    .option("--retry-max-delay-ms <number>", "Maximum delay for full-jitter retry backoff", "30000")
+    .option("--out <path>", "Optional local JSON output path")
+    .action(async (options) => {
+    const runId = z.string().uuid().parse(options.runId);
+    const maxSlices = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(1000)
+        .parse(options.maxSlices);
+    const numberOfAccountsOption = String(options.numberOfAccounts ?? "all")
+        .trim()
+        .toLowerCase();
+    const requestedAccountsOption = numberOfAccountsOption === "all"
+        ? null
+        : z.coerce
+            .number()
+            .int()
+            .min(1)
+            .max(100000)
+            .parse(options.numberOfAccounts);
+    const pageSize = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .parse(options.pageSize);
+    const maxRepairResults = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(100000)
+        .parse(options.maxRepairResults);
+    const pageDelayMinMs = z.coerce
+        .number()
+        .int()
+        .min(0)
+        .max(300000)
+        .parse(options.pageDelayMinMs);
+    const pageDelayMaxMs = z.coerce
+        .number()
+        .int()
+        .min(0)
+        .max(300000)
+        .parse(options.pageDelayMaxMs);
+    if (pageDelayMaxMs < pageDelayMinMs) {
+        throw new Error("--page-delay-max-ms must be greater than or equal to --page-delay-min-ms.");
+    }
+    const retry = {
+        maxRetries: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(5)
+            .parse(options.maxRetries),
+        retryBaseDelayMs: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(300000)
+            .parse(options.retryBaseDelayMs),
+        retryMaxDelayMs: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(300000)
+            .parse(options.retryMaxDelayMs),
+    };
+    const templateRequest = parseSalesNavigatorCurlRequest(await readFile(options.curlFile, "utf8"));
+    if (!new URL(templateRequest.url).pathname.includes("/sales-api/salesApiAccountSearch")) {
+        throw new Error("Account repair --curl-file must contain a /sales-api/salesApiAccountSearch request.");
+    }
+    const store = await createSalesNavigatorAccountSearchStore();
+    const repaired = [];
+    const skipped = [];
+    let stoppedByRateLimit = null;
+    try {
+        const slices = await listSalesNavigatorAccountSearchRepairSlices({
+            store,
+            runId,
+            limit: maxSlices,
+        });
+        for (const slice of slices) {
+            const startOffset = resolveAccountRepairStartOffset(slice);
+            const remainingFromReported = slice.totalResults == null
+                ? null
+                : Math.max(0, slice.totalResults - startOffset);
+            if (remainingFromReported === 0) {
+                continue;
+            }
+            if (startOffset === 0 &&
+                slice.storedAccounts === 0 &&
+                slice.totalResults != null &&
+                slice.totalResults > maxRepairResults) {
+                skipped.push({
+                    sliceId: slice.id,
+                    slicedQueryUrl: slice.slicedQueryUrl,
+                    totalResults: slice.totalResults,
+                    storedAccounts: slice.storedAccounts,
+                    reason: `reported total ${slice.totalResults} is above max repair results ${maxRepairResults}`,
+                });
+                continue;
+            }
+            if (startOffset === 0 &&
+                slice.storedAccounts === 0 &&
+                !asJsonObject(slice.rawPayload).stop &&
+                /\b(429|rate[-\s]?limit|too many requests)\b/i.test(slice.lastError ?? "")) {
+                skipped.push({
+                    sliceId: slice.id,
+                    slicedQueryUrl: slice.slicedQueryUrl,
+                    totalResults: slice.totalResults,
+                    storedAccounts: slice.storedAccounts,
+                    reason: "zero-progress slice has no resume offset and the previous failure was rate limited",
+                });
+                continue;
+            }
+            const requestedAccounts = requestedAccountsOption == null
+                ? remainingFromReported
+                : remainingFromReported == null
+                    ? requestedAccountsOption
+                    : Math.min(requestedAccountsOption, remainingFromReported);
+            const parsedRequest = buildSalesNavigatorAccountApiRequestFromSearchUrlWithTemplate(slice.slicedQueryUrl, templateRequest, pageSize);
+            const fetchResult = await fetchAllLocalSalesNavigatorAccounts(parsedRequest, {
+                requestedAccounts,
+                startOffset,
+                pageSize,
+                pageDelayMinMs,
+                pageDelayMaxMs,
+                maxAllowedResults: 100000,
+                retry,
+                allowPartialPageErrors: true,
+            });
+            const rateLimit = fetchResult.pacing.rateLimit;
+            const pageError = fetchResult.pacing.pageError;
+            const partialError = describeLocalSalesNavigatorAccountPartialError(fetchResult);
+            const cumulativeStoredAccounts = slice.storedAccounts + fetchResult.accounts.length;
+            const attempt = repairSliceToCrawlAttempt({
+                ...slice,
+                maxResultsPerSearch: fetchResult.totalResults ??
+                    slice.totalResults ??
+                    slice.maxResultsPerSearch,
+                pageSize,
+            });
+            const sliceId = await upsertSalesNavigatorAccountSearchSlice({
+                store,
+                runId,
+                orgId: slice.orgId,
+                attempt,
+                status: partialError ? "failed" : "finished",
+                totalResults: fetchResult.totalResults ?? slice.totalResults,
+                fetchedPages: slice.fetchedPages + fetchResult.fetchedPages,
+                storedAccounts: cumulativeStoredAccounts,
+                retryCount: slice.retryCount + fetchResult.pacing.retryCount,
+                retryDelayMs: slice.retryDelayMs + fetchResult.pacing.totalDelayMs,
+                lastError: partialError,
+                rawPayload: {
+                    ...slice.rawPayload,
+                    repair: {
+                        repairedAt: new Date().toISOString(),
+                        previousStoredAccounts: slice.storedAccounts,
+                        startOffset,
+                        fetchedAccounts: fetchResult.accounts.length,
+                    },
+                    pacing: fetchResult.pacing,
+                    stop: fetchResult.pacing.stop,
+                },
+            });
+            const storedAccounts = await upsertSalesNavigatorAccounts({
+                store,
+                orgId: slice.orgId,
+                runId,
+                sliceId,
+                accounts: fetchResult.accounts,
+            });
+            repaired.push({
+                sliceId,
+                slicedQueryUrl: slice.slicedQueryUrl,
+                startOffset,
+                totalResults: fetchResult.totalResults ?? slice.totalResults,
+                fetchedPages: fetchResult.fetchedPages,
+                fetchedAccounts: fetchResult.accounts.length,
+                storedAccounts,
+                cumulativeStoredAccounts,
+                status: partialError ? "failed" : "finished",
+                stop: fetchResult.pacing.stop,
+                error: partialError,
+            });
+            if (rateLimit) {
+                stoppedByRateLimit = {
+                    sliceId,
+                    message: rateLimit.message,
+                };
+                break;
+            }
+        }
+        const summary = await summarizeSalesNavigatorAccountSearchRunFromSlices({
+            store,
+            runId,
+        });
+        await updateSalesNavigatorAccountSearchRun({
+            store,
+            runId,
+            status: summary.truncated ? "failed" : "finished",
+            totalSlices: summary.totalSlices,
+            storedAccounts: summary.storedAccounts,
+            attemptedSlices: summary.attemptedSlices,
+            splitEvents: summary.splitEvents,
+            failedSlices: summary.failedSlices,
+            unresolvedSlices: summary.unresolvedSlices,
+            truncated: summary.truncated,
+            lastError: stoppedByRateLimit?.message ?? summary.lastError,
+            rawPayload: {
+                lastRepair: {
+                    repairedAt: new Date().toISOString(),
+                    repairedSlices: repaired.length,
+                    skippedSlices: skipped.length,
+                    stoppedByRateLimit,
+                },
+            },
+        });
+        const payload = {
+            status: stoppedByRateLimit ? "rate_limited" : "ok",
+            mode: "account-repair",
+            runId,
+            inspectedSlices: repaired.length + skipped.length,
+            repaired,
+            skipped,
+            stoppedByRateLimit,
+            run: summary,
+        };
+        if (options.out) {
+            await writeJsonFile(options.out, payload);
+        }
+        printOutput(payload);
+        if (stoppedByRateLimit) {
+            throw new Error(stoppedByRateLimit.message);
+        }
+    }
+    finally {
+        await closeSalesNavigatorAccountSearchStore(store);
+    }
+});
+program
+    .command("salesnav:accounts:status")
+    .alias("accounts:status")
+    .description("Return the current status of a Sales Navigator account-search run.")
+    .requiredOption("--run-id <id>", "Sales Navigator account-search run id")
+    .option("--cooldown-seconds <number>", "Seconds to wait after a rate-limit before resuming", "3600")
+    .action(async (options) => {
+    const runId = z.string().uuid().parse(options.runId);
+    const cooldownSeconds = z.coerce
+        .number()
+        .int()
+        .min(60)
+        .max(86_400)
+        .parse(options.cooldownSeconds);
+    const session = await requireAuthSession();
+    const status = await getSalesNavigatorAccountRunStatus(session, runId, {
+        cooldownSeconds
+    });
+    printOutput({
+        status: "ok",
+        runId,
+        run: status.value.run,
+        workflow: {
+            ...status.value.run.workflow,
+            repairCommand: status.value.run.nextAction === "complete"
+                ? null
+                : buildSalesNavigatorAccountRepairCommand({ runId }),
+        },
+        stoppedSlices: status.value.run.problemSlices.map((slice) => ({
+            sliceId: slice.sliceId,
+            status: slice.status,
+            totalResults: slice.totalResults,
+            storedAccounts: slice.storedAccounts,
+            stopReason: slice.stopReason,
+            nextStart: slice.nextStart,
+            missingFromReported: slice.missingFromReported,
+            lastError: slice.lastError,
+            slicedQueryUrl: slice.slicedQueryUrl
+        }))
+    });
+});
+program
+    .command("salesnav:accounts:resume")
+    .alias("accounts:resume")
+    .description("Start the durable account-search coordinator for a previous account run.")
+    .requiredOption("--run-id <id>", "Sales Navigator account-search run id")
+    .option("--cooldown-seconds <number>", "Seconds to wait after a rate-limit before resuming", "3600")
+    .option("--status-only", "Only inspect the run and print the next action without starting a Vercel workflow", false)
+    .action(async (options) => {
+    const runId = z.string().uuid().parse(options.runId);
+    const cooldownSeconds = z.coerce
+        .number()
+        .int()
+        .min(60)
+        .max(86_400)
+        .parse(options.cooldownSeconds);
+    const session = await requireAuthSession();
+    const status = await getSalesNavigatorAccountRunStatus(session, runId, {
+        cooldownSeconds
+    });
+    if (options.statusOnly) {
+        printOutput({
+            status: "ok",
+            runId,
+            startedWorkflow: false,
+            nextAction: status.value.run.nextAction,
+            run: status.value.run,
+            workflow: {
+                ...status.value.run.workflow,
+                repairCommand: status.value.run.nextAction === "complete"
+                    ? null
+                    : buildSalesNavigatorAccountRepairCommand({ runId }),
+            },
+        });
+        return;
+    }
+    const workflow = await startSalesNavigatorAccountRunWorkflow(status.session, runId, { cooldownSeconds });
+    printOutput({
+        status: "accepted",
+        runId,
+        workflowRunId: workflow.value.workflowRunId,
+        nextAction: status.value.run.nextAction,
+        cooldownUntil: status.value.run.cooldownUntil,
+        repairCommand: buildSalesNavigatorAccountRepairCommand({ runId }),
+        problemSlices: status.value.run.problemSlices
+    });
+});
 program
     .command("phantombuster:containers:sync")
     .alias("pb:containers:sync")
     .description("Fetch Phantombuster containers for configured agents and store them in Neon.")
     .option("--agent-id <id>", "Phantombuster agent id to sync. Repeat to sync multiple agents.", collectStringOptionValue, [])
-    .option("--container-id <id>", "Specific Phantombuster container id to sync. Repeat to sync multiple containers.", collectStringOptionValue, [])
     .option("--limit <number>", "Maximum containers to fetch per Phantombuster page", "100")
     .option("--max-pages <number>", "Maximum Phantombuster pages to fetch per agent", "50")
     .option("--mode <mode>", "Phantombuster container mode: all or finalized", "all")
     .option("--before-ended-at <iso>", "Only fetch containers that ended before this ISO timestamp")
     .option("--metadata-only", "Store container metadata without fetching output and result objects", false)
-    .option("--refresh-lead-pool", "After syncing results, rebuild the Neon lead_pool_new reporting table. This can take several minutes.", false)
     .option("--out <path>", "Optional local JSON output path")
     .action(async (options) => {
     const agentIds = z.array(z.string().min(1)).parse(options.agentId);
-    const containerIds = z.array(z.string().min(1)).parse(options.containerId);
     const limit = z.coerce.number().int().min(1).max(500).parse(options.limit);
     const maxPages = z.coerce.number().int().min(1).max(500).parse(options.maxPages);
     const mode = z.enum(["all", "finalized"]).parse(options.mode);
@@ -10645,13 +13226,11 @@ program
     const session = await requireAuthSession();
     const result = await syncPhantombusterContainersViaApp(session, {
         agentIds: agentIds.length > 0 ? agentIds : undefined,
-        containerIds: containerIds.length > 0 ? containerIds : undefined,
         limit,
         maxPages,
         mode,
         beforeEndedAt,
-        includeResults: !options.metadataOnly,
-        refreshLeadPool: Boolean(options.refreshLeadPool)
+        includeResults: !options.metadataOnly
     });
     const payload = {
         ...result,
@@ -10737,100 +13316,6 @@ program
     }
     printOutput(payload);
 });
-program
-    .command("salesnav:local-import")
-    .alias("search:local-import")
-    .description("Run a saved Sales Navigator API request locally and store the people in Salesprompter.")
-    .option("--curl-file <path>", "Path to a saved curl request copied from the Sales Navigator network panel")
-    .option("--query-url <url>", "Sales Navigator people search URL. Uses the locally captured extension session automatically.")
-    .option("--max-results-per-search <number>", "Maximum expected results for this local request", "100")
-    .option("--number-of-profiles <number>", "Total profiles to import, or 'all' for the full reported result set", "all")
-    .option("--page-size <number>", "Profiles requested per local Sales Navigator API page", "25")
-    .option("--page-delay-min-ms <number>", "Minimum randomized delay between Sales Navigator result pages", "1500")
-    .option("--page-delay-max-ms <number>", "Maximum randomized delay between Sales Navigator result pages", "6000")
-    .option("--max-retries <number>", "Bounded retries for transient network/5xx failures. Rate limits still stop immediately.", "2")
-    .option("--retry-base-delay-ms <number>", "Base delay for full-jitter retry backoff", "2000")
-    .option("--retry-max-delay-ms <number>", "Maximum delay for full-jitter retry backoff", "30000")
-    .option("--slice-preset <name>", "Slice preset label stored with the import run", "local-salesnav")
-    .option("--out <path>", "Optional local JSON output path")
-    .option("--dry-run", "Run and normalize the local request without writing to Salesprompter", false)
-    .action(async (options) => {
-    const maxResultsPerSearch = z.coerce.number().int().min(1).max(100000).parse(options.maxResultsPerSearch);
-    const numberOfProfilesOption = String(options.numberOfProfiles ?? "all").trim().toLowerCase();
-    const requestedProfiles = numberOfProfilesOption === "all" ? null : z.coerce.number().int().min(1).max(100000).parse(options.numberOfProfiles);
-    const pageSize = z.coerce.number().int().min(1).max(100).parse(options.pageSize);
-    const pageDelayMinMs = z.coerce.number().int().min(0).max(300000).parse(options.pageDelayMinMs);
-    const pageDelayMaxMs = z.coerce.number().int().min(0).max(300000).parse(options.pageDelayMaxMs);
-    if (pageDelayMaxMs < pageDelayMinMs) {
-        throw new Error("--page-delay-max-ms must be greater than or equal to --page-delay-min-ms.");
-    }
-    const retry = {
-        maxRetries: z.coerce.number().int().min(0).max(5).parse(options.maxRetries),
-        retryBaseDelayMs: z.coerce.number().int().min(0).max(300000).parse(options.retryBaseDelayMs),
-        retryMaxDelayMs: z.coerce.number().int().min(0).max(300000).parse(options.retryMaxDelayMs)
-    };
-    const curlFile = typeof options.curlFile === "string" && options.curlFile.trim().length > 0 ? options.curlFile.trim() : null;
-    const queryUrl = typeof options.queryUrl === "string" && options.queryUrl.trim().length > 0 ? z.string().url().parse(options.queryUrl.trim()) : null;
-    if (Boolean(curlFile) === Boolean(queryUrl)) {
-        throw new Error("Provide exactly one of --curl-file or --query-url.");
-    }
-    const parsedRequest = curlFile
-        ? parseSalesNavigatorCurlRequest(await readFile(curlFile, "utf8"))
-        : buildSalesNavigatorApiRequestFromSearchUrl(queryUrl, await readLinkedInDirectLookupConfig(), pageSize);
-    const localFetch = await fetchAllLocalSalesNavigatorPeople(parsedRequest, {
-        requestedProfiles,
-        pageSize,
-        pageDelayMinMs,
-        pageDelayMaxMs,
-        retry
-    });
-    const people = localFetch.people;
-    const totalResults = localFetch.totalResults;
-    const dryRun = Boolean(options.dryRun);
-    if (people.length === 0) {
-        throw new Error("The local Sales Navigator response did not contain any importable people rows.");
-    }
-    const basePayload = {
-        status: "ok",
-        dryRun,
-        sourceQueryUrl: localFetch.sourceQueryUrl,
-        totalResults,
-        discovered: people.length,
-        fetchedPages: localFetch.fetchedPages,
-        requestedProfiles: requestedProfiles ?? "all",
-        pacing: localFetch.pacing,
-        people
-    };
-    if (dryRun) {
-        if (options.out) {
-            await writeJsonFile(options.out, basePayload);
-        }
-        printOutput(basePayload);
-        return;
-    }
-    const session = await requireAuthSession();
-    const imported = await importLocalSalesNavigatorPeopleViaApp(session, {
-        sourceQueryUrl: localFetch.sourceQueryUrl,
-        people,
-        totalResults,
-        fetchedPages: localFetch.fetchedPages,
-        pacing: localFetch.pacing,
-        maxResultsPerSearch,
-        numberOfProfiles: requestedProfiles ?? people.length,
-        slicePreset: options.slicePreset
-    });
-    const payload = {
-        ...basePayload,
-        runId: imported.runId,
-        containerId: imported.containerId,
-        imported: imported.imported,
-        upserted: imported.upserted
-    };
-    if (options.out) {
-        await writeJsonFile(options.out, payload);
-    }
-    printOutput(payload);
-});
 program
     .command("salesnav:count")
     .alias("search:count")
@@ -11493,54 +13978,6 @@ program
         execution
     });
 });
-program
-    .command("affiliate:launch")
-    .description("Turn an affiliate link and LinkedIn audience URL into a ready-to-review outreach campaign.")
-    .requiredOption("--affiliate-link <url>", "Affiliate landing URL, including the tracking/referral parameter")
-    .requiredOption("--linkedin-url <url>", "LinkedIn content/search URL for the audience")
-    .option("--max-results <number>", "Maximum audience profiles to extract", "1000")
-    .option("--dry-run", "Validate inputs and show the planned campaign without launching extraction", false)
-    .action(async (options) => {
-    const session = await requireAuthSession();
-    const result = await launchAffiliateCampaignViaApp(session, {
-        affiliateLink: z.string().url().parse(options.affiliateLink),
-        linkedInUrl: z.string().url().parse(options.linkedinUrl),
-        maxResults: z.coerce.number().int().min(1).max(1000).parse(options.maxResults),
-        dryRun: Boolean(options.dryRun)
-    });
-    printOutput(result);
-});
-program
-    .command("leads:process")
-    .description("Automatically process the lead pool: companies, contact cleanup, email finding, and qualified leads.")
-    .option("--client-id <number>", "Limit processing to one Salesprompter clientId")
-    .option("--company-limit <number>", "Max companies to start per enrichment batch", "10")
-    .option("--contact-country-limit <number>", "Max contact country-code rows to process", "500")
-    .option("--contact-name-limit <number>", "Max contact name rows to clean", "250")
-    .option("--hunter-limit <number>", "Max Hunter email-finder rows to process", "500")
-    .option("--hunter-concurrency <number>", "Hunter email-finder concurrency", "6")
-    .option("--refresh", "Run a full lead-pool refresh after processing", false)
-    .option("--no-qualified-leads", "Skip rebuilding the qualified lead snapshot")
-    .action(async (options) => {
-    const session = await requireAuthSession();
-    const clientId = options.clientId == null || String(options.clientId).trim() === ''
-        ? null
-        : parsePositiveClientIdValue(options.clientId);
-    const result = await runLeadPoolAutoProcessViaApp(session, {
-        clientId,
-        companyLimit: z.coerce.number().int().min(1).max(50).parse(options.companyLimit),
-        contactCountryLimit: z.coerce.number().int().min(1).max(5000).parse(options.contactCountryLimit),
-        contactNameLimit: z.coerce.number().int().min(1).max(250).parse(options.contactNameLimit),
-        hunterLimit: z.coerce.number().int().min(1).max(10000).parse(options.hunterLimit),
-        hunterConcurrency: z.coerce.number().int().min(1).max(12).parse(options.hunterConcurrency),
-        refresh: Boolean(options.refresh),
-        qualifiedLeads: options.qualifiedLeads !== false,
-    });
-    printOutput({
-        status: result.success ? "ok" : "partial",
-        ...result,
-    });
-});
 program
     .command("contacts:process-emails")
     .alias("contacts:resolve-emails")
@@ -11552,8 +13989,6 @@ program
     .requiredOption("--out-dir <path>", "Output directory for artifacts")
     .option("--trace-id <traceId>", "Trace id for this batch")
     .option("--endpoint-url <url>", "Override the enrichment workflow endpoint")
-    .option("--provider <provider>", "Email finder provider for workspace queue: hunter or phantombuster", "hunter")
-    .option("--retry-not-found-after-days <number>", "Retry stale Email not found rows after this many days", "1")
     .option("--timeout-ms <number>", "Workflow trigger timeout in milliseconds", "30000")
     .option("--company-cleaning <mode>", "Company cleaning mode for direct input: off, basic, or ai", "basic")
     .option("--dry-run", "Preview the next batch without starting background processing", false)
@@ -11562,69 +13997,7 @@ program
     const outDir = z.string().min(1).parse(options.outDir);
     const timeoutMs = z.coerce.number().int().min(1000).max(300000).parse(options.timeoutMs);
     const usingDirectInput = typeof options.in === "string" && options.in.trim().length > 0;
-    const provider = z.enum(["hunter", "phantombuster"]).parse(String(options.provider ?? "hunter").trim().toLowerCase());
-    const retryNotFoundAfterDays = z.coerce.number().int().min(0).max(30).parse(options.retryNotFoundAfterDays);
     const companyCleaningMode = resolveCompanyCleaningMode(String(options.companyCleaning ?? process.env.SALESPROMPTER_COMPANY_CLEANING_MODE ?? "basic"));
-    if (provider === "phantombuster" && !usingDirectInput) {
-        await mkdir(outDir, { recursive: true });
-        const traceId = z.string().min(1).parse(options.traceId ?? `salesprompter-cli-email-phantombuster-${Date.now()}`);
-        const requestPath = `${outDir}/email-enrichment-request-phantombuster.json`;
-        const responsePath = `${outDir}/email-enrichment-response-phantombuster.json`;
-        const requestPayload = {
-            traceId,
-            provider,
-            limit,
-            retryNotFoundAfterDays
-        };
-        await writeJsonFile(requestPath, requestPayload);
-        if (options.dryRun) {
-            printOutput({
-                status: "ok",
-                provider,
-                limit,
-                traceId,
-                dryRun: true,
-                mode: "workspace-queue",
-                contactsQueued: null,
-                started: false,
-                artifacts: {
-                    inputSqlPath: null,
-                    inputRowsPath: null,
-                    directReportPath: null,
-                    requestPath,
-                    responsePath: null
-                }
-            });
-            return;
-        }
-        const session = await requireAuthSession();
-        const result = await runLeadPoolEmailFinderViaApp(session, {
-            provider,
-            limit,
-            retryNotFoundAfterDays
-        });
-        await writeJsonFile(responsePath, result);
-        printOutput({
-            status: result.success ? "ok" : "partial",
-            provider,
-            limit,
-            traceId,
-            dryRun: false,
-            mode: "workspace-queue",
-            contactsQueued: result.selected,
-            started: Boolean(result.launched),
-            agentId: result.agentId ?? null,
-            containerId: result.containerId ?? null,
-            artifacts: {
-                inputSqlPath: null,
-                inputRowsPath: null,
-                directReportPath: null,
-                requestPath,
-                responsePath
-            }
-        });
-        return;
-    }
     let clientId;
     let queueRows;
     let directReportRows = null;