@sellable/mcp 0.1.335 → 0.1.337

package/dist/server.js

@@ -6,9 +6,11 @@ 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 { resolveCampaignFillRoute } from "./tools/campaign-fill-routing.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 { refillCampaignSends } from "./tools/refill-campaign-sends.js";
+import { getCampaignTableSchema, queueCampaignCells, recordCampaignReviewBatch, reviseMessageTemplateAndRerun, selectCampaignCells, waitForCampaignProcessing, } from "./tools/campaign-processing.js";
 import { createCampaign, duplicateCampaign, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
 import { queueCells, updateCell } from "./tools/cells.js";
 import { handleStartCliLogin, handleWaitForCliLogin, } from "./tools/cli-login.js";
@@ -179,6 +181,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_campaign_messages_preview":
                 result = await getCampaignMessagesPreview(args);
                 break;
+            case "resolve_campaign_fill_route":
+                result = await resolveCampaignFillRoute(args);
+                break;
+            case "refill_campaign_sends":
+                result = await refillCampaignSends(args);
+                if (args?.mode === "apply" && Array.isArray(result?.appliedCampaignIds)) {
+                    for (const campaignId of result.appliedCampaignIds) {
+                        markCampaignContextDirty(campaignId, "refill_campaign_sends");
+                    }
+                }
+                break;
             case "fill_campaign_horizon":
                 result = await fillCampaignHorizon(args);
                 if (args?.campaignId) {
@@ -219,6 +232,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     markCampaignContextDirty(args.campaignId, "queue_campaign_cells");
                 }
                 break;
+            case "record_campaign_review_batch":
+                result = await recordCampaignReviewBatch(args);
+                break;
             case "wait_for_campaign_processing":
                 result = await waitForCampaignProcessing(args);
                 break;

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

@@ -0,0 +1,39 @@
+type CampaignFillIntent = "plain" | "evergreen" | "active";
+type ResolveCampaignFillRouteInput = {
+    intent: CampaignFillIntent;
+    campaignId?: string;
+    tableId?: string;
+    limit?: number;
+};
+export declare const campaignFillRoutingToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            intent: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            campaignId: {
+                type: string;
+                description: string;
+            };
+            tableId: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function resolveCampaignFillRoute(input: ResolveCampaignFillRouteInput): Promise<unknown>;
+export {};

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

@@ -0,0 +1,45 @@
+import { getApi } from "../api.js";
+async function postCampaignFillRoute(body) {
+    const api = getApi();
+    return api.post("/api/v3/mcp/campaign-fill-routing", body);
+}
+export const campaignFillRoutingToolDefinitions = [
+    {
+        name: "resolve_campaign_fill_route",
+        description: 'Audit-only resolver to call before interpreting plain "fill campaigns", "load everyone up", or similar fill requests. It decides whether the workspace has evergreen/horizon targets, currently active campaign-backed sequence targets, or no targets so the agent must ask what to create. It does not create, append, prepare, approve, schedule, launch, archive, delete, send, or call lower-level fill tools. Only call fill_campaign_horizon when this resolver returns route "evergreen_horizon" or the user explicitly requested evergreen/horizon and the returned target is eligible. Exact target narrowing uses campaignId or tableId only; never fuzzy campaign names.',
+        inputSchema: {
+            type: "object",
+            properties: {
+                intent: {
+                    type: "string",
+                    enum: ["plain", "evergreen", "active"],
+                    description: 'Use "plain" for generic fill/load requests, "evergreen" for explicit evergreen/horizon fill, and "active" for explicit active campaign fill.',
+                },
+                campaignId: {
+                    type: "string",
+                    description: "Optional exact CampaignOffer.id to narrow routing. Do not pass campaign names.",
+                },
+                tableId: {
+                    type: "string",
+                    description: "Optional exact WorkflowTable.id to narrow routing. Do not pass table names.",
+                },
+                limit: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 100,
+                    description: "Maximum returned targets/skippedTargets.",
+                },
+            },
+            required: ["intent"],
+            additionalProperties: false,
+        },
+    },
+];
+export function resolveCampaignFillRoute(input) {
+    return postCampaignFillRoute({
+        intent: input.intent,
+        campaignId: input.campaignId,
+        tableId: input.tableId,
+        limit: input.limit,
+    });
+}

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

@@ -6,7 +6,7 @@ async function postHorizonFill(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, launch, send, or directly write scheduledFor. Prepared/approved rows are intermediate only; report scheduled completion only after re-reading scheduler-owned scheduled cells with non-null scheduledFor.",
+        description: "Evergreen/horizon-only tool: audit or apply a bounded CampaignOffer horizon fill from Signal Discovery/source lead-list rows only when resolve_campaign_fill_route returns route evergreen_horizon or the user explicitly requested evergreen/horizon and the target is managed-waterfall eligible. 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, send messages, or directly assign scheduler-owned send timestamps. Prepared/approved rows are intermediate only; report scheduled completion only after re-reading scheduler-owned scheduled cells with non-null scheduler timestamps.",
         inputSchema: {
             type: "object",
             properties: {

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

@@ -6,7 +6,7 @@ async function postPrepareMessages(body) {
 export const campaignMessagePreparationToolDefinitions = [
     {
         name: "start_campaign_message_preparation",
-        description: 'Start a bounded campaign message preparation job for a CampaignOffer campaignId. Use this after lead/message approval when the user asks to "fill up", "load", or "prepare" sends for attached senders. It never launches the campaign, sends messages, or directly writes scheduledFor. The job queues pending Enrich Prospect cells first, lets ICP/rubric and Generate Message cascade, then marks ready or approves only the bounded cohort. Prepared/approved/ready rows are intermediate only; scheduled completion requires a later re-read proving scheduler-owned scheduled cells with non-null scheduledFor. Omit maxRowsToCheck and batchSize for the adaptive default: calibrate on at least 100 actually-enriched rows, estimate the row budget from observed rubric/pass yield, cap rows at 300, and process at most 100 newly checked rows at a time. The worker will not pull another row batch while the current checked batch still has queueable or active cells. Do not interpret checkedRows as enriched rows; use progress.enrichedRows, needsEnrichRows, activeCellCount, preparedMessages, approvedMessages, and stopReason.',
+        description: 'Start a bounded message-preparation job for a specific existing CampaignOffer campaignId/tableId. This is the active_campaigns existing-row path after resolve_campaign_fill_route, exact target re-read, and active prep-job check; it is not campaign creation and not evergreen horizon fill. It never launches the campaign, sends messages, or directly writes scheduledFor. The job queues pending Enrich Prospect cells first, lets ICP/rubric and Generate Message cascade, then marks ready or approves only the bounded cohort. Prepared/approved/ready rows are intermediate only; scheduled completion requires a later re-read proving scheduler-owned scheduled cells with non-null scheduledFor. Surface active preparation jobs, exhausted source rows, disconnected Sales Nav/deleted sender accounts, missing sequence state, and other sender-health blockers separately from prepared/approved/scheduled counts. Omit maxRowsToCheck and batchSize for the adaptive default: calibrate on at least 100 actually-enriched rows, estimate the row budget from observed rubric/pass yield, cap rows at 300, and process at most 100 newly checked rows at a time. The worker will not pull another row batch while the current checked batch still has queueable or active cells. Do not interpret checkedRows as enriched rows; use progress.enrichedRows, needsEnrichRows, activeCellCount, preparedMessages, approvedMessages, and stopReason.',
         inputSchema: {
             type: "object",
             properties: {

package/dist/tools/campaign-processing.d.ts

@@ -42,6 +42,11 @@ type ReviseTemplateInput = SchemaInput & {
     rowSelector?: RowSelector;
     limit?: number;
 };
+type RecordReviewBatchInput = SchemaInput & {
+    tableId: string;
+    rowIds: string[];
+    enrichCellIds?: string[];
+};
 type ReviseTemplateResponse = Record<string, unknown> & {
     approvalsReset?: number;
 };
@@ -99,6 +104,8 @@ export declare const campaignProcessingToolDefinitions: ({
             templateRevision?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
+            rowIds?: undefined;
+            enrichCellIds?: undefined;
             templateMarkdown?: undefined;
             approvedMessageTemplate?: undefined;
         };
@@ -154,6 +161,8 @@ export declare const campaignProcessingToolDefinitions: ({
             templateRevision?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
+            rowIds?: undefined;
+            enrichCellIds?: undefined;
             templateMarkdown?: undefined;
             approvedMessageTemplate?: undefined;
         };
@@ -213,6 +222,8 @@ export declare const campaignProcessingToolDefinitions: ({
             templateRevision?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
+            rowIds?: undefined;
+            enrichCellIds?: undefined;
             templateMarkdown?: undefined;
             approvedMessageTemplate?: undefined;
         };
@@ -252,12 +263,52 @@ export declare const campaignProcessingToolDefinitions: ({
             limit?: undefined;
             forceRerun?: undefined;
             reason?: undefined;
+            rowIds?: undefined;
+            enrichCellIds?: undefined;
             templateMarkdown?: undefined;
             approvedMessageTemplate?: undefined;
         };
         additionalProperties: boolean;
         required?: undefined;
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            tableId: {
+                type: string;
+            };
+            rowIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            enrichCellIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            campaignId?: undefined;
+            columnRole?: undefined;
+            rowSelector?: undefined;
+            limit?: undefined;
+            forceRerun?: undefined;
+            reason?: undefined;
+            minPassedCount?: undefined;
+            minGeneratedMessages?: undefined;
+            templateRevision?: undefined;
+            timeoutMs?: undefined;
+            intervalMs?: undefined;
+            templateMarkdown?: undefined;
+            approvedMessageTemplate?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
 } | {
     name: string;
     description: string;
@@ -308,6 +359,8 @@ export declare const campaignProcessingToolDefinitions: ({
             templateRevision?: undefined;
             timeoutMs?: undefined;
             intervalMs?: undefined;
+            rowIds?: undefined;
+            enrichCellIds?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -316,6 +369,7 @@ export declare const campaignProcessingToolDefinitions: ({
 export declare function getCampaignTableSchema(input: SchemaInput): Promise<CampaignProcessingSchemaResponse>;
 export declare function selectCampaignCells(input: SelectInput): Promise<unknown>;
 export declare function queueCampaignCells(input: QueueInput): Promise<unknown>;
+export declare function recordCampaignReviewBatch(input: RecordReviewBatchInput): Promise<unknown>;
 export declare function reviseMessageTemplateAndRerun(input: ReviseTemplateInput): Promise<ReviseTemplateResponse>;
 export declare function waitForCampaignProcessing(input: WaitInput): Promise<{
     ready: boolean;

package/dist/tools/campaign-processing.js

@@ -142,6 +142,20 @@ export const campaignProcessingToolDefinitions = [
             additionalProperties: false,
         },
     },
+    {
+        name: "record_campaign_review_batch",
+        description: "Record a fresh campaign-table review batch from explicit row IDs. Use for same-source new-sample recovery after a zero-pass bounded filter run; do not use for new lead sourcing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tableId: { type: "string" },
+                rowIds: { type: "array", items: { type: "string" } },
+                enrichCellIds: { type: "array", items: { type: "string" } },
+            },
+            required: ["tableId", "rowIds"],
+            additionalProperties: false,
+        },
+    },
     {
         name: "revise_message_template_and_rerun",
         description: "Update the approved message template in the campaign brief, mark prior generated messages stale, reset unsent approvals, and force-rerun Generate Message cells. Does not directly overwrite row message cells.",
@@ -192,6 +206,12 @@ export async function queueCampaignCells(input) {
         ...input,
     });
 }
+export async function recordCampaignReviewBatch(input) {
+    return postCampaignProcessing({
+        action: "recordReviewBatch",
+        ...input,
+    });
+}
 export async function reviseMessageTemplateAndRerun(input) {
     const result = await postCampaignProcessing({
         action: "reviseTemplateAndRerun",
@@ -245,28 +265,36 @@ function buildProcessingTimeoutRecovery({ input, schema, stats, minPassedCount,
             },
         });
     }
-    if (!passFloorMet && pendingWorkCount === 0 && campaignId) {
+    if (!passFloorMet && pendingWorkCount === 0) {
         suggestedToolCalls.push({
-            tool: "search_signals",
-            reason: "The checked sample missed the validation floor; revise the source before Settings.",
+            tool: "get_rows_minimal",
+            reason: "The checked sample missed the validation floor; inspect compact row miss patterns before choosing rubric revision, same-source new sample, or source revision.",
             args: {
-                campaignOfferId: campaignId,
-                currentStep: "signal-discovery",
-                currentStepTransition: "revise-source-after-validation",
+                ...(campaignId ? { campaignId } : { tableId: schema.tableId }),
             },
         });
+        suggestedToolCalls.push({
+            tool: "record_campaign_review_batch",
+            reason: "If the source is still viable but this slice was unrepresentative, record explicit same-source rowIds as a fresh review batch, then queue enrich on rowSelector reviewBatch.",
+            args: {
+                tableId: schema.tableId,
+                rowIds: ["<choose unprocessed same-source row ids>"],
+            },
+        });
+    }
+    if (!passFloorMet && pendingWorkCount === 0 && campaignId) {
         suggestedToolCalls.push({
             tool: "update_campaign",
-            reason: "If the user chooses a non-source revision path, persist the chosen recovery step explicitly.",
+            reason: "Persist the chosen recovery step explicitly; do not jump straight to source revision unless rubric relaxation and same-source sampling are not viable.",
             args: {
                 campaignId,
-                currentStep: "signal-discovery",
-                currentStepTransition: "revise-source-after-validation",
+                currentStep: "apply-icp-rubric",
+                currentStepTransition: "sample-needs-revision",
             },
         });
     }
     const nextAction = !passFloorMet && pendingWorkCount === 0
-        ? "revise-source-or-filters"
+        ? "revise-rubric-new-sample-or-source"
         : !generatedFloorMet
             ? "queue-or-retry-message-generation"
             : pendingWorkCount > 0
@@ -404,7 +432,7 @@ export async function waitForCampaignProcessing(input) {
                     minGeneratedMessages,
         },
         recovery,
-        guidance: "Surface this partial validation checkpoint before taking another action. Use recovery.suggestedToolCalls to retry processing, queue missing work, or revise source/filter/message quality instead of moving to Settings on a weak sample.",
+        guidance: "Surface this partial validation checkpoint before taking another action. Use recovery.suggestedToolCalls to retry processing, queue missing work, revise rubrics, record a fresh same-source sample, revise source, or revise message quality instead of moving to Settings on a weak sample.",
         stats: lastStats,
     };
 }

package/dist/tools/prompts.js

@@ -371,7 +371,7 @@ export function getPostFindLeadsScoutRegistry() {
             codex: 'After confirm_lead_list copies source rows and the initial campaign-table execution slice exists, ask the filter-choice question immediately. Do not spawn anything before that question. After the answer, launch only Message Drafting. The filter-choice answer is the post-import user gate for this single worker; do not ask another question about starting it in step-wise or YOLO mode. The registry lookup is not a launch: after get_post_find_leads_scout_registry, immediately invoke Task/spawn_agent or the host background-agent mechanism before loading filter-leads.md, before saving rubrics, and before treating skip-filters as ready for message review. Both choices route through this kickoff; do not let filters_skipped jump straight from filter-choice to message-generation. If filters are chosen, the parent stays on Filter Rules and drafts/saves rubrics with MCP tools while Message Drafting runs in the background. If filters are skipped, move to Messages/message review only after Message Drafting has started or is ready; update_campaign(currentStep=messages) is not proof of launch. If the named Message Drafting custom agent is unavailable, spawn a generic gpt-5.5 xhigh Message Drafting background agent with the same lean campaign/table basis. When the background worker starts, persist workerDetails.messageDraftBuilder with statusSource "branch", status "branch-running", runId, startedAt, updatedAt, basisToken when known, and basis containing campaignId, selectedLeadListId, workflowTableId, filterChoice, and reviewBatchRowHash or reviewBatchRowIds; workerStatuses.messageDraftBuilder may be "running" as a simple badge only. Never put rich proof under workerStatuses and never use workerStatuses.messageDrafting. If no background-agent tool is callable, start the same full message branch inline before filter drafting or before skip-filter message review, record workerDetails.messageDraftBuilder with statusSource "parent-thread-fallback" and status "fallback-active", and require the same live context, prompt, assets, and validation gate before message review; do not wait until filters are saved and then call the registry.',
             claude: "After confirm_lead_list copies source rows and the initial campaign-table execution slice exists, ask the filter-choice question immediately. Do not invoke any Task/Agent before that question. After the answer, invoke only Message Drafting. If filters are chosen, parent drafts/saves rubrics with MCP tools while Message Drafting runs, asks filter approval, then joins Message Drafting. If filters are skipped, invoke only Message Drafting and move to Messages/message review.",
             parentThreadRule: 'Named agents are optional acceleration, but message drafting is not optional. The only normal background worker is Message Drafting. The filter-choice answer is the campaign-scoped go-ahead for this single post-import worker; do not ask another question to start it in step-wise or YOLO mode. If a named agent is unavailable, use a generic gpt-5.5 xhigh Message Drafting background agent. source work and filter work stay in the parent thread with MCP tools. If post-find-leads-message-scout is available, run it as the background Message Draft Builder after the filter-choice answer. The registry lookup is not a launch: get_post_find_leads_scout_registry only identifies the worker, and Message Drafting counts as started only after Task/spawn_agent or the host background-agent tool is invoked, or after the parent begins the same full message branch inline because no background-agent tool is callable. This launch must happen before loading filter-leads.md, save_rubrics, filter approval, or skip-filter message review; currentStep=messages is not proof of launch. If post-find-leads-message-scout is absent, do not customer-surface install status. Do not silently treat message drafting as started; the main thread must either launch the background worker or execute the same message branch from CampaignOffer state, selected source state, workflowTableId, and initial campaign-table execution slice rows. For a spawned worker, record workerDetails.messageDraftBuilder with statusSource branch / status branch-running, runId, startedAt, updatedAt, and basis containing campaignId, selectedLeadListId, workflowTableId, filterChoice, and reviewBatchRowHash or reviewBatchRowIds. workerStatuses.messageDraftBuilder is optional simple badge text only ("running", "ready", "blocked", "idle"); never put runId/statusSource/basis under workerStatuses and never use workerStatuses.messageDrafting. If no background-agent tool is callable, start that same full message branch inline before filter drafting or before skip-filter message review, record workerDetails.messageDraftBuilder with statusSource parent-thread-fallback / status fallback-active then ready, and require the same live context, prompt, assets, and validation gate before message review; do not report that as a background worker failure. If neither branch nor inline fallback can run, return blocked/retry-needed; do not wait until filters are saved and then call the registry. The Message Drafting handoff must be lean. Do not paste copied row counts, brief hashes, review-batch hashes, full reviewBatchRowIds, broad row data, or local debug artifacts into the spawn prompt. Local markdown/json files are not normal-path inputs. The filter-choice question is the first post-import user gate; do not load post-lead registries or filter references before it. Message drafting starts after the filter-choice answer, must load get_subskill_prompt({ subskillName: "generate-messages" }), and must load every required message asset named by generate-messages Mode 0 through get_subskill_asset before drafting. Reference Asset Loading means loading the required pre-draft reference pack before drafting; return blocked/retry-needed if required assets cannot be loaded; load ai-tells.md because it is never optional. The branch or parent-thread fallback loads the full generate-messages prompt and every referenced asset through get_subskill_asset. After generating/revising the candidate and before returning ready, must load get_subskill_prompt({ subskillName: "create-campaign-v2-validation" }) as the final internal validation gate, must read live campaign table state through scoped MCP/product tools, and must reject mismatched selectedLeadListId/workflowTableId/campaign/workspace input. Do not block when filters were chosen but leadScoringRubrics are not yet visible in the branch read; the parent owns save_rubrics and filter approval in parallel, so Message Drafting should return status ready with basisStatus usable_initial when campaign/list/table identity and the non-empty execution slice match. Do not use any alternate, local-artifact, or examples-only message prompt. User copy feedback, message QA, or rewrite requests before approve-message must be routed back to Message Drafting with the current recommendation, lean campaign/table basis, and latest user text; the parent must not rewrite or QA the template from memory and must not call update_campaign_brief before approve-message. The worker validates internally and returns only templateRecommendation, tokenFillRules, renderedGoodSample, status, approveOrReviseRecommendation, validationStatus, outputAt, outputHash, and blocked/retry detail. Do not render renderedFallbackSample, risk notes, or a qaReceipt on the normal happy path. On the filter path, save_rubrics keeps the browser on Filter Rules after save_rubrics so the user can approve the saved criteria; after saved-filter approval, move to Filter Leads with currentStep=apply-icp-rubric whether Message Drafting is ready or still running. Wait there for message approval. Enrichment, filtering, Generate Message cells, sender setup, sequence attach, and launch wait for template approval on the Use Template path. On the skip path, move to Messages/message review after Message Drafting has started or is ready and wait for message approval before enrichment or Settings. Do not render message review from checklist or shortcut instructions; message review requires a messageDraftRecommendation whose basis proves the generate-messages prompt, required message assets, and validation gate ran for the current campaign/table execution slice. Do not automatically rerun Message Drafting after filters/enrichment finish; show the initial draft by default and offer an enriched rewrite only with explicit user opt-in. Handoff and recommendation output are Markdown with labeled fields, not raw JSON.',
-            prepareMessagesRule: 'Default create-campaign stays on the existing reviewBatchLimit:15 first campaign-table execution slice. Only call start_campaign_message_preparation when the user explicitly asks for more prepared messages, a send count, or to fill up/load sends for senders. Treat "fill up/load sends" as capacity-fill preparation: calculate the bounded target from sender capacity when needed, then let the job queue pending Enrich Prospect cells first, wait for ICP/rubric and Generate Message to cascade, and mark ready or approve only the target cohort. Do not interpret checkedRows as enriched rows; it is only the table cursor. Poll get_campaign_message_preparation_status and summarize enrichedRows, needsEnrichRows, activeCellCount, passed/prepared/approved count, target, estimated row budget remaining, and stopReason. Prepared, approved, and ready_to_schedule rows are intermediate states; never call them scheduled unless a re-read proves scheduler-owned scheduled cells with non-null scheduledFor. For "prepare/generate X messages", set targetPreparedMessages:X, omit maxRowsToCheck so the backend calibrates on at least 100 actually-enriched rows, estimates the row budget from observed rubric/pass yield, caps maxRowsToCheck at 300, and use approvalMode:mark_ready. After the calibration sample settles, the backend continues in batches capped at 100 newly checked rows and will not pull another row batch while the current checked batch still has queueable or active cells. For "approve X messages", use approvalMode:approve but still do not launch. For "schedule X sends" or "fill sender sends", use approvalMode:approve only when the user explicitly asked for approval, approve exactly the bounded X-message cohort during preparation, then re-read campaign/table scheduled counts; if scheduler-owned scheduledFor cells are not present, report prepared/approved/ready - awaiting scheduler instead of success. Do not call start_campaign as part of fill/schedule horizon. Launch/start is a separate explicit human action after the operator intentionally wants sends to go out, and it must still verify that the bounded cohort is the only approved cohort and must not broad approve-all. campaignId is CampaignOffer.id. If the user asks to stop preparation, the target is wrong, or status shows the wrong campaign/table, call cancel_campaign_message_preparation; otherwise do not cancel a healthy prepare run. cancel_campaign_message_preparation cancels the same pending workflow-table cells as the UI Cancel Pending Cells action. Low-level selectors are diagnostics and recovery only for this lane. start_campaign remains forbidden until explicit launch/start approval outside fill-horizon.',
+            prepareMessagesRule: `Default create-campaign stays on the existing reviewBatchLimit:15 first campaign-table execution slice. For plain post-mint fill/load/refill requests, first call refill_campaign_sends({ mode:"plan", intent:"plain" }). Plain fill is not an alias for fill_campaign_horizon or campaign creation. If no --yolo is present, report the plan and stop. If --yolo is present, call plan first, inspect blockers, then call refill_campaign_sends({ mode:"apply", yolo:true, planRevision, actionIds }) using only selected immutable actionIds from the fresh plan. Use resolve_campaign_fill_route, fill_campaign_horizon, and start_campaign_message_preparation only as fallback/lower-level diagnostics when refill_campaign_sends is unavailable or when the refill command returns an evergreen subplan. fill_campaign_horizon is evergreen-only and is not the generic regular-campaign fill path. Treat "fill up/load sends" as capacity-fill preparation: calculate the bounded target from sender capacity when needed, then let the command plan source, enrichment, ICP/rubric, Generate Message propagation, approval/ready state, scheduler reread, and blockers. Do not interpret checkedRows as enriched rows; it is only the table cursor. Prepared, approved, and ready_to_schedule rows are intermediate states; never call them scheduled unless a re-read proves scheduler-owned scheduled cells with non-null scheduledFor. For "approve X messages", use approvalMode:approve only when explicitly requested, but still do not launch. For "schedule X sends" or "fill sender sends", approve only when explicitly requested, then re-read campaign/table scheduled counts; if scheduler-owned scheduledFor cells are not present, report prepared/approved/ready - awaiting scheduler instead of success. Do not call start_campaign as part of refill sends. Launch/start is a separate explicit human action after the operator intentionally wants sends to go out, and it must still verify that the bounded cohort is the only approved cohort and must not broad approve-all. campaignId is CampaignOffer.id. If the user asks to stop preparation, the target is wrong, or status shows the wrong campaign/table, use cancel_campaign_message_preparation only for the exact active job. Low-level selectors are diagnostics and recovery only for this lane. start_campaign remains forbidden until explicit launch/start approval outside refill sends.`,
         },
     };
 }

package/dist/tools/refill-campaign-sends.d.ts

@@ -0,0 +1,92 @@
+type RefillCampaignSendsInput = {
+    mode?: "plan" | "apply";
+    intent?: "plain" | "evergreen" | "active";
+    campaignIds?: string[];
+    tableIds?: string[];
+    sendWindowDays?: number;
+    targetDates?: string[];
+    targetScheduledSends?: number;
+    approvalMode?: "mark_ready" | "approve";
+    yolo?: boolean;
+    planRevision?: string;
+    actionIds?: string[];
+};
+export declare const refillCampaignSendsToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            mode: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
+            intent: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            campaignIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            tableIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            sendWindowDays: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            targetDates: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            targetScheduledSends: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            approvalMode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            yolo: {
+                type: string;
+                description: string;
+            };
+            planRevision: {
+                type: string;
+                description: string;
+            };
+            actionIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+}[];
+export declare function refillCampaignSends(input: RefillCampaignSendsInput): Promise<unknown>;
+export {};

package/dist/tools/refill-campaign-sends.js

@@ -0,0 +1,91 @@
+import { getApi } from "../api.js";
+async function postRefillCampaignSends(body) {
+    const api = getApi();
+    return api.post("/api/v3/mcp/refill-campaign-sends", body);
+}
+export const refillCampaignSendsToolDefinitions = [
+    {
+        name: "refill_campaign_sends",
+        description: "Default mode is plan and read-only. Use this as the canonical tool for plain fill, refill sends, max out sends, load everyone up, and fill send window requests. It returns a campaign send refill plan for regular campaigns and evergreen campaigns, including campaign/table ids, senders, source state, current evergreen source audit evidence, funnel counts, blockers, stable planRevision, and immutable actionIds. It does not create campaigns, create side campaigns, use unsupported_campaign_type internal targets, does not launch or start campaigns, spend paid InMail opt-in, and does not raw-write scheduler fields. mode apply requires yolo: true, the fresh planRevision from the immediately preceding plan, and selected actionIds only; apply rejects changed caps, source ids, target dates, approval mode, or selectors. Evergreen source fallback is evidence-gated: audit the current evergreen source first and recommend the next source-ladder option only after current-source exhaustion or insufficient good-prospect yield is proven. Scheduled completion is not claimed until scheduler-owned cells are reread with non-null scheduledFor.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                mode: {
+                    type: "string",
+                    enum: ["plan", "apply"],
+                    default: "plan",
+                    description: 'Defaults to "plan"; plan mode is read-only and returns the plan of attack.',
+                },
+                intent: {
+                    type: "string",
+                    enum: ["plain", "evergreen", "active"],
+                    description: 'Use "plain" for generic fill/refill sends, "evergreen" for explicit evergreen, and "active" for exact active campaign refill.',
+                },
+                campaignIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 25,
+                    description: "Optional exact CampaignOffer ids. Do not pass names.",
+                },
+                tableIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 25,
+                    description: "Optional exact WorkflowTable ids. Do not pass names.",
+                },
+                sendWindowDays: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 30,
+                    description: "Optional send window size in days.",
+                },
+                targetDates: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 30,
+                    description: "Optional ISO date keys for the send window.",
+                },
+                targetScheduledSends: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 500,
+                    description: "Optional bounded send target. This is not a launch request.",
+                },
+                approvalMode: {
+                    type: "string",
+                    enum: ["mark_ready", "approve"],
+                    description: "Planning preference. Use approve only when the user explicitly asked for approval; launch remains separate.",
+                },
+                yolo: {
+                    type: "boolean",
+                    description: "Required true for apply. Never use in production without explicit operator approval of exact workspace, campaign/table ids, action ids, caps/dates, and expected side effects.",
+                },
+                planRevision: {
+                    type: "string",
+                    description: "Required for apply. Copy from the fresh read-only plan response.",
+                },
+                actionIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Required for apply. Select immutable actionIds from the fresh plan only.",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+];
+export function refillCampaignSends(input) {
+    return postRefillCampaignSends({
+        mode: input.mode ?? "plan",
+        intent: input.intent,
+        campaignIds: input.campaignIds,
+        tableIds: input.tableIds,
+        sendWindowDays: input.sendWindowDays,
+        targetScheduledSends: input.targetScheduledSends,
+        targetDates: input.targetDates,
+        approvalMode: input.approvalMode,
+        yolo: input.yolo,
+        planRevision: input.planRevision,
+        actionIds: input.actionIds,
+    });
+}