@sellable/mcp 0.1.273 → 0.1.275

package/README.md

@@ -16,9 +16,10 @@ Each message gets 5+ minutes of Claude attention with deep research - no other t
 
 ### Prompt Source Of Truth
 
-There are four public Sellable entrypoints shared across hosts:
+There are five public Sellable entrypoints shared across hosts:
 
 - `sellable:create-campaign`
+- `sellable:create-ab-test`
 - `sellable:foundation`
 - `sellable:content`
 - `sellable:create-post`
@@ -29,6 +30,11 @@ the approval-gated workflow from:
 
 - `mcp/sellable/skills/create-campaign-v2/SKILL.md`
 
+The create-ab-test public wrapper prepares clean A/B split lead lists and
+review-copy campaigns from:
+
+- `mcp/sellable/skills/create-ab-test/SKILL.md`
+
 The foundation public wrapper loads the core identity/company memory workflow
 from:
 
@@ -148,8 +154,9 @@ The installer does the full local setup:
   `mcp__sellable__*` tools into skill sessions
 
 After the installer passes, fully quit and reopen Codex Desktop. Start a new
-thread and select `Sellable Create Campaign`, `Sellable Foundation`,
-`Sellable Content`, or `Sellable Create Post`; or invoke `$sellable:create-campaign`,
+thread and select `Sellable Create Campaign`, `Sellable Create A/B Test`,
+`Sellable Foundation`, `Sellable Content`, or `Sellable Create Post`; or invoke
+`$sellable:create-campaign`, `$sellable:create-ab-test`,
 `$sellable:foundation`, `$sellable:content`, or `$sellable:create-post`. If the app still says
 `mcp__sellable__*` tools are missing after the installer passes, check that
 `~/.codex/config.toml` contains both `[marketplaces.sellable]` and
@@ -162,19 +169,23 @@ the Sellable MCP tools for Codex Desktop.
 Use these names consistently:
 
 - Claude Code command: `/sellable:create-campaign`
+- Claude Code command: `/sellable:create-ab-test`
 - Claude Code command: `/sellable:foundation`
 - Claude Code command: `/sellable:content`
 - Claude Code command: `/sellable:create-post`
 - Codex command: `$sellable:create-campaign`
+- Codex command: `$sellable:create-ab-test`
 - Codex command: `$sellable:foundation`
 - Codex command: `$sellable:content`
 - Codex command: `$sellable:create-post`
 - Codex Desktop plugin: `sellable@sellable`
 - Codex visible skill: `Sellable Create Campaign`
+- Codex visible skill: `Sellable Create A/B Test`
 - Codex visible skill: `Sellable Foundation`
 - Codex visible skill: `Sellable Content`
 - Codex visible skill: `Sellable Create Post`
 - Codex skill frontmatter name: `create-campaign`
+- Codex skill frontmatter name: `create-ab-test`
 - Codex skill frontmatter name: `foundation`
 - Codex skill frontmatter name: `content`
 - Codex skill frontmatter name: `create-post`

package/dist/server.js

@@ -7,6 +7,7 @@ import { handleAddColumn, handleCommitBlueprint, } from "./tools/blueprint-commi
 import { bootstrapCreateCampaign } from "./tools/bootstrap.js";
 import { getCampaignTableSchema, queueCampaignCells, reviseMessageTemplateAndRerun, selectCampaignCells, waitForCampaignProcessing, } from "./tools/campaign-processing.js";
 import { createCampaign, duplicateCampaign, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
+import { prepareCampaignAbTest } from "./tools/campaign-ab-test.js";
 import { queueCells, updateCell } from "./tools/cells.js";
 import { handleStartCliLogin, handleWaitForCliLogin, } from "./tools/cli-login.js";
 import { calculateLinkedInHookPreviewTool, capturePostIdeaTool, getPostDraftTool, getPostIdeaTool, getPublishedPostTool, listPostDraftIterationsTool, listPostDraftsTool, listPostIdeasTool, listPublishedPostsTool, markPostPublishedTool, renderLinkedInPostPreviewTool, saveHookResearchTool, savePostDraftTool, updatePostDraftTool, updatePublishedPostMetricsTool, } from "./tools/content-posts.js";
@@ -18,6 +19,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";
@@ -214,6 +216,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     markCampaignContextDirty(result.campaignOfferId, "duplicate_campaign");
                 }
                 break;
+            case "prepare_campaign_ab_test":
+                result = await prepareCampaignAbTest(args);
+                if (result?.variants?.A?.campaignId) {
+                    markCampaignContextDirty(result.variants.A.campaignId, "prepare_campaign_ab_test");
+                }
+                if (result?.variants?.B?.campaignId) {
+                    markCampaignContextDirty(result.variants.B.campaignId, "prepare_campaign_ab_test");
+                }
+                break;
             case "update_campaign_brief":
                 result = await updateCampaignBrief(args?.campaignId, args?.campaignBrief);
                 if (args?.campaignId) {
@@ -372,6 +383,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/campaign-ab-test.d.ts

@@ -0,0 +1,72 @@
+export interface PrepareCampaignAbTestInput {
+    sourceCampaignId: string;
+    variantName: string;
+    variantBriefDelta: string;
+    variantALabel?: string;
+    variantABriefDelta?: string;
+    splitStrategy?: "alternating_stable_sort";
+    targetCounts?: {
+        a?: number;
+        b?: number;
+    };
+    dryRun?: boolean;
+    idempotencyKey?: string;
+}
+export declare const campaignAbTestToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            sourceCampaignId: {
+                type: string;
+                description: string;
+            };
+            variantName: {
+                type: string;
+                description: string;
+            };
+            variantBriefDelta: {
+                type: string;
+                description: string;
+            };
+            variantALabel: {
+                type: string;
+                description: string;
+            };
+            variantABriefDelta: {
+                type: string;
+                description: string;
+            };
+            splitStrategy: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            targetCounts: {
+                type: string;
+                properties: {
+                    a: {
+                        type: string;
+                    };
+                    b: {
+                        type: string;
+                    };
+                };
+                additionalProperties: boolean;
+                description: string;
+            };
+            dryRun: {
+                type: string;
+                description: string;
+            };
+            idempotencyKey: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function prepareCampaignAbTest(input: PrepareCampaignAbTestInput): Promise<unknown>;

package/dist/tools/campaign-ab-test.js

@@ -0,0 +1,60 @@
+import { getApi } from "../api.js";
+export const campaignAbTestToolDefinitions = [
+    {
+        name: "prepare_campaign_ab_test",
+        description: "Prepare a campaign A/B test from an existing campaign using its clean source lead list. Creates deterministic A/B split lead lists and review-copy campaigns, updates the variant brief, and never launches either campaign.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sourceCampaignId: {
+                    type: "string",
+                    description: "Existing source campaign ID.",
+                },
+                variantName: {
+                    type: "string",
+                    description: "Short label for variant B, e.g. New CTA.",
+                },
+                variantBriefDelta: {
+                    type: "string",
+                    description: "The specific campaign brief/copy change for variant B.",
+                },
+                variantALabel: {
+                    type: "string",
+                    description: "Optional label for the control variant.",
+                },
+                variantABriefDelta: {
+                    type: "string",
+                    description: "Optional explicit brief change for variant A. Omit for unchanged control.",
+                },
+                splitStrategy: {
+                    type: "string",
+                    enum: ["alternating_stable_sort"],
+                    description: "Deterministic split strategy. Defaults to alternating_stable_sort.",
+                },
+                targetCounts: {
+                    type: "object",
+                    properties: {
+                        a: { type: "number" },
+                        b: { type: "number" },
+                    },
+                    additionalProperties: false,
+                    description: "Optional exact split counts. Omit for an even alternating split.",
+                },
+                dryRun: {
+                    type: "boolean",
+                    description: "When true, returns split plan and review names without creating campaigns/lists.",
+                },
+                idempotencyKey: {
+                    type: "string",
+                    description: "Optional stable key for retrying the same A/B preparation safely.",
+                },
+            },
+            required: ["sourceCampaignId", "variantName", "variantBriefDelta"],
+            additionalProperties: false,
+        },
+    },
+];
+export async function prepareCampaignAbTest(input) {
+    const api = getApi();
+    return api.post("/api/v3/mcp/campaign-ab-test", input);
+}

package/dist/tools/csv-linkedin.d.ts

@@ -9,6 +9,18 @@ export type CsvLinkedinLimits = {
     maxRows: number;
     maxCarryColumns: number;
 };
+export type CsvLinkedinIgnoredReservedColumn = {
+    originalHeader: string;
+    canonicalName: string;
+    reason: string;
+};
+export type CsvLinkedinContentFingerprint = {
+    fileSha256: string;
+    sanitizedHeaderSha256: string;
+    selectedColumnsSha256: string;
+    ignoredReservedColumnsSha256: string;
+    rowCount: number;
+};
 export type CsvLinkedinPreview = {
     resolvedFilePath: string;
     suggestedLeadListName: string;
@@ -26,6 +38,8 @@ export type CsvLinkedinPreview = {
     duplicateLinkedInCount: number;
     emptyLinkedInRowCount: number;
     duplicatePolicy: "first_wins";
+    ignoredReservedColumns: CsvLinkedinIgnoredReservedColumn[];
+    reservedColumnWarning: string | null;
     limits: CsvLinkedinLimits;
     warnings: string[];
     blockingErrors: string[];
@@ -38,6 +52,8 @@ export type CsvLinkedinConfirmationPayload = {
     fileMtimeMs: number;
     linkedInColumn: string;
     selectedColumns: string[];
+    ignoredReservedColumns: CsvLinkedinIgnoredReservedColumn[];
+    contentFingerprint: CsvLinkedinContentFingerprint;
 };
 export type PreparedLinkedinLeadRow = {
     row: Record<string, string>;
@@ -76,6 +92,9 @@ type ParsedCsvLinkedinFile = {
     headers: string[];
     rows: Array<Record<string, string>>;
     totalRows: number;
+    ignoredReservedColumns: CsvLinkedinIgnoredReservedColumn[];
+    reservedColumnWarning: string | null;
+    fileSha256: string;
     blockingErrors: string[];
     warnings: string[];
 };
@@ -86,6 +105,10 @@ export type LinkedInValidationResult = {
     valid: false;
     reason: string;
 };
+export declare function getReservedWorkflowColumnMatch(header: string): {
+    canonicalName: string;
+    reason: string;
+} | null;
 export declare function validateAndNormalizeLinkedInUrl(value: string): LinkedInValidationResult;
 export declare function makeLinkedinConfirmationToken(payload: CsvLinkedinConfirmationPayload): string;
 export declare function parseLinkedinConfirmationToken(token: string): CsvLinkedinConfirmationPayload;

package/dist/tools/csv-linkedin.js

@@ -1,5 +1,5 @@
 import { parse } from "csv-parse/sync";
-import { createHmac, randomBytes } from "node:crypto";
+import { createHash, createHmac, randomBytes } from "node:crypto";
 import { readFileSync, statSync } from "node:fs";
 import { basename, dirname, extname, isAbsolute, resolve } from "node:path";
 import { resolveWorkspaceRoot } from "../utils/workspace-root.js";
@@ -49,6 +49,86 @@ const CSV_LINKEDIN_LIMITS = {
     maxRows: MAX_CSV_LINKEDIN_UPLOAD_ROWS,
     maxCarryColumns: MAX_CSV_LINKEDIN_UPLOAD_CARRY_COLUMNS,
 };
+const RESERVED_WORKFLOW_COLUMNS = new Map([
+    "DNC Check",
+    "Enable ICP Filtering",
+    "ICP Score",
+    "ICP Alignment Notes",
+    "Passes Rubric",
+    "Generate Message",
+    "Message",
+    "Subject",
+    "Approved",
+    "Enable Scheduling",
+    "Scheduled",
+    "Scheduled At",
+    "Scheduled For",
+    "Sent",
+    "Sent At",
+    "Send Status",
+    "Delivery Status",
+    "Reply Status",
+    "Connection Status",
+    "Invite Status",
+    "InMail Status",
+    "DM Status",
+    "Status",
+    "Result",
+    "Error",
+    "Last Error",
+    "Generated Message",
+    "Message Draft",
+    "Message Status",
+    "Approval Status",
+    "Queued At",
+    "Processing Status",
+    "Workflow Status",
+    "Cell Status",
+].map((name) => [normalizeReservedWorkflowHeaderKey(name), name]));
+function normalizeReservedWorkflowHeaderKey(value) {
+    return value
+        .trim()
+        .replace(/\s*(?:\(\d+\)|[._-]\d+|\s+\d+)$/u, "")
+        .toLowerCase()
+        .replace(/[\s_.-]+/g, " ")
+        .replace(/[^a-z0-9 ]+/g, "")
+        .trim();
+}
+export function getReservedWorkflowColumnMatch(header) {
+    const key = normalizeReservedWorkflowHeaderKey(header);
+    if (!key) {
+        return null;
+    }
+    const canonicalName = RESERVED_WORKFLOW_COLUMNS.get(key);
+    if (!canonicalName) {
+        return null;
+    }
+    return {
+        canonicalName,
+        reason: "Sellable workflow/output columns are recreated by each campaign table and cannot be imported as lead source fields.",
+    };
+}
+function buildReservedColumnWarning(ignored) {
+    if (ignored.length === 0) {
+        return null;
+    }
+    const names = Array.from(new Set(ignored.map((column) => column.originalHeader)));
+    return `Detected campaign workflow columns and stripped them because Sellable recreates those columns in each campaign table: ${names.join(", ")}.`;
+}
+function hashJson(value) {
+    return createHash("sha256")
+        .update(JSON.stringify(value))
+        .digest("hex");
+}
+function buildContentFingerprint(params) {
+    return {
+        fileSha256: params.fileSha256,
+        sanitizedHeaderSha256: hashJson(params.headers),
+        selectedColumnsSha256: hashJson(params.selectedColumns),
+        ignoredReservedColumnsSha256: hashJson(params.ignoredReservedColumns),
+        rowCount: params.rowCount,
+    };
+}
 function normalizeHeaderKey(value) {
     return value
         .trim()
@@ -61,6 +141,17 @@ function compareStringArrays(left, right) {
     }
     return left.every((value, index) => value === right[index]);
 }
+function compareIgnoredReservedColumns(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((column, index) => {
+        const other = right[index];
+        return (column.originalHeader === other.originalHeader &&
+            column.canonicalName === other.canonicalName &&
+            column.reason === other.reason);
+    });
+}
 function getLimits() {
     return { ...CSV_LINKEDIN_LIMITS };
 }
@@ -100,6 +191,30 @@ function buildRowObjects(headers, dataRows) {
         return out;
     });
 }
+function stripReservedWorkflowColumns(headers, dataRows) {
+    const keepIndexes = [];
+    const ignoredReservedColumns = [];
+    headers.forEach((header, index) => {
+        const match = getReservedWorkflowColumnMatch(header);
+        if (!match) {
+            keepIndexes.push(index);
+            return;
+        }
+        ignoredReservedColumns.push({
+            originalHeader: header,
+            canonicalName: match.canonicalName,
+            reason: match.reason,
+        });
+    });
+    if (ignoredReservedColumns.length === 0) {
+        return { headers, dataRows, ignoredReservedColumns };
+    }
+    return {
+        headers: keepIndexes.map((index) => headers[index]),
+        dataRows: dataRows.map((row) => keepIndexes.map((index) => String(row[index] ?? ""))),
+        ignoredReservedColumns,
+    };
+}
 function resolveHeaderSelection(headers, requested, kind) {
     const trimmed = requested.trim();
     if (!trimmed) {
@@ -516,7 +631,17 @@ export function matchesLinkedinConfirmationToken(token, payload) {
         parsed.fileSizeBytes === payload.fileSizeBytes &&
         parsed.fileMtimeMs === payload.fileMtimeMs &&
         parsed.linkedInColumn === payload.linkedInColumn &&
-        compareStringArrays(parsed.selectedColumns, payload.selectedColumns));
+        compareStringArrays(parsed.selectedColumns, payload.selectedColumns) &&
+        compareIgnoredReservedColumns(parsed.ignoredReservedColumns, payload.ignoredReservedColumns) &&
+        parsed.contentFingerprint.fileSha256 ===
+            payload.contentFingerprint.fileSha256 &&
+        parsed.contentFingerprint.sanitizedHeaderSha256 ===
+            payload.contentFingerprint.sanitizedHeaderSha256 &&
+        parsed.contentFingerprint.selectedColumnsSha256 ===
+            payload.contentFingerprint.selectedColumnsSha256 &&
+        parsed.contentFingerprint.ignoredReservedColumnsSha256 ===
+            payload.contentFingerprint.ignoredReservedColumnsSha256 &&
+        parsed.contentFingerprint.rowCount === payload.contentFingerprint.rowCount);
 }
 export function parseCsvLinkedinFile(input) {
     const resolvedFilePath = resolveCsvLinkedinPath(input.filePath, input.workspaceRoot);
@@ -536,8 +661,9 @@ export function parseCsvLinkedinFile(input) {
         blockingErrors.push(`CSV file exceeds the ${MAX_CSV_LINKEDIN_UPLOAD_BYTES} byte limit.`);
     }
     let rawRows;
+    let content;
     try {
-        const content = readFileSync(resolvedFilePath, "utf8");
+        content = readFileSync(resolvedFilePath, "utf8");
         rawRows = parse(content, {
             bom: true,
             columns: false,
@@ -559,6 +685,9 @@ export function parseCsvLinkedinFile(input) {
             headers: [],
             rows: [],
             totalRows: 0,
+            ignoredReservedColumns: [],
+            reservedColumnWarning: null,
+            fileSha256: "",
             blockingErrors,
             warnings,
         };
@@ -567,6 +696,14 @@ export function parseCsvLinkedinFile(input) {
     const dataRows = rawRows
         .slice(1)
         .map((row) => row.map((value) => String(value ?? "")));
+    const fileSha256 = createHash("sha256").update(content).digest("hex");
+    const stripped = stripReservedWorkflowColumns(headers, dataRows);
+    const sanitizedHeaders = stripped.headers;
+    const sanitizedDataRows = stripped.dataRows;
+    const reservedColumnWarning = buildReservedColumnWarning(stripped.ignoredReservedColumns);
+    if (reservedColumnWarning) {
+        warnings.push(reservedColumnWarning);
+    }
     if (headers.length === 0) {
         blockingErrors.push("CSV file must include at least one header column.");
     }
@@ -574,7 +711,10 @@ export function parseCsvLinkedinFile(input) {
     if (blankHeaderCount > 0) {
         blockingErrors.push("CSV header row contains blank column names.");
     }
-    const duplicateHeaders = findDuplicateHeaders(headers);
+    if (sanitizedHeaders.length === 0 && headers.length > 0) {
+        blockingErrors.push("CSV looks like a campaign workflow export rather than a clean LinkedIn lead list; all usable columns were Sellable workflow/output columns.");
+    }
+    const duplicateHeaders = findDuplicateHeaders(sanitizedHeaders);
     if (duplicateHeaders.length > 0) {
         blockingErrors.push(`CSV header row contains duplicate columns: ${duplicateHeaders.join(", ")}`);
     }
@@ -585,7 +725,9 @@ export function parseCsvLinkedinFile(input) {
     if (dataRows.length > MAX_CSV_LINKEDIN_UPLOAD_ROWS) {
         blockingErrors.push(`CSV contains ${dataRows.length} data rows, which exceeds the ${MAX_CSV_LINKEDIN_UPLOAD_ROWS} row limit.`);
     }
-    const rows = blockingErrors.length > 0 ? [] : buildRowObjects(headers, dataRows);
+    const rows = blockingErrors.length > 0
+        ? []
+        : buildRowObjects(sanitizedHeaders, sanitizedDataRows);
     if (rows.length === 0 && dataRows.length === 0) {
         warnings.push("CSV contains headers but no data rows.");
     }
@@ -594,9 +736,12 @@ export function parseCsvLinkedinFile(input) {
         suggestedLeadListName: buildLeadListNameSuggestion(resolvedFilePath),
         fileSizeBytes: stats.size,
         fileMtimeMs: stats.mtimeMs,
-        headers,
+        headers: sanitizedHeaders,
         rows,
         totalRows: dataRows.length,
+        ignoredReservedColumns: stripped.ignoredReservedColumns,
+        reservedColumnWarning,
+        fileSha256,
         blockingErrors,
         warnings,
     };
@@ -752,8 +897,13 @@ export function buildCsvLinkedinPreview(input) {
             duplicateCount: 0,
             emptyCount: 0,
         };
+    if (!resolvedLinkedInColumn && parsed.ignoredReservedColumns.length > 0) {
+        blockingErrors.push("CSV looks like a campaign workflow export rather than a clean LinkedIn lead list; after stripping Sellable workflow/output columns, no LinkedIn profile URL column was available.");
+    }
     if (resolvedLinkedInColumn && prepared.rows.length === 0) {
-        blockingErrors.push("CSV did not produce any valid LinkedIn profile URLs after validation.");
+        blockingErrors.push(parsed.ignoredReservedColumns.length > 0
+            ? "CSV looks like a campaign workflow export rather than a clean LinkedIn lead list; no valid LinkedIn profile URLs remained after stripping Sellable workflow/output columns."
+            : "CSV did not produce any valid LinkedIn profile URLs after validation.");
     }
     if (prepared.invalidCount > 0) {
         warnings.push(`Skipped ${prepared.invalidCount} invalid LinkedIn URL row(s).`);
@@ -772,6 +922,14 @@ export function buildCsvLinkedinPreview(input) {
             fileMtimeMs: parsed.fileMtimeMs,
             linkedInColumn: resolvedLinkedInColumn,
             selectedColumns,
+            ignoredReservedColumns: parsed.ignoredReservedColumns,
+            contentFingerprint: buildContentFingerprint({
+                fileSha256: parsed.fileSha256,
+                headers,
+                selectedColumns,
+                ignoredReservedColumns: parsed.ignoredReservedColumns,
+                rowCount: parsed.totalRows,
+            }),
         }
         : null;
     return {
@@ -792,6 +950,8 @@ export function buildCsvLinkedinPreview(input) {
             duplicateLinkedInCount: prepared.duplicateCount,
             emptyLinkedInRowCount: prepared.emptyCount,
             duplicatePolicy: "first_wins",
+            ignoredReservedColumns: parsed.ignoredReservedColumns,
+            reservedColumnWarning: parsed.reservedColumnWarning,
             limits: getLimits(),
             warnings,
             blockingErrors,