@sellable/mcp 0.1.363 → 0.1.364

package/dist/server.js

@@ -43,6 +43,7 @@ import { addRubricItem, checkRubric, deleteRubricItem, draftRubrics, saveRubrics
 import { getSenderRoutingTool, setSenderRoutingTool, } from "./tools/sender-routing.js";
 import { getSender, listSenders } from "./tools/senders.js";
 import { attachRecommendedSequence, attachSequence, createWorkflowTable, } from "./tools/sequencer.js";
+import { setupEvergreenCampaigns } from "./tools/setup-evergreen-campaigns.js";
 import { exportTableCsv, listTables } from "./tools/tables.js";
 import { handleVerifyTableRow } from "./tools/verify-row.js";
 import { sanitizeWatchUrlsForMcpResult } from "./tools/watch-url-security.js";
@@ -69,6 +70,34 @@ function parseOptionalNumber(value) {
     }
     return undefined;
 }
+function markEvergreenSetupCampaignsDirty(args) {
+    if (!args || args.mode !== "verify")
+        return;
+    const campaignIds = new Set();
+    const bindings = Array.isArray(args.bindings) ? args.bindings : [];
+    for (const binding of bindings) {
+        if (!binding || typeof binding !== "object" || Array.isArray(binding)) {
+            continue;
+        }
+        const campaignId = binding.campaignId;
+        if (typeof campaignId === "string" && campaignId.trim()) {
+            campaignIds.add(campaignId.trim());
+        }
+    }
+    const receipts = Array.isArray(args.receipts) ? args.receipts : [];
+    for (const receipt of receipts) {
+        if (!receipt || typeof receipt !== "object" || Array.isArray(receipt)) {
+            continue;
+        }
+        const campaignId = receipt.campaignId;
+        if (typeof campaignId === "string" && campaignId.trim()) {
+            campaignIds.add(campaignId.trim());
+        }
+    }
+    for (const campaignId of campaignIds) {
+        markCampaignContextDirty(campaignId, "setup_evergreen_campaigns");
+    }
+}
 function formatSubskillPromptText(result) {
     const header = result.chunkCount && result.chunkCount > 1
         ? [
@@ -188,6 +217,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_campaign_refill_state":
                 result = await getCampaignRefillState(args);
                 break;
+            case "setup_evergreen_campaigns":
+                result = await setupEvergreenCampaigns(args);
+                markEvergreenSetupCampaignsDirty(args);
+                break;
             case "fill_campaign_horizon":
                 result = await fillCampaignHorizon(args);
                 if (args?.campaignId) {

package/dist/tools/registry.js

@@ -38,6 +38,7 @@ import { rubricToolDefinitions } from "./rubrics.js";
 import { senderRoutingToolDefinitions } from "./sender-routing.js";
 import { senderToolDefinitions } from "./senders.js";
 import { sequencerToolDefinitions } from "./sequencer.js";
+import { setupEvergreenCampaignsToolDefinitions } from "./setup-evergreen-campaigns.js";
 import { tableToolDefinitions } from "./tables.js";
 import { verifyRowToolDefinitions } from "./verify-row.js";
 import { waterfallToolDefinitions } from "./waterfalls.js";
@@ -48,6 +49,7 @@ export const allTools = [
     ...campaignAbTestToolDefinitions,
     ...campaignFillRoutingToolDefinitions,
     ...campaignRefillStateToolDefinitions,
+    ...setupEvergreenCampaignsToolDefinitions,
     ...campaignHorizonFillToolDefinitions,
     ...campaignMessagePreparationToolDefinitions,
     ...campaignProcessingToolDefinitions,

package/dist/tools/setup-evergreen-campaigns.d.ts

@@ -0,0 +1,113 @@
+type SetupEvergreenCampaignsInput = {
+    mode?: "plan" | "verify";
+    depth?: "structure_only" | "customer_visible";
+    yolo?: boolean;
+    allConnectedSenders?: boolean;
+    selectedSenderIds?: string[];
+    postEngagerSenderIds?: string[];
+    sharedSenderIds?: string[];
+    bindings?: Array<{
+        laneKey: string;
+        campaignId: string;
+        tableId: string;
+    }>;
+    planRevision?: string;
+    selectedActionIds?: string[];
+    receipts?: Array<Record<string, unknown>>;
+};
+export declare const setupEvergreenCampaignsToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            depth: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            yolo: {
+                type: string;
+                description: string;
+            };
+            allConnectedSenders: {
+                type: string;
+                description: string;
+            };
+            selectedSenderIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            postEngagerSenderIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            sharedSenderIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            bindings: {
+                type: string;
+                maxItems: number;
+                items: {
+                    type: string;
+                    properties: {
+                        laneKey: {
+                            type: string;
+                        };
+                        campaignId: {
+                            type: string;
+                        };
+                        tableId: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                description: string;
+            };
+            planRevision: {
+                type: string;
+                description: string;
+            };
+            selectedActionIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            receipts: {
+                type: string;
+                maxItems: number;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function setupEvergreenCampaigns(input: SetupEvergreenCampaignsInput): Promise<unknown>;
+export {};

package/dist/tools/setup-evergreen-campaigns.js

@@ -0,0 +1,100 @@
+import { getApi } from "../api.js";
+async function postSetupEvergreenCampaigns(body) {
+    const api = getApi();
+    return api.post("/api/v3/mcp/setup-evergreen-campaigns", body);
+}
+export const setupEvergreenCampaignsToolDefinitions = [
+    {
+        name: "setup_evergreen_campaigns",
+        description: "Evergreen campaign setup plan/verify command. Use plan mode first to inspect exact workspace/sender/campaign/table/source state and receive immutable lane packets. `selectedSenderIds` is a legacy shorthand for both scopes; prefer `postEngagerSenderIds` for the Post Engagers sender scope and `sharedSenderIds` for the shared lane sender scope when they differ. The command plans one Post Engagers lane per post-engager sender plus shared Signal Discovery and Shared Cold Fallback lanes for the shared sender set. yolo is only a parent-skill auto-execution hint for safe lane packets; this backend command remains read-only in plan mode and verifies receipts in verify mode. When safe-yolo needs normal setup work, the parent skill may ask for bounded delegated approval: one approval over the current planRevision, selected action ids, caps, allowed side-effect classes, and stop conditions lets lane workers execute without per-substep approval while staying inside that packet. Lane workers must execute creation, source import, create-campaign workflow steps, generate-messages, sequence attachment, pause_campaign review-state transition when the current table is still DRAFT, and review readiness through existing create-campaign workflow/subskills, then return receipts here for verification. Customer-visible verify receipts must include createCampaignStepReceipt with setupPlanCall, campaignBriefReceipt, sourceDecisionReceipt, filterDecisionReceipt, messageDraftingReceipt, reviewBatchReceipt, sequenceReceipt, and verifyCall. messageDraftingReceipt must use statusSource:'branch' or statusSource:'packaged-generate-messages-worker' and include proof that generate-messages was loaded, start_campaign_message_preparation/get_campaign_message_preparation_status ran when the packaged worker path is used, validationResult:'passed', a passed qualityReview, and at least 3 concrete sampleMessages with row ids, generated message text, pass verdicts, and no issues; Shared Cold Fallback samples with a standalone name followed by 'Hey there' are rejected. This command does not launch campaigns, does not schedule sends, does not assign scheduler-owned send fields, does not raw-write campaign status, does not archive/delete cleanup targets, and does not spend paid credits.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                mode: {
+                    type: "string",
+                    enum: ["plan", "verify"],
+                    description: 'Defaults to "plan". Verify only validates worker receipts.',
+                },
+                depth: {
+                    type: "string",
+                    enum: ["structure_only", "customer_visible"],
+                    description: 'Use "customer_visible" for full setup proof or "structure_only" when only ensuring lane shells/config.',
+                },
+                yolo: {
+                    type: "boolean",
+                    description: "plan mode only. Requests auto-executable lane packets when state is safe; never authorizes cleanup, launch, scheduling, sending, or ambiguous target choice.",
+                },
+                allConnectedSenders: {
+                    type: "boolean",
+                    description: "Plan sender-owned Post Engagers lanes for all eligible connected senders in the active workspace.",
+                },
+                selectedSenderIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 25,
+                    description: "Legacy shorthand: exact OutboundSenderIdentity ids for both sender-owned Post Engagers lanes and shared-lane sender set. Prefer scoped fields when those differ.",
+                },
+                postEngagerSenderIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 25,
+                    description: "Exact OutboundSenderIdentity ids that should receive sender-owned Post Engagers lanes.",
+                },
+                sharedSenderIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 25,
+                    description: "Exact OutboundSenderIdentity ids attached to shared Signal Discovery and Shared Cold Fallback lanes.",
+                },
+                bindings: {
+                    type: "array",
+                    maxItems: 20,
+                    items: {
+                        type: "object",
+                        properties: {
+                            laneKey: { type: "string" },
+                            campaignId: { type: "string" },
+                            tableId: { type: "string" },
+                        },
+                        required: ["laneKey", "campaignId", "tableId"],
+                        additionalProperties: false,
+                    },
+                    description: "Exact existing campaign/table bindings to reuse for lane keys. Do not pass names.",
+                },
+                planRevision: {
+                    type: "string",
+                    description: "Required for verify. Copy from the immediately preceding plan.",
+                },
+                selectedActionIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 20,
+                    description: "Required for verify. Immutable action ids selected from the current plan.",
+                },
+                receipts: {
+                    type: "array",
+                    maxItems: 20,
+                    items: { type: "object" },
+                    description: "Required for verify. Structured lane worker receipts from create-campaign/source/message/sequence execution. Customer-visible lanes must include createCampaignStepReceipt with setupPlanCall, campaignBriefReceipt, sourceDecisionReceipt, filterDecisionReceipt, messageDraftingReceipt, reviewBatchReceipt, sequenceReceipt, and verifyCall.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+];
+export function setupEvergreenCampaigns(input) {
+    return postSetupEvergreenCampaigns({
+        mode: input.mode,
+        yolo: input.yolo,
+        depth: input.depth,
+        allConnectedSenders: input.allConnectedSenders,
+        selectedSenderIds: input.selectedSenderIds,
+        postEngagerSenderIds: input.postEngagerSenderIds,
+        sharedSenderIds: input.sharedSenderIds,
+        bindings: input.bindings,
+        planRevision: input.planRevision,
+        selectedActionIds: input.selectedActionIds,
+        receipts: input.receipts,
+    });
+}

package/package.json

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