@sellable/mcp 0.1.470 → 0.1.472

package/dist/server.js

@@ -11,6 +11,7 @@ import { fillCampaignHorizon } from "./tools/campaign-horizon-fill.js";
 import { cancelPrepareCampaignMessages, getPrepareCampaignMessagesStatus, startPrepareCampaignMessages, } from "./tools/campaign-message-preparation.js";
 import { getCampaignRefillState } from "./tools/campaign-refill-state.js";
 import { getRefillTargetPlan } from "./tools/refill-target-plan.js";
+import { getSchedulerFillCapacity } from "./tools/scheduler-fill-capacity.js";
 import { getCampaignTableSchema, queueCampaignCells, recordCampaignReviewBatch, reviseMessageTemplateAndRerun, selectCampaignCells, waitForCampaignProcessing, } from "./tools/campaign-processing.js";
 import { archiveCampaign, createCampaign, duplicateCampaign, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
 import { queueCells, updateCell } from "./tools/cells.js";
@@ -225,6 +226,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_refill_target_plan":
                 result = await getRefillTargetPlan(args);
                 break;
+            case "get_scheduler_fill_capacity":
+                result = await getSchedulerFillCapacity(args);
+                break;
             case "refill_sends":
                 result = refillSendsCommand(args);
                 break;

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

@@ -7,6 +7,7 @@ type RefillSendsCommandInput = {
     senderNames?: string[];
     horizonSendDays?: number;
     untilDate?: string;
+    targetDate?: string;
     campaignId?: string;
     tableId?: string;
     intent?: RefillSendsIntent;
@@ -54,6 +55,11 @@ export declare const refillSendsToolDefinitions: {
                 pattern: string;
                 description: string;
             };
+            targetDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
             campaignId: {
                 type: string;
                 description: string;
@@ -84,12 +90,21 @@ export declare function refillSendsCommand(input?: RefillSendsCommandInput): {
     workflowPromptName: string;
     yolo: boolean;
     intent: RefillSendsIntent;
+    targetDate: string | null;
     untilDate: string | null;
     horizonSendDays: number | null;
     fillWindow: {
+        mode: string;
+        targetDate: string;
+        description: string;
+        untilDate?: undefined;
+        horizonSendDays?: undefined;
+        horizonHours?: undefined;
+    } | {
         mode: string;
         untilDate: string;
         description: string;
+        targetDate?: undefined;
         horizonSendDays?: undefined;
         horizonHours?: undefined;
     } | {
@@ -97,6 +112,7 @@ export declare function refillSendsCommand(input?: RefillSendsCommandInput): {
         horizonSendDays: number | null;
         horizonHours: number | null;
         description: string;
+        targetDate?: undefined;
         untilDate?: undefined;
     };
     approvalMode: RefillSendsApprovalMode;
@@ -121,6 +137,7 @@ export declare function refillSendsCommand(input?: RefillSendsCommandInput): {
                 senders: string[];
                 senderIds: string[];
                 senderNames: string[];
+                targetDate: string | null;
                 untilDate: string | null;
                 horizonSendDays: number | null;
                 campaignId: string | undefined;

package/dist/tools/refill-sends.js

@@ -34,6 +34,25 @@ function normalizeUntilDate(value) {
     }
     return trimmed;
 }
+function normalizeTargetDate(value) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    if (typeof value !== "string") {
+        throw new Error("targetDate must be a string in YYYY-MM-DD format.");
+    }
+    const trimmed = value.trim();
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+        throw new Error("targetDate must use YYYY-MM-DD format.");
+    }
+    const [year, month, day] = trimmed.split("-").map((part) => Number(part));
+    const parsed = new Date(Date.UTC(year, month - 1, day));
+    if (parsed.getUTCFullYear() !== year ||
+        parsed.getUTCMonth() !== month - 1 ||
+        parsed.getUTCDate() !== day) {
+        throw new Error("targetDate must be a valid calendar date.");
+    }
+    return trimmed;
+}
 export const refillSendsToolDefinitions = [
     {
         name: "refill_sends",
@@ -71,6 +90,11 @@ export const refillSendsToolDefinitions = [
                     pattern: "^\\d{4}-\\d{2}-\\d{2}$",
                     description: "Optional sender-local YYYY-MM-DD date to fill through, inclusive. Overrides the default scheduler-forward 48-hour target window.",
                 },
+                targetDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                    description: "Optional exact sender-local YYYY-MM-DD date to fill. This prepares rows only for scheduler-fillable slots on that date and is distinct from untilDate.",
+                },
                 campaignId: {
                     type: "string",
                     description: "Optional exact CampaignOffer.id to narrow routing. Do not pass campaign names.",
@@ -101,8 +125,9 @@ export function refillSendsCommand(input = {}) {
     const senderNames = normalizeStrings(input.senderNames);
     const hasSenderSelectors = senders.length > 0 || senderIds.length > 0 || senderNames.length > 0;
     const yolo = input.yolo === true;
-    const untilDate = normalizeUntilDate(input.untilDate);
-    const horizonSendDays = untilDate
+    const targetDate = normalizeTargetDate(input.targetDate);
+    const untilDate = targetDate ? null : normalizeUntilDate(input.untilDate);
+    const horizonSendDays = targetDate || untilDate
         ? null
         : normalizeHorizonSendDays(input.horizonSendDays);
     const intent = input.intent ?? "plain";
@@ -119,24 +144,31 @@ export function refillSendsCommand(input = {}) {
         workflowPromptName: "refill-sends-workflow",
         yolo,
         intent,
+        targetDate,
         untilDate,
         horizonSendDays,
-        fillWindow: untilDate
+        fillWindow: targetDate
             ? {
-                mode: "until_date",
-                untilDate,
-                description: "Fill through this sender-local date inclusive, skipping no-send days and never extending beyond the date without a new packet.",
+                mode: "target_date",
+                targetDate,
+                description: "Fill only this sender-local date by preparing rows for scheduler-fillable slots on that date.",
             }
-            : {
-                mode: horizonSendDays === null
-                    ? "scheduler_forward_48h"
-                    : "horizon_send_days",
-                horizonSendDays,
-                horizonHours: horizonSendDays === null ? DEFAULT_SCHEDULER_FORWARD_HOURS : null,
-                description: horizonSendDays === null
-                    ? "Fill the default scheduler-forward 48-hour target window."
-                    : "Fill the explicit compatibility horizon by sender-local send days.",
-            },
+            : untilDate
+                ? {
+                    mode: "until_date",
+                    untilDate,
+                    description: "Fill through this sender-local date inclusive, skipping no-send days and never extending beyond the date without a new packet.",
+                }
+                : {
+                    mode: horizonSendDays === null
+                        ? "scheduler_forward_48h"
+                        : "horizon_send_days",
+                    horizonSendDays,
+                    horizonHours: horizonSendDays === null ? DEFAULT_SCHEDULER_FORWARD_HOURS : null,
+                    description: horizonSendDays === null
+                        ? "Fill the default scheduler-forward 48-hour target window."
+                        : "Fill the explicit compatibility horizon by sender-local send days.",
+                },
         approvalMode,
         campaignId: input.campaignId ?? null,
         tableId: input.tableId ?? null,
@@ -153,22 +185,26 @@ export function refillSendsCommand(input = {}) {
                 ? `, senderIds: ${JSON.stringify(senderIds)}`
                 : ""}${senderNames.length > 0
                 ? `, senderNames: ${JSON.stringify(senderNames)}`
-                : ""}${senders.length > 0 ? `, senders: ${JSON.stringify(senders)}` : ""}${untilDate
-                ? `, untilDate: "${untilDate}"`
-                : horizonSendDays === null
-                    ? ""
-                    : `, horizonSendDays: ${horizonSendDays}`}, approvalMode: "${approvalMode}" }) before any import, prep, approval, start, or schedule-affecting action.`,
+                : ""}${senders.length > 0 ? `, senders: ${JSON.stringify(senders)}` : ""}${targetDate
+                ? `, targetDate: "${targetDate}"`
+                : untilDate
+                    ? `, untilDate: "${untilDate}"`
+                    : horizonSendDays === null
+                        ? ""
+                        : `, horizonSendDays: ${horizonSendDays}`}, approvalMode: "${approvalMode}" }) before any import, prep, approval, start, or schedule-affecting action.`,
             "If get_refill_target_plan returns status complete, report eligible sender ledger, gross target, selected days, sent count, scheduled count, projected count, campaign ids, targetShapeRevision, and no-op proof without asking for approval.",
             "Refill target lanes are only connection invites (send_invite) or paid InMails (send_inmail_closed). Do not count send_dm or send_inmail_open as horizon target capacity; they may exist in sequences, but the planner must pick the refill lane from the most recent active campaign-backed send evidence for each sender.",
             "If remainingReadyOrProjectedGap is 0 but remainingProjectedGap is positive, run only a persistent read-only scheduler wait/reread loop; do not ask for prep/import/approval and do not close out while scheduler pickup is the only remaining state.",
             `Resolve route with resolve_campaign_fill_route({ intent: "${intent}"${input.campaignId ? `, campaignId: "${input.campaignId}"` : ""}${input.tableId ? `, tableId: "${input.tableId}"` : ""} }).`,
             'If the plain route shows stale managed waterfall evidence, archived/completed shared slots, or targets that do not cover the selected sender set, immediately call resolve_campaign_fill_route({ intent: "active" }) and inspect current dashboard-active ACTIVE/PAUSED campaign-backed sequence campaigns before declaring a sender blocked.',
             "Call list_senders and get_sender_routing, then resolve sender selectors against active enrolled campaign-backed sequence senders.",
-            untilDate
-                ? `Use fill window untilDate="${untilDate}" as the inclusive sender-local through date; do not extend beyond that date without a new approval packet.`
-                : horizonSendDays === null
-                    ? "Use the default scheduler-forward 48-hour target window from get_refill_target_plan; do not reinterpret it as two calendar days from today."
-                    : `Use the explicit compatibility fill window of ${horizonSendDays} sender-local send days.`,
+            targetDate
+                ? `Use fill window targetDate="${targetDate}" as one exact sender-local date; prepare rows only for scheduler-fillable slots on that date. Do not treat it as an inclusive through-date.`
+                : untilDate
+                    ? `Use fill window untilDate="${untilDate}" as the inclusive sender-local through date; do not extend beyond that date without a new approval packet.`
+                    : horizonSendDays === null
+                        ? "Use the default scheduler-forward 48-hour target window from get_refill_target_plan; do not reinterpret it as two calendar days from today."
+                        : `Use the explicit compatibility fill window of ${horizonSendDays} sender-local send days.`,
             "Read get_campaign_refill_state for enough exact candidate campaigns to pick the best per-sender target by recent/future scheduler-owned sends, then recent result evidence, then source health.",
             "Treat current dashboard-active PAUSED campaign-backed sequence campaigns as start-eligible candidates: read refill state before deciding whether to prep, approve, start, or skip.",
             "Fresh reread get_campaign_refill_state immediately before any import, prep, approval, or horizon-fill mutation.",
@@ -196,11 +232,13 @@ export function refillSendsCommand(input = {}) {
         hostExamples: {
             claude: [
                 "/sellable:refill-sends --yolo",
+                "/sellable:refill-sends --yolo --target-date 2026-07-01",
                 "/sellable:refill-sends --yolo --until 2026-06-30",
                 '/sellable:refill-sends --sender "Christian Reyes" --sender "Thomas Nobbs"',
             ],
             codex: [
                 "$sellable:refill-sends --yolo",
+                "$sellable:refill-sends --yolo --target-date 2026-07-01",
                 "$sellable:refill-sends --yolo --until 2026-06-30",
                 '$sellable:refill-sends --sender "Christian Reyes" --sender "Thomas Nobbs"',
             ],
@@ -211,6 +249,7 @@ export function refillSendsCommand(input = {}) {
                     senders,
                     senderIds,
                     senderNames,
+                    targetDate,
                     untilDate,
                     horizonSendDays,
                     campaignId: input.campaignId,

package/dist/tools/refill-target-plan.d.ts

@@ -4,6 +4,7 @@ type GetRefillTargetPlanInput = {
     intent?: RefillTargetPlanIntent;
     horizonSendDays?: number;
     untilDate?: string;
+    targetDate?: string;
     campaignId?: string;
     tableId?: string;
     senderIds?: string[];
@@ -34,6 +35,11 @@ export declare const refillTargetPlanToolDefinitions: {
                 pattern: string;
                 description: string;
             };
+            targetDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
             campaignId: {
                 type: string;
                 description: string;

package/dist/tools/refill-target-plan.js

@@ -188,13 +188,15 @@ function sanitizeRefillTargetPlanResult(result) {
     const remainingProjectedGap = senderPlans.reduce((sum, plan) => sum + numberValue(plan.remainingProjectedGap), 0);
     const remainingReadyOrProjectedGap = senderPlans.reduce((sum, plan) => sum + numberValue(plan.remainingReadyOrProjectedGap), 0);
     const blockers = sanitizeBlockers(result.blockers, selectedKeys);
-    const status = blockers.some((blocker) => ["sender_disconnected", "sender_sales_nav_disconnected"].includes(String(blocker.code))) || grossTarget <= 0
+    const status = blockers.some((blocker) => ["sender_disconnected", "sender_sales_nav_disconnected"].includes(String(blocker.code)))
         ? "blocked"
         : remainingProjectedGap === 0
             ? "complete"
-            : remainingReadyOrProjectedGap === 0
-                ? "awaiting_scheduler_after_ready_buffer"
-                : "needs_refill";
+            : grossTarget <= 0
+                ? "blocked"
+                : remainingReadyOrProjectedGap === 0
+                    ? "awaiting_scheduler_after_ready_buffer"
+                    : "needs_refill";
     return {
         ...result,
         status,
@@ -252,6 +254,11 @@ export const refillTargetPlanToolDefinitions = [
                     pattern: "^\\d{4}-\\d{2}-\\d{2}$",
                     description: "Optional sender-local YYYY-MM-DD date to inspect through, inclusive. Overrides the default scheduler-forward 48-hour target window.",
                 },
+                targetDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                    description: "Optional exact sender-local YYYY-MM-DD date to fill. Distinct from untilDate: targetDate asks how many scheduler-fillable slots exist on only this date.",
+                },
                 campaignId: {
                     type: "string",
                     description: "Optional exact CampaignOffer.id to narrow routing. Do not pass campaign names.",
@@ -299,6 +306,7 @@ export async function getRefillTargetPlan(input = {}) {
         intent: input.intent,
         horizonSendDays: input.horizonSendDays,
         untilDate: input.untilDate,
+        targetDate: input.targetDate,
         campaignId: input.campaignId,
         tableId: input.tableId,
         senderIds: input.senderIds,

package/dist/tools/registry.d.ts

@@ -660,6 +660,55 @@ export declare const allTools: ({
         additionalProperties: boolean;
         required?: undefined;
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            capacityRequests: {
+                type: string;
+                minItems: number;
+                items: {
+                    type: string;
+                    properties: {
+                        senderId: {
+                            type: string;
+                            description: string;
+                        };
+                        actionType: {
+                            type: string;
+                            enum: string[];
+                            description: string;
+                        };
+                        cellId: {
+                            type: string;
+                            description: string;
+                        };
+                        columnId: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                description: string;
+            };
+            targetDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
 } | {
     name: string;
     description: string;

package/dist/tools/registry.js

@@ -37,6 +37,7 @@ import { refillTargetPlanToolDefinitions } from "./refill-target-plan.js";
 import { refillSendsToolDefinitions } from "./refill-sends.js";
 import { rowToolDefinitions } from "./rows.js";
 import { rubricToolDefinitions } from "./rubrics.js";
+import { schedulerFillCapacityToolDefinitions } from "./scheduler-fill-capacity.js";
 import { senderRoutingToolDefinitions } from "./sender-routing.js";
 import { senderToolDefinitions } from "./senders.js";
 import { sequencerToolDefinitions } from "./sequencer.js";
@@ -52,6 +53,7 @@ export const allTools = [
     ...campaignFillRoutingToolDefinitions,
     ...campaignRefillStateToolDefinitions,
     ...refillTargetPlanToolDefinitions,
+    ...schedulerFillCapacityToolDefinitions,
     ...refillSendsToolDefinitions,
     ...setupEvergreenCampaignsToolDefinitions,
     ...campaignHorizonFillToolDefinitions,

package/dist/tools/scheduler-fill-capacity.d.ts

@@ -0,0 +1,65 @@
+type SchedulerFillCapacityActionType = "send_invite" | "send_inmail_closed" | "send_inmail_open" | "send_dm" | "react_and_comment";
+type SchedulerFillCapacityMode = "default_horizon" | "target_date";
+type SchedulerFillCapacityRequest = {
+    senderId: string;
+    actionType: SchedulerFillCapacityActionType;
+    cellId?: string;
+    columnId?: string;
+};
+type GetSchedulerFillCapacityInput = {
+    capacityRequests: SchedulerFillCapacityRequest[];
+    targetDate?: string;
+    mode?: SchedulerFillCapacityMode;
+};
+export declare const schedulerFillCapacityToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            capacityRequests: {
+                type: string;
+                minItems: number;
+                items: {
+                    type: string;
+                    properties: {
+                        senderId: {
+                            type: string;
+                            description: string;
+                        };
+                        actionType: {
+                            type: string;
+                            enum: string[];
+                            description: string;
+                        };
+                        cellId: {
+                            type: string;
+                            description: string;
+                        };
+                        columnId: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                description: string;
+            };
+            targetDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function getSchedulerFillCapacity(input: GetSchedulerFillCapacityInput): Promise<unknown>;
+export {};

package/dist/tools/scheduler-fill-capacity.js

@@ -0,0 +1,70 @@
+import { getApi } from "../api.js";
+async function postSchedulerFillCapacity(body) {
+    const api = getApi();
+    return api.post("/api/v3/mcp/scheduler-fill-capacity", body);
+}
+export const schedulerFillCapacityToolDefinitions = [
+    {
+        name: "get_scheduler_fill_capacity",
+        description: "read-only scheduler capacity query for refill-sends before any refill mutation. It asks the product scheduler model how many additional cells the scheduler will try to place for exact sender/action requests, using the default scheduler-forward horizon or one exact targetDate. It returns scheduler-fillable slots, occupied scheduled/processing slots, sender sendability gates, cooldowns, Sales Navigator status for paid InMail, cached paid-InMail credit feasibility, threshold source, blockers, warnings, and explicit sideEffects false. This tool does not create rows, import leads, prepare messages, approve messages, does not schedule sends, does not refresh paid InMail credits, mutate thresholds, start campaigns, launch, or send. Use exact senderId values only; never pass sender names.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                capacityRequests: {
+                    type: "array",
+                    minItems: 1,
+                    items: {
+                        type: "object",
+                        properties: {
+                            senderId: {
+                                type: "string",
+                                description: "Exact Sender.id to inspect. Do not pass sender names.",
+                            },
+                            actionType: {
+                                type: "string",
+                                enum: [
+                                    "send_invite",
+                                    "send_inmail_closed",
+                                    "send_inmail_open",
+                                    "send_dm",
+                                    "react_and_comment",
+                                ],
+                                description: "Exact scheduler action lane to inspect for this sender.",
+                            },
+                            cellId: {
+                                type: "string",
+                                description: "Optional exact WorkflowTableCell.id for paid-InMail threshold context. Invalid scoped ids block instead of falling back to defaults.",
+                            },
+                            columnId: {
+                                type: "string",
+                                description: "Optional exact WorkflowTableColumn.id for paid-InMail threshold context. Invalid scoped ids block instead of falling back to defaults.",
+                            },
+                        },
+                        required: ["senderId", "actionType"],
+                        additionalProperties: false,
+                    },
+                    description: "One or more exact sender/action capacity requests. Example: [{ senderId:'snd_...', actionType:'send_invite' }].",
+                },
+                targetDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                    description: "Optional sender-local YYYY-MM-DD date to inspect. When present, the query uses target_date mode.",
+                },
+                mode: {
+                    type: "string",
+                    enum: ["default_horizon", "target_date"],
+                    description: "Optional mode hint. Omit for default_horizon; target_date requires targetDate.",
+                },
+            },
+            required: ["capacityRequests"],
+            additionalProperties: false,
+        },
+    },
+];
+export function getSchedulerFillCapacity(input) {
+    return postSchedulerFillCapacity({
+        capacityRequests: input.capacityRequests,
+        targetDate: input.targetDate,
+        mode: input.mode,
+    });
+}

package/package.json

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

package/skills/refill-sends/SKILL.md

@@ -5,6 +5,7 @@ visibility: public
 allowed-tools:
   - mcp__sellable__refill_sends
   - mcp__sellable__get_refill_target_plan
+  - mcp__sellable__get_scheduler_fill_capacity
   - mcp__sellable__refresh_paid_inmail_credits
   - mcp__sellable__get_auth_status
   - mcp__sellable__start_cli_login
@@ -71,16 +72,21 @@ Accepted invocation flags in the same user request:
   senders.
 - `--until <YYYY-MM-DD>`: fill through that sender-local date, inclusive,
   instead of the default scheduler-forward 48-hour target window.
+- `--target-date <YYYY-MM-DD>`: fill only that sender-local date. This means
+  prepare rows for scheduler-fillable slots on that date, not every remaining
+  daily-limit slot and not an inclusive through-date.
 - `senderIds: <id>, <id>` or `senderNames: <name>, <name>`: explicit selector
   alternatives when the host preserves natural-language arguments better than
   shell-style flags.
 - `untilDate: YYYY-MM-DD`: explicit date selector alternative when the host
   preserves natural-language arguments better than shell-style flags.
+- `targetDate: YYYY-MM-DD`: exact-date selector alternative when the host
+  preserves natural-language arguments better than shell-style flags.
 
 When the host can call typed MCP tools, start with:
 
 ```text
-refill_sends({ yolo?: boolean, senders?: string[], senderIds?: string[], senderNames?: string[], horizonSendDays?: number, untilDate?: "YYYY-MM-DD" })
+refill_sends({ yolo?: boolean, senders?: string[], senderIds?: string[], senderNames?: string[], horizonSendDays?: number, untilDate?: "YYYY-MM-DD", targetDate?: "YYYY-MM-DD" })
 ```
 
 That command helper only normalizes arguments and returns the execution
@@ -137,6 +143,11 @@ two lanes to fill. If a stale target plan selects `send_dm` or
 `send_inmail_open`, stop and re-plan with the current planner before mutation.
 Short form: trust the target plan's inferred lane only when it is a
 connection-invite or paid-InMail refill lane.
+For exact-date requests, pass `targetDate` to `get_refill_target_plan`. If you
+need raw proof, call the read-only `get_scheduler_fill_capacity` query for the
+same sender/action/date; it tells the MCP how many cells the product scheduler
+will try to place and does not import, approve, schedule, refresh credits, or
+mutate.
 If the target plan is complete by projected coverage, report that the selected
 target is already filled and no-op without asking for approval. If the ready
 buffer covers the projected gap but scheduled coverage is still short, keep the
@@ -229,8 +240,10 @@ blocked only because it is still `awaiting_scheduler_after_ready_buffer`; keep
 waiting unless Christian stops the run or the host cannot continue.
 
 In `--yolo`, the default fill target is the scheduler-forward 48-hour window
-unless `--until`/`untilDate` or an explicit compatibility `horizonSendDays` is
-provided. If an until date is provided, compute bounded gaps through that
+unless `--target-date`/`targetDate`, `--until`/`untilDate`, or an explicit
+compatibility `horizonSendDays` is provided. If a target date is provided,
+compute bounded gaps for only that sender-local date using scheduler-fillable
+slots. If an until date is provided, compute bounded gaps through that
 sender-local date inclusive, skipping no-send days and never extending beyond
 that date without a new packet. For each target sender, compute the bounded gap
 from that sender's healthy daily capacity, existing future scheduler-owned

package/skills/refill-sends-workflow/SKILL.md

@@ -4,6 +4,7 @@ description: Internal skill-led refill sends workflow for regular campaigns and
 visibility: internal
 allowed-tools:
   - mcp__sellable__get_refill_target_plan
+  - mcp__sellable__get_scheduler_fill_capacity
   - mcp__sellable__refresh_paid_inmail_credits
   - mcp__sellable__list_senders
   - mcp__sellable__get_sender_routing
@@ -88,6 +89,12 @@ in-progress wait state, not a reason to mark the goal complete or blocked.
    mutation.
    Short form: trust the target plan's inferred lane only when it is a
    connection-invite or paid-InMail refill lane.
+   For exact-date requests, pass `targetDate` to `get_refill_target_plan`.
+   When you need raw diagnostic proof, call `get_scheduler_fill_capacity` for
+   the same exact sender/action/date. That query is read-only and tells the MCP
+   how many cells the product scheduler will try to place for that sender; it
+   does not create rows, import, approve, schedule, refresh paid-InMail credits,
+   or mutate thresholds.
    If `status:"complete"`, report the target, selected dates, sent count,
    scheduled count, projected count, campaign ids, and no-op proof without
    asking for approval or mutating.
@@ -213,24 +220,24 @@ skip a visible paused shared campaign that can be started through a bounded
 packet.
 
 Default `--yolo` target is the scheduler-forward 48-hour window when the user
-asks to fill, refill, load, or max sends without naming a different horizon.
+asks to fill, refill, load, or max sends without naming a different horizon or
+exact `targetDate`.
 The planner selects sender-local days whose configured sending windows overlap
 that rolling target window; do not treat weekends or other no-send-hour days as
 fillable capacity. If the user explicitly names a no-send calendar date, report
 that date as unschedulable and continue only for the next valid send day when
 the packet says "send days" or the user asked to max/refill senders broadly.
 
-For campaign-scoped requests, compute the target from the selected campaign's
-healthy sender daily capacity in the scheduler-forward target window, minus
-already scheduler-owned future scheduled sends for those days and minus rows
-already ready to schedule. For sender-scoped requests, compute that gap per
-target sender across all active enrolled campaigns for that sender; count future
-scheduled cells and ready-to-schedule cells in any active enrolled campaign
-toward that sender's gap before preparing more rows. If ready/scheduled rows
-already cover a sender's gap, do not add rows or prep for that sender; report
-that the sender is loaded, awaiting scheduler. If the gap is positive, prepare
-only the gap in the best same-sender campaign and keep all source-copy/prep caps
-tied to that target-window packet.
+For campaign-scoped requests, compute the target from scheduler-fillable
+capacity in the selected target window/date, not the full daily limit. For
+sender-scoped requests, compute that scheduler-fillable gap per target sender
+across all active enrolled campaigns for that sender; count ready-to-schedule
+cells in any active enrolled campaign toward that sender's fillable gap before
+preparing more rows. If ready rows already cover a sender's scheduler-fillable
+gap, do not add rows or prep for that sender; report that the sender is loaded,
+awaiting scheduler. If the gap is positive, prepare only the gap in the best
+same-sender campaign and keep all source-copy/prep caps tied to that target
+window/date packet.
 Short form: default `--yolo refill senders` target is each eligible sender's
 scheduler-forward 48-hour gap.