@sellable/mcp 0.1.540 → 0.1.541

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,
@@ -380,16 +379,9 @@ 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(packet.doneReason) ??
-        stringValue(plan.doneReason) ??
-        (status === "complete" ? "complete" : null) ??
-        (status === "awaiting_scheduler_after_ready_buffer"
-            ? "loaded_awaiting_scheduler"
-            : null) ??
-        (status === "blocked" ? "blocked" : null));
+        stringValue(recordValue(plan.packet)?.doneReason) ??
+        stringValue(plan.doneReason));
 }
 function selectedLaneAuthority(plan, action) {
     const senderId = actionSenderId(action);
@@ -425,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)
@@ -642,21 +599,17 @@ function getPlanLine(plan) {
     };
 }
 function packetCoherenceFailure(plan) {
+    const fingerprint = fingerprintFromPlan(plan);
+    if (!fingerprint.planRevision || !fingerprint.targetShapeRevision) {
+        return "missing_fingerprint";
+    }
     const action = firstAction(plan);
     const doneReason = doneReasonFromPlan(plan);
     if (doneReason && action && action.type !== "done") {
-        const type = stringValue(action.type);
-        if (!(doneReason === "loaded_awaiting_scheduler" &&
-            type === "wait_for_scheduler")) {
-            return "terminal_with_action_queue";
-        }
+        return "terminal_with_action_queue";
     }
     if (!action)
         return null;
-    const fingerprint = fingerprintFromPlan(plan);
-    if (!fingerprint.planRevision || !fingerprint.targetShapeRevision) {
-        return "missing_fingerprint";
-    }
     const toolInput = actionToolInput(action);
     const type = stringValue(action.type);
     if (type === "prepare_messages" &&
@@ -717,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,
@@ -815,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,
@@ -829,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,
@@ -849,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 ?? []),
@@ -981,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",
@@ -1085,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({
@@ -1347,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) {
@@ -1380,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;
@@ -1423,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") {
@@ -1480,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) {
@@ -1554,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/server.js

@@ -319,7 +319,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 break;
             case "start_campaign":
-                result = await startCampaign(args?.campaignId);
+                result = await startCampaign(args?.campaignId, args?.workspaceId);
                 if (args?.campaignId && result?.success) {
                     markCampaignContextDirty(args.campaignId, "start_campaign");
                 }

package/dist/tools/campaigns.d.ts

@@ -185,6 +185,7 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
+            workspaceId?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -223,6 +224,7 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
+            workspaceId?: undefined;
         };
         required: never[];
         additionalProperties?: undefined;
@@ -261,6 +263,7 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
+            workspaceId?: undefined;
         };
         required: string[];
         additionalProperties?: undefined;
@@ -342,6 +345,7 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
+            workspaceId?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -536,6 +540,7 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
+            workspaceId?: undefined;
         };
         required: never[];
         additionalProperties?: undefined;
@@ -741,6 +746,49 @@ export declare const campaignToolDefinitions: ({
             clientProspectId?: undefined;
             senderLinkedinUrl?: undefined;
             messageGenerationMode?: undefined;
+            workspaceId?: undefined;
+        };
+        required: string[];
+        additionalProperties?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignId: {
+                type: string;
+                description: string;
+            };
+            workspaceId: {
+                type: string;
+                description: string;
+            };
+            limit?: undefined;
+            tableId?: undefined;
+            leadLimit?: undefined;
+            page?: undefined;
+            filters?: undefined;
+            name?: undefined;
+            clientProspectId?: undefined;
+            senderLinkedinUrl?: undefined;
+            offerPositioning?: undefined;
+            campaignBrief?: undefined;
+            messageGenerationMode?: undefined;
+            currentStep?: undefined;
+            watchNarration?: undefined;
+            leadSourceType?: undefined;
+            leadSourceProvider?: undefined;
+            selectedLeadListId?: undefined;
+            senderIds?: undefined;
+            currentStepTransition?: undefined;
+            clearCurrentStepIfMatches?: undefined;
+            interactionMode?: undefined;
+            enableICPFilters?: undefined;
+            useMessagingTemplate?: undefined;
+            rubric?: undefined;
+            flowVersion?: undefined;
         };
         required: string[];
         additionalProperties?: undefined;
@@ -782,6 +830,7 @@ export declare const campaignToolDefinitions: ({
             useMessagingTemplate?: undefined;
             rubric?: undefined;
             flowVersion?: undefined;
+            workspaceId?: undefined;
         };
         required: string[];
         additionalProperties?: undefined;
@@ -821,7 +870,7 @@ export interface UpdateCampaignResult {
     _campaign?: CampaignOfferNavigation;
 }
 export declare function updateCampaign(campaignId: string, input: UpdateCampaignInput): Promise<UpdateCampaignResult>;
-export declare function startCampaign(campaignId: string): Promise<{
+export declare function startCampaign(campaignId: string, workspaceId?: string | null): Promise<{
     success: boolean;
 }>;
 export declare function pauseCampaign(campaignId: string): Promise<{

package/dist/tools/campaigns.js

@@ -476,6 +476,10 @@ export const campaignToolDefinitions = [
                     type: "string",
                     description: "Campaign ID to start",
                 },
+                workspaceId: {
+                    type: "string",
+                    description: "Optional explicit request-scoped workspace id. Pass this for scheduled/yolo refill automation instead of relying on the shared active workspace.",
+                },
             },
             required: ["campaignId"],
         },
@@ -1026,9 +1030,9 @@ export async function updateCampaign(campaignId, input) {
         _campaign: result,
     };
 }
-export async function startCampaign(campaignId) {
+export async function startCampaign(campaignId, workspaceId) {
     const api = getApi();
-    return api.post(`/api/v3/campaigns/${campaignId}/start`);
+    return api.post(`/api/v3/campaigns/${campaignId}/start`, undefined, workspaceId ? { workspaceId } : undefined);
 }
 export async function pauseCampaign(campaignId) {
     const api = getApi();

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>;