@sellable/mcp 0.1.274 → 0.1.276

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

@@ -6,7 +6,9 @@ import { getAuthStatus } from "./tools/auth.js";
 import { handleAddColumn, handleCommitBlueprint, } from "./tools/blueprint-commit.js";
 import { bootstrapCreateCampaign } from "./tools/bootstrap.js";
 import { getCampaignTableSchema, queueCampaignCells, reviseMessageTemplateAndRerun, selectCampaignCells, waitForCampaignProcessing, } from "./tools/campaign-processing.js";
+import { cancelPrepareCampaignMessages, getPrepareCampaignMessagesStatus, startPrepareCampaignMessages, } from "./tools/campaign-message-preparation.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";
@@ -163,6 +165,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_campaign_messages_preview":
                 result = await getCampaignMessagesPreview(args);
                 break;
+            case "start_prepare_campaign_messages":
+                result = await startPrepareCampaignMessages(args);
+                if (args?.campaignId) {
+                    markCampaignContextDirty(args.campaignId, "start_prepare_campaign_messages");
+                }
+                break;
+            case "get_prepare_campaign_messages_status":
+                result = await getPrepareCampaignMessagesStatus(args);
+                if (args?.campaignId &&
+                    ["succeeded", "cancelled", "failed"].includes(String(result?.status))) {
+                    markCampaignContextDirty(args.campaignId, "get_prepare_campaign_messages_status");
+                }
+                break;
+            case "cancel_prepare_campaign_messages":
+                result = await cancelPrepareCampaignMessages(args);
+                if (args?.campaignId) {
+                    markCampaignContextDirty(args.campaignId, "cancel_prepare_campaign_messages");
+                }
+                break;
             case "get_campaign_table_schema":
                 result = await getCampaignTableSchema(args);
                 break;
@@ -215,6 +236,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) {

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/campaign-message-preparation.d.ts

@@ -0,0 +1,81 @@
+type ApprovalMode = "mark_ready" | "approve";
+type PrepareMessagesBaseInput = {
+    campaignId?: string;
+    tableId?: string;
+    jobId?: string;
+};
+type StartPrepareMessagesInput = PrepareMessagesBaseInput & {
+    campaignId: string;
+    targetPreparedMessages?: number;
+    maxRowsToCheck?: number;
+    batchSize?: number;
+    approvalMode?: ApprovalMode;
+    autoContinue?: boolean;
+};
+type StatusPrepareMessagesInput = PrepareMessagesBaseInput;
+type CancelPrepareMessagesInput = PrepareMessagesBaseInput;
+export declare const campaignMessagePreparationToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignId: {
+                type: string;
+                description: string;
+            };
+            tableId: {
+                type: string;
+            };
+            targetPreparedMessages: {
+                type: string;
+            };
+            maxRowsToCheck: {
+                type: string;
+            };
+            batchSize: {
+                type: string;
+            };
+            approvalMode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            autoContinue: {
+                type: string;
+            };
+            jobId?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            jobId: {
+                type: string;
+            };
+            campaignId: {
+                type: string;
+                description?: undefined;
+            };
+            tableId: {
+                type: string;
+            };
+            targetPreparedMessages?: undefined;
+            maxRowsToCheck?: undefined;
+            batchSize?: undefined;
+            approvalMode?: undefined;
+            autoContinue?: undefined;
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+})[];
+export declare function startPrepareCampaignMessages(input: StartPrepareMessagesInput): Promise<unknown>;
+export declare function getPrepareCampaignMessagesStatus(input: StatusPrepareMessagesInput): Promise<unknown>;
+export declare function cancelPrepareCampaignMessages(input: CancelPrepareMessagesInput): Promise<unknown>;
+export {};

package/dist/tools/campaign-message-preparation.js

@@ -0,0 +1,86 @@
+import { getApi } from "../api.js";
+async function postPrepareMessages(body) {
+    const api = getApi();
+    return api.post("/api/v3/mcp/campaign-message-preparation", body);
+}
+export const campaignMessagePreparationToolDefinitions = [
+    {
+        name: "start_prepare_campaign_messages",
+        description: 'Start a bounded Prepare Messages job for a CampaignOffer campaignId. Use this after lead/message approval when the user asks for a target like "prepare 100 messages"; default approvalMode is mark_ready and it never starts the campaign.',
+        inputSchema: {
+            type: "object",
+            properties: {
+                campaignId: {
+                    type: "string",
+                    description: "CampaignOffer.id for the campaign whose workflow table should prepare messages.",
+                },
+                tableId: { type: "string" },
+                targetPreparedMessages: { type: "number" },
+                maxRowsToCheck: { type: "number" },
+                batchSize: { type: "number" },
+                approvalMode: {
+                    type: "string",
+                    enum: ["mark_ready", "approve"],
+                    description: 'Defaults to mark_ready. Use approve only when the user explicitly asks to flip Approved cells.',
+                },
+                autoContinue: { type: "boolean" },
+            },
+            required: ["campaignId"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "get_prepare_campaign_messages_status",
+        description: "Poll compact Prepare Messages progress: checked rows, prepared/approved count, target, remaining row budget, warnings, and stop reason. Does not return raw rows or message bodies.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                jobId: { type: "string" },
+                campaignId: { type: "string" },
+                tableId: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "cancel_prepare_campaign_messages",
+        description: "Cancel an active Prepare Messages job. Cancellation is cooperative and launch remains a separate explicit start_campaign step.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                jobId: { type: "string" },
+                campaignId: { type: "string" },
+                tableId: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+    },
+];
+export function startPrepareCampaignMessages(input) {
+    return postPrepareMessages({
+        action: "start",
+        campaignId: input.campaignId,
+        tableId: input.tableId,
+        targetPreparedMessages: input.targetPreparedMessages,
+        maxRowsToCheck: input.maxRowsToCheck,
+        batchSize: input.batchSize,
+        approvalMode: input.approvalMode,
+        autoContinue: input.autoContinue,
+    });
+}
+export function getPrepareCampaignMessagesStatus(input) {
+    return postPrepareMessages({
+        action: "status",
+        jobId: input.jobId,
+        campaignId: input.campaignId,
+        tableId: input.tableId,
+    });
+}
+export function cancelPrepareCampaignMessages(input) {
+    return postPrepareMessages({
+        action: "cancel",
+        jobId: input.jobId,
+        campaignId: input.campaignId,
+        tableId: input.tableId,
+    });
+}

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;