@sellable/mcp 0.1.323 → 0.1.324

package/dist/server.js

@@ -41,6 +41,7 @@ import { attachRecommendedSequence, attachSequence, createWorkflowTable, } from
 import { exportTableCsv, listTables } from "./tools/tables.js";
 import { handleVerifyTableRow } from "./tools/verify-row.js";
 import { sanitizeWatchUrlsForMcpResult } from "./tools/watch-url-security.js";
+import { getCampaignWaterfall, setCampaignWaterfallOrder, } from "./tools/waterfalls.js";
 import { addTeammate, createWorkspace, getActiveWorkspace, listWorkspaces, setActiveWorkspace, } from "./tools/workspaces.js";
 import { checkForUpdates, logUpdateNotice } from "./update-check.js";
 const server = new Server({
@@ -378,6 +379,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "verify_table_row":
                 result = await handleVerifyTableRow(args);
                 break;
+            case "get_campaign_waterfall":
+                result = await getCampaignWaterfall();
+                break;
+            case "set_campaign_waterfall_order":
+                result = await setCampaignWaterfallOrder(args);
+                break;
             case "get_rows":
                 result = await getRows(args?.tableId, args?.rowIds);
                 break;

package/dist/tools/registry.d.ts

@@ -7421,6 +7421,36 @@ export declare const allTools: ({
         };
         required: string[];
     };
+} | {
+    readonly name: "get_campaign_waterfall";
+    readonly description: "Read the active workspace's managed-campaign waterfall hierarchy: each waterfall (per sender or shared) with its campaign slots in stored priority order. Use this before fill-send-horizon runs to follow the configured lane order, or when the user asks what order their campaigns fill in. Returns empty when the workspace has no managed-campaign program (the hierarchy is created by evergreen reconcile).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+} | {
+    readonly name: "set_campaign_waterfall_order";
+    readonly description: "Reorder one waterfall's campaign slots — the stored hierarchy that decides which lane fills first (e.g. move Shared Signal Discovery above Post Engagers). Pass the waterfallKey from get_campaign_waterfall and orderedSlotKeys containing EXACTLY that waterfall's slot keys in the desired order; priorities are renumbered 10/20/30. Confirm the new order with the user before calling unless they stated it explicitly.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly waterfallKey: {
+                readonly type: "string";
+                readonly description: "Waterfall key from get_campaign_waterfall.";
+            };
+            readonly orderedSlotKeys: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "All of the waterfall's slot keys in the desired fill order (highest priority first). Must match the existing slot set exactly — no additions or omissions.";
+            };
+        };
+        readonly required: readonly ["waterfallKey", "orderedSlotKeys"];
+        readonly additionalProperties: false;
+    };
 } | {
     name: string;
     description: string;

package/dist/tools/registry.js

@@ -35,6 +35,7 @@ import { senderToolDefinitions } from "./senders.js";
 import { sequencerToolDefinitions } from "./sequencer.js";
 import { tableToolDefinitions } from "./tables.js";
 import { verifyRowToolDefinitions } from "./verify-row.js";
+import { waterfallToolDefinitions } from "./waterfalls.js";
 import { workspaceToolDefinitions } from "./workspaces.js";
 export const allTools = [
     ...campaignToolDefinitions,
@@ -76,4 +77,5 @@ export const allTools = [
     ...columnDeleteToolDefinitions,
     ...columnReorderToolDefinitions,
     ...verifyRowToolDefinitions,
+    ...waterfallToolDefinitions,
 ];

package/dist/tools/waterfalls.d.ts

@@ -0,0 +1,67 @@
+export interface WaterfallSlotEntry {
+    slotKey: string;
+    priority: number;
+    displayName: string;
+    campaignOfferId: string | null;
+    workflowTableId: string | null;
+    sourceType: string;
+    sourceScope: string;
+    slotStatus: string;
+}
+export interface WaterfallEntry {
+    programKey: string;
+    waterfallKey: string;
+    displayName: string;
+    senderRefs: string[];
+    slots: WaterfallSlotEntry[];
+}
+export interface GetCampaignWaterfallResponse {
+    waterfalls: WaterfallEntry[];
+}
+export interface SetWaterfallOrderInput {
+    waterfallKey: string;
+    orderedSlotKeys: string[];
+}
+export declare const waterfallToolDefinitions: readonly [{
+    readonly name: "get_campaign_waterfall";
+    readonly description: "Read the active workspace's managed-campaign waterfall hierarchy: each waterfall (per sender or shared) with its campaign slots in stored priority order. Use this before fill-send-horizon runs to follow the configured lane order, or when the user asks what order their campaigns fill in. Returns empty when the workspace has no managed-campaign program (the hierarchy is created by evergreen reconcile).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+}, {
+    readonly name: "set_campaign_waterfall_order";
+    readonly description: "Reorder one waterfall's campaign slots — the stored hierarchy that decides which lane fills first (e.g. move Shared Signal Discovery above Post Engagers). Pass the waterfallKey from get_campaign_waterfall and orderedSlotKeys containing EXACTLY that waterfall's slot keys in the desired order; priorities are renumbered 10/20/30. Confirm the new order with the user before calling unless they stated it explicitly.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly waterfallKey: {
+                readonly type: "string";
+                readonly description: "Waterfall key from get_campaign_waterfall.";
+            };
+            readonly orderedSlotKeys: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "All of the waterfall's slot keys in the desired fill order (highest priority first). Must match the existing slot set exactly — no additions or omissions.";
+            };
+        };
+        readonly required: readonly ["waterfallKey", "orderedSlotKeys"];
+        readonly additionalProperties: false;
+    };
+}];
+export declare function getCampaignWaterfall(): Promise<GetCampaignWaterfallResponse | {
+    waterfalls: never[];
+    _notice: string;
+}>;
+export declare function setCampaignWaterfallOrder(input: SetWaterfallOrderInput): Promise<{
+    waterfallKey: string;
+    slots: Array<{
+        slotKey: string;
+        priority: number;
+    }>;
+    previousOrder: string[];
+}>;

package/dist/tools/waterfalls.js

@@ -0,0 +1,51 @@
+import { getApi } from "../api.js";
+export const waterfallToolDefinitions = [
+    {
+        name: "get_campaign_waterfall",
+        description: "Read the active workspace's managed-campaign waterfall hierarchy: each waterfall (per sender or shared) with its campaign slots in stored priority order. Use this before fill-send-horizon runs to follow the configured lane order, or when the user asks what order their campaigns fill in. Returns empty when the workspace has no managed-campaign program (the hierarchy is created by evergreen reconcile).",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "set_campaign_waterfall_order",
+        description: "Reorder one waterfall's campaign slots — the stored hierarchy that decides which lane fills first (e.g. move Shared Signal Discovery above Post Engagers). Pass the waterfallKey from get_campaign_waterfall and orderedSlotKeys containing EXACTLY that waterfall's slot keys in the desired order; priorities are renumbered 10/20/30. Confirm the new order with the user before calling unless they stated it explicitly.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                waterfallKey: {
+                    type: "string",
+                    description: "Waterfall key from get_campaign_waterfall.",
+                },
+                orderedSlotKeys: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "All of the waterfall's slot keys in the desired fill order (highest priority first). Must match the existing slot set exactly — no additions or omissions.",
+                },
+            },
+            required: ["waterfallKey", "orderedSlotKeys"],
+            additionalProperties: false,
+        },
+    },
+];
+export async function getCampaignWaterfall() {
+    const api = getApi();
+    const response = await api.get("/api/v3/managed-campaigns/waterfalls");
+    if (!response.waterfalls || response.waterfalls.length === 0) {
+        return {
+            waterfalls: [],
+            _notice: "No managed-campaign waterfalls exist in this workspace yet. Run the evergreen reconcile (create-evergreen-campaigns) to materialize the hierarchy, or fall back to the per-invocation order.",
+        };
+    }
+    return response;
+}
+export async function setCampaignWaterfallOrder(input) {
+    const api = getApi();
+    return api.put("/api/v3/managed-campaigns/waterfalls", {
+        waterfallKey: input.waterfallKey,
+        orderedSlotKeys: input.orderedSlotKeys,
+    });
+}

package/package.json

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

package/skills/fill-send-horizon/SKILL.md

@@ -33,19 +33,22 @@ For each target campaign:
 <waterfall>
 ## Campaign hierarchy (waterfall order)
 
-When the invoking prompt gives an ordered list — or when a sender has the standard evergreen lanes — fill in **priority order** and only fall through when a lane runs dry:
+The fill order is **stored workspace state**, not something each automation restates. Resolve it in this precedence:
 
-1. **Default order per sender**: `<Sender> - Post Engagers` (warmest) → `Shared Signal Discovery` → `Shared Cold Fallback` (coldest). The invoking prompt can override with any explicit order ("fill in this order: A, B, C").
-2. **Fill the top lane first.** Move to the next lane ONLY when the current one stops with source exhaustion / no more eligible rows — never because it is merely slow.
-3. **Stop descending once the horizon target is met.** If the warm lane alone fills the horizon, the cold lanes get nothing this run — that is correct, not a gap.
-4. **Report per lane** so the operator can see the waterfall working:
+1. **Stored hierarchy (default)**: call `get_campaign_waterfall` first. It returns each waterfall (per sender or shared) with slots in stored priority order — campaign offer IDs included. Fill in that order.
+2. **Per-invocation override**: if the invoking prompt states an explicit order ("fill in this order: Signal Discovery, Post Engagers"), use it for this run only and say in the report that the stored order was overridden. To change the order durably, use `set_campaign_waterfall_order` — but only when the user/automation explicitly asks to change the hierarchy, never as a side effect of a fill run.
+3. **No stored hierarchy** (tool returns empty — evergreen reconcile hasn't run): fall back to the conventional order `<Sender> - Post Engagers` (warmest) → `Shared Signal Discovery` → `Shared Cold Fallback` (coldest), and note that running `create-evergreen-campaigns` will materialize a stored hierarchy.
+
+Fill mechanics, whatever the source of the order:
+
+- **Fill the top lane first.** Move to the next lane ONLY when the current one stops with source exhaustion / no more eligible rows — never because it is merely slow.
+- **Stop descending once the horizon target is met.** If the warm lane alone fills the horizon, the cold lanes get nothing this run — that is correct, not a gap.
+- **Report per lane** so the operator can see the waterfall working:
 
 ```
-csreyes92 waterfall: Post Engagers filled 4/4 (horizon met — lower lanes skipped)
-thomas waterfall: Post Engagers 1/4 (source thin) → Shared Signal Discovery 3/3 remaining
+csreyes92 waterfall (stored order): Post Engagers filled 4/4 (horizon met — lower lanes skipped)
+thomas waterfall (stored order): Post Engagers 1/4 (source thin) → Shared Signal Discovery 3/3 remaining
 ```
-
-To **change the hierarchy**, the scheduled automation just states the new order in its prompt — the order is an input to this skill, not stored state.
 </waterfall>
 
 <safety>