@sellable/mcp 0.1.328 → 0.1.330

package/dist/server.js

@@ -6,6 +6,7 @@ import { getAuthStatus } from "./tools/auth.js";
 import { handleAddColumn, handleCommitBlueprint, } from "./tools/blueprint-commit.js";
 import { bootstrapCreateCampaign } from "./tools/bootstrap.js";
 import { prepareCampaignAbTest } from "./tools/campaign-ab-test.js";
+import { fillCampaignHorizon } from "./tools/campaign-horizon-fill.js";
 import { cancelPrepareCampaignMessages, getPrepareCampaignMessagesStatus, startPrepareCampaignMessages, } from "./tools/campaign-message-preparation.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";
@@ -178,6 +179,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_campaign_messages_preview":
                 result = await getCampaignMessagesPreview(args);
                 break;
+            case "fill_campaign_horizon":
+                result = await fillCampaignHorizon(args);
+                if (args?.campaignId) {
+                    markCampaignContextDirty(args.campaignId, "fill_campaign_horizon");
+                }
+                break;
             case "start_campaign_message_preparation":
             case "start_prepare_campaign_messages":
                 result = await startPrepareCampaignMessages(args);

package/dist/tools/campaign-horizon-fill.d.ts

@@ -0,0 +1,93 @@
+type FillCampaignHorizonInput = {
+    action: "audit" | "apply";
+    campaignId: string;
+    tableId?: string;
+    stateRevision?: string;
+    excludedPostIds?: string[];
+    excludedPostUrls?: string[];
+    excludedAuthorProfileUrls?: string[];
+    excludedAuthorNames?: string[];
+    targetPreparedMessages?: number;
+    maxRowsToCheck?: number;
+    batchSize?: number;
+};
+export declare const campaignHorizonFillToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            campaignId: {
+                type: string;
+                description: string;
+            };
+            tableId: {
+                type: string;
+                description: string;
+            };
+            stateRevision: {
+                type: string;
+                description: string;
+            };
+            excludedPostIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            excludedPostUrls: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            excludedAuthorProfileUrls: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            excludedAuthorNames: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            targetPreparedMessages: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            maxRowsToCheck: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            batchSize: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function fillCampaignHorizon(input: FillCampaignHorizonInput): Promise<unknown>;
+export {};

package/dist/tools/campaign-horizon-fill.js

@@ -0,0 +1,92 @@
+import { getApi } from "../api.js";
+async function postHorizonFill(body) {
+    const api = getApi();
+    return api.post("/api/v3/mcp/campaign-horizon-fill", body);
+}
+export const campaignHorizonFillToolDefinitions = [
+    {
+        name: "fill_campaign_horizon",
+        description: "Audit or apply a bounded CampaignOffer horizon fill from Signal Discovery/source lead-list rows. Use audit first to get stateRevision, then apply with that stateRevision. Apply imports at most 300 eligible non-excluded source rows, starts bounded message preparation in approval mode, skips rows from excluded posts/authors, and does not start or launch the campaign.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["audit", "apply"],
+                    description: 'Use "audit" to inspect counts/receipt without writes. Use "apply" with the audit stateRevision to import/prep.',
+                },
+                campaignId: {
+                    type: "string",
+                    description: "CampaignOffer.id for the campaign to fill.",
+                },
+                tableId: {
+                    type: "string",
+                    description: "Optional workflow table id. Must match the campaign workflowTableId when provided.",
+                },
+                stateRevision: {
+                    type: "string",
+                    description: "Required for apply. Copy from the immediately preceding audit receipt.",
+                },
+                excludedPostIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 100,
+                    description: "Exact SignalSearchPost ids to exclude from import/preparation.",
+                },
+                excludedPostUrls: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 100,
+                    description: "Exact LinkedIn post URLs to exclude from import/preparation.",
+                },
+                excludedAuthorProfileUrls: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 100,
+                    description: "Exact LinkedIn author profile URLs whose source rows should be excluded.",
+                },
+                excludedAuthorNames: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 25,
+                    description: "Exact author names to exclude only when they resolve unambiguously inside campaign Signal Discovery posts.",
+                },
+                targetPreparedMessages: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 300,
+                    description: "Prepared/approved message target for the first pass. Backend caps this at 300.",
+                },
+                maxRowsToCheck: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 300,
+                    description: "Hard first-pass row cap. Backend caps import and prep at 300 rows.",
+                },
+                batchSize: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 100,
+                    description: "Preparation batch size. Backend caps newly checked rows at 100 per batch.",
+                },
+            },
+            required: ["action", "campaignId"],
+            additionalProperties: false,
+        },
+    },
+];
+export function fillCampaignHorizon(input) {
+    return postHorizonFill({
+        action: input.action,
+        campaignId: input.campaignId,
+        tableId: input.tableId,
+        stateRevision: input.stateRevision,
+        excludedPostIds: input.excludedPostIds,
+        excludedPostUrls: input.excludedPostUrls,
+        excludedAuthorProfileUrls: input.excludedAuthorProfileUrls,
+        excludedAuthorNames: input.excludedAuthorNames,
+        targetPreparedMessages: input.targetPreparedMessages,
+        maxRowsToCheck: input.maxRowsToCheck,
+        batchSize: input.batchSize,
+    });
+}

package/dist/tools/registry.d.ts

@@ -474,6 +474,83 @@ export declare const allTools: ({
         required: string[];
         additionalProperties: boolean;
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            campaignId: {
+                type: string;
+                description: string;
+            };
+            tableId: {
+                type: string;
+                description: string;
+            };
+            stateRevision: {
+                type: string;
+                description: string;
+            };
+            excludedPostIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            excludedPostUrls: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            excludedAuthorProfileUrls: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            excludedAuthorNames: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            targetPreparedMessages: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            maxRowsToCheck: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            batchSize: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
 } | {
     name: string;
     description: string;

package/dist/tools/registry.js

@@ -2,6 +2,7 @@ import { authToolDefinitions } from "./auth.js";
 import { blueprintCommitToolDefinitions } from "./blueprint-commit.js";
 import { bootstrapToolDefinitions } from "./bootstrap.js";
 import { campaignAbTestToolDefinitions } from "./campaign-ab-test.js";
+import { campaignHorizonFillToolDefinitions } from "./campaign-horizon-fill.js";
 import { campaignMessagePreparationToolDefinitions } from "./campaign-message-preparation.js";
 import { campaignProcessingToolDefinitions } from "./campaign-processing.js";
 import { campaignToolDefinitions } from "./campaigns.js";
@@ -42,6 +43,7 @@ import { workspaceToolDefinitions } from "./workspaces.js";
 export const allTools = [
     ...campaignToolDefinitions,
     ...campaignAbTestToolDefinitions,
+    ...campaignHorizonFillToolDefinitions,
     ...campaignMessagePreparationToolDefinitions,
     ...campaignProcessingToolDefinitions,
     ...authToolDefinitions,

package/package.json

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

package/skills/create-campaign/SKILL.md

@@ -46,6 +46,7 @@ allowed-tools:
   - mcp__sellable__select_campaign_cells
   - mcp__sellable__queue_campaign_cells
   - mcp__sellable__wait_for_campaign_processing
+  - mcp__sellable__fill_campaign_horizon
   - mcp__sellable__start_campaign_message_preparation
   - mcp__sellable__get_campaign_message_preparation_status
   - mcp__sellable__cancel_campaign_message_preparation
@@ -107,6 +108,13 @@ the template is approved.
 The default path stays the existing first campaign-table execution slice:
 review the normal `reviewBatchLimit:15`, approve reviewed draft rows, then move
 to Settings/sequence/final greenlight. Only call
+`fill_campaign_horizon` for explicit source-cleanup horizon-fill requests, such
+as "fill sends from Signal Discovery but not John Cutler posts." Run
+`fill_campaign_horizon({ action:"audit", ... })` first, then apply with the
+returned `stateRevision`. It imports/prepares at most 300 eligible non-excluded
+source rows in the first pass, caps prep batches at 100, skips existing rows
+from excluded post/author sources, and does not launch the campaign. If the
+user only asks for generic extra sends with no source cleanup, use
 `start_campaign_message_preparation` when the user explicitly asks for more
 prepared messages, a send count, or language like "fill up/load sends for these
 senders." Treat those requests as capacity-fill preparation: calculate the

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

@@ -1,6 +1,6 @@
 ---
 name: create-evergreen-campaigns
-description: Reconcile a sender team's evergreen campaign structure — create-or-reuse the standing campaigns (per-sender post engagers + shared fallback lanes) idempotently, with sequences attached and prospect-safe message briefs. Never duplicates, never launches. Schedule-automation friendly ("make sure evergreen campaigns exist for these users").
+description: Reconcile a sender team's evergreen campaign structure — create-or-reuse the standing campaigns (per-sender post engagers + shared fallback/source lanes) idempotently, with send-lane sequences and prospect-safe message briefs. Never duplicates, never launches. Schedule-automation friendly ("make sure evergreen campaigns exist for these users").
 visibility: internal
 ---
 
@@ -16,15 +16,28 @@ producing duplicates. Reconcile/create-reuse only; this skill never launches cam
 <inputs>
 The invoking prompt names the senders ("create evergreen campaigns for csreyes92 and thomas"). Resolve each via `list_senders`.
 
+If the invoking prompt says scheduled, automation, cron, heartbeat, fresh-thread,
+run without user input, or similar, run in **automation mode**:
+
+- Do not ask the user to confirm templates, delivery format, or sample output.
+- Reconcile structure and record any template/config polish as `created`,
+  `reused`, `repaired`, `flagged`, or `blocked`.
+- Apply only safe metadata repairs that do not create rows, generate messages,
+  approve rows, launch campaigns, send messages, or spend paid InMail.
+
+If the invoking prompt explicitly asks for interactive message polish or sample
+proof, run in **interactive polish mode** and use the confirmation/sample steps
+below.
+
 Default evergreen plan per workspace (override only if the prompt specifies different lanes):
 
 1. **`<Sender Name> - Post Engagers`** — one per sender (warm lane, highest priority)
-2. **`<Workspace/Team> - Shared Signal Discovery`** — one shared across senders
-3. **`<Workspace/Team> - Shared Cold Fallback`** — one shared across senders
+2. **`<Workspace/Team> - Shared Signal Discovery`** — one shared source lane across senders
+3. **`<Workspace/Team> - Shared Cold Fallback`** — one shared source/fallback lane across senders
 </inputs>
 
 <objective>
-1. **Inventory first**: `get_campaigns` + `list_tables` in the active workspace. Match existing campaigns to the plan by name (case-insensitive, ignore suffixes like "(Copy)"). A matching non-archived campaign = REUSE; record it and move on. Never create a second campaign for a slot that already has one.
+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. 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 })`:
    - Post Engagers lanes: that sender's ID only. Shared lanes: all the senders' IDs.
    - The brief must include the warm post-engager first-message template style — short, casual, references the post they engaged with, closed question, **no internal vocabulary, no pitch, no meeting ask** in message one:
@@ -42,23 +55,27 @@ Default evergreen plan per workspace (override only if the prompt specifies diff
      - **InMail lanes can never be multiline**: an InMail is one message and the recipient must reply before anything else can be sent. InMail-bound templates must read as one cohesive message — declare `Delivery format: single message (InMail — no follow-up until reply)` and never structure the copy to depend on multi-message pacing.
 
    - The sequence is auto-selected by sender tier; do not hand-author sequence templates here. Never select a paid-InMail template.
-3. **Verify each slot** after create/reuse: `get_campaign` shows the table exists and a sequence is attached (`list_tables({ hasSequence: true })` as a cross-check).
-4. **Confirm the message template with the user — and check it reads chat-native.** Show the exact first-message template each created campaign's brief carries and ask the user to confirm or adjust it before moving on. Because DM copy may send paragraph-by-paragraph (each blank-line block becomes its own message), every paragraph must read like something a human literally typed as a separate chat message:
+3. **Verify each slot** after create/reuse/repair:
+   - `get_campaign` shows the campaign exists, remains unlaunched, and has the expected workflow table.
+   - Send/action lanes such as Post Engagers have a sequence attached (`list_tables({ hasSequence: true })` as a cross-check).
+   - Source-only shared lanes may legitimately have `hasSequence:false` when they only supply rows through the managed waterfall. For those, verify the active waterfall linkage, table ID, campaign ID, source type, and priority; report `source-only/no sequence expected` instead of repairing or duplicating.
+4. **Interactive polish mode only: confirm the message template with the user — and check it reads chat-native.** Show the exact first-message template each created campaign's brief carries and ask the user to confirm or adjust it before moving on. Because DM copy may send paragraph-by-paragraph (each blank-line block becomes its own message), every paragraph must read like something a human literally typed as a separate chat message:
    - **No letter punctuation.** `Hey {{first_name}}` — never `Hey {{first_name}},` (nobody types a trailing comma and hits send). No `Dear`, no sign-offs, no `Best,`.
    - Each paragraph stands alone as a message — short, lowercase-casual is fine, sentence fragments are fine.
    - No paragraph should depend on letter formatting (no "As I mentioned above" referencing layout).
    If the template violates these, propose the chat-native version and ask; on approval, update the brief via `update_campaign_brief` and show the final version.
 
    **Also confirm the delivery format and keep config in sync.** Ask the user whether DM lanes should send multiline (paragraph-per-message) or as a single message. Record the answer as the brief's `Delivery format:` line, and when multiline is chosen, set `actionConfig.sendEachParagraphAsMessage: true` on that campaign's `send_dm` column via `update_column` (config edits run no cells and nothing sends from unlaunched campaigns). Never set the paragraph-split flag on InMail columns — the option does not apply to InMail.
-5. **Prove the template on one real row.** For ONE campaign that has at least one lead row (add one via `add_on_demand_leads` if every lane is empty and the user provides/approves a test lead), generate a message for exactly one row (`queue_campaign_cells` with `columnRole: "generateMessage"`, `rowSelector: { type: "reviewBatch", limit: 1 }` or the single row's ID), wait for it, then show the user the generated message next to the template — AND show how it would split if paragraph-per-message sending is enabled (list each paragraph as `msg 1:`, `msg 2:`, …) so the user confirms each one reads like a real typed message. Check alignment: tone, structure, no internal vocabulary, correct token substitution, no letter punctuation. Do NOT approve the row or generate for more rows — one sample only.
-6. **Report the reconcile plan and result** — every slot tagged `reused` or `created`, plus the confirmed template and the sample message:
+5. **Interactive polish mode only: prove the template on one real row.** For ONE campaign that has at least one lead row (add one via `add_on_demand_leads` if every lane is empty and the user provides/approves a test lead), generate a message for exactly one row (`queue_campaign_cells` with `columnRole: "generateMessage"`, `rowSelector: { type: "reviewBatch", limit: 1 }` or the single row's ID), wait for it, then show the user the generated message next to the template — AND show how it would split if paragraph-per-message sending is enabled (list each paragraph as `msg 1:`, `msg 2:`, …) so the user confirms each one reads like a real typed message. Check alignment: tone, structure, no internal vocabulary, correct token substitution, no letter punctuation. Do NOT approve the row or generate for more rows — one sample only.
+6. **Automation mode template/config audit**: inspect existing send-lane briefs for a `Delivery format:` line and chat-native warm template. If a send lane is missing the line and the prompt allows cleanup, update only the campaign brief metadata with the safest default for that lane (`Delivery format: single message (LinkedIn DM; line breaks remain inside one generated message; no follow-up until reply)`). If cleanup is not allowed, flag it. Do not generate a sample row in automation mode unless the invocation explicitly asks for sample proof.
+7. **Report the reconcile plan and result** — every slot tagged `reused`, `created`, `repaired`, `flagged`, or `blocked`, plus template/sample details only when that mode ran:
 
 ```
 Evergreen Reconcile — {date}
-• Christian Reyes - Post Engagers: reused (18 rows)
-• Thomas Nobbs - Post Engagers: reused (8 rows)
-• Sellable.dev - Shared Signal Discovery: reused
-• Sellable.dev - Shared Cold Fallback: created (empty — needs leads)
+• Christian Reyes - Post Engagers: reused (18 rows, sequence attached)
+• Thomas Nobbs - Post Engagers: reused (8 rows, sequence attached)
+• Sellable.dev - Shared Signal Discovery: reused (source-only/no sequence expected)
+• Sellable.dev - Shared Cold Fallback: created (source-only/no sequence expected)
 All campaigns remain unlaunched. Next: refresh-sender-engagement to supply the warm lanes, then fill-send-horizon.
 ```
 </objective>