@sellable/mcp 0.1.342 → 0.1.344

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";
@@ -68,6 +69,32 @@ 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
         ? [
@@ -187,6 +214,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";
@@ -47,6 +48,7 @@ export const allTools = [
     ...campaignAbTestToolDefinitions,
     ...campaignFillRoutingToolDefinitions,
     ...campaignRefillStateToolDefinitions,
+    ...setupEvergreenCampaignsToolDefinitions,
     ...campaignHorizonFillToolDefinitions,
     ...campaignMessagePreparationToolDefinitions,
     ...campaignProcessingToolDefinitions,

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

@@ -0,0 +1,95 @@
+type SetupEvergreenCampaignsInput = {
+    mode?: "plan" | "verify";
+    depth?: "structure_only" | "customer_visible";
+    yolo?: boolean;
+    allConnectedSenders?: boolean;
+    selectedSenderIds?: string[];
+    bindings?: Array<{
+        laneKey: string;
+        campaignId: string;
+        tableId: string;
+    }>;
+    planRevision?: string;
+    selectedActionIds?: string[];
+    receipts?: 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;
+            };
+            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,86 @@
+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 for one Post Engagers lane per selected sender plus shared Signal Discovery and Shared Cold Fallback lanes. 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, and review readiness through existing create-campaign workflow/subskills, then return receipts here for verification. This command does not launch campaigns, does not schedule sends, does not assign scheduler-owned send fields, 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: "Exact OutboundSenderIdentity ids for sender-owned Post Engagers lanes and shared-lane sender set.",
+                },
+                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.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+];
+export function setupEvergreenCampaigns(input) {
+    return postSetupEvergreenCampaigns({
+        mode: input.mode,
+        yolo: input.yolo,
+        depth: input.depth,
+        allConnectedSenders: input.allConnectedSenders,
+        selectedSenderIds: input.selectedSenderIds,
+        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.342",
+  "version": "0.1.344",
   "type": "module",
   "description": "Sellable MCP server for Claude Code and Codex campaign workflows",
   "main": "dist/index.js",

package/skills/create-evergreen-campaigns/SKILL.md

@@ -51,6 +51,78 @@ Default evergreen plan per workspace (override only if the prompt specifies diff
 3. **`<Workspace/Team> - Shared Cold Fallback`** — one shared cold/fallback campaign lane across senders
 </inputs>
 
+<command_backed_workflow>
+For full/customer-visible setup, the first operational command is always
+`setup_evergreen_campaigns({ mode:"plan", yolo })`. Inventory can happen first
+for operator understanding, but do not create/reuse/repair campaign shells,
+source rows, messages, sequence, approvals, or cleanup before the command-backed
+plan returns lane packets.
+
+Plan shape:
+
+- one Post Engagers lane per selected sender;
+- one shared Signal Discovery lane;
+- one shared Cold Fallback lane;
+- explicit existing campaign/table bindings when the user points at a canonical
+  lane. Pass those exact ids to the plan and reuse/verify them instead of
+  creating duplicates.
+- If a user supplies canonical ids, reuse/verify them instead of creating duplicates.
+
+When senders are ambiguous, ask which sender ids need Post Engagers lanes before
+planning. If the operator says all connected senders, pass `allConnectedSenders`
+and let the command return exact selected sender ids or blockers.
+
+`--yolo` is supported, but it is a safety-scoped execution mode, not a cleanup
+or launch permission. With `--yolo`, pass `yolo:true` to
+`setup_evergreen_campaigns({ mode:"plan", yolo })` and proceed without
+intermediate approval only when every selected lane packet returns
+`autoExecutable:true`. `--yolo` does not authorize archive/delete cleanup,
+launch/start, schedule/send, broad approve-all, wrong workspace work, stale
+plan execution, paid InMail spend, or ambiguous target choice. Stop on wrong
+workspace, cleanup/archive/delete need, stale plan, disconnected sender,
+duplicate candidate, unsafe side effect, missing source proof, or missing
+message proof.
+
+When safe-yolo is blocked only because the plan needs normal setup work, ask
+for a **bounded delegated approval** over the rendered current plan instead of
+asking for each substep. The approval packet must name the workspace id, sender
+ids, lane keys, campaign/table ids or create intents, source/import caps,
+generate-message caps, route-proof approval policy, selectedActionIds,
+planRevision, allowed side-effect classes, and stop conditions. After that one
+approval covers the current planRevision, the parent may act on behalf of the
+operator and execute the selectedActionIds end to end. Do not ask again for
+substep approvals for source import, create-campaign choices, Message Drafting,
+sequence attach/precheck, or exactly one route-proof approval when those actions
+are within the lane packet, approved caps, approved side-effect classes, and
+route-proof approval policy. Stop and re-plan if any fresh reread changes the
+workspace id, sender ids, source/list id, campaign/table id, new campaign/table
+id, planRevision, actionId, selectedActionIds, allowed side effects, caps,
+status, or blocker set outside the approved packet.
+The short rule: one approval covers the current planRevision and selectedActionIds.
+The execution rule: act on behalf of the operator; do not ask again for substep approvals while work stays within the lane packet, approved caps, approved side-effect classes, and route-proof approval policy.
+The drift rule: stop and re-plan when ids, caps, blockers, side-effect classes, or any new campaign/table id leave the approved packet.
+
+After bounded delegated approval or safe `--yolo`, fan out lane worker tasks
+only from the current plan. Each worker receives the complete lane packet:
+workspace id, sender ids, lane key/type, existing campaign/table binding or
+create intent, source hints, caps, planRevision, actionId, allowed side effects,
+and postconditions. Workers must use the create-campaign workflow and
+create-campaign workflow/subskills for campaign creation/setup, source/import,
+filter choice, Message Drafting, packaged `generate-messages`, sequence
+attachment, and send-review readiness. Do not rebuild those steps ad hoc in the
+parent thread.
+
+Workers return worker receipts. The parent then calls
+`setup_evergreen_campaigns({ mode:"verify", planRevision, selectedActionIds,
+receipts })` and report only verified completion. If verify blocks, report the
+blocker and repair only the missing postconditions from the same current plan.
+
+Message proof for every customer-visible lane must come from the current
+campaign/table basis and include at least 3 generated review rows from the
+packaged `generate-messages` path before completion is reported.
+Parent-thread handwritten copy or setting `currentStep` is not proof.
+</command_backed_workflow>
+
 <objective>
 1. **Inventory first**: `get_campaigns` + `list_tables` + `get_campaign_waterfall` in the active workspace. Treat `list_tables` and the managed waterfall as authoritative for older managed slots; `get_campaigns` is a recent campaign page and may miss canonical evergreen lanes. Match existing campaigns/tables/waterfall slots to the plan by name (case-insensitive, ignore suffixes like "(Copy)") and stored slot identity. `list_tables.campaignStatus` and `list_tables.dashboardBucket` are part of the identity check: a matching `ARCHIVED` table/campaign is not a plain `REUSE`. If it is the canonical prod slot and the invocation explicitly allows dashboard visibility repair, repair it to `PAUSED`; otherwise mark it `flagged`/`blocked` and do not create a duplicate. A matching non-archived campaign/table/waterfall slot = REUSE; record it and move on. Never create a second campaign for a slot that already has one in any of those inventories.
 2. **Create only the missing slots** with `create_on_demand_campaign({ name, senderIds, campaignBrief })`: