@sellable/mcp 0.1.537 → 0.1.538

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,6 +1,7 @@
 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 { classifyPaidInmailRefreshReceipt, prepareRowSelectorValue as defaultPrepareRowSelectorValue, refillPrepareRequestHash as defaultRefillPrepareRequestHash, } from "./tools/refill-executors.js";
+import { prepareRowSelectorValue as defaultPrepareRowSelectorValue, refillPrepareRequestHash as defaultRefillPrepareRequestHash, } from "./tools/refill-executors.js";
 const DEFAULT_BUDGETS = {
     maxGateCyclesPerInvocation: 8,
     pollIntervalMs: 15_000,
@@ -379,9 +380,16 @@ function firstAction(plan) {
 }
 function doneReasonFromPlan(plan) {
     const action = firstAction(plan);
+    const packet = recordValue(plan.packet) ?? {};
+    const status = stringValue(plan.status) ?? stringValue(packet.status);
     return (stringValue(action?.doneReason) ??
-        stringValue(recordValue(plan.packet)?.doneReason) ??
-        stringValue(plan.doneReason));
+        stringValue(packet.doneReason) ??
+        stringValue(plan.doneReason) ??
+        (status === "complete" ? "complete" : null) ??
+        (status === "awaiting_scheduler_after_ready_buffer"
+            ? "loaded_awaiting_scheduler"
+            : null) ??
+        (status === "blocked" ? "blocked" : null));
 }
 function selectedLaneAuthority(plan, action) {
     const senderId = actionSenderId(action);
@@ -417,6 +425,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 +713,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 +811,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 +825,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,45 +845,31 @@ 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))
         .filter((entry) => Boolean(entry)));
-    const attemptedSenderIds = new Set(arrayValue(recordValue(ctx.runState.creditTrust)?.attemptedSenderIds)
-        .map((entry) => stringValue(entry))
-        .filter((entry) => Boolean(entry)));
     const receipts = [];
     for (const entry of paidCredit) {
         const senderId = stringValue(entry.senderId);
         if (!senderId ||
             !entry.plannedJitRefresh ||
-            refreshedSenderIds.has(senderId) ||
-            attemptedSenderIds.has(senderId)) {
+            refreshedSenderIds.has(senderId)) {
             continue;
         }
         const receipt = await deps.executors.refreshPaidInmailCreditsWithRetry(senderId, input.workspaceId);
-        attemptedSenderIds.add(senderId);
-        const classification = classifyPaidInmailRefreshReceipt(receipt.receipt);
-        receipts.push({ senderId, receipt, classification });
-        if (classification.usableCurrentFacts) {
-            refreshedSenderIds.add(senderId);
-        }
+        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],
-            attemptedSenderIds: [...attemptedSenderIds],
             receipts,
         },
-    });
+    }), ctx.dateWindow);
     await safeJournalAppend(ctx, deps, deps.journal.renderBootstrapSection({
         summary: "Refill v2 execution bootstrap",
         senderSummary: safeJson(recordValue(plan.bootstrap)?.senders ?? []),
@@ -895,13 +977,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",
@@ -1004,13 +1081,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({
@@ -1272,13 +1343,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) {
@@ -1310,31 +1376,30 @@ async function verifySchedulerWait(input, deps, ctx, action, budgets) {
     if (!jitFired) {
         const senderId = actionSenderId(action);
         if (senderId) {
-            const refresh = await deps.executors.refreshPaidInmailCreditsWithRetry(senderId, input.workspaceId);
-            const classification = classifyPaidInmailRefreshReceipt(refresh.receipt);
-            if (!classification.usableCurrentFacts) {
-                return {
-                    status: "blocked",
-                    blocker: "paid_inmail_refresh_failed",
-                    runId: ctx.runId,
-                    fence: ctx.fence,
-                    gate: ctx.gate,
-                    guidance: "Paid InMail credit refresh did not return usable current facts, so scheduler JIT was not requested.",
-                    report: {
-                        senderId,
-                        receiptStatus: classification.status,
-                        error: classification.error,
-                        receipt: refresh.receipt,
-                        attempts: refresh.attempts,
-                        errors: refresh.errors,
-                    },
-                    journalPath: ctx.journalPath,
-                };
-            }
+            await deps.executors.refreshPaidInmailCreditsWithRetry(senderId, input.workspaceId);
         }
         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;
@@ -1354,13 +1419,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") {
@@ -1416,13 +1476,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) {
@@ -1495,15 +1550,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;