@sellable/mcp 0.1.272 → 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.272",
+  "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/create-post/SKILL.md

@@ -606,6 +606,7 @@ Visible Flow Trace
 - worker status per person:
 - recent posts sampled:
 - voice model:
+- mechanics receipts:
 - complete voice variants:
 - follower-adjusted signal when available:
 - hook/body moves worth stealing:
@@ -623,6 +624,11 @@ Visible Flow Trace
 - proof gate:
 - voice gate:
 - anti-AI gate:
+- local finalizer pass:
+- turn separators added:
+- contractions applied:
+- lowercase pass:
+- abstract-to-concrete rewrites:
 - mobile preview gate:
 - template adaptation gate:
 - hook-to-body repayment:
@@ -1242,6 +1248,42 @@ either completed for every active configured influencer or the validation
 receipt has an explicit user opt-out reason. A light source-research summary
 does not satisfy this gate.
 
+## Step 3.5: Local Finalizer Pass
+
+Run this pass after the canonical draft exists and before validation and save.
+
+1. Add `--` between each major turn in the post so the story is easier to read.
+   Use it to separate turns such as hook, context, problem, mechanism, product
+   proof, concrete example, and CTA. Do not add `--` inside a tight list where
+   it would make the post harder to scan.
+2. Use contractions in the draft body by default: `don't`, `isn't`, `that's`,
+   `it's`, `can't`, `we're`, `you're`, and similar natural phrasing. Keep the
+   non-contracted form only when the user explicitly wrote it that way, when a
+   quoted line must stay exact, or when the contraction would sound unnatural.
+3. Keep optional headings, section labels, and line starts lowercase by default
+   when the post still reads naturally. Preserve proper nouns, acronyms, product
+   names, and required capitalization such as `Claude`, `LinkedIn`, `Codex`,
+   `Sellable.dev`, `Clay`, `HeyReach`, and `ICP`.
+4. Run a Harry Dry-style concrete-language audit:
+   - highlight every abstract or vague word/phrase in the validation receipt
+     before saving
+   - replace each one in the draft with a concrete object, action, number,
+     example, screen, list, person, place, or visible workflow step
+   - prefer words a reader can picture, such as `lead list`, `send settings`,
+     `reply inbox`, `follow-up`, `team post`, `warm LinkedIn prospect`,
+     `reply handling`, or `one sentence in Claude Code`
+   - do not make a phrase concrete by inventing proof, metrics, customers, or
+     product behavior the user did not provide
+5. Record this pass in the validation receipt as `localFinalizerPass` with:
+   - `turnSeparatorsAdded: yes | no` and a short reason
+   - `contractionsApplied: yes | no`
+   - `lowercasePass: yes | no` with preserved proper nouns listed
+   - `abstractToConcreteRewrites`, listing each abstract phrase, why it was
+     weak, and the concrete replacement used
+
+If this pass cannot be completed, save the draft as `needs_revision` instead of
+`ready`, and explain which finalizer requirement failed.
+
 ## Step 4: Validation
 
 Use `references/post-validation.md`.
@@ -1280,6 +1322,8 @@ Every saved draft needs a validation receipt with:
 - outbound AI-tell audit findings
 - hook preview pass/warn/fail status and compact fallback when warned
 - finalizer changes
+- local finalizer pass with turn separators, contractions, lowercase pass, and
+  abstract-to-concrete rewrites
 - blocked/retry-needed reasons, if any
 
 If validation fails, do not save the draft as `ready`. Save as `needs_revision` or return blocked/retry-needed.

package/skills/create-post/references/post-file-contract.md

@@ -118,6 +118,10 @@ Draft files must preserve:
   promise, concrete examples, abstractions to remove, and draft risks
 - validation receipt, including LinkedIn preview pass/warn/fail status and
   compact fallback when the selected hook carries a warning
+- local finalizer pass: whether `--` turn separators were added, whether
+  contractions were applied, whether lowercase style was applied where safe,
+  preserved proper nouns/acronyms, and abstract-to-concrete rewrites with the
+  before/after phrases used in the final draft
 - visible flow trace when the user asked for whole-flow, debug, or step-by-step
   mode, including checkpoint statuses, quality break, downstream effect, and
   whether the trace was shown before saving

package/skills/create-post/references/post-validation.md

@@ -125,6 +125,41 @@ After the first draft:
 9. preserve the user's actual story and point
 10. remove AI tells
 11. re-check LinkedIn preview fit after edits
+12. add `--` between major story turns when it improves scanability
+13. use natural contractions by default
+14. keep optional headings, section labels, and line starts lowercase when safe
+15. run the concrete-language audit below and replace abstract phrasing before
+    saving
+
+### Local Finalizer Pass
+
+Before a draft can be saved as `ready`, record a local finalizer pass. This is
+the last copy pass after the draft body exists and before `save_post_draft`.
+
+Record:
+
+- `turnSeparatorsAdded`: yes | no
+- `turnSeparatorReason`: where `--` was inserted or why it was skipped
+- `contractionsApplied`: yes | no
+- `contractionsChanged`: examples such as `do not -> don't`, `is not -> isn't`,
+  `that is -> that's`, or `it is -> it's`
+- `lowercasePass`: yes | no
+- `preservedCapitalization`: proper nouns, acronyms, product names, and required
+  capitalization such as `Claude`, `LinkedIn`, `Codex`, `Sellable.dev`, `Clay`,
+  `HeyReach`, and `ICP`
+- `abstractToConcreteRewrites`: every abstract phrase flagged, why it was weak,
+  and the concrete replacement used
+
+Save as `needs_revision` when:
+
+- major story turns are visually hard to follow and no `--` separators or other
+  clear turn markers were added
+- the draft keeps stiff non-contracted phrasing without a user/source reason
+- optional headings or labels stay title-cased in a way that clashes with the
+  user's lowercase post style
+- meaningful abstract phrases remain in the draft after the concrete-language
+  audit
+- the validation receipt does not show what changed during this finalizer pass
 
 ## Visible Flow Trace Audit
 
@@ -260,7 +295,9 @@ or practical next action.
 ## Abstraction-To-Concrete Rewrite Audit
 
 Record every meaningful abstraction found in the draft and the concrete
-replacement. Do not merely say "made concrete."
+replacement. Do not merely say "made concrete." Use a Harry Dry-style standard:
+if the reader cannot picture the word on a screen, in a list, in a sentence they
+would type, or as a workflow step someone could perform, make it more concrete.
 
 Use this format:
 
@@ -279,11 +316,25 @@ Common abstractions to flag:
 - vague nouns such as `signal`, `market`, `attention`, `system`, `quality`,
   `context`, `machine`, or `workflow` when the sentence does not name the actual
   source, action, number, or object
+- vague product words such as `orchestrator`, `campaign object`, `GTM
+  superpowers`, `agentic`, `AI-native`, or `platform` when the sentence does not
+  name the visible work being done
 - broad persona labels used as lead sources
 - "warm" without explaining what made the source warm
 - "offer" without explaining why the recipient would believe or want it
 - "learning" without naming what metric changes the next decision
 
+Concrete replacements should name visible things, for example:
+
+- `lead list`
+- `send settings`
+- `reply inbox`
+- `follow-up`
+- `team post`
+- `warm LinkedIn prospect`
+- `reply handling`
+- `one sentence in Claude Code`
+
 Do not make language concrete by inventing facts. If the concrete replacement
 requires missing proof, ask the user or save as `needs_revision`.
 

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
-}