@sellable/mcp 0.1.273 → 0.1.274

package/dist/server.js

@@ -18,6 +18,7 @@ import { copySenderConfigTool, getEngageMemoryTool, migrateFlatConfigsTool, reco
 import { getEngageStateTool, setEngageStateTool, } from "./tools/engage-state.js";
 import { bulkEnrichWithProspeo, enrichWithProspeo, getProspeoCredits, } from "./tools/enrichment.js";
 import { getCampaignFramework } from "./tools/framework.js";
+import { confirmHarvestJobCompanies, searchHarvestJobs, } from "./tools/harvest-jobs.js";
 import { cancelLeadImport, confirmLeadList, confirmProspeoCompanyAccounts, getProviderPrompt, importLeads, listDncEntriesTool, loadCsvDncEntriesTool, loadCsvDomains, loadCsvLinkedinLeads, lookupSalesNavFilter, saveDomainFilters, searchApollo, searchProspeo, searchProspeoCompanies, searchSalesNav, searchSignals, selectPromisingPosts, setHeadlineICPCriteria, } from "./tools/leads.js";
 import { fetchCompany, fetchCompanyPosts, fetchLinkedInPosts, fetchLinkedInProfile, fetchPostEngagers, getLinkedInProfile, getUserPosts, } from "./tools/linkedin.js";
 import { getCampaignNavigationState } from "./tools/navigation.js";
@@ -372,6 +373,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "confirm_prospeo_company_accounts":
                 result = await confirmProspeoCompanyAccounts(args);
                 break;
+            case "search_harvest_jobs":
+                result = await searchHarvestJobs(args);
+                break;
+            case "confirm_harvest_job_companies":
+                result = await confirmHarvestJobCompanies(args);
+                break;
             case "load_csv_domains":
                 result = await loadCsvDomains(args);
                 break;

package/dist/tools/harvest-jobs.d.ts

@@ -0,0 +1,182 @@
+type ArtifactFormat = "markdown" | "csv" | "both";
+export interface SearchHarvestJobsInput {
+    search?: string;
+    searches?: string[];
+    location?: string;
+    geoId?: string;
+    postedLimit?: "24h" | "week" | "month";
+    sortBy?: "relevance" | "date";
+    workplaceType?: string | string[];
+    employmentType?: string | string[];
+    experienceLevel?: string | string[];
+    easyApply?: boolean;
+    under10Applicants?: boolean;
+    salary?: string;
+    pages?: number;
+    maxRows?: number;
+    artifactFormat?: ArtifactFormat;
+    outputDir?: string;
+    fileBaseName?: string;
+}
+export interface ConfirmHarvestJobCompaniesInput {
+    searchToken?: string;
+    selectedJobIds?: string[];
+    name?: string;
+    outputDir?: string;
+    fileBaseName?: string;
+    [key: string]: unknown;
+}
+export declare const harvestJobToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            search: {
+                type: string;
+            };
+            searches: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            location: {
+                type: string;
+            };
+            geoId: {
+                type: string;
+            };
+            postedLimit: {
+                type: string;
+                enum: string[];
+            };
+            sortBy: {
+                type: string;
+                enum: string[];
+            };
+            workplaceType: {
+                oneOf: ({
+                    type: string;
+                    items?: undefined;
+                } | {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                })[];
+            };
+            employmentType: {
+                oneOf: ({
+                    type: string;
+                    items?: undefined;
+                } | {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                })[];
+            };
+            experienceLevel: {
+                oneOf: ({
+                    type: string;
+                    items?: undefined;
+                } | {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                })[];
+            };
+            easyApply: {
+                type: string;
+            };
+            under10Applicants: {
+                type: string;
+            };
+            salary: {
+                type: string;
+            };
+            pages: {
+                type: string;
+                description: string;
+            };
+            maxRows: {
+                type: string;
+                description: string;
+            };
+            artifactFormat: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            outputDir: {
+                type: string;
+                description: string;
+            };
+            fileBaseName: {
+                type: string;
+                description: string;
+            };
+            searchToken?: undefined;
+            selectedJobIds?: undefined;
+            name?: undefined;
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            searchToken: {
+                type: string;
+                description: string;
+            };
+            selectedJobIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            name: {
+                type: string;
+            };
+            outputDir: {
+                type: string;
+                description: string;
+            };
+            fileBaseName: {
+                type: string;
+                description: string;
+            };
+            search?: undefined;
+            searches?: undefined;
+            location?: undefined;
+            geoId?: undefined;
+            postedLimit?: undefined;
+            sortBy?: undefined;
+            workplaceType?: undefined;
+            employmentType?: undefined;
+            experienceLevel?: undefined;
+            easyApply?: undefined;
+            under10Applicants?: undefined;
+            salary?: undefined;
+            pages?: undefined;
+            maxRows?: undefined;
+            artifactFormat?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+})[];
+export declare function searchHarvestJobs(input: SearchHarvestJobsInput): Promise<{
+    [k: string]: unknown;
+}>;
+export declare function confirmHarvestJobCompanies(input: ConfirmHarvestJobCompaniesInput): Promise<{
+    [k: string]: unknown;
+}>;
+export {};

package/dist/tools/harvest-jobs.js

@@ -0,0 +1,429 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getApi } from "../api.js";
+import { resolveWorkspaceRoot } from "../utils/workspace-root.js";
+const entryPath = process.argv[1] ? path.resolve(process.argv[1]) : process.cwd();
+const workspaceRoot = resolveWorkspaceRoot(path.dirname(entryPath));
+const HARVEST_JOB_SEARCH_TOKEN_REF_PREFIX = "mcp-harvest-job-search-token:";
+const MAX_HARVEST_JOB_SEARCH_TOKEN_REFS = 200;
+const tokenRefs = new Map();
+let tokenRefCounter = 0;
+export const harvestJobToolDefinitions = [
+    {
+        name: "search_harvest_jobs",
+        description: "Search current LinkedIn jobs through Sellable's Harvest-backed v3 API, write markdown/CSV review artifacts, and return a token reference for selected-company confirmation. Use when account-source intent is current LinkedIn job posts. Does not call Prospeo or confirm companies.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                search: { type: "string" },
+                searches: { type: "array", items: { type: "string" } },
+                location: { type: "string" },
+                geoId: { type: "string" },
+                postedLimit: { type: "string", enum: ["24h", "week", "month"] },
+                sortBy: { type: "string", enum: ["relevance", "date"] },
+                workplaceType: {
+                    oneOf: [
+                        { type: "string" },
+                        { type: "array", items: { type: "string" } },
+                    ],
+                },
+                employmentType: {
+                    oneOf: [
+                        { type: "string" },
+                        { type: "array", items: { type: "string" } },
+                    ],
+                },
+                experienceLevel: {
+                    oneOf: [
+                        { type: "string" },
+                        { type: "array", items: { type: "string" } },
+                    ],
+                },
+                easyApply: { type: "boolean" },
+                under10Applicants: { type: "boolean" },
+                salary: { type: "string" },
+                pages: {
+                    type: "number",
+                    description: "Max pages per search term. Backend cap is 2.",
+                },
+                maxRows: {
+                    type: "number",
+                    description: "Max returned rows across searches. Backend cap is 100.",
+                },
+                artifactFormat: {
+                    type: "string",
+                    enum: ["markdown", "csv", "both"],
+                    description: "Review artifact format. Defaults to markdown.",
+                },
+                outputDir: {
+                    type: "string",
+                    description: "Optional safe output directory under the workspace, home, or temp root.",
+                },
+                fileBaseName: {
+                    type: "string",
+                    description: "Optional safe artifact filename base without extension.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "confirm_harvest_job_companies",
+        description: "Confirm selected Harvest LinkedIn job IDs into a backend-resolved Prospeo domainFilterId, then guide the follow-on search_prospeo people search. Requires searchToken or token reference from search_harvest_jobs. Does not accept raw domains.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                searchToken: {
+                    type: "string",
+                    description: "Signed search token or mcp-harvest-job-search-token:* reference from search_harvest_jobs.",
+                },
+                selectedJobIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Harvest job IDs selected from the search artifact.",
+                },
+                name: { type: "string" },
+                outputDir: {
+                    type: "string",
+                    description: "Optional safe output directory under the workspace, home, or temp root.",
+                },
+                fileBaseName: {
+                    type: "string",
+                    description: "Optional safe artifact filename base without extension.",
+                },
+            },
+            required: ["searchToken", "selectedJobIds"],
+            additionalProperties: false,
+        },
+    },
+];
+function removeUndefinedValues(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}
+function storeTokenRef(token) {
+    if (typeof token !== "string" || token.length === 0)
+        return token;
+    if (token.startsWith(HARVEST_JOB_SEARCH_TOKEN_REF_PREFIX))
+        return token;
+    const ref = `${HARVEST_JOB_SEARCH_TOKEN_REF_PREFIX}${Date.now().toString(36)}-${(++tokenRefCounter).toString(36)}`;
+    tokenRefs.set(ref, token);
+    while (tokenRefs.size > MAX_HARVEST_JOB_SEARCH_TOKEN_REFS) {
+        const oldest = tokenRefs.keys().next().value;
+        if (!oldest)
+            break;
+        tokenRefs.delete(oldest);
+    }
+    return ref;
+}
+function resolveTokenRef(token) {
+    if (!token.startsWith(HARVEST_JOB_SEARCH_TOKEN_REF_PREFIX))
+        return token;
+    const resolved = tokenRefs.get(token);
+    if (!resolved) {
+        throw new Error("confirm_harvest_job_companies received a stale Harvest job search token reference. Re-run search_harvest_jobs.");
+    }
+    return resolved;
+}
+function validateSearchInput(input) {
+    if (!input?.search && (!input?.searches || input.searches.length === 0)) {
+        throw new Error("search_harvest_jobs requires search or searches.");
+    }
+}
+function validateConfirmInput(input) {
+    if (!input?.searchToken) {
+        throw new Error("confirm_harvest_job_companies requires searchToken from search_harvest_jobs.");
+    }
+    if (!input.selectedJobIds || input.selectedJobIds.length === 0) {
+        throw new Error("confirm_harvest_job_companies requires selectedJobIds from search_harvest_jobs results.");
+    }
+    if ("domain" in input ||
+        "domains" in input ||
+        "includeDomains" in input ||
+        "companyDomains" in input) {
+        throw new Error("confirm_harvest_job_companies does not accept raw domains. Use searchToken and selectedJobIds.");
+    }
+}
+function decodeMaybe(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function isPathInside(candidate, root) {
+    const relative = path.relative(root, candidate);
+    return (relative === "" ||
+        (!relative.startsWith("..") && !path.isAbsolute(relative)));
+}
+function safeBaseName(value, fallback) {
+    const raw = (value ?? fallback).trim();
+    const decoded = decodeMaybe(raw);
+    const cleaned = decoded
+        .replace(/\.[A-Za-z0-9]+$/, "")
+        .replace(/[^A-Za-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+    if (!cleaned || cleaned.includes("..")) {
+        throw new Error("fileBaseName must be a safe filename.");
+    }
+    return cleaned;
+}
+function allowedRoots() {
+    return [workspaceRoot, os.homedir(), os.tmpdir()]
+        .map((root) => {
+        const resolved = path.resolve(root);
+        try {
+            return fs.realpathSync(resolved);
+        }
+        catch {
+            return resolved;
+        }
+    })
+        .filter(Boolean);
+}
+function resolveOutputDir(outputDir) {
+    const target = outputDir
+        ? path.isAbsolute(outputDir)
+            ? path.resolve(outputDir)
+            : path.resolve(workspaceRoot, outputDir)
+        : path.resolve(workspaceRoot, ".sellable", "artifacts", "harvest-jobs");
+    if (target.includes("\0")) {
+        throw new Error("outputDir contains invalid characters.");
+    }
+    fs.mkdirSync(target, { recursive: true });
+    const real = fs.realpathSync(target);
+    if (!allowedRoots().some((root) => isPathInside(real, root))) {
+        throw new Error("outputDir must be inside the workspace, home directory, or temp directory.");
+    }
+    return real;
+}
+function collisionSafePath(outputDir, fileBaseName, ext) {
+    const extension = ext.startsWith(".") ? ext : `.${ext}`;
+    if (![".md", ".csv"].includes(extension)) {
+        throw new Error(`Unsupported artifact extension: ${extension}`);
+    }
+    let candidate = path.join(outputDir, `${fileBaseName}${extension}`);
+    let counter = 1;
+    while (fs.existsSync(candidate)) {
+        candidate = path.join(outputDir, `${fileBaseName}-${counter}${extension}`);
+        counter += 1;
+    }
+    const resolved = path.resolve(candidate);
+    if (!isPathInside(resolved, outputDir)) {
+        throw new Error("Artifact path escapes outputDir.");
+    }
+    if (fs.existsSync(resolved) && fs.lstatSync(resolved).isSymbolicLink()) {
+        throw new Error("Refusing to write through symlink artifact path.");
+    }
+    return resolved;
+}
+function csvEscape(value) {
+    const text = value === null || value === undefined ? "" : String(value);
+    return /[",\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function formatValue(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+function renderSearchMarkdown(response) {
+    const rows = Array.isArray(response.rows) ? response.rows : [];
+    const lines = [
+        "# Harvest LinkedIn Job Search",
+        "",
+        `Row count: ${response.rowCount ?? rows.length}`,
+        `Cost summary: ${JSON.stringify(response.costSummary ?? {})}`,
+        `Search summary: ${JSON.stringify(response.summary ?? {})}`,
+        "",
+        "Domains are resolved only during confirmation. Select stable Harvest job IDs, not LinkedIn company URLs.",
+        "",
+        "| Job ID | Company | Title | Posted | Location | Easy Apply | Job URL | Company LinkedIn | Request ID |",
+        "| --- | --- | --- | --- | --- | --- | --- | --- | --- |",
+        ...rows.map((row) => [
+            row.jobId,
+            row.companyName,
+            row.title,
+            row.postedDate,
+            row.locationText,
+            row.easyApply,
+            row.jobUrl,
+            row.companyLinkedinUrl,
+            row.harvestRequestId,
+        ]
+            .map((value) => String(value ?? "").replace(/\|/g, "\\|"))
+            .join(" | ")
+            .replace(/^/, "| ")
+            .replace(/$/, " |")),
+        "",
+        "Next step: confirm_harvest_job_companies({ searchToken, selectedJobIds: [...] })",
+    ];
+    return `${lines.join("\n")}\n`;
+}
+function renderSearchCsv(response) {
+    const rows = Array.isArray(response.rows) ? response.rows : [];
+    const columns = [
+        "rowId",
+        "jobId",
+        "companyName",
+        "title",
+        "jobUrl",
+        "postedDate",
+        "locationText",
+        "easyApply",
+        "companyLinkedinUrl",
+        "companyUniversalName",
+        "harvestRequestId",
+        "search",
+        "page",
+    ];
+    return [
+        columns.join(","),
+        ...rows.map((row) => columns.map((column) => csvEscape(row[column])).join(",")),
+    ].join("\n");
+}
+function renderConfirmMarkdown(response) {
+    const unresolved = Array.isArray(response.unresolvedJobs)
+        ? response.unresolvedJobs
+        : [];
+    const skipped = Array.isArray(response.skippedJobs) ? response.skippedJobs : [];
+    const lines = [
+        "# Harvest LinkedIn Job Confirmation",
+        "",
+        `Domain filter ID: ${response.domainFilterId ?? ""}`,
+        `Resolved: ${response.resolvedCount ?? 0}`,
+        `Unresolved: ${response.unresolvedCount ?? 0}`,
+        `Duplicates: ${response.duplicateCount ?? 0}`,
+        `Skipped: ${response.skippedCount ?? 0}`,
+        `Cost summary: ${JSON.stringify(response.costSummary ?? {})}`,
+        "",
+        "## Resolved Domains",
+        "",
+        ...(response.includeDomains ?? []).map((domain) => `- ${domain}`),
+        "",
+        "## Unresolved Jobs",
+        "",
+        ...unresolved.map((row) => `- ${formatValue(row.jobId)}: ${formatValue(row.reason)}`),
+        "",
+        "## Skipped Jobs",
+        "",
+        ...skipped.map((row) => `- ${formatValue(row.jobId)}: ${formatValue(row.reason)}`),
+        "",
+        "Next step: search_prospeo with the returned domainFilterId.",
+    ];
+    return `${lines.join("\n")}\n`;
+}
+function writeSearchArtifacts(response, input) {
+    const format = input.artifactFormat ?? "markdown";
+    const outputDir = resolveOutputDir(input.outputDir);
+    const baseName = safeBaseName(input.fileBaseName, `harvest-jobs-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+    const artifacts = {};
+    if (format === "markdown" || format === "both") {
+        const markdownPath = collisionSafePath(outputDir, baseName, ".md");
+        fs.writeFileSync(markdownPath, renderSearchMarkdown(response), "utf8");
+        artifacts.markdown = markdownPath;
+    }
+    if (format === "csv" || format === "both") {
+        const csvPath = collisionSafePath(outputDir, baseName, ".csv");
+        fs.writeFileSync(csvPath, renderSearchCsv(response), "utf8");
+        artifacts.csv = csvPath;
+    }
+    return artifacts;
+}
+function writeConfirmArtifact(response, input) {
+    const outputDir = resolveOutputDir(input.outputDir);
+    const baseName = safeBaseName(input.fileBaseName, `harvest-jobs-confirm-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+    const artifactPath = collisionSafePath(outputDir, baseName, ".md");
+    fs.writeFileSync(artifactPath, renderConfirmMarkdown(response), "utf8");
+    return artifactPath;
+}
+function compactSearchResponse(response, artifacts) {
+    const rows = Array.isArray(response.rows) ? response.rows : [];
+    const token = storeTokenRef(response.searchToken);
+    return removeUndefinedValues({
+        success: response.success ?? true,
+        rowCount: typeof response.rowCount === "number" ? response.rowCount : rows.length,
+        costSummary: response.costSummary ?? {},
+        artifacts,
+        sampleJobs: rows.slice(0, 10).map((row) => removeUndefinedValues({
+            rowId: row.rowId,
+            jobId: row.jobId,
+            company: row.companyName,
+            title: row.title,
+            jobUrl: row.jobUrl,
+            postedDate: row.postedDate,
+            location: row.locationText,
+            easyApply: row.easyApply,
+            companyLinkedinUrl: row.companyLinkedinUrl,
+            companyUniversalName: row.companyUniversalName,
+        })),
+        searchToken: token,
+        nextStep: "Review the artifact, then call confirm_harvest_job_companies with searchToken and selectedJobIds. Harvest jobs are account-source evidence; Prospeo is the follow-on people search.",
+    });
+}
+function compactConfirmResponse(response, artifactPath) {
+    return removeUndefinedValues({
+        success: response.success ?? true,
+        domainFilterId: response.domainFilterId,
+        includeDomains: response.includeDomains,
+        resolvedCount: response.resolvedCount,
+        unresolvedCount: response.unresolvedCount,
+        duplicateCount: response.duplicateCount,
+        skippedCount: response.skippedCount,
+        costSummary: response.costSummary,
+        unresolvedJobs: response.unresolvedJobs ?? [],
+        skippedJobs: response.skippedJobs ?? [],
+        carryoverSummary: response.carryoverSummary,
+        confirmArtifactPath: artifactPath,
+        suggestedNextCall: {
+            tool: "search_prospeo",
+            arguments: response.nextSearchProspeoCall ?? {
+                domainFilterId: response.domainFilterId,
+                filters: { max_person_per_company: 1 },
+            },
+        },
+    });
+}
+export async function searchHarvestJobs(input) {
+    validateSearchInput(input);
+    const api = getApi();
+    const response = await api.post("/api/v3/harvest/linkedin-jobs/search", removeUndefinedValues({
+        search: input.search,
+        searches: input.searches,
+        location: input.location,
+        geoId: input.geoId,
+        postedLimit: input.postedLimit,
+        sortBy: input.sortBy,
+        workplaceType: input.workplaceType,
+        employmentType: input.employmentType,
+        experienceLevel: input.experienceLevel,
+        easyApply: input.easyApply,
+        under10Applicants: input.under10Applicants,
+        salary: input.salary,
+        pages: input.pages,
+        maxRows: input.maxRows,
+    }));
+    if (!response || typeof response !== "object" || !response.searchToken) {
+        throw new Error("search_harvest_jobs API response did not include a searchToken.");
+    }
+    const artifacts = writeSearchArtifacts(response, input);
+    return compactSearchResponse(response, artifacts);
+}
+export async function confirmHarvestJobCompanies(input) {
+    validateConfirmInput(input);
+    const api = getApi();
+    const response = await api.post("/api/v3/harvest/linkedin-jobs/confirm-domain-filter", removeUndefinedValues({
+        searchToken: resolveTokenRef(input.searchToken),
+        selectedJobIds: input.selectedJobIds,
+        name: input.name,
+    }));
+    if (!response || typeof response !== "object" || !response.domainFilterId) {
+        throw new Error("confirm_harvest_job_companies API response did not include a domainFilterId.");
+    }
+    const artifactPath = writeConfirmArtifact(response, input);
+    return compactConfirmResponse(response, artifactPath);
+}

package/dist/tools/leads.js

@@ -1813,7 +1813,7 @@ export const leadToolDefinitions = [
     },
     {
         name: "search_prospeo",
-        description: 'Search Prospeo for people using filters and optional domainFilterId. Requires get_provider_prompt({ provider: "prospeo" }) first. Use Prospeo first for hiring-led targeting because it supports company_job_posting_hiring_for and company_job_posting_quantity; Sales Nav does not filter companies by hiring role. When targeting known accounts, call load_csv_domains for CSV-on-disk workflows or save_domain_filters for pasted/raw domain lists, then pass domainFilterId. For company lookalike/account asks, call search_prospeo_companies first, review accounts, then confirm_prospeo_company_accounts to create a domainFilterId before using search_prospeo for people. Raw domain inputs and company-name targeting are NOT supported in this MCP tool. Strategy: start with 2-3 high-signal filters (title/seniority + industry or domainFilterId + headcount), add job-posting filters for hiring-led campaigns, then tighten one filter at a time. For security, AppSec, SOC, RevOps, Demand Gen, and similar function-specific lanes, do not widen with bare seniority labels like "Head" or "Director" alone; pair them with explicit function-title keywords and inspect the sample for off-function `Head of X` leakage. If output includes warnings/fallback, report that the MCP retried a rejected precise title request with a safer domain-filter people search instead of claiming the original precise filter succeeded. Prefer person location over company HQ unless HQ is explicitly needed. `campaignOfferId` routing rule: OMIT campaignOfferId ONLY in pre-mint Phase 84 `find leads` discovery mode (validating ICP before the commit gate). In every other context — post-mint lead additions, operator-driven searches on a live campaign, any search where the intent is to persist results to a specific campaign — you MUST pass campaignOfferId so the search shows up in that campaign\'s Contact Search panel. Post-mint create-campaign-v2 watch runs MUST pass currentStep: "prospeo". Omitting campaignOfferId post-mint orphans the search from the UI. Returns normalized results with pagination.',
+        description: 'Search Prospeo for people using filters and optional domainFilterId. Requires get_provider_prompt({ provider: "prospeo" }) first. Use Prospeo first for hiring-led targeting because it supports company_job_posting_hiring_for and company_job_posting_quantity; Sales Nav does not filter companies by hiring role. When targeting known accounts, call load_csv_domains for CSV-on-disk workflows or save_domain_filters for pasted/raw domain lists, then pass domainFilterId. For current LinkedIn job-post account-source asks, call search_harvest_jobs first, review the artifact, then confirm_harvest_job_companies to create a domainFilterId before using search_prospeo for people. For company lookalike/account asks, call search_prospeo_companies first, review accounts, then confirm_prospeo_company_accounts to create a domainFilterId before using search_prospeo for people. Raw domain inputs, LinkedIn company URLs as domains, and company-name targeting are NOT supported in this MCP tool. Strategy: start with 2-3 high-signal filters (title/seniority + industry or domainFilterId + headcount), add job-posting filters for hiring-led campaigns, then tighten one filter at a time. For security, AppSec, SOC, RevOps, Demand Gen, and similar function-specific lanes, do not widen with bare seniority labels like "Head" or "Director" alone; pair them with explicit function-title keywords and inspect the sample for off-function `Head of X` leakage. If output includes warnings/fallback, report that the MCP retried a rejected precise title request with a safer domain-filter people search instead of claiming the original precise filter succeeded. Prefer person location over company HQ unless HQ is explicitly needed. `campaignOfferId` routing rule: OMIT campaignOfferId ONLY in pre-mint Phase 84 `find leads` discovery mode (validating ICP before the commit gate). In every other context — post-mint lead additions, operator-driven searches on a live campaign, any search where the intent is to persist results to a specific campaign — you MUST pass campaignOfferId so the search shows up in that campaign\'s Contact Search panel. Post-mint create-campaign-v2 watch runs MUST pass currentStep: "prospeo". Omitting campaignOfferId post-mint orphans the search from the UI. Returns normalized results with pagination.',
         inputSchema: {
             type: "object",
             properties: {

package/dist/tools/registry.d.ts

@@ -1956,6 +1956,53 @@ export declare const allTools: ({
         };
         required: never[];
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            searchToken: {
+                type: string;
+                description: string;
+            };
+            selectedJobIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            name: {
+                type: string;
+            };
+            outputDir: {
+                type: string;
+                description: string;
+            };
+            fileBaseName: {
+                type: string;
+                description: string;
+            };
+            search?: undefined;
+            searches?: undefined;
+            location?: undefined;
+            geoId?: undefined;
+            postedLimit?: undefined;
+            sortBy?: undefined;
+            workplaceType?: undefined;
+            employmentType?: undefined;
+            experienceLevel?: undefined;
+            easyApply?: undefined;
+            under10Applicants?: undefined;
+            salary?: undefined;
+            pages?: undefined;
+            maxRows?: undefined;
+            artifactFormat?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
 } | {
     name: string;
     description: string;

package/dist/tools/registry.js

@@ -14,6 +14,7 @@ import { engageMemoryToolDefinitions } from "./engage-memory.js";
 import { engageStateToolDefinitions } from "./engage-state.js";
 import { enrichmentToolDefinitions } from "./enrichment.js";
 import { frameworkToolDefinitions } from "./framework.js";
+import { harvestJobToolDefinitions } from "./harvest-jobs.js";
 import { leadToolDefinitions } from "./leads.js";
 import { linkedinToolDefinitions } from "./linkedin.js";
 import { navigationToolDefinitions } from "./navigation.js";
@@ -43,6 +44,7 @@ export const allTools = [
     ...contentPostToolDefinitions,
     ...navigationToolDefinitions,
     ...leadToolDefinitions,
+    ...harvestJobToolDefinitions,
     ...enrichmentToolDefinitions,
     ...processingToolDefinitions,
     ...rubricToolDefinitions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.273",
+  "version": "0.1.274",
   "type": "module",
   "description": "Sellable MCP server for Claude Code and Codex campaign workflows",
   "main": "dist/index.js",

package/skills/create-campaign/SKILL.md

@@ -29,6 +29,8 @@ allowed-tools:
   - mcp__sellable__search_prospeo
   - mcp__sellable__search_prospeo_companies
   - mcp__sellable__confirm_prospeo_company_accounts
+  - mcp__sellable__search_harvest_jobs
+  - mcp__sellable__confirm_harvest_job_companies
   - mcp__sellable__search_signals
   - mcp__sellable__fetch_post_engagers
   - mcp__sellable__enrich_with_prospeo
@@ -227,6 +229,14 @@ are likely. Sales Nav is useful for recent LinkedIn activity, role/title
 precision, and referral paths, but it does not provide hiring-by-role filters;
 say that distinction plainly in the source-plan gate.
 
+When the brief asks for current LinkedIn job-post intent, such as companies
+hiring Power BI developers this month, use Harvest jobs as the account source:
+`search_harvest_jobs -> confirm_harvest_job_companies -> search_prospeo`.
+First write and review the Harvest job artifact. Then confirm selected Harvest
+job IDs into a `domainFilterId`; Prospeo remains the people-search provider.
+Do not paste LinkedIn company URLs as domains. Do not fetch full job details for
+every search row by default; selected batches only.
+
 For company lookalikes, best-customer lookalikes, "companies like X",
 lookalike accounts, companies that use AI, companies with API/SSO/Chrome
 extension, news/award/integration/key-customer filters, or account discovery

package/skills/create-campaign/core/providers/prospeo.json

@@ -7,6 +7,8 @@
   "requiredTools": [
     "update_campaign",
     "get_provider_prompt",
+    "search_harvest_jobs",
+    "confirm_harvest_job_companies",
     "search_prospeo_companies",
     "confirm_prospeo_company_accounts",
     "search_prospeo",
@@ -24,13 +26,14 @@
     "useWhen": [
       "You want Prospeo filters or domain-based search",
       "You need company lookalike account discovery before finding people",
+      "You need current LinkedIn job-post evidence before finding hiring stakeholders",
       "You want companies like X, target-domain, best-customer/top-customer, or job-search employer lookalikes, or accounts using AI/API/SSO/Chrome extensions",
       "You need companies hiring for specific roles using job-posting filters",
       "You need high deliverability from Prospeo"
     ],
     "avoidWhen": ["You need LinkedIn activity filters"],
-    "reason": "Strong for hiring-led search, company/account lookalikes, Prospeo-specific filters, verified contacts, and domain lists.",
-    "prose": "Since you're targeting **{icp}**, I'd recommend **Prospeo**.\n\nHere's why:\n- Prospeo can discover lookalike accounts first, then turn approved accounts into a domainFilterId for people search\n- Prospeo can filter for companies hiring specific roles with job-posting filters\n- We can pair those company signals with buyer/referrer titles and verified-contact coverage\n\nFor lookalike accounts, I will show an account sample first; those account rows are not people leads yet. After approval, I will use the companySearchToken to confirm the accounts, then search people at the returned domainFilterId. For outbound lookalikes, I will use target/account/customer domains or verified past-customer accounts, not the sender's company. For job-search/application lookalikes, I can use current or past employers as existing-company seeds.\n\nShould I search Prospeo for {icp}?"
+    "reason": "Strong for hiring-led search, current LinkedIn job-post account sourcing, company/account lookalikes, Prospeo-specific filters, verified contacts, and domain lists.",
+    "prose": "Since you're targeting **{icp}**, I'd recommend **Prospeo**.\n\nHere's why:\n- Prospeo can discover lookalike accounts first, then turn approved accounts into a domainFilterId for people search\n- Harvest job search can source companies from current LinkedIn job posts, then confirm selected jobs into a domainFilterId for Prospeo people search\n- Prospeo can filter for companies hiring specific roles with job-posting filters\n- We can pair those company signals with buyer/referrer titles and verified-contact coverage\n\nFor current LinkedIn job-post evidence, I will use search_harvest_jobs -> confirm_harvest_job_companies -> search_prospeo. I will not paste LinkedIn company URLs as domains, and I will only fetch job details for selected batches. For lookalike accounts, I will show an account sample first; those account rows are not people leads yet. After approval, I will use the companySearchToken to confirm the accounts, then search people at the returned domainFilterId. For outbound lookalikes, I will use target/account/customer domains or verified past-customer accounts, not the sender's company. For job-search/application lookalikes, I can use current or past employers as existing-company seeds.\n\nShould I search Prospeo for {icp}?"
   },
   "askOption": {
     "label": "Prospeo",

package/skills/generate-messages/SKILL.md

@@ -761,6 +761,15 @@ help...` or `built for [buyer] to...`. Do not overuse generic solved-state
   bridges like `there's a way to...`; they read informercial when they imply
   the buyer's problem is now solved before the product or artifact has earned
   that claim.
+- run a contraction naturalness pass on the buyer-facing copy before selecting
+  the winner. Use common contractions when they make the message sound like a
+  human LinkedIn note: `it is` -> `it's`, `does not` -> `doesn't`, `do not` ->
+  `don't`, `cannot` -> `can't`, `we are` -> `we're`, `I am` -> `I'm`, and
+  `you are` -> `you're`. Keep the uncontracted form only when emphasis,
+  grammar, token boundaries, legal/technical clarity, or a deliberate formal
+  voice requires it. Do not create awkward noun contractions like
+  `outbound's becoming`. If selected copy contains stiff helper-verb phrasing
+  such as `It is knowing...`, rewrite it before approval.
 - do not let the first substantive line become a generic problem-solved
   promise. Openers shaped like `there's a way to stop/fix/solve [problem]`
   are BLOCKED when they sound like an ad, imply the problem is already
@@ -2633,6 +2642,7 @@ hiring for`
 - Best PS / no-PS decision: Candidate [A|B|C] — reason
 - Element edits made by finalizer: ...
 - Parallel action formatting: bullets used | paragraphs kept | not applicable — reason
+- Contraction naturalness: PASS | BLOCKED — reason
 - Style consistency check: PASS | BLOCKED — reason
 - Assembly note: clean combination or one candidate swept
 

package/skills/providers/prospeo.md

@@ -9,10 +9,31 @@ Prospeo supports search + import in the campaign builder flow.
 ## Provider Decision Tree
 
 - Known account list or CSV: use `load_csv_domains` or `save_domain_filters`, then `search_prospeo`.
+- Current LinkedIn job-post intent: use `search_harvest_jobs`, review the job artifact, then use `confirm_harvest_job_companies` with selected Harvest job IDs to create a `domainFilterId`; only then call `search_prospeo` for hiring stakeholders at those companies. Harvest jobs are the account source, not a people-search replacement.
 - Company/account lookalikes: use `search_prospeo_companies`, review the account sample, then use `confirm_prospeo_company_accounts` with the returned `companySearchToken` to create a `domainFilterId`; only then call `search_prospeo` for people at those accounts. Account rows are not people leads yet.
 - Person search with known filters: use `search_prospeo` directly.
 - LinkedIn activity, content-source, or post-engagement intent: stay on Signal Discovery or Sales Nav, not Prospeo.
 
+Current LinkedIn job-post account sourcing must follow:
+
+```text
+search_harvest_jobs -> confirm_harvest_job_companies -> search_prospeo
+```
+
+Use `search_harvest_jobs` when the user's account-source intent is current
+LinkedIn job posts, for example "companies hiring Power BI developers in the US
+this month." The search tool writes review artifacts and returns a token or
+`mcp-harvest-job-search-token:*` reference. After reviewing selected jobs, call
+`confirm_harvest_job_companies` with selected Harvest job IDs only. It resolves
+real company website domains from selected job details and bounded
+`/linkedin/company` fallback, then returns a `domainFilterId` for
+`search_prospeo`.
+
+Do not paste LinkedIn company URLs as domains. Do not detail-fetch every job row
+by default; fetch details only for selected batches during confirmation. Use
+Prospeo directly when the user wants broader volume, company attributes,
+lookalikes, or people search without needing current LinkedIn job evidence.
+
 Company/account lookalikes must follow:
 
 ```text

package/skills/research/config.json

@@ -1,9 +0,0 @@
-{
-  "parallelMode": "wide",
-  "agentCount": 6,
-  "maxToolCallsPerAgent": 2,
-  "senderMaxAgents": 2,
-  "senderMaxToolCallsPerAgent": 3,
-  "progressMode": true,
-  "debugMode": true
-}