@sellable/mcp 0.1.469 → 0.1.471

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/prompts.js

@@ -373,7 +373,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. For plain post-mint fill/load/refill requests, load get_subskill_prompt({ subskillName: "refill-sends-workflow" }), then call resolve_campaign_fill_route({ intent:"plain" }), list_senders, and get_campaign_refill_state for enough candidate campaigns to identify the campaign that most recently had scheduler-owned sends for the relevant sender set before any mutation. Route outcomes are route:"evergreen_horizon", route:"active_campaigns", and route:"ask_create"; if a plain managed-waterfall route has archived/completed skipped slots or does not cover the named sender set, immediately refetch with resolve_campaign_fill_route({ intent:"active" }) and inspect current dashboard-active ACTIVE/PAUSED campaign-backed sequence campaigns before declaring a sender blocked; stay in the same campaignOfferId/campaignId context after minting. Plain fill is not an alias for fill_campaign_horizon or campaign creation. fill_campaign_horizon is evergreen-only and is not the generic regular-campaign fill path. Campaign creation is allowed only after route:"ask_create" and explicit user selection; it is never the default response to plain fill. Treat "fill up/load sends" as capacity-fill preparation, and treat "refill senders", "fill senders", "max out senders", and "load everyone up" as sender-scoped capacity-fill preparation. For sender-scoped requests with no named senders, --yolo means all eligible healthy senders enrolled in active campaign-backed sequence campaigns in the active workspace; without --yolo, ask which eligible enrolled senders to refill before choosing campaigns or mutating. In non-yolo interactive Codex or Claude Code sessions, post the full sender/campaign/action approval packet in normal chat as Markdown first, then ask request_user_input/AskUserQuestion with exactly Accept and Decline and a compact body that refers back to the posted packet; do not duplicate the campaign table or full operator packet inside the structured question. The chat packet must show workspace, sender scope, a campaign-by-campaign table, exact ids/caps/dates, side effects, forbidden actions, and stop condition before mutation. Default --yolo horizon is a two-send-day horizon: two sender-local send days, skipping no-send-hour days. For campaign-scoped fill/refill, select the best recent-send campaign and calculate the bounded gap from healthy sender daily capacity minus projected coverage (actual sent plus future scheduler-owned scheduled sends) and ready-to-schedule rows, then prepare only that gap. For sender-scoped fill/refill, calculate the bounded gap per eligible sender across active enrolled campaigns, counting actual sent coverage, future scheduled rows, and ready-to-schedule rows across those campaigns, then choose the best same-sender campaign to fill each sender gap: prefer recent/future scheduler-owned sends for that sender, then strongest recent result evidence, then source health. Maintain a horizon saturation ledger per selected sender with selected send days, gross capacity, actual sent counts, future scheduler-owned scheduled counts, projected coverage, ready-to-schedule buffer, remaining projected gap, paid-InMail threshold feasibility, and the next MCP primitive. Do not stop after filling only one sender when the request was sender-scoped. In --yolo, continue through every safe selected sender/campaign action covered by the rendered packet, reread after each terminal apply/prep/start result, recompute the horizon saturation ledger, and keep going until projected coverage (sent + scheduled) fills the requested horizon or a concrete non-scheduler blocker is proven. Ready-to-schedule rows are buffer, not completion; if ready covers the projected gap but scheduled cells do not, run a persistent read-only scheduler wait/reread loop and keep the run open while awaiting_scheduler_after_ready_buffer is the only remaining state. Paid-InMail threshold changes and connection-campaign creation are explicit continuation options, never --yolo side effects. When no safe in-packet action remains return concrete continuation options with campaign names, exact ids, and which options require a new approval packet; do not return final completion for scheduler wait unless Christian explicitly asks for status or stops the run. Use the refill workflow to decide whether to enrich/prep more rows in that same recent-send/best-result campaign, add/import more rows to that same campaign/source path, use a different existing campaign only when the selected same-sender lane is blocked/exhausted/already loaded while the sender still has a gap, or ask what to create. Do not create warm-post-engager side campaigns. Surface sender-health blockers and paid-InMail threshold blockers separately from prepared/approved/scheduled counts. User-facing refill decisions must be campaign-name-first and sender-name-first, with ids as proof/execution targets only. For already-running regular campaigns that need Signal Discovery source replenishment, use the guarded currentStep clear with clearCurrentStepIfMatches:"running", campaign-scoped provider prompt/search/select, and import_leads with the existing sourceLeadListId when a newly approved selected-post scrape would otherwise return reusedExistingSourceList. Before prep, inspect get_campaign_refill_state.preparationFrontier. If hasLaterPreparedIsland:true or earliestUnpreparedRow exists before later successful enrichment, use rowSelector:{type:"needsEnrichment"} with columnRole:"enrich" in table-position order or start_campaign_message_preparation adaptive defaults; do not use the UI Jump anchor or needsGeneratedMessage as the refill cursor. After confirm_lead_list copies rows into an existing table, avoid fixed maxRowsToCheck:100; if confirm_lead_list returns USER_ADDED_ROWS_LIMIT_EXCEEDED, create a bounded same-source split from selectedLeadListId with get_rows_minimal/load_csv_linkedin_leads, confirm that smaller source list into the same campaign, and inspect reviewBatch only as diagnostics unless the approved packet explicitly prioritizes the just-copied split and earlier needsEnrichment rows are exhausted, dependency-blocked, or excluded. For approval diagnostics use rowSelector:{type:"needsApproval"} after current generated messages exist; mutating Approved cells still requires approvalMode:approve and exact bounded approval. 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 contribute to projected coverage, and never call them complete unless a final re-read proves projected coverage fills the requested horizon. Before source import, prep, approval, or selected paused campaign start, require exact visible approval or --yolo packet auto-accept and a fresh get_campaign_refill_state reread; stop if freshness.stateHash or exact ids changed. For "approve X messages", use approvalMode:approve only when explicitly requested. For "schedule X sends" or "fill sender sends", approve only when explicitly requested, then re-read campaign/table scheduled counts; if projected coverage does not fill the horizon, keep polling when ready buffer covers the gap and report only interim prepared/approved/ready - awaiting scheduler status if Christian asks. Do not call start_campaign as part of fill/schedule horizon. start_campaign is allowed in refill only for exact selected PAUSED, dashboard-active, campaign-backed sequence targets named in the bounded packet, and the packet must state that starting can let the product scheduler schedule/send approved eligible sequence actions. Never start unrelated, archived, completed, draft, direct, or non-selected campaigns, never broad approve-all, and never use direct scheduler writes. 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.`,
+            prepareMessagesRule: `Default create-campaign stays on the existing reviewBatchLimit:15 first campaign-table execution slice. For plain post-mint fill/load/refill requests, load get_subskill_prompt({ subskillName: "refill-sends-workflow" }), then call resolve_campaign_fill_route({ intent:"plain" }), list_senders, and get_campaign_refill_state for enough candidate campaigns to identify the campaign that most recently had scheduler-owned sends for the relevant sender set before any mutation. Route outcomes are route:"evergreen_horizon", route:"active_campaigns", and route:"ask_create"; if a plain managed-waterfall route has archived/completed skipped slots or does not cover the named sender set, immediately refetch with resolve_campaign_fill_route({ intent:"active" }) and inspect current dashboard-active ACTIVE/PAUSED campaign-backed sequence campaigns before declaring a sender blocked; stay in the same campaignOfferId/campaignId context after minting. Plain fill is not an alias for fill_campaign_horizon or campaign creation. fill_campaign_horizon is evergreen-only and is not the generic regular-campaign fill path. Campaign creation is allowed only after route:"ask_create" and explicit user selection; it is never the default response to plain fill. Treat "fill up/load sends" as capacity-fill preparation, and treat "refill senders", "fill senders", "max out senders", and "load everyone up" as sender-scoped capacity-fill preparation. For sender-scoped requests with no named senders, --yolo means all eligible healthy senders enrolled in active campaign-backed sequence campaigns in the active workspace; without --yolo, ask which eligible enrolled senders to refill before choosing campaigns or mutating. In non-yolo interactive Codex or Claude Code sessions, post the full sender/campaign/action approval packet in normal chat as Markdown first, then ask request_user_input/AskUserQuestion with exactly Accept and Decline and a compact body that refers back to the posted packet; do not duplicate the campaign table or full operator packet inside the structured question. The chat packet must show workspace, sender scope, a campaign-by-campaign table, exact ids/caps/dates, side effects, forbidden actions, and stop condition before mutation. Default --yolo target is the scheduler-forward 48-hour target window: sender-local send days whose configured sending windows overlap the rolling target window, skipping no-send-hour days. For campaign-scoped fill/refill, select the best recent-send campaign and calculate the bounded gap from healthy sender daily capacity minus projected coverage (actual sent plus future scheduler-owned scheduled sends) and ready-to-schedule rows, then prepare only that gap. For sender-scoped fill/refill, calculate the bounded gap per eligible sender across active enrolled campaigns, counting actual sent coverage, future scheduled rows, and ready-to-schedule rows across those campaigns, then choose the best same-sender campaign to fill each sender gap: prefer recent/future scheduler-owned sends for that sender, then strongest recent result evidence, then source health. Maintain a target-window saturation ledger per selected sender with selected send days, gross capacity, actual sent counts, future scheduler-owned scheduled counts, projected coverage, ready-to-schedule buffer, remaining projected gap, paid-InMail threshold feasibility, and the next MCP primitive. Do not stop after filling only one sender when the request was sender-scoped. In --yolo, continue through every safe selected sender/campaign action covered by the rendered packet, reread after each terminal apply/prep/start result, recompute the target-window saturation ledger, and keep going until projected coverage (sent + scheduled) fills the scheduler-forward target window or a concrete non-scheduler blocker is proven. Ready-to-schedule rows are buffer, not completion; if ready covers the projected gap but scheduled cells do not, report loaded, awaiting scheduler and run a persistent read-only scheduler wait/reread loop and keep the run open while awaiting_scheduler_after_ready_buffer is the only remaining state. Paid-InMail threshold changes and connection-campaign creation are explicit continuation options, never --yolo side effects. When no safe in-packet action remains return concrete continuation options with campaign names, exact ids, and which options require a new approval packet; do not return final completion for scheduler wait unless Christian explicitly asks for status or stops the run. Use the refill workflow to decide whether to enrich/prep more rows in that same recent-send/best-result campaign, add/import more rows to that same campaign/source path, use a different existing campaign only when the selected same-sender lane is blocked/exhausted/already loaded while the sender still has a gap, or ask what to create. Do not create warm-post-engager side campaigns. Surface sender-health blockers and paid-InMail threshold blockers separately from prepared/approved/scheduled counts. User-facing refill decisions must be campaign-name-first and sender-name-first, with ids as proof/execution targets only. For already-running regular campaigns that need Signal Discovery source replenishment, use the guarded currentStep clear with clearCurrentStepIfMatches:"running", campaign-scoped provider prompt/search/select, and import_leads with the existing sourceLeadListId when a newly approved selected-post scrape would otherwise return reusedExistingSourceList. Before prep, inspect get_campaign_refill_state.preparationFrontier. If hasLaterPreparedIsland:true or earliestUnpreparedRow exists before later successful enrichment, use rowSelector:{type:"needsEnrichment"} with columnRole:"enrich" in table-position order or start_campaign_message_preparation adaptive defaults; do not use the UI Jump anchor or needsGeneratedMessage as the refill cursor. After confirm_lead_list copies rows into an existing table, avoid fixed maxRowsToCheck:100; if confirm_lead_list returns USER_ADDED_ROWS_LIMIT_EXCEEDED, create a bounded same-source split from selectedLeadListId with get_rows_minimal/load_csv_linkedin_leads, confirm that smaller source list into the same campaign, and inspect reviewBatch only as diagnostics unless the approved packet explicitly prioritizes the just-copied split and earlier needsEnrichment rows are exhausted, dependency-blocked, or excluded. For approval diagnostics use rowSelector:{type:"needsApproval"} after current generated messages exist; mutating Approved cells still requires approvalMode:approve and exact bounded approval. 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 contribute to projected coverage, and never call them complete unless a final re-read proves projected coverage fills the scheduler-forward target window. Before source import, prep, approval, or selected paused campaign start, require exact visible approval or --yolo packet auto-accept and a fresh get_campaign_refill_state reread; stop if freshness.stateHash or exact ids changed. For "approve X messages", use approvalMode:approve only when explicitly requested. For "schedule X sends" or "fill sender sends", approve only when explicitly requested, then re-read campaign/table scheduled counts; if projected coverage does not fill the horizon, keep polling when ready buffer covers the gap and report only interim prepared/approved/ready - awaiting scheduler status if Christian asks. Do not call start_campaign as part of fill/schedule horizon. start_campaign is allowed in refill only for exact selected PAUSED, dashboard-active, campaign-backed sequence targets named in the bounded packet, and the packet must state that starting can let the product scheduler schedule/send approved eligible sequence actions. Never start unrelated, archived, completed, draft, direct, or non-selected campaigns, never broad approve-all, and never use direct scheduler writes. 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.`,
         },
     };
 }

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,17 +90,29 @@ 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;
     } | {
         mode: string;
         horizonSendDays: number | null;
+        horizonHours: number | null;
         description: string;
+        targetDate?: undefined;
         untilDate?: undefined;
     };
     approvalMode: RefillSendsApprovalMode;
@@ -119,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

@@ -1,4 +1,4 @@
-const DEFAULT_HORIZON_SEND_DAYS = 2;
+const DEFAULT_SCHEDULER_FORWARD_HOURS = 48;
 function normalizeStrings(values) {
     if (!Array.isArray(values))
         return [];
@@ -9,9 +9,10 @@ function normalizeStrings(values) {
     ];
 }
 function normalizeHorizonSendDays(value) {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        return DEFAULT_HORIZON_SEND_DAYS;
-    }
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
     return Math.max(1, Math.min(7, Math.floor(value)));
 }
 function normalizeUntilDate(value) {
@@ -33,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",
@@ -63,12 +83,17 @@ export const refillSendsToolDefinitions = [
                     type: "number",
                     minimum: 1,
                     maximum: 7,
-                    description: "Number of sender-local send days to fill. Defaults to 2 when untilDate is not provided.",
+                    description: "Compatibility override for an explicit sender-local send-day horizon. Omit for the default scheduler-forward 48-hour target window.",
                 },
                 untilDate: {
                     type: "string",
                     pattern: "^\\d{4}-\\d{2}-\\d{2}$",
-                    description: "Optional sender-local YYYY-MM-DD date to fill through, inclusive. Overrides the default two send-day horizon.",
+                    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",
@@ -100,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";
@@ -118,19 +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: "horizon_send_days",
-                horizonSendDays,
-                description: "Fill the default bounded 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,
@@ -147,25 +185,33 @@ 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: ${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.`
-                : `Use the default 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.",
-            "Maintain a target-led horizon saturation ledger per selected sender from get_refill_target_plan: selected days, gross capacity, actual sent counts, future scheduler-owned scheduled counts, projected counts, ready-to-schedule buffer, remaining projected gap, paid InMail threshold feasibility, targetShapeRevision, stateRevision, and next MCP primitive.",
+            "Maintain a target-window saturation ledger per selected sender from get_refill_target_plan: selected days, gross capacity, actual sent counts, future scheduler-owned scheduled counts, projected counts, ready-to-schedule buffer, remaining projected gap, paid InMail threshold feasibility, targetShapeRevision, stateRevision, and next MCP primitive.",
             "If paid InMail feasibility is below threshold, stale, or missing, report the exact sender/campaign/table/column threshold action or connection fallback; --yolo must not lower paid InMail thresholds or create campaigns.",
             "In --yolo or after one Accept, continue through every safe selected sender/campaign action covered by the rendered target packet; sent/scheduled-count progress changes stateRevision and should continue while targetShapeRevision is stable.",
-            "Do not complete a fill/schedule request until a final get_refill_target_plan or refill-state reread proves projected coverage (sent + scheduled) fills the horizon. Treat awaiting_scheduler_after_ready_buffer as in-progress when ready buffer covers the gap; keep polling unless Christian stops/statuses the run or a concrete non-scheduler blocker such as paid_inmail_below_threshold appears.",
+            "Do not complete a fill/schedule request until a final get_refill_target_plan or refill-state reread proves projected coverage (sent + scheduled) fills the scheduler-forward target window. Treat awaiting_scheduler_after_ready_buffer as loaded, awaiting scheduler when ready buffer covers the gap; do not import/prep more rows in that state, and keep polling unless Christian stops/statuses the run or a concrete non-scheduler blocker such as paid_inmail_below_threshold appears.",
         ],
         approvalContract: yolo
             ? "Auto-accept only the rendered bounded refill target packet after get_refill_target_plan and fresh reread. Continue through every safe apply/prep/start action inside that packet, including start_campaign only for exact selected PAUSED campaign-backed sequence refill targets named in the packet. After each action, rerun get_refill_target_plan; keep going while targetShapeRevision is stable and projected coverage (sent + scheduled) progresses toward the target, even though stateRevision changes. Ready-to-schedule rows are buffer, not completion. If ready buffer covers the projected gap, use only persistent read-only scheduler wait/reread and keep the run open until projected coverage fills or Christian stops/statuses it. Stop immediately if targetShapeRevision changes because sender set, route, ids, caps, dates, blockers, action class, paid InMail threshold feasibility, or side-effect class drifts. --yolo does not authorize lowering paid InMail thresholds or creating connection campaigns."
@@ -186,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"',
             ],
@@ -201,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

@@ -89,7 +89,7 @@ function sanitizeActionCandidates(candidates, selectedKeys, status, remainingRea
         !filtered.some((item) => item.type === "wait_for_scheduler")) {
         filtered.push({
             type: "wait_for_scheduler",
-            reason: "ready buffer covers the projected target gap but scheduledFor coverage is still short",
+            reason: "loaded, awaiting scheduler: ready buffer covers the projected target gap but scheduledFor coverage is still short",
         });
     }
     return filtered;
@@ -232,7 +232,7 @@ function sanitizeRefillTargetPlanResult(result) {
 export const refillTargetPlanToolDefinitions = [
     {
         name: "get_refill_target_plan",
-        description: "read-only refill target planner to call before any refill mutation. It identifies eligible senders and infers one implicit refill lane per sender: connection invites or paid InMails, chosen from future scheduled, recent scheduled, and ready-to-schedule evidence in active campaign-backed sequence campaigns before falling back to campaign sequences. DMs and open-profile InMails are follow-up sequence actions, not refill target lanes. The planner computes selected sender-local days, gross target, actual sent coverage, scheduler-owned scheduled coverage, projected coverage (sent + scheduled), ready buffer, remaining projected gap, paid InMail credit/threshold feasibility, bounded action candidates, and targetRevision drift proof. This tool does not create rows, import leads, prepare messages, approve messages, does not schedule sends, start campaigns, lower paid InMail thresholds, create campaigns, launch, spend InMail credits, or write scheduler fields. Complete projected targets no-op without approval; incomplete targets must be followed by a bounded approval packet.",
+        description: "read-only refill target planner to call before any refill mutation. It identifies eligible senders and infers one implicit refill lane per sender: connection invites or paid InMails, chosen from future scheduled, recent scheduled, and ready-to-schedule evidence in active campaign-backed sequence campaigns before falling back to campaign sequences. DMs and open-profile InMails are follow-up sequence actions, not refill target lanes. By default the planner computes the scheduler-forward 48-hour target window, selected sender-local days whose sending windows overlap that window, gross target, actual sent coverage, scheduler-owned scheduled coverage, projected coverage (sent + scheduled), ready buffer, remaining projected gap, paid InMail credit/threshold feasibility, bounded action candidates, and targetRevision drift proof. This tool does not create rows, import leads, prepare messages, approve messages, does not schedule sends, start campaigns, lower paid InMail thresholds, create campaigns, launch, spend InMail credits, or write scheduler fields. Complete projected targets no-op without approval; loaded, awaiting scheduler targets use read-only wait/reread until projected coverage fills.",
         inputSchema: {
             type: "object",
             properties: {
@@ -245,12 +245,17 @@ export const refillTargetPlanToolDefinitions = [
                     type: "number",
                     minimum: 1,
                     maximum: 7,
-                    description: "Calendar-day refill horizon to inspect from the sender-local current day. Defaults to 2 when untilDate is not provided; no-send days contribute zero target.",
+                    description: "Compatibility override for explicit sender-local send-day horizon planning. Omit for the default scheduler-forward 48-hour target window; no-send days contribute zero target.",
                 },
                 untilDate: {
                     type: "string",
                     pattern: "^\\d{4}-\\d{2}-\\d{2}$",
-                    description: "Optional sender-local YYYY-MM-DD date to inspect through, inclusive.",
+                    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",
@@ -299,6 +304,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.469",
+  "version": "0.1.471",
   "type": "module",
   "description": "Sellable MCP server for Claude Code and Codex campaign workflows",
   "main": "dist/index.js",

package/skills/create-campaign/SKILL.md

@@ -138,10 +138,10 @@ explicit user selection; it is never the default response to plain fill. When
 choosing among active targets, use refill-state scheduled-count evidence to
 continue the campaign that most recently had scheduler-owned sends for the
 relevant sender set; do not treat every active campaign as a refill candidate.
-In `--yolo` fill/refill mode, default to one best recent-send campaign and a
-two-send-day horizon: subtract future scheduler-owned scheduled sends and
-ready-to-schedule rows from healthy sender daily capacity, then prepare only
-that bounded gap.
+In `--yolo` fill/refill mode, default to one best recent-send campaign and the
+scheduler-forward 48-hour target window: subtract future scheduler-owned
+scheduled sends and ready-to-schedule rows from healthy sender daily capacity,
+then prepare only that bounded gap.
 When more leads are needed, the refill workflow must recommend same-campaign
 source-ladder replenishment first; do not create warm-post-engager side
 campaigns, on-demand campaigns, or unrelated campaigns. If same-source copy hits

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
@@ -70,17 +71,22 @@ Accepted invocation flags in the same user request:
 - `--sender <name-or-id>`: scope to a specific sender; repeat for multiple
   senders.
 - `--until <YYYY-MM-DD>`: fill through that sender-local date, inclusive,
-  instead of the default two send-day horizon.
+  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
@@ -99,10 +105,11 @@ resolver.
 
 Goal-mode continuation: a skill cannot create or invoke `/goal` by itself. When
 this command is already running inside an active Codex goal, keep that goal open
-until every selected sender lane is horizon-filled by projected coverage
-(`sent + scheduled`), Christian explicitly stops/statuses the run, or a concrete
-non-scheduler blocker appears. Do not call the goal complete or blocked only
-because the current state is `awaiting_scheduler_after_ready_buffer`.
+until every selected sender lane is filled by projected coverage
+(`sent + scheduled`) for the scheduler-forward target window, Christian
+explicitly stops/statuses the run, or a concrete non-scheduler blocker appears.
+Do not call the goal complete or blocked only because the current state is
+`awaiting_scheduler_after_ready_buffer`; treat it as loaded, awaiting scheduler.
 
 Load the internal workflow prompt before taking any operational step:
 
@@ -136,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
@@ -210,32 +222,35 @@ return concrete continuation options with campaign names, exact ids, which optio
 is already covered by the current packet, and which option needs a new approval
 packet.
 
-For `--yolo` fill/schedule requests, completion means projected horizon
-saturation (`sent + scheduled`), not merely prepared/approved/ready rows.
-Maintain a horizon saturation ledger per selected sender: selected send days,
-gross capacity, actual sent cells, future scheduler-owned scheduled cells with
-non-null `scheduledFor`, projected count, ready-to-schedule buffer, remaining
-projected gap, paid-InMail feasibility, `targetShapeRevision`,
-`stateRevision`, and the next MCP primitive that can reduce the gap. After every
-apply/prep/start result, wait for processing, reread the target plan/refill
-state, recompute the ledger, then keep applying safe bounded actions until
-projected coverage fills the horizon or a concrete non-scheduler blocker is
-proven.
+For `--yolo` fill/schedule requests, completion means projected saturation
+(`sent + scheduled`) for the scheduler-forward target window, not merely
+prepared/approved/ready rows. Maintain a target-window saturation ledger per
+selected sender: selected send days, gross capacity, actual sent cells, future
+scheduler-owned scheduled cells with non-null `scheduledFor`, projected count,
+ready-to-schedule buffer, remaining projected gap, paid-InMail feasibility,
+`targetShapeRevision`, `stateRevision`, and the next MCP primitive that can
+reduce the gap. After every apply/prep/start result, wait for processing, reread
+the target plan/refill state, recompute the ledger, then keep applying safe
+bounded actions until projected coverage fills the target window or a concrete
+non-scheduler blocker is proven.
 If ready rows cover the projected gap but the scheduler has not picked them up
-yet, run the persistent read-only scheduler wait loop. Do not finish the refill
-goal, mark it complete, or mark it 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 two-day fill horizon is two send days unless
-`--until`/`untilDate` is provided. 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 scheduled sends, and rows already ready to schedule across
-active campaigns enrolled with that sender. Then pick the best same-sender
-campaign to fill the gap: prefer recent/future scheduler-owned sends for that
-sender, then strongest recent result evidence, then source health. Do not stop
+yet, report loaded, awaiting scheduler and run the persistent read-only
+scheduler wait loop. Do not finish the refill goal, mark it complete, or mark it
+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 `--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
+scheduled sends, and rows already ready to schedule across active campaigns
+enrolled with that sender. Then pick the best same-sender campaign to fill the
+gap: prefer recent/future scheduler-owned sends for that sender, then strongest
+recent result evidence, then source health. Do not stop
 after filling only one sender when the request was sender-scoped. If a
 same-source copy hits the campaign-table row cap, split the current source into
 a bounded LinkedIn profile source list, confirm only that smaller list into the

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.
@@ -171,8 +178,8 @@ Use the refill-state response as the current facts receipt:
   cursor/inventory state, dedupe/DNC/provider exclusions, good-prospect yield,
   scan/import caps, and proof;
 - sender ids, healthy senders, disconnected senders, and daily capacity;
-- horizon saturation ledger per target sender: sender-local send days in scope,
-  gross horizon capacity, actual sent coverage, future scheduler-owned
+- target-window saturation ledger per target sender: sender-local send days in
+  scope, gross target capacity, actual sent coverage, future scheduler-owned
   scheduled counts in that window, projected coverage (`sent + scheduled`),
   ready-to-schedule buffer, remaining projected gap, paid-InMail
   credit/threshold feasibility, `targetShapeRevision`, `stateRevision`, and the
@@ -212,25 +219,27 @@ discovery. The stale waterfall slot remains diagnostic proof, not a reason to
 skip a visible paused shared campaign that can be started through a bounded
 packet.
 
-Default `--yolo` horizon is two send days when the user asks to fill, refill,
-load, or max sends without naming a different horizon. Send days are sender-local
-days with configured sending hours; 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 for the next two send days, 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 and awaiting the 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
-two-day packet.
-Short form: default `--yolo refill senders` target is each eligible sender's two-send-day gap.
+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 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 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.
 
 Lane selection must choose one refill lane per sender from current
 dashboard-active campaign-backed sequence evidence:
@@ -246,23 +255,25 @@ dashboard-active campaign-backed sequence evidence:
    `send_inmail_closed` for that sender.
 
 For `--yolo` fill/schedule requests, do not treat "ready" as completion. Build
-and maintain a horizon saturation ledger for every selected sender from
+and maintain a target-window saturation ledger for every selected sender from
 `get_refill_target_plan`. A sender is complete only when a final target-plan or
 refill-state reread proves projected coverage (`sent + scheduled`) meets or
-exceeds the sender's horizon capacity for the selected send days. Put another
-way: complete when the same daily-limit/readback model would show no remaining
+exceeds the sender's capacity for the selected target window. Put another way:
+complete when the same daily-limit/readback model would show no remaining
 send-day capacity for that selected lane. Ready-to-schedule rows are only buffer
-for the product scheduler. If ready plus projected coverage covers the horizon
-but scheduled cells do not yet, run a persistent read-only scheduler wait loop:
-wait, reread, recompute the ledger, and continue until projected coverage is
-proved, a concrete non-scheduler blocker appears, or Christian explicitly stops
-or asks for status only. `awaiting_scheduler_after_ready_buffer` is not success
-and is not a terminal blocker for an active refill goal; it is the poll state
-that keeps the thread waiting. It does not need a prep/import/approval packet.
+for the product scheduler. If ready plus projected coverage covers the target
+window but scheduled cells do not yet, run a persistent read-only scheduler wait
+loop: wait, reread, recompute the ledger, and continue until projected coverage
+is proved, a concrete non-scheduler blocker appears, or Christian explicitly
+stops or asks for status only. `awaiting_scheduler_after_ready_buffer` is not
+success and is not a terminal blocker for an active refill goal; it is the
+loaded, awaiting scheduler poll state that keeps the thread waiting. It does not
+need a prep/import/approval packet.
 Short form: ready buffer is not success.
 Short form: keep polling the scheduler instead of closing out while ready buffer
 covers the gap.
-Short form: `--yolo refill senders` completes only on projected horizon saturation or a concrete blocker.
+Short form: `--yolo refill senders` completes only on projected target-window
+saturation or a concrete blocker.
 
 Rank candidates in this order:
 
@@ -493,7 +504,7 @@ same refill request, do not ask the `Accept` / `Decline` question. Instead:
 4. execute only the exact packet;
 5. after each terminal credit-refresh/apply/prep/start result, rerun
    `get_refill_target_plan`, reread state, settle processing when needed,
-   recompute the horizon saturation ledger, and continue with the next smallest
+   recompute the target-window saturation ledger, and continue with the next smallest
    safe action inside the same bounded packet until every selected sender is
    saturated by projected coverage or blocked by non-scheduler evidence. Do not
    stop at "loaded" or "awaiting scheduler"; when no in-packet MCP mutation
@@ -586,8 +597,8 @@ when generated/pass counts are still settling, then poll `get_campaign_refill_st
 remains awaiting scheduler. Do not force scheduler fields directly.
 
 For requested fill/refill completion, continue the saturation loop after each
-poll: recompute projected horizon coverage by sender and date, subtract it from
-the requested horizon capacity, and decide whether another safe prep/import/
+poll: recompute projected target-window coverage by sender and date, subtract it
+from the requested target capacity, and decide whether another safe prep/import/
 approval pass is required. If projected coverage is still short and ready buffer
 is also short, run the next bounded MCP primitive that can create more eligible
 rows: `fill_campaign_horizon` for the selected evergreen target, or