@sellable/mcp 0.1.534 → 0.1.536

package/README.md

@@ -74,9 +74,12 @@ sending from:
 
 The refill-sends public command wrapper plans and executes approval-gated send
 refills. It supports `--yolo` and optional sender selectors such as
-`--sender "Christian Reyes"`, optional through-date selectors such as
+`--sender "Christian Reyes"`, exact-date selectors such as
+`--target-date 2026-06-30`, optional through-date selectors such as
 `--until 2026-06-30`, or typed MCP calls to `refill_sends({ yolo, senders,
-untilDate })` from:
+horizonSendDays, targetDate, untilDate })`. Date selectors resolve by
+`targetDate > untilDate > horizonSendDays`, where `targetDate` means one exact
+sender-local date and `untilDate` means an inclusive through-date, from:
 
 - `mcp/sellable/skills/refill-sends/SKILL.md`
 

package/dist/refill-date-window.d.ts

@@ -0,0 +1,34 @@
+export type RefillDateWindowSource = "default_scheduler_forward" | "horizon_send_days" | "until_date" | "target_date";
+export type NormalizedRefillDateSelector = {
+    source: RefillDateWindowSource;
+    targetDate: string | null;
+    untilDate: string | null;
+    horizonSendDays: number | null;
+};
+export type RefillRunDateWindow = NormalizedRefillDateSelector & {
+    version: 1;
+    selectedDates: string[];
+    senderWindows?: Array<{
+        senderId: string | null;
+        timeZone: string | null;
+        selectedDates: string[];
+    }>;
+};
+type DateSelectorInput = {
+    targetDate?: unknown;
+    untilDate?: unknown;
+    horizonSendDays?: unknown;
+};
+export declare function normalizeRefillDateSelector(input: DateSelectorInput): NormalizedRefillDateSelector;
+export declare function refillDateSelectorBody(selector: NormalizedRefillDateSelector): {
+    targetDate?: string;
+    untilDate?: string;
+    horizonSendDays?: number;
+};
+export declare function dateWindowFromSelector(selector: NormalizedRefillDateSelector): RefillRunDateWindow;
+export declare function dateWindowFromPlan(plan: Record<string, unknown>, selector: NormalizedRefillDateSelector): RefillRunDateWindow;
+export declare function dateWindowFromRunState(runState: unknown): RefillRunDateWindow | null;
+export declare function selectorFromDateWindow(window: RefillRunDateWindow): NormalizedRefillDateSelector;
+export declare function dateSelectorMatchesWindow(selector: NormalizedRefillDateSelector, window: RefillRunDateWindow): boolean;
+export declare function schedulerSweepTargetDates(window: RefillRunDateWindow): string[];
+export {};

package/dist/refill-date-window.js

@@ -0,0 +1,210 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function isValidDateKey(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const [year, month, day] = value.split("-").map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}
+function normalizeDateKey(value, field) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    if (typeof value !== "string") {
+        throw new Error(`${field} must be a string in YYYY-MM-DD format.`);
+    }
+    const trimmed = value.trim();
+    if (!isValidDateKey(trimmed)) {
+        throw new Error(`${field} must be a valid YYYY-MM-DD calendar date.`);
+    }
+    return trimmed;
+}
+function normalizeHorizonSendDays(value) {
+    if (value === undefined)
+        return null;
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < 1 ||
+        value > 7) {
+        throw new Error("horizonSendDays must be an integer between 1 and 7.");
+    }
+    return value;
+}
+export function normalizeRefillDateSelector(input) {
+    const targetDate = normalizeDateKey(input.targetDate, "targetDate");
+    const untilDate = normalizeDateKey(input.untilDate, "untilDate");
+    const horizonSendDays = normalizeHorizonSendDays(input.horizonSendDays);
+    if (targetDate) {
+        return {
+            source: "target_date",
+            targetDate,
+            untilDate: null,
+            horizonSendDays: null,
+        };
+    }
+    if (untilDate) {
+        return {
+            source: "until_date",
+            targetDate: null,
+            untilDate,
+            horizonSendDays: null,
+        };
+    }
+    if (horizonSendDays !== null) {
+        return {
+            source: "horizon_send_days",
+            targetDate: null,
+            untilDate: null,
+            horizonSendDays,
+        };
+    }
+    return {
+        source: "default_scheduler_forward",
+        targetDate: null,
+        untilDate: null,
+        horizonSendDays: null,
+    };
+}
+export function refillDateSelectorBody(selector) {
+    if (selector.source === "target_date" && selector.targetDate) {
+        return { targetDate: selector.targetDate };
+    }
+    if (selector.source === "until_date" && selector.untilDate) {
+        return { untilDate: selector.untilDate };
+    }
+    if (selector.source === "horizon_send_days" &&
+        selector.horizonSendDays !== null) {
+        return { horizonSendDays: selector.horizonSendDays };
+    }
+    return {};
+}
+export function dateWindowFromSelector(selector) {
+    return {
+        version: 1,
+        ...selector,
+        selectedDates: selector.targetDate ? [selector.targetDate] : [],
+    };
+}
+function selectedDatesFromPlan(plan) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const target = isRecord(packet.target) ? packet.target : {};
+    const window = isRecord(target.window) ? target.window : {};
+    const senderWindows = arrayValue(window.senderWindows).filter(isRecord);
+    const fromWindows = senderWindows.flatMap((senderWindow) => arrayValue(senderWindow.selectedDates)
+        .map((entry) => stringValue(entry))
+        .filter((entry) => Boolean(entry)));
+    if (fromWindows.length > 0)
+        return Array.from(new Set(fromWindows)).sort();
+    const senderRefillPlans = arrayValue(target.senderRefillPlans).filter(isRecord);
+    return Array.from(new Set(senderRefillPlans.flatMap((senderPlan) => {
+        const horizon = isRecord(senderPlan.horizon) ? senderPlan.horizon : {};
+        return arrayValue(horizon.selectedDays)
+            .filter(isRecord)
+            .map((day) => stringValue(day.date))
+            .filter((entry) => Boolean(entry));
+    }))).sort();
+}
+function senderWindowsFromPlan(plan) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const target = isRecord(packet.target) ? packet.target : {};
+    const window = isRecord(target.window) ? target.window : {};
+    return arrayValue(window.senderWindows)
+        .filter(isRecord)
+        .map((senderWindow) => ({
+        senderId: stringValue(senderWindow.senderId),
+        timeZone: stringValue(senderWindow.timeZone),
+        selectedDates: arrayValue(senderWindow.selectedDates)
+            .map((entry) => stringValue(entry))
+            .filter((entry) => Boolean(entry)),
+    }));
+}
+export function dateWindowFromPlan(plan, selector) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const request = isRecord(packet.request) ? packet.request : {};
+    const targetDate = stringValue(request.targetDate) ?? selector.targetDate ?? null;
+    const untilDate = stringValue(request.untilDate) ?? selector.untilDate ?? null;
+    const horizonSendDays = numberValue(request.horizonSendDays) ?? selector.horizonSendDays ?? null;
+    const source = targetDate
+        ? "target_date"
+        : untilDate
+            ? "until_date"
+            : horizonSendDays !== null
+                ? "horizon_send_days"
+                : selector.source;
+    const selectedDates = selectedDatesFromPlan(plan);
+    return {
+        version: 1,
+        source,
+        targetDate: source === "target_date" ? targetDate : null,
+        untilDate: source === "until_date" ? untilDate : null,
+        horizonSendDays: source === "horizon_send_days" ? horizonSendDays : null,
+        selectedDates: selectedDates.length > 0
+            ? selectedDates
+            : targetDate
+                ? [targetDate]
+                : [],
+        senderWindows: senderWindowsFromPlan(plan),
+    };
+}
+export function dateWindowFromRunState(runState) {
+    const state = isRecord(runState) ? runState : {};
+    const raw = isRecord(state.dateWindow) ? state.dateWindow : null;
+    if (!raw || raw.version !== 1)
+        return null;
+    const source = raw.source === "target_date" ||
+        raw.source === "until_date" ||
+        raw.source === "horizon_send_days" ||
+        raw.source === "default_scheduler_forward"
+        ? raw.source
+        : null;
+    if (!source)
+        return null;
+    return {
+        version: 1,
+        source,
+        targetDate: source === "target_date" ? stringValue(raw.targetDate) : null,
+        untilDate: source === "until_date" ? stringValue(raw.untilDate) : null,
+        horizonSendDays: source === "horizon_send_days"
+            ? numberValue(raw.horizonSendDays)
+            : null,
+        selectedDates: arrayValue(raw.selectedDates)
+            .map((entry) => stringValue(entry))
+            .filter((entry) => Boolean(entry)),
+    };
+}
+export function selectorFromDateWindow(window) {
+    return {
+        source: window.source,
+        targetDate: window.targetDate,
+        untilDate: window.untilDate,
+        horizonSendDays: window.horizonSendDays,
+    };
+}
+export function dateSelectorMatchesWindow(selector, window) {
+    return (selector.source === window.source &&
+        selector.targetDate === window.targetDate &&
+        selector.untilDate === window.untilDate &&
+        selector.horizonSendDays === window.horizonSendDays);
+}
+export function schedulerSweepTargetDates(window) {
+    if (window.source === "target_date" && window.targetDate) {
+        return [window.targetDate];
+    }
+    if (window.source === "until_date" ||
+        window.source === "horizon_send_days") {
+        return window.selectedDates;
+    }
+    return [];
+}

package/dist/refill-run-loop.d.ts

@@ -13,6 +13,9 @@ export interface RefillV2LoopInput {
     };
     approvalMode?: "approve" | "mark_ready";
     dryRun?: boolean;
+    targetDate?: string | null;
+    untilDate?: string | null;
+    horizonSendDays?: number | null;
 }
 export interface RefillV2LoopBudgets {
     maxGateCyclesPerInvocation: number;
@@ -60,6 +63,9 @@ export interface RefillV2LoopDeps {
         intent?: string;
         senderIds?: string[];
         runState?: Record<string, unknown>;
+        targetDate?: string;
+        untilDate?: string;
+        horizonSendDays?: number;
         journal?: boolean;
     }) => Promise<Record<string, unknown>>;
     executors: RefillV2Executors;
@@ -68,7 +74,9 @@ export interface RefillV2LoopDeps {
     budgets?: Partial<RefillV2LoopBudgets>;
     now?: () => Date;
     sleep?: (ms: number) => Promise<void>;
-    requestSchedulerRun?: (workspaceId: string) => Promise<unknown>;
+    requestSchedulerRun?: (workspaceId: string, options?: {
+        targetDate?: string;
+    }) => Promise<unknown>;
 }
 export type RefillV2LoopResult = {
     status: "dry_run";

package/dist/refill-run-loop.js

@@ -1,4 +1,5 @@
 import { SellableApiError } from "./api.js";
+import { dateSelectorMatchesWindow, dateWindowFromPlan, dateWindowFromRunState, dateWindowFromSelector, normalizeRefillDateSelector, refillDateSelectorBody, schedulerSweepTargetDates, selectorFromDateWindow, } from "./refill-date-window.js";
 import { buildRunStateFromLocalHints } from "./tools/evergreen-refill-plan.js";
 import { prepareRowSelectorValue as defaultPrepareRowSelectorValue, refillPrepareRequestHash as defaultRefillPrepareRequestHash, } from "./tools/refill-executors.js";
 const DEFAULT_BUDGETS = {
@@ -417,6 +418,41 @@ function mergeRunState(current, updates) {
         ...updates,
     };
 }
+function dateSelectorFromInput(input) {
+    return normalizeRefillDateSelector({
+        targetDate: input.targetDate,
+        untilDate: input.untilDate,
+        horizonSendDays: input.horizonSendDays,
+    });
+}
+function runStateWithDateWindow(runState, dateWindow) {
+    return mergeRunState(runState, { dateWindow });
+}
+function readPlanRequest(input) {
+    return {
+        workspaceId: input.workspaceId,
+        intent: input.intent,
+        senderIds: input.senderIds,
+        runState: input.runState,
+        journal: input.journal,
+        ...refillDateSelectorBody(input.dateSelector),
+    };
+}
+async function readLoopPlan(input, deps, ctx, journal) {
+    return deps.readPlan(readPlanRequest({
+        workspaceId: input.workspaceId,
+        intent: input.intent,
+        senderIds: input.senderIds,
+        runState: ctx.runState,
+        journal,
+        dateSelector: ctx.dateSelector,
+    }));
+}
+function applyPlanDateWindow(ctx, plan) {
+    ctx.dateWindow = dateWindowFromPlan(plan, ctx.dateSelector);
+    ctx.dateSelector = selectorFromDateWindow(ctx.dateWindow);
+    ctx.runState = runStateWithDateWindow(ctx.runState, ctx.dateWindow);
+}
 function normalizeDoneReason(value) {
     const raw = stringValue(value);
     if (!raw)
@@ -670,14 +706,63 @@ async function createJournal(input, deps, runId) {
         return null;
     }
 }
-async function startOrResume(input, deps) {
-    const initialRunState = buildRunStateFromLocalHints(input.workspaceId);
+async function preflightResumeDateWindow(input, deps, requestedSelector) {
+    const requestedWindow = dateWindowFromSelector(requestedSelector);
+    if (!input.resume) {
+        return { ok: true, selector: requestedSelector, window: requestedWindow };
+    }
+    const status = await deps.runClient.refillRunStatus({
+        workspaceId: input.workspaceId,
+        runId: input.resume.runId,
+    });
+    if (hasBlocker(status, "lease_lost")) {
+        return {
+            status: "blocked",
+            blocker: "lease_lost",
+            runId: input.resume.runId,
+            fence: input.resume.fence,
+            guidance: "Refill run lease was lost before resume date-window preflight.",
+        };
+    }
+    const storedWindow = dateWindowFromRunState(recordValue(status)?.runState);
+    const explicitSelector = requestedSelector.source !== "default_scheduler_forward";
+    if (!storedWindow) {
+        if (explicitSelector) {
+            return {
+                status: "blocked",
+                blocker: "date_window_conflict",
+                runId: input.resume.runId,
+                fence: input.resume.fence,
+                guidance: "This legacy refill_sends_v2 run has no stored date window. Resume it without a new date selector or start a new run.",
+                report: { requestedDateWindow: requestedWindow },
+            };
+        }
+        return { ok: true, selector: requestedSelector, window: requestedWindow };
+    }
+    if (explicitSelector && !dateSelectorMatchesWindow(requestedSelector, storedWindow)) {
+        return {
+            status: "blocked",
+            blocker: "date_window_conflict",
+            runId: input.resume.runId,
+            fence: input.resume.fence,
+            guidance: "Resume date selector conflicts with the stored refill run date window.",
+            report: { requestedDateWindow: requestedWindow, storedDateWindow: storedWindow },
+        };
+    }
+    const selector = explicitSelector
+        ? requestedSelector
+        : selectorFromDateWindow(storedWindow);
+    return { ok: true, selector, window: storedWindow };
+}
+async function startOrResume(input, deps, dateWindow) {
+    const initialRunState = runStateWithDateWindow(buildRunStateFromLocalHints(input.workspaceId), dateWindow);
     const started = await deps.runClient.startRefillRunRemote({
         workspaceId: input.workspaceId,
         config: {
             intent: input.intent ?? "auto",
             senderIds: input.senderIds,
             approvalMode: input.approvalMode ?? "approve",
+            dateWindow,
         },
         runState: initialRunState,
         resume: input.resume,
@@ -719,6 +804,8 @@ async function startOrResume(input, deps) {
             laneCooldowns: [],
             passRates: [],
         };
+    const storedDateWindow = dateWindowFromRunState(runState) ?? dateWindow;
+    const storedDateSelector = selectorFromDateWindow(storedDateWindow);
     const journalPath = await createJournal(input, deps, runId);
     const ctx = {
         workspaceId: input.workspaceId,
@@ -731,6 +818,8 @@ async function startOrResume(input, deps) {
         plan: null,
         headAction: null,
         lastFingerprint: null,
+        dateSelector: storedDateSelector,
+        dateWindow: storedDateWindow,
         recoveryPoint: recordValue(result.recoveryPoint),
         gateCycles: 0,
         sleptMs: 0,
@@ -749,13 +838,8 @@ async function startOrResume(input, deps) {
     return ctx;
 }
 async function gateBootstrap(input, deps, ctx) {
-    const plan = await deps.readPlan({
-        workspaceId: input.workspaceId,
-        intent: input.intent,
-        senderIds: input.senderIds,
-        runState: ctx.runState,
-        journal: false,
-    });
+    const plan = await readLoopPlan(input, deps, ctx, false);
+    applyPlanDateWindow(ctx, plan);
     const paidCredit = arrayValue(recordValue(plan.bootstrap)?.paidCredit).filter(isRecord);
     const refreshedSenderIds = new Set(arrayValue(recordValue(ctx.runState.creditTrust)?.senderIds)
         .map((entry) => stringValue(entry))
@@ -772,13 +856,13 @@ async function gateBootstrap(input, deps, ctx) {
         receipts.push({ senderId, receipt });
         refreshedSenderIds.add(senderId);
     }
-    const nextRunState = mergeRunState(ctx.runState, {
+    const nextRunState = runStateWithDateWindow(mergeRunState(ctx.runState, {
         creditTrust: {
             refreshedAt: (deps.now?.() ?? new Date()).toISOString(),
             senderIds: [...refreshedSenderIds],
             receipts,
         },
-    });
+    }), ctx.dateWindow);
     await safeJournalAppend(ctx, deps, deps.journal.renderBootstrapSection({
         summary: "Refill v2 execution bootstrap",
         senderSummary: safeJson(recordValue(plan.bootstrap)?.senders ?? []),
@@ -886,13 +970,8 @@ async function completeTerminal(input, deps, ctx, doneReasonInput, reportInput =
     };
 }
 async function gatePlan(input, deps, ctx) {
-    const plan = await deps.readPlan({
-        workspaceId: input.workspaceId,
-        intent: input.intent,
-        senderIds: input.senderIds,
-        runState: ctx.runState,
-        journal: false,
-    });
+    const plan = await readLoopPlan(input, deps, ctx, false);
+    applyPlanDateWindow(ctx, plan);
     if (plan.blocker === "workspace_access") {
         return {
             status: "blocked",
@@ -995,13 +1074,7 @@ async function verifyRecoveryPoint(input, deps, ctx) {
         stateRevision: stringValue(planned.stateRevision),
         targetShapeRevision: stringValue(planned.targetShapeRevision),
     };
-    const fresh = await deps.readPlan({
-        workspaceId: input.workspaceId,
-        intent: input.intent,
-        senderIds: input.senderIds,
-        runState: ctx.runState,
-        journal: false,
-    });
+    const fresh = await readLoopPlan(input, deps, ctx, false);
     const changed = fingerprintChanged(expected, fingerprintFromPlan(fresh));
     if (changed.length > 0) {
         await deps.runClient.recordRunOutcome({
@@ -1263,13 +1336,8 @@ async function verifyPrepareAction(input, deps, ctx, action, budgets) {
 }
 async function verifyReadOnlyWait(input, deps, ctx, budgets, waitKind) {
     for (let poll = 0; poll < budgets.maxPollsPerWait; poll += 1) {
-        const fresh = await deps.readPlan({
-            workspaceId: input.workspaceId,
-            intent: input.intent,
-            senderIds: input.senderIds,
-            runState: ctx.runState,
-            journal: false,
-        });
+        const fresh = await readLoopPlan(input, deps, ctx, false);
+        applyPlanDateWindow(ctx, fresh);
         ctx.plan = fresh;
         const doneReason = doneReasonFromPlan(fresh);
         if (doneReason) {
@@ -1305,7 +1373,26 @@ async function verifySchedulerWait(input, deps, ctx, action, budgets) {
         }
         if (deps.requestSchedulerRun) {
             try {
-                schedulerRunReceipt = sanitizeSchedulerRunReceipt(await deps.requestSchedulerRun(input.workspaceId));
+                const targetDates = schedulerSweepTargetDates(ctx.dateWindow);
+                const sweepReceipts = [];
+                if (targetDates.length === 0) {
+                    schedulerRunReceipt = sanitizeSchedulerRunReceipt(await deps.requestSchedulerRun(input.workspaceId));
+                }
+                else {
+                    for (const targetDate of targetDates) {
+                        const receipt = sanitizeSchedulerRunReceipt(await deps.requestSchedulerRun(input.workspaceId, { targetDate }));
+                        if (receipt)
+                            sweepReceipts.push({ targetDate, ...receipt });
+                    }
+                    schedulerRunReceipt = sweepReceipts[0] ?? null;
+                }
+                if (sweepReceipts.length > 1) {
+                    ctx.runState = mergeRunState(ctx.runState, {
+                        progress: mergeProgress(ctx, {
+                            schedulerRunReceipts: sweepReceipts,
+                        }),
+                    });
+                }
             }
             catch {
                 schedulerRunReceipt = null;
@@ -1325,13 +1412,8 @@ async function verifySchedulerWait(input, deps, ctx, action, budgets) {
     // full wait budget when the fresh receipt says nothing was placeable now.
     const readbackBudget = zeroScheduledFresh ? 1 : budgets.maxSchedulerReadbacks;
     for (let poll = 0; poll < readbackBudget; poll += 1) {
-        const fresh = await deps.readPlan({
-            workspaceId: input.workspaceId,
-            intent: input.intent,
-            senderIds: input.senderIds,
-            runState: ctx.runState,
-            journal: false,
-        });
+        const fresh = await readLoopPlan(input, deps, ctx, false);
+        applyPlanDateWindow(ctx, fresh);
         ctx.plan = fresh;
         const doneReason = normalizeDoneReason(doneReasonFromPlan(fresh));
         if (doneReason === "complete" || doneReason === "capped_by_scheduler") {
@@ -1387,13 +1469,8 @@ async function gateVerify(input, deps, ctx, budgets) {
         actionType === "wait_for_source_import") {
         return verifyReadOnlyWait(input, deps, ctx, budgets, actionType);
     }
-    const fresh = await deps.readPlan({
-        workspaceId: input.workspaceId,
-        intent: input.intent,
-        senderIds: input.senderIds,
-        runState: ctx.runState,
-        journal: false,
-    });
+    const fresh = await readLoopPlan(input, deps, ctx, false);
+    applyPlanDateWindow(ctx, fresh);
     ctx.plan = fresh;
     const doneReason = doneReasonFromPlan(fresh);
     if (doneReason) {
@@ -1466,15 +1543,21 @@ export async function runRefillV2Loop(input, deps) {
     let ctx = null;
     try {
         if (input.dryRun) {
-            const plan = await deps.readPlan({
+            const dateSelector = dateSelectorFromInput(input);
+            const plan = await deps.readPlan(readPlanRequest({
                 workspaceId: input.workspaceId,
                 intent: input.intent,
                 senderIds: input.senderIds,
                 journal: true,
-            });
+                dateSelector,
+            }));
             return { status: "dry_run", plan };
         }
-        const started = await startOrResume(input, deps);
+        const requestedSelector = dateSelectorFromInput(input);
+        const preflight = await preflightResumeDateWindow(input, deps, requestedSelector);
+        if ("status" in preflight)
+            return preflight;
+        const started = await startOrResume(input, deps, preflight.window);
         if ("status" in started)
             return started;
         ctx = started;

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

@@ -3,6 +3,9 @@ type GetRefillPlanV2Input = {
     intent?: "auto" | "evergreen" | "plain" | "active";
     senderIds?: string[];
     runState?: Record<string, unknown>;
+    targetDate?: string | null;
+    untilDate?: string | null;
+    horizonSendDays?: number | null;
     journal?: boolean;
     journalNote?: string;
 };
@@ -38,6 +41,22 @@ export declare const refillPlanV2ToolDefinitions: {
                 enum: string[];
                 description: string;
             };
+            targetDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            untilDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            horizonSendDays: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
             journal: {
                 type: string;
                 description: string;

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

@@ -1,5 +1,6 @@
 import * as path from "node:path";
 import { getApi, SellableApiError } from "../api.js";
+import { normalizeRefillDateSelector, refillDateSelectorBody, } from "../refill-date-window.js";
 import { appendIndexLine, appendJournalEvent, createRunJournal, renderBootstrapSection, renderPlanSection, renderTerminalSection, } from "../refill-journal.js";
 import { readRefillWorkspaceState } from "../refill-local-state.js";
 import { normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
@@ -175,6 +176,22 @@ export const refillPlanV2ToolDefinitions = [
                     enum: ["auto", "evergreen", "plain", "active"],
                     description: 'Planner intent. Defaults to "auto" for refill-sends-v2.',
                 },
+                targetDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                    description: "Optional one exact sender-local date (YYYY-MM-DD) to plan. Takes precedence over untilDate and horizonSendDays.",
+                },
+                untilDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                    description: "Optional inclusive sender-local through-date (YYYY-MM-DD) to plan.",
+                },
+                horizonSendDays: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 7,
+                    description: "Optional explicit next N sender-local send days to plan.",
+                },
                 journal: {
                     type: "boolean",
                     description: "Set false to skip the local dry-run journal write.",
@@ -197,6 +214,7 @@ export async function getRefillPlanV2(input) {
     const runState = input.runState !== undefined
         ? input.runState
         : buildRunStateFromLocalHints(workspaceId);
+    const dateSelector = normalizeRefillDateSelector(input);
     let raw;
     try {
         raw = await postRefillPlanV2({
@@ -204,6 +222,7 @@ export async function getRefillPlanV2(input) {
             intent: input.intent ?? "auto",
             senderIds: input.senderIds,
             runState,
+            ...refillDateSelectorBody(dateSelector),
         }, workspaceId);
     }
     catch (error) {

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

@@ -6,6 +6,9 @@ type RefillSendsV2Input = {
     approvalMode?: "approve" | "mark_ready";
     senderIds?: string[];
     intent?: "auto" | "evergreen" | "plain" | "active";
+    targetDate?: string | null;
+    untilDate?: string | null;
+    horizonSendDays?: number | null;
 };
 export declare const refillSendsV2ToolDefinitions: {
     name: string;
@@ -44,6 +47,22 @@ export declare const refillSendsV2ToolDefinitions: {
                 type: string;
                 enum: string[];
             };
+            targetDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            untilDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            horizonSendDays: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
         };
         required: string[];
         additionalProperties: boolean;

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

@@ -18,7 +18,7 @@ const BOUNDED_AUTHORITY = "Within the refill run, bounded approvals, preparation
 export const refillSendsV2ToolDefinitions = [
     {
         name: "refill_sends_v2",
-        description: "Execute the refill sends v2 loop with run-record fencing, packet re-planning, shared refill executors, and resumable dry-run/real-run modes.",
+        description: "Execute the refill sends v2 loop with run-record fencing, packet re-planning, shared refill executors, and resumable dry-run/real-run modes. Date selectors match refill_sends: targetDate is one exact sender-local date, untilDate is inclusive, horizonSendDays is the next N sender-local send days, with precedence targetDate > untilDate > horizonSendDays > default scheduler-forward planning.",
         inputSchema: {
             type: "object",
             properties: {
@@ -51,6 +51,22 @@ export const refillSendsV2ToolDefinitions = [
                     type: "string",
                     enum: ["auto", "evergreen", "plain", "active"],
                 },
+                targetDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                    description: "Optional one exact sender-local date (YYYY-MM-DD) to refill.",
+                },
+                untilDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                    description: "Optional inclusive sender-local through-date (YYYY-MM-DD) to refill.",
+                },
+                horizonSendDays: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 7,
+                    description: "Optional explicit next N sender-local send days to refill.",
+                },
             },
             required: ["workspaceId"],
             additionalProperties: false,
@@ -99,6 +115,9 @@ export async function refillSendsV2Command(input) {
             workspaceId,
             intent: input.intent,
             senderIds: input.senderIds,
+            targetDate: input.targetDate,
+            untilDate: input.untilDate,
+            horizonSendDays: input.horizonSendDays,
             journal: true,
         });
         return {
@@ -113,6 +132,9 @@ export async function refillSendsV2Command(input) {
         workspaceId,
         intent: input.intent,
         senderIds: input.senderIds,
+        targetDate: input.targetDate,
+        untilDate: input.untilDate,
+        horizonSendDays: input.horizonSendDays,
         approvalMode: input.approvalMode ?? "approve",
         resume: resumeHandle(input),
     }, {
@@ -129,6 +151,9 @@ export async function refillSendsV2Command(input) {
             workspaceId: planInput.workspaceId,
             intent: planInput.intent,
             senderIds: planInput.senderIds,
+            targetDate: planInput.targetDate,
+            untilDate: planInput.untilDate,
+            horizonSendDays: planInput.horizonSendDays,
             runState: planInput.runState,
             journal: planInput.journal,
         }),
@@ -153,7 +178,11 @@ export async function refillSendsV2Command(input) {
         localState: {
             writeRefillWorkspaceState,
         },
-        requestSchedulerRun: (workspaceId) => runSchedulerSweep({ workspaceId, action: "run" }),
+        requestSchedulerRun: (workspaceId, options) => runSchedulerSweep({
+            workspaceId,
+            action: "run",
+            targetDate: options?.targetDate,
+        }),
     });
     return {
         ...(await maybeAddLostFenceGuidance(result, { ...input, workspaceId })),

package/dist/tools/refill-sends.js

@@ -4,11 +4,15 @@ import { createWorkspaceContext, normalizeExplicitWorkspaceId, } from "./workspa
 const DEFAULT_SCHEDULER_FORWARD_HOURS = 48;
 const MCP_PAID_INMAIL_CREDITS_MAX_STALENESS_SECONDS = 4 * 60 * 60;
 function normalizeHorizonSendDays(value) {
-    if (value === undefined || value === null)
+    if (value === undefined)
         return null;
-    if (typeof value !== "number" || !Number.isFinite(value))
-        return null;
-    return Math.max(1, Math.min(7, Math.floor(value)));
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < 1 ||
+        value > 7) {
+        throw new Error("horizonSendDays must be an integer between 1 and 7.");
+    }
+    return value;
 }
 function normalizeUntilDate(value) {
     if (value === undefined || value === null || value === "")
@@ -91,7 +95,7 @@ export const refillSendsToolDefinitions = [
                     type: "number",
                     minimum: 1,
                     maximum: 7,
-                    description: "Compatibility override for an explicit sender-local send-day horizon. Omit for the default scheduler-forward 48-hour target window.",
+                    description: "Compatibility override for explicit next N sender-local send days. Omit for the default scheduler-forward 48-hour target window.",
                 },
                 untilDate: {
                     type: "string",
@@ -184,7 +188,7 @@ export function refillSendsCommand(input = {}) {
                     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.",
+                        : `Fill the next ${horizonSendDays} sender-local send days.`,
                 },
         approvalMode,
         campaignId: input.campaignId ?? null,

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

@@ -1026,6 +1026,16 @@ function sanitizeRefillTargetPlanResult(result) {
         mcpSanitizedRefillLanes: true,
     };
 }
+function stripInternalTargetDateKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => stripInternalTargetDateKeys(item));
+    }
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key]) => key !== "targetDateKey")
+        .map(([key, nested]) => [key, stripInternalTargetDateKeys(nested)]));
+}
 export const refillTargetPlanToolDefinitions = [
     {
         name: "get_refill_target_plan",
@@ -1042,7 +1052,7 @@ export const refillTargetPlanToolDefinitions = [
                     type: "number",
                     minimum: 1,
                     maximum: 7,
-                    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.",
+                    description: "Compatibility override for explicit next N sender-local send days. Omit for the default scheduler-forward 48-hour target window; no-send days are skipped while choosing the requested send days.",
                 },
                 untilDate: {
                     type: "string",
@@ -1052,7 +1062,7 @@ export const refillTargetPlanToolDefinitions = [
                 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.",
+                    description: "Optional one exact sender-local date (YYYY-MM-DD) to fill. Distinct from untilDate: targetDate asks how many scheduler-fillable slots exist on only this date.",
                 },
                 campaignId: {
                     type: "string",
@@ -1102,11 +1112,14 @@ export const refillTargetPlanToolDefinitions = [
 ];
 export async function getRefillTargetPlan(input = {}) {
     const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
+    const targetDate = input.targetDate;
+    const untilDate = targetDate ? undefined : input.untilDate;
+    const horizonSendDays = targetDate || untilDate ? undefined : input.horizonSendDays;
     const result = await postRefillTargetPlan({
         intent: input.intent,
-        horizonSendDays: input.horizonSendDays,
-        untilDate: input.untilDate,
-        targetDate: input.targetDate,
+        horizonSendDays,
+        untilDate,
+        targetDate,
         campaignId: input.campaignId,
         tableId: input.tableId,
         senderIds: input.senderIds,
@@ -1117,7 +1130,7 @@ export async function getRefillTargetPlan(input = {}) {
         paidInmailCreditsMaxStalenessSeconds: MCP_PAID_INMAIL_CREDITS_MAX_STALENESS_SECONDS,
         ...(workspaceId ? { workspaceId } : {}),
     }, workspaceId ?? undefined);
-    const sanitized = sanitizeRefillTargetPlanResult(result);
+    const sanitized = stripInternalTargetDateKeys(sanitizeRefillTargetPlanResult(result));
     if (!workspaceId || !isRecord(sanitized))
         return sanitized;
     return {

package/dist/tools/registry.d.ts

@@ -2758,6 +2758,22 @@ export declare const allTools: ({
                 enum: string[];
                 description: string;
             };
+            targetDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            untilDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            horizonSendDays: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
             journal: {
                 type: string;
                 description: string;
@@ -7385,6 +7401,10 @@ export declare const allTools: ({
                 enum: string[];
                 description: string;
             };
+            targetDate: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
         additionalProperties: boolean;
@@ -7426,6 +7446,22 @@ export declare const allTools: ({
                 type: string;
                 enum: string[];
             };
+            targetDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            untilDate: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            horizonSendDays: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
         };
         required: string[];
         additionalProperties: boolean;

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

@@ -10,7 +10,7 @@ async function postSchedulerFillCapacity(body, workspaceId) {
 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.",
+        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. Use get_refill_target_plan for multi-day untilDate or horizonSendDays planning. 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: {

package/dist/tools/scheduler-run.d.ts

@@ -2,6 +2,7 @@ type SchedulerRunAction = "run" | "status";
 type RunSchedulerSweepInput = {
     workspaceId: string;
     action?: SchedulerRunAction;
+    targetDate?: string | null;
 };
 export declare const schedulerRunToolDefinitions: {
     name: string;
@@ -18,6 +19,10 @@ export declare const schedulerRunToolDefinitions: {
                 enum: string[];
                 description: string;
             };
+            targetDate: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
         additionalProperties: boolean;

package/dist/tools/scheduler-run.js

@@ -10,7 +10,7 @@ async function postSchedulerRun(body, workspaceId) {
 export const schedulerRunToolDefinitions = [
     {
         name: "run_scheduler_sweep",
-        description: 'Trigger the product scheduler placement sweep for one explicit workspace now, or read the last on-demand scheduler run status with action "status". A run is workspace-wide, not a scoped run for one campaign/table, and returns a synchronous envelope with status ran, attached, backoff, window_closed_noop, or failed; retryAfterMs for backoff replays; and a backward-compatible receipt. In v2 receipts, readyCellsFound is total scheduler-ready supply found before filters, cellsConsidered is the allocation-attempt count that survived prefilters, prefiltered means ready cells removed before allocation such as no capacity, stale paid InMail credit facts, or sender mismatch, skipped means considered cells rejected by hard scheduler gates, and deferred means considered cells waiting on windows/capacity/cooldown. campaignScopeSummary lists bounded tables/campaigns the workspace-wide run inspected; absence there is not a scoped-run guarantee that the target was ready. The receipt can include readyCellsByType, consideredCellsByType, prefilterReasons, skippedReasons, deferredReasons, summary, and nextAction. It places cells within existing scheduler gates only: it can move placement earlier, but it cannot bypass sending windows, daily limits, cooldowns, sender gates, billing, or credit thresholds, and it never sends messages directly. Repeated calls inside the backoff window replay the last receipt verbatim. Status is read-only and scoped to the last on-demand run only; cron sweeps are not recorded here.',
+        description: 'Trigger the product scheduler placement sweep for one explicit workspace now, or read the last on-demand scheduler run status with action "status". By default a run is workspace-wide, not a scoped run for one campaign/table. Pass targetDate to scope placement to one exact sender-local date while still remaining workspace-wide inside that date. Multi-day untilDate or horizonSendDays planning should come from get_refill_target_plan, then use exact per-date run_scheduler_sweep calls only for dates that still need scheduler placement. The synchronous envelope includes status ran, attached, backoff, window_closed_noop, or failed; retryAfterMs for matching-scope backoff replays; and a backward-compatible receipt with public scope metadata. In v2 receipts, readyCellsFound is total scheduler-ready supply found before filters, cellsConsidered is the allocation-attempt count that survived prefilters, prefiltered means ready cells removed before allocation such as no capacity, stale paid InMail credit facts, or sender mismatch, skipped means considered cells rejected by hard scheduler gates, and deferred means considered cells waiting on windows/capacity/cooldown. campaignScopeSummary lists bounded tables/campaigns the workspace-wide run inspected; absence there is not a scoped-run guarantee that the target was ready. The receipt can include readyCellsByType, consideredCellsByType, prefilterReasons, skippedReasons, deferredReasons, summary, and nextAction. It places cells within existing scheduler gates only: it can move placement earlier, but it cannot bypass sending windows, daily limits, cooldowns, sender gates, billing, or credit thresholds, and it never sends messages directly. Repeated calls inside the backoff window replay the last receipt only when the recorded public scope matches this request. Status is read-only and scoped to the last on-demand run only; cron sweeps are not recorded here.',
         inputSchema: {
             type: "object",
             properties: {
@@ -23,12 +23,33 @@ export const schedulerRunToolDefinitions = [
                     enum: ["run", "status"],
                     description: 'Use "run" to trigger a placement sweep now. Use "status" for a read-only view of the last on-demand run. Defaults to "run".',
                 },
+                targetDate: {
+                    type: "string",
+                    description: "Optional one exact sender-local date (YYYY-MM-DD) to scope scheduler placement/status. The run remains workspace-wide inside that date.",
+                },
             },
             required: ["workspaceId"],
             additionalProperties: false,
         },
     },
 ];
+function isValidDateKey(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const [year, month, day] = value.split("-").map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}
+function normalizeTargetDate(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !isValidDateKey(value)) {
+        throw new Error("targetDate must be a valid YYYY-MM-DD calendar date.");
+    }
+    return value;
+}
 export async function runSchedulerSweep(input) {
     const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
     if (!workspaceId) {
@@ -38,8 +59,10 @@ export async function runSchedulerSweep(input) {
     if (action !== "run" && action !== "status") {
         throw new Error('action must be "run" or "status" for run_scheduler_sweep.');
     }
+    const targetDate = normalizeTargetDate(input.targetDate);
     return postSchedulerRun({
         workspaceId,
         action,
+        targetDate,
     }, workspaceId);
 }

package/package.json

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

package/skills/refill-sends/SKILL.md

@@ -87,6 +87,12 @@ Accepted invocation flags in the same user request:
   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.
+- `horizonSendDays: N`: compatibility selector for the next N sender-local send
+  days when no exact or through-date selector is present.
+
+Date selector precedence is `targetDate > untilDate > horizonSendDays`. Use
+`targetDate` for one exact sender-local date, `untilDate` for an inclusive
+through-date, and `horizonSendDays` for the next N sender-local send days.
 
 When the host can call typed MCP tools, start with:
 
@@ -272,7 +278,9 @@ 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.
 When the refill loop has ready rows and needs scheduler pickup now, use
-`run_scheduler_sweep` with the same explicit `workspaceId`; it can place cells
+`run_scheduler_sweep({ workspaceId, targetDate })` for exact-date requests. For
+`untilDate` or `horizonSendDays` requests, sweep each planner-selected
+`targetDate` with the same explicit `workspaceId`. The sweep can place cells
 within existing scheduler gates and returns the receipt, but it never sends or
 bypasses limits.
 Scheduler-run receipt interpretation: `cellsConsidered is allocation-attempt

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

@@ -37,16 +37,21 @@ active workspace readback. Scheduled or autonomous usage must carry
 `workspaceId` on every tool call. If the workspace is missing or ambiguous, stop
 with `WORKSPACE_REQUIRED`; do not switch the shared active workspace.
 
+Date selectors are sender-local and mutually exclusive by precedence:
+`targetDate > untilDate > horizonSendDays`. Use `targetDate` for one exact sender-local date, `untilDate` for an inclusive through-date, and `horizonSendDays` for the next N sender-local send days. If none is provided, the planner uses the default scheduler-forward 48-hour behavior.
+
 For a real refill run:
 
 ```text
-refill_sends_v2({ workspaceId, intent:"auto", senderIds?, approvalMode? })
+refill_sends_v2({ workspaceId, intent:"auto", senderIds?, approvalMode?, targetDate?, untilDate?, horizonSendDays? })
+refill_sends_v2({ workspaceId, targetDate:"2026-07-07" })
+refill_sends_v2({ workspaceId, untilDate:"2026-07-09" })
 ```
 
 For read-only inspection:
 
 ```text
-refill_sends_v2({ workspaceId, dryRun:true, intent:"auto", senderIds? })
+refill_sends_v2({ workspaceId, dryRun:true, intent:"auto", senderIds?, targetDate?, untilDate?, horizonSendDays? })
 ```
 
 To resume an in-progress run, pass the handle back exactly:
@@ -55,6 +60,11 @@ To resume an in-progress run, pass the handle back exactly:
 refill_sends_v2({ workspaceId, runId, fence })
 ```
 
+The original run's date window is stored in the run record. On resume, the
+stored window is reused and conflicting resume input is blocked; do not add,
+change, or remove `targetDate`, `untilDate`, or `horizonSendDays` while passing
+an existing `{ runId, fence }`.
+
 If a stale handle loses the lease, the tool reports the holder status and the
 approximately 10 minute lockout window. Reinvoke with the current handle or wait
 for lease expiry; never guess a fence.
@@ -125,9 +135,12 @@ host guard, heartbeats the run lease, and may return:
 ```
 
 Reinvoke with that handle. The approximately five minute scheduler budget is at
-the run level, not one tool call. A window-closed or loaded-awaiting scheduler
-report must include remaining-ready count, exact expected pickup time, and the
-resume handle; never treat bare "awaiting scheduler" copy as a final answer.
+the run level, not one tool call. Exact-date runs request pickup with
+`run_scheduler_sweep({ workspaceId, targetDate })`; `untilDate` and
+`horizonSendDays` runs sweep each planner-selected exact target date. A
+window-closed or loaded-awaiting scheduler report must include remaining-ready
+count, exact expected pickup time, and the resume handle; never treat bare
+"awaiting scheduler" copy as a final answer.
 Scheduler-run receipt interpretation still applies to terminal progress:
 `cellsConsidered is allocation-attempt count`, not total ready supply, while
 `readyCellsFound` is ready inventory found before prefilters. Inspect

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

@@ -33,10 +33,16 @@ local files or memory.
 Resolve request-scoped `workspaceId` using read-only auth and workspace tools.
 Scheduled or autonomous runs must not rely on implicit workspace state.
 
+Carry the request date selector through bootstrap, planning, execution, and
+resume. Date selector precedence is `targetDate > untilDate > horizonSendDays`:
+`targetDate` is one exact sender-local date, `untilDate` is an inclusive
+through-date, and `horizonSendDays` is the next N sender-local send days. If no
+selector is present, use the default scheduler-forward 48-hour behavior.
+
 Start or resume the execution loop:
 
 ```text
-refill_sends_v2({ workspaceId, intent:"auto", senderIds?, approvalMode?, runId?, fence? })
+refill_sends_v2({ workspaceId, intent:"auto", senderIds?, approvalMode?, targetDate?, untilDate?, horizonSendDays?, runId?, fence? })
 ```
 
 Use `dryRun:true` only when the user asked for read-only inspection. A dry run
@@ -44,6 +50,11 @@ writes a journal only. A real run creates or resumes a run record, refreshes
 paid-credit trust only when packet facts require it, and returns a resume handle
 when the current invocation must pause.
 
+The run record stores the selected date window. On resume, reuse that stored
+window and block conflicting resume input; do not accept a changed
+`targetDate`, `untilDate`, or `horizonSendDays` with an existing `{ runId,
+fence }`.
+
 ## G1 Plan
 
 The loop reads `get_refill_plan_v2` with runState fed back from the run record.
@@ -116,7 +127,10 @@ outcome, then verifies before replanning.
 Scheduler wait is cross-invocation. If the tool returns `in_progress` with
 sweep guidance, re-invoke `refill_sends_v2` with `{runId, fence}`. The scheduler
 budget is cumulative at the run level. Zero pickup after a confirmed sweep is
-debugged from `pipelineDiagnosis`; it is not waited out forever.
+debugged from `pipelineDiagnosis`; it is not waited out forever. Exact-date
+runs request pickup with `run_scheduler_sweep({ workspaceId, targetDate })`;
+`untilDate` and `horizonSendDays` runs sweep each planner-selected exact target
+date.
 Scheduler-run receipt interpretation still applies to terminal progress:
 `cellsConsidered is allocation-attempt count`, not total ready supply, while
 `readyCellsFound` is ready inventory found before prefilters. Inspect

package/skills/refill-sends-v2-workflow/core/flow.v1.json

@@ -1,7 +1,7 @@
 {
   "version": "v1.0",
   "workflow": "refill-sends-v2-workflow",
-  "principle": "Execute refill sends v2 through a fenced run record: bootstrap, plan, execute, verify, and report. Dry runs stay read-only; real runs execute only packet-named bounded work.",
+  "principle": "Execute refill sends v2 through a fenced run record: bootstrap, plan, execute, verify, and report. Dry runs stay read-only; real runs execute only packet-named bounded work. Date selectors use targetDate > untilDate > horizonSendDays precedence.",
   "laneSources": [
     "managed_waterfall",
     "dashboard_evergreen",
@@ -50,6 +50,9 @@
     "repair rungs come from the plan packet; the loop bounds and refuses, never self-emits repair actions",
     "capped_by_scheduler is complete, never poll",
     "awaiting scheduler is not an end state; window-closed reports name remaining-ready, expected pickup time, and resume handle",
+    "date selectors resolve by targetDate > untilDate > horizonSendDays; targetDate is one exact sender-local date, untilDate is an inclusive through-date, and horizonSendDays means next N sender-local send days",
+    "dateWindow is stored on the run record and conflicting resume input is blocked",
+    "exact-date scheduler pickup uses run_scheduler_sweep({ workspaceId, targetDate }); untilDate and horizonSendDays runs sweep each planner-selected exact targetDate",
     "honest-rubric-fail means a human updates the rubric or changes lead source",
     "source replenishment beyond same-source-automatic is a scoped create-campaign handoff, never refill-owned provider search",
     "no campaign creation, provider-family switch, threshold lowering, scheduler writes, sends, archives, deletes, or brief/filter/message/sequence/sender mutation without a separate approval packet"
@@ -143,7 +146,16 @@
         },
         {
           "tool": "refill_sends_v2",
-          "requiredFields": ["workspaceId"]
+          "requiredFields": ["workspaceId"],
+          "optionalFields": [
+            "senderIds",
+            "approvalMode",
+            "targetDate",
+            "untilDate",
+            "horizonSendDays",
+            "runId",
+            "fence"
+          ]
         },
         {
           "tool": "get_subskill_prompt",
@@ -176,6 +188,9 @@
           "optionalFields": [
             "intent",
             "senderIds",
+            "targetDate",
+            "untilDate",
+            "horizonSendDays",
             "runState",
             "journal",
             "journalNote"
@@ -311,7 +326,7 @@
     },
     {
       "id": "verify",
-      "description": "Verify whole-row outcomes before another plan read. Reattach to an own active prep job by requestSource/requestHash; never re-dispatch prep while a matching job is active. Foreign prep waits until clear or blocks foreign_prep_active. wait_for_active_work and wait_for_source_import reread the plan on bounded cadence. wait_for_scheduler is cross-invocation: each tool call polls briefly under the host guard, heartbeats the lease, and returns in_progress sweep guidance so the agent re-invokes refill_sends_v2 with {runId,fence}. The approximately five minute scheduler budget is cumulative at the run level.",
+      "description": "Verify whole-row outcomes before another plan read. Reattach to an own active prep job by requestSource/requestHash; never re-dispatch prep while a matching job is active. Foreign prep waits until clear or blocks foreign_prep_active. wait_for_active_work and wait_for_source_import reread the plan on bounded cadence. wait_for_scheduler is cross-invocation: each tool call polls briefly under the host guard, heartbeats the lease, and returns in_progress sweep guidance so the agent re-invokes refill_sends_v2 with {runId,fence}. Exact-date scheduler pickup uses run_scheduler_sweep({ workspaceId, targetDate }); untilDate and horizonSendDays runs sweep each planner-selected exact targetDate. The approximately five minute scheduler budget is cumulative at the run level.",
       "allowedTools": ["refill_sends_v2", "get_refill_plan_v2"],
       "onEnter": [
         {
@@ -322,6 +337,7 @@
       "hardRules": [
         "do not re-dispatch prep when an own active job exists; reattach and poll status",
         "capped_by_scheduler is complete",
+        "resume uses the stored dateWindow; conflicting resume input is blocked",
         "replan-driven repair: the planner names rerun_errored_cells, approve_messages, start_campaign, or source work; the loop bounds and refuses",
         "conversion verdict is journaled from packet facts after the first prep batch; the plan gate withholds a second unproven prep batch",
         "zero pickup after a confirmed sweep is debugged from pipelineDiagnosis, not waited out forever",

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

@@ -189,9 +189,11 @@ files or memory.
    does not create rows, import, approve, schedule, refresh paid-InMail credits,
    or mutate thresholds.
    When ready rows exist and the wait is for scheduler pickup, call
-   `run_scheduler_sweep` with the same explicit `workspaceId` to request the
-   product scheduler placement pass now and read its receipt. This may place
-   cells within existing gates, never sends messages, and never bypasses limits.
+   `run_scheduler_sweep({ workspaceId, targetDate })` for exact-date requests
+   to request the product scheduler placement pass now and read its receipt. For
+   `untilDate` or `horizonSendDays` requests, sweep each planner-selected
+   `targetDate` with the same explicit `workspaceId`. This may place cells
+   within existing gates, never sends messages, and never bypasses limits.
    Scheduler-run receipt interpretation: `cellsConsidered is
    allocation-attempt count`, not total ready supply, while `readyCellsFound`
    is ready inventory found before prefilters. Inspect `campaignScopeSummary`

package/skills/refill-sends-workflow/core/flow.v1.json

@@ -202,7 +202,7 @@
       ],
       "rules": [
         "Poll every 60-120 seconds or on the host continuation interval.",
-        "Use run_scheduler_sweep with the explicit workspaceId when ready rows need scheduler pickup now; it places cells only inside existing gates and never sends.",
+        "Use run_scheduler_sweep({ workspaceId, targetDate }) for exact-date scheduler pickup; for untilDate or horizonSendDays requests, sweep each planner-selected targetDate with the explicit workspaceId. It places cells only inside existing gates and never sends.",
         "cellsConsidered is allocation-attempt count; inspect campaignScopeSummary before assuming the selected refill campaign/table was included or ready-but-blocked.",
         "Read prefiltered, skipped, and deferred separately: prefiltered ready closed-InMail cells with stale paid-credit facts require refresh_paid_inmail_credits_then_rerun once, then rerun/status.",
         "wait_for_capacity_or_window means report loaded/capped/waiting and do not source or prep more rows; no_ready_cells_continue_refill_prep means return to the refill/prep ladder.",