@sellable/mcp 0.1.536 → 0.1.537

package/README.md

@@ -74,12 +74,9 @@ 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"`, exact-date selectors such as
-`--target-date 2026-06-30`, optional through-date selectors such as
+`--sender "Christian Reyes"`, optional through-date selectors such as
 `--until 2026-06-30`, or typed MCP calls to `refill_sends({ yolo, senders,
-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:
+untilDate })` from:
 
 - `mcp/sellable/skills/refill-sends/SKILL.md`
 

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

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

package/dist/refill-run-loop.js

@@ -1,7 +1,6 @@
 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";
+import { classifyPaidInmailRefreshReceipt, prepareRowSelectorValue as defaultPrepareRowSelectorValue, refillPrepareRequestHash as defaultRefillPrepareRequestHash, } from "./tools/refill-executors.js";
 const DEFAULT_BUDGETS = {
     maxGateCyclesPerInvocation: 8,
     pollIntervalMs: 15_000,
@@ -418,41 +417,6 @@ 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)
@@ -706,63 +670,14 @@ async function createJournal(input, deps, runId) {
         return null;
     }
 }
-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);
+async function startOrResume(input, deps) {
+    const initialRunState = buildRunStateFromLocalHints(input.workspaceId);
     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,
@@ -804,8 +719,6 @@ async function startOrResume(input, deps, dateWindow) {
             laneCooldowns: [],
             passRates: [],
         };
-    const storedDateWindow = dateWindowFromRunState(runState) ?? dateWindow;
-    const storedDateSelector = selectorFromDateWindow(storedDateWindow);
     const journalPath = await createJournal(input, deps, runId);
     const ctx = {
         workspaceId: input.workspaceId,
@@ -818,8 +731,6 @@ async function startOrResume(input, deps, dateWindow) {
         plan: null,
         headAction: null,
         lastFingerprint: null,
-        dateSelector: storedDateSelector,
-        dateWindow: storedDateWindow,
         recoveryPoint: recordValue(result.recoveryPoint),
         gateCycles: 0,
         sleptMs: 0,
@@ -838,31 +749,45 @@ async function startOrResume(input, deps, dateWindow) {
     return ctx;
 }
 async function gateBootstrap(input, deps, ctx) {
-    const plan = await readLoopPlan(input, deps, ctx, false);
-    applyPlanDateWindow(ctx, plan);
+    const plan = await deps.readPlan({
+        workspaceId: input.workspaceId,
+        intent: input.intent,
+        senderIds: input.senderIds,
+        runState: ctx.runState,
+        journal: false,
+    });
     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)) {
+            refreshedSenderIds.has(senderId) ||
+            attemptedSenderIds.has(senderId)) {
             continue;
         }
         const receipt = await deps.executors.refreshPaidInmailCreditsWithRetry(senderId, input.workspaceId);
-        receipts.push({ senderId, receipt });
-        refreshedSenderIds.add(senderId);
+        attemptedSenderIds.add(senderId);
+        const classification = classifyPaidInmailRefreshReceipt(receipt.receipt);
+        receipts.push({ senderId, receipt, classification });
+        if (classification.usableCurrentFacts) {
+            refreshedSenderIds.add(senderId);
+        }
     }
-    const nextRunState = runStateWithDateWindow(mergeRunState(ctx.runState, {
+    const nextRunState = 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 ?? []),
@@ -970,8 +895,13 @@ async function completeTerminal(input, deps, ctx, doneReasonInput, reportInput =
     };
 }
 async function gatePlan(input, deps, ctx) {
-    const plan = await readLoopPlan(input, deps, ctx, false);
-    applyPlanDateWindow(ctx, plan);
+    const plan = await deps.readPlan({
+        workspaceId: input.workspaceId,
+        intent: input.intent,
+        senderIds: input.senderIds,
+        runState: ctx.runState,
+        journal: false,
+    });
     if (plan.blocker === "workspace_access") {
         return {
             status: "blocked",
@@ -1074,7 +1004,13 @@ async function verifyRecoveryPoint(input, deps, ctx) {
         stateRevision: stringValue(planned.stateRevision),
         targetShapeRevision: stringValue(planned.targetShapeRevision),
     };
-    const fresh = await readLoopPlan(input, deps, ctx, false);
+    const fresh = await deps.readPlan({
+        workspaceId: input.workspaceId,
+        intent: input.intent,
+        senderIds: input.senderIds,
+        runState: ctx.runState,
+        journal: false,
+    });
     const changed = fingerprintChanged(expected, fingerprintFromPlan(fresh));
     if (changed.length > 0) {
         await deps.runClient.recordRunOutcome({
@@ -1336,8 +1272,13 @@ 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 readLoopPlan(input, deps, ctx, false);
-        applyPlanDateWindow(ctx, fresh);
+        const fresh = await deps.readPlan({
+            workspaceId: input.workspaceId,
+            intent: input.intent,
+            senderIds: input.senderIds,
+            runState: ctx.runState,
+            journal: false,
+        });
         ctx.plan = fresh;
         const doneReason = doneReasonFromPlan(fresh);
         if (doneReason) {
@@ -1369,30 +1310,31 @@ async function verifySchedulerWait(input, deps, ctx, action, budgets) {
     if (!jitFired) {
         const senderId = actionSenderId(action);
         if (senderId) {
-            await deps.executors.refreshPaidInmailCreditsWithRetry(senderId, input.workspaceId);
+            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,
+                };
+            }
         }
         if (deps.requestSchedulerRun) {
             try {
-                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,
-                        }),
-                    });
-                }
+                schedulerRunReceipt = sanitizeSchedulerRunReceipt(await deps.requestSchedulerRun(input.workspaceId));
             }
             catch {
                 schedulerRunReceipt = null;
@@ -1412,8 +1354,13 @@ 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 readLoopPlan(input, deps, ctx, false);
-        applyPlanDateWindow(ctx, fresh);
+        const fresh = await deps.readPlan({
+            workspaceId: input.workspaceId,
+            intent: input.intent,
+            senderIds: input.senderIds,
+            runState: ctx.runState,
+            journal: false,
+        });
         ctx.plan = fresh;
         const doneReason = normalizeDoneReason(doneReasonFromPlan(fresh));
         if (doneReason === "complete" || doneReason === "capped_by_scheduler") {
@@ -1469,8 +1416,13 @@ async function gateVerify(input, deps, ctx, budgets) {
         actionType === "wait_for_source_import") {
         return verifyReadOnlyWait(input, deps, ctx, budgets, actionType);
     }
-    const fresh = await readLoopPlan(input, deps, ctx, false);
-    applyPlanDateWindow(ctx, fresh);
+    const fresh = await deps.readPlan({
+        workspaceId: input.workspaceId,
+        intent: input.intent,
+        senderIds: input.senderIds,
+        runState: ctx.runState,
+        journal: false,
+    });
     ctx.plan = fresh;
     const doneReason = doneReasonFromPlan(fresh);
     if (doneReason) {
@@ -1543,21 +1495,15 @@ export async function runRefillV2Loop(input, deps) {
     let ctx = null;
     try {
         if (input.dryRun) {
-            const dateSelector = dateSelectorFromInput(input);
-            const plan = await deps.readPlan(readPlanRequest({
+            const plan = await deps.readPlan({
                 workspaceId: input.workspaceId,
                 intent: input.intent,
                 senderIds: input.senderIds,
                 journal: true,
-                dateSelector,
-            }));
+            });
             return { status: "dry_run", plan };
         }
-        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);
+        const started = await startOrResume(input, deps);
         if ("status" in started)
             return started;
         ctx = started;

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

@@ -3,9 +3,6 @@ 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;
 };
@@ -41,22 +38,6 @@ 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,6 +1,5 @@
 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";
@@ -176,22 +175,6 @@ 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.",
@@ -214,7 +197,6 @@ export async function getRefillPlanV2(input) {
     const runState = input.runState !== undefined
         ? input.runState
         : buildRunStateFromLocalHints(workspaceId);
-    const dateSelector = normalizeRefillDateSelector(input);
     let raw;
     try {
         raw = await postRefillPlanV2({
@@ -222,7 +204,6 @@ export async function getRefillPlanV2(input) {
             intent: input.intent ?? "auto",
             senderIds: input.senderIds,
             runState,
-            ...refillDateSelectorBody(dateSelector),
         }, workspaceId);
     }
     catch (error) {

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

@@ -14,6 +14,12 @@ export type PaidInmailCreditRefreshOptions = {
     maxStalenessSeconds?: number | null;
     paidInmailCreditsMaxStalenessSeconds?: number | null;
 };
+export type PaidInmailRefreshReceiptClassification = {
+    usableCurrentFacts: boolean;
+    status: string;
+    error: string | null;
+    refreshed: boolean;
+};
 export type YoloPrimitiveExecution = {
     enabled: true;
     status: "no_action" | "read_only_reread" | "executed_and_reread" | "refused" | "skipped_after_paid_refresh";
@@ -135,6 +141,7 @@ export declare function userAddedRowsLimitPayloadFromError(error: unknown): User
 export declare function sourceImportInProgressPayloadFromError(error: unknown): SourceImportInProgressPayload | null;
 export declare function paidRefreshActionFrom(value: unknown): PaidInmailRefreshAction | null;
 export declare function collectPaidInmailRefreshActions(plan: unknown): PaidInmailRefreshAction[];
+export declare function classifyPaidInmailRefreshReceipt(value: unknown): PaidInmailRefreshReceiptClassification;
 export declare function firstGlobalAction(plan: unknown): Record<string, unknown> | null;
 export declare function actionIds(action: Record<string, unknown>): Record<string, unknown>;
 export declare function actionToolInput(action: Record<string, unknown>): Record<string, unknown>;

package/dist/tools/refill-executors.js

@@ -10,6 +10,11 @@ const PAID_INMAIL_REFRESH_RETRY_DELAY_MS = Number(process.env.SELLABLE_MCP_PAID_
 const SIGNAL_DISCOVERY_MIN_REFILL_POSTS = 3;
 const SIGNAL_DISCOVERY_MAX_REFILL_POSTS = 10;
 const SIGNAL_DISCOVERY_TARGET_ROWS_PER_POST = 150;
+const USABLE_PAID_INMAIL_REFRESH_RECEIPT_STATUSES = new Set([
+    "fresh",
+    "refreshed",
+    "below_threshold",
+]);
 export function normalizeStrings(values) {
     if (!Array.isArray(values))
         return [];
@@ -206,6 +211,23 @@ export function collectPaidInmailRefreshActions(plan) {
         add(action);
     return [...bySender.values()];
 }
+export function classifyPaidInmailRefreshReceipt(value) {
+    const response = recordValue(value);
+    const nestedReceipt = recordValue(response?.receipt);
+    const status = stringValue(nestedReceipt?.status) ??
+        stringValue(response?.status) ??
+        (response?.refreshed === true ? "refreshed" : "not_refreshed");
+    const refreshed = response?.refreshed === true || nestedReceipt?.refreshed === true;
+    const usableCurrentFacts = refreshed || USABLE_PAID_INMAIL_REFRESH_RECEIPT_STATUSES.has(status);
+    return {
+        usableCurrentFacts,
+        status,
+        refreshed,
+        error: stringValue(response?.error) ??
+            stringValue(nestedReceipt?.error) ??
+            (usableCurrentFacts ? null : "paid InMail credit refresh did not return usable current facts"),
+    };
+}
 export function firstGlobalAction(plan) {
     const root = recordValue(plan);
     const target = recordValue(root?.target);

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

@@ -6,9 +6,6 @@ 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;
@@ -47,22 +44,6 @@ 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. 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.",
+        description: "Execute the refill sends v2 loop with run-record fencing, packet re-planning, shared refill executors, and resumable dry-run/real-run modes.",
         inputSchema: {
             type: "object",
             properties: {
@@ -51,22 +51,6 @@ 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,
@@ -115,9 +99,6 @@ export async function refillSendsV2Command(input) {
             workspaceId,
             intent: input.intent,
             senderIds: input.senderIds,
-            targetDate: input.targetDate,
-            untilDate: input.untilDate,
-            horizonSendDays: input.horizonSendDays,
             journal: true,
         });
         return {
@@ -132,9 +113,6 @@ 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),
     }, {
@@ -151,9 +129,6 @@ 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,
         }),
@@ -178,11 +153,7 @@ export async function refillSendsV2Command(input) {
         localState: {
             writeRefillWorkspaceState,
         },
-        requestSchedulerRun: (workspaceId, options) => runSchedulerSweep({
-            workspaceId,
-            action: "run",
-            targetDate: options?.targetDate,
-        }),
+        requestSchedulerRun: (workspaceId) => runSchedulerSweep({ workspaceId, action: "run" }),
     });
     return {
         ...(await maybeAddLostFenceGuidance(result, { ...input, workspaceId })),

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

@@ -292,6 +292,8 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
             attempts?: number;
             error: string;
             errors?: string[];
+            receiptStatus?: string;
+            receipt?: unknown;
         }[];
         refreshReceipts: {
             senderId: string;
@@ -301,6 +303,8 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
             approvalSource: string;
             approvalPacket: PaidInmailRefreshApprovalPacket;
             receipt: import("./senders.js").RefreshPaidInmailCreditsResponse;
+            receiptStatus: string;
+            usableCurrentFacts: boolean;
         }[];
         attemptedSenderIds: string[];
         targetPlanReread: boolean;
@@ -309,6 +313,14 @@ export declare function executeRefillSendsCommand(input?: RefillSendsCommandInpu
         note: string;
     };
     yoloExecution: {
+        enabled: false;
+        status: "not_run_without_yolo";
+        selectedAction: null;
+        targetPlanReread: false;
+        result?: undefined;
+        refusalReason?: undefined;
+        postActionFirstAction?: undefined;
+    } | {
         enabled: true;
         status: "skipped_after_paid_refresh";
         selectedAction: null;