@sellable/mcp 0.1.533 → 0.1.535

package/dist/refill-run-loop.js

@@ -1,6 +1,6 @@
 import { SellableApiError } from "./api.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,
@@ -19,34 +19,6 @@ const REFILL_DONE_REASONS = new Set([
     "not_an_evergreen_workspace",
     "no_refillable_campaigns",
 ]);
-const SCHEDULER_RUN_ENVELOPE_STATUSES = new Set([
-    "ran",
-    "attached",
-    "backoff",
-    "window_closed_noop",
-    "failed",
-]);
-const SCHEDULER_RUN_RECEIPT_STATUSES = new Set([
-    "ran",
-    "window_closed_noop",
-    "failed",
-]);
-const SCHEDULER_RUN_SKIP_REASONS = [
-    "window_closed",
-    "daily_limit",
-    "cooldown",
-    "sender_gate",
-    "credit_threshold",
-    "billing_blocked",
-    "duplicate_lead",
-    "no_senders",
-    "other",
-];
-const SCHEDULER_RUN_HARD_BLOCK_REASONS = new Set([
-    "billing_blocked",
-    "credit_threshold",
-    "cooldown",
-]);
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -68,89 +40,6 @@ function arrayValue(value) {
 function hasBlocker(value, blocker) {
     return isRecord(value) && value.blocker === blocker;
 }
-function schedulerRunSkipReasons(value) {
-    const raw = recordValue(value) ?? {};
-    const normalized = {};
-    for (const reason of SCHEDULER_RUN_SKIP_REASONS) {
-        normalized[reason] = numberValue(raw[reason]) ?? 0;
-    }
-    return normalized;
-}
-function dominantSchedulerRunSkipReason(skipReasons) {
-    let dominant = null;
-    let dominantCount = 0;
-    for (const reason of SCHEDULER_RUN_SKIP_REASONS) {
-        const count = skipReasons[reason] ?? 0;
-        if (count > dominantCount) {
-            dominant = reason;
-            dominantCount = count;
-        }
-    }
-    return dominantCount > 0 ? dominant : null;
-}
-function sanitizeSchedulerRunReceipt(raw) {
-    const envelope = recordValue(raw);
-    if (!envelope)
-        return null;
-    const status = stringValue(envelope.status);
-    if (!status || !SCHEDULER_RUN_ENVELOPE_STATUSES.has(status))
-        return null;
-    const retryAfterMs = envelope.retryAfterMs == null ? null : numberValue(envelope.retryAfterMs);
-    if (envelope.retryAfterMs != null && retryAfterMs == null)
-        return null;
-    const receiptInput = envelope.receipt;
-    let receipt = null;
-    let dominantSkipReason = null;
-    if (receiptInput != null) {
-        const rawReceipt = recordValue(receiptInput);
-        if (!rawReceipt)
-            return null;
-        const receiptStatus = stringValue(rawReceipt.status);
-        if (!receiptStatus || !SCHEDULER_RUN_RECEIPT_STATUSES.has(receiptStatus)) {
-            return null;
-        }
-        const cellsConsidered = numberValue(rawReceipt.cellsConsidered);
-        const cellsScheduled = numberValue(rawReceipt.cellsScheduled);
-        const cellsSkipped = numberValue(rawReceipt.cellsSkipped);
-        const cellsDeferred = numberValue(rawReceipt.cellsDeferred);
-        const tablesFilteredForNoCapacity = numberValue(rawReceipt.tablesFilteredForNoCapacity);
-        if (cellsConsidered == null ||
-            cellsScheduled == null ||
-            cellsSkipped == null ||
-            cellsDeferred == null ||
-            tablesFilteredForNoCapacity == null) {
-            return null;
-        }
-        const skipReasons = schedulerRunSkipReasons(rawReceipt.skipReasons);
-        dominantSkipReason = dominantSchedulerRunSkipReason(skipReasons);
-        receipt = {
-            status: receiptStatus,
-            cellsConsidered,
-            cellsScheduled,
-            cellsSkipped,
-            cellsDeferred,
-            tablesFilteredForNoCapacity,
-            skipReasons,
-        };
-    }
-    return {
-        status,
-        retryAfterMs,
-        receipt,
-        dominantSkipReason,
-        hardBlocked: dominantSkipReason != null &&
-            SCHEDULER_RUN_HARD_BLOCK_REASONS.has(dominantSkipReason),
-    };
-}
-function schedulerRunReceiptIsFreshZeroScheduled(schedulerRunReceipt) {
-    const status = stringValue(schedulerRunReceipt?.status);
-    const fresh = status === "ran" || status === "window_closed_noop";
-    if (!fresh)
-        return false;
-    const receipt = recordValue(schedulerRunReceipt?.receipt);
-    return (status === "window_closed_noop" ||
-        numberValue(receipt?.cellsScheduled) === 0);
-}
 function isLeaseLost(value) {
     return hasBlocker(value, "lease_lost");
 }
@@ -587,22 +476,31 @@ async function gateBootstrap(input, deps, ctx) {
     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 = mergeRunState(ctx.runState, {
         creditTrust: {
             refreshedAt: (deps.now?.() ?? new Date()).toISOString(),
             senderIds: [...refreshedSenderIds],
+            attemptedSenderIds: [...attemptedSenderIds],
             receipts,
         },
     });
@@ -1124,34 +1022,42 @@ async function verifySchedulerWait(input, deps, ctx, action, budgets) {
     const enteredAt = stringValue(progress.schedulerWaitEnteredAt) ??
         (deps.now?.() ?? new Date()).toISOString();
     const jitFired = booleanValue(progress.schedulerJitFired) ?? false;
-    let schedulerRunReceipt = recordValue(progress.schedulerRunReceipt) ?? null;
     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 {
-                schedulerRunReceipt = sanitizeSchedulerRunReceipt(await deps.requestSchedulerRun(input.workspaceId));
-            }
-            catch {
-                schedulerRunReceipt = null;
-            }
+            await deps.requestSchedulerRun(input.workspaceId);
         }
         ctx.runState = mergeRunState(ctx.runState, {
             progress: mergeProgress(ctx, {
                 schedulerWaitEnteredAt: enteredAt,
                 schedulerJitFired: true,
-                ...(schedulerRunReceipt ? { schedulerRunReceipt } : {}),
             }),
         });
     }
-    const zeroScheduledFresh = schedulerRunReceiptIsFreshZeroScheduled(schedulerRunReceipt);
-    // EDGE-2: the on-demand run only executes placement; cron can still process
-    // due/timed-out cells later. We still do one readback, then avoid burning the
-    // 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) {
+    for (let poll = 0; poll < budgets.maxSchedulerReadbacks; poll += 1) {
         const fresh = await deps.readPlan({
             workspaceId: input.workspaceId,
             intent: input.intent,

package/dist/server.js

@@ -45,7 +45,6 @@ import { allTools } from "./tools/registry.js";
 import { getRows, getTableRows, getTableRowsMinimal } from "./tools/rows.js";
 import { addRubricItem, checkRubric, deleteRubricItem, draftRubrics, saveRubrics, selectNecessaryRubrics, updateRubricItem, waitForRubricResults, } from "./tools/rubrics.js";
 import { getSchedulerFillCapacity } from "./tools/scheduler-fill-capacity.js";
-import { runSchedulerSweep } from "./tools/scheduler-run.js";
 import { getSenderRoutingTool, setSenderRoutingTool, } from "./tools/sender-routing.js";
 import { getSender, listSenders, refreshPaidInmailCredits, } from "./tools/senders.js";
 import { attachRecommendedSequence, attachSequence, createWorkflowTable, } from "./tools/sequencer.js";
@@ -236,9 +235,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_scheduler_fill_capacity":
                 result = await getSchedulerFillCapacity(args);
                 break;
-            case "run_scheduler_sweep":
-                result = await runSchedulerSweep(args);
-                break;
             case "refill_sends":
                 result = await executeRefillSendsCommand(args);
                 break;

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

@@ -5,7 +5,6 @@ import { runRefillV2Loop } from "../refill-run-loop.js";
 import { getPrepareCampaignMessagesStatus } from "./campaign-message-preparation.js";
 import { getRefillPlanV2 } from "./evergreen-refill-plan.js";
 import { executeOneYoloPrimitive, executeStartCampaignPrimitive, prepareRowSelectorValue, refillPrepareRequestHash, refreshPaidInmailCreditsWithRetry, } from "./refill-executors.js";
-import { runSchedulerSweep } from "./scheduler-run.js";
 const FORBIDDEN_ACTIONS = [
     "Do not schedule sends.",
     "Do not send messages.",
@@ -153,7 +152,6 @@ export async function refillSendsV2Command(input) {
         localState: {
             writeRefillWorkspaceState,
         },
-        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;

package/dist/tools/refill-sends.js

@@ -1,4 +1,4 @@
-import { actionIds, collectPaidInmailRefreshActions, executeOneYoloPrimitive, firstGlobalAction, normalizeStrings, numberValue, recordValue, refreshPaidInmailCreditsWithRetry, stringValue, } from "./refill-executors.js";
+import { actionIds, classifyPaidInmailRefreshReceipt, collectPaidInmailRefreshActions, executeOneYoloPrimitive, firstGlobalAction, normalizeStrings, numberValue, recordValue, refreshPaidInmailCreditsWithRetry, stringValue, } from "./refill-executors.js";
 import { getRefillTargetPlan } from "./refill-target-plan.js";
 import { createWorkspaceContext, normalizeExplicitWorkspaceId, } from "./workspace-context.js";
 const DEFAULT_SCHEDULER_FORWARD_HOURS = 48;
@@ -231,7 +231,7 @@ export function refillSendsCommand(input = {}) {
             "Fresh reread get_campaign_refill_state immediately before any import, prep, approval, or horizon-fill mutation.",
             "Maintain a target-window saturation ledger per selected sender from get_refill_target_plan: selected days, gross capacity, actual sent counts, future scheduler-owned scheduled counts, projected counts, ready-to-schedule buffer, remaining projected gap, paid InMail threshold feasibility, targetShapeRevision, stateRevision, and next MCP primitive.",
             "Source/fallback primitives require receipt-proven exhaustion: existingRowFrontier.hasMoreFrontierRows:false, approvalCandidates:0, no fresh active prep, no stuckActiveCells, and no non-terminal approvedNotDispatched rows. Treat anomalies, stuckActiveCells, and non-terminal approvedNotDispatched as diagnose-and-report gates, not exhaustion. Terminal approvedNotDispatched blockers may be reported and then the ladder can proceed.",
-            "In --yolo, this tool automatically maintains a run-local refreshedPaidInmailSenderIds set: when the first target plan returns refresh_paid_inmail_credits candidates for selected paid-InMail lanes, it refreshes each exact sender at most once, reruns get_refill_target_plan, and returns the post-refresh targetPlan before any prep/source-copy/bounded-approval/read-only wait action is chosen.",
+            "In manual/non-yolo, scheduled, and --yolo modes, this tool may automatically refresh stale or missing paid-InMail credit facts once per selected sender when the first target plan returns refresh_paid_inmail_credits candidates. This is the only newly allowed automatic write in manual/non-yolo mode; it reruns get_refill_target_plan and returns autoPaidInmailRefresh with attemptedSenderIds, refreshedPaidInmailSenderIds, failedPaidInmailRefreshes, and the post-refresh targetPlan before any prep/source-copy/bounded-approval/read-only wait action is chosen.",
             "Freshness gate precedes scheduler wait: if any selected target.senderRefillPlans[].paidInmail.status is missing_credit_facts or stale_credit_facts, or the target plan contains refresh_paid_inmail_credits, do not enter wait_for_scheduler even when remainingReadyOrProjectedGap is 0; refresh exact sender credit facts once, reread get_refill_target_plan, then choose scheduler wait only if freshness is clean.",
             "For wait_for_active_work and wait_for_scheduler, honor the receipt's absolute wait.deadlineAt when present. If the deadline is expired on this call, escalate to diagnostics with the receipt evidence instead of issuing another blind wait.",
             "Do not present paid-credit refresh as the next operator action after refill_sends returns autoPaidInmailRefresh and the post-refresh targetPlan.",
@@ -374,7 +374,11 @@ export async function executeRefillSendsCommand(input = {}) {
         ? { ...input, workspaceId: workspaceContext.context.workspaceId }
         : input;
     const command = refillSendsCommand(scopedInput);
-    if (!yolo) {
+    const workspaceId = workspaceContext && workspaceContext.ok
+        ? workspaceContext.context.workspaceId
+        : normalizeExplicitWorkspaceId(scopedInput.workspaceId);
+    const canRefreshPaidInmailFacts = yolo || executionMode === "scheduled" || Boolean(workspaceId);
+    if (!canRefreshPaidInmailFacts) {
         return {
             ...command,
             autoPaidInmailRefresh: {
@@ -382,7 +386,7 @@ export async function executeRefillSendsCommand(input = {}) {
                 status: "not_run_without_yolo",
                 refreshedPaidInmailSenderIds: [],
                 failedPaidInmailRefreshes: [],
-                note: "Automatic paid InMail credit refresh only runs for --yolo refill_sends calls.",
+                note: "Automatic paid InMail credit refresh requires --yolo, scheduled mode, or an explicit workspaceId so the request can refresh exact sender facts safely.",
             },
             yoloExecution: {
                 enabled: false,
@@ -392,9 +396,6 @@ export async function executeRefillSendsCommand(input = {}) {
             },
         };
     }
-    const workspaceId = workspaceContext && workspaceContext.ok
-        ? workspaceContext.context.workspaceId
-        : normalizeExplicitWorkspaceId(scopedInput.workspaceId);
     const targetPlanInput = targetPlanInputFor(scopedInput);
     const targetPlanBeforePaidRefresh = await getRefillTargetPlan(targetPlanInput);
     const refreshActions = collectPaidInmailRefreshActions(targetPlanBeforePaidRefresh);
@@ -420,7 +421,7 @@ export async function executeRefillSendsCommand(input = {}) {
         }
         const refreshResult = await refreshPaidInmailCreditsWithRetry(action.senderId, workspaceId, paidRefreshOptionsFromApprovalPacket(approvalPacket));
         if (refreshResult.receipt) {
-            refreshedPaidInmailSenderIds.push(action.senderId);
+            const classification = classifyPaidInmailRefreshReceipt(refreshResult.receipt);
             refreshReceipts.push({
                 senderId: action.senderId,
                 actionKey: action.actionKey ?? null,
@@ -429,7 +430,23 @@ export async function executeRefillSendsCommand(input = {}) {
                 approvalSource: "explicit_yolo_flag",
                 approvalPacket,
                 receipt: refreshResult.receipt,
+                receiptStatus: classification.status,
+                usableCurrentFacts: classification.usableCurrentFacts,
             });
+            if (classification.usableCurrentFacts) {
+                refreshedPaidInmailSenderIds.push(action.senderId);
+            }
+            else {
+                failedPaidInmailRefreshes.push({
+                    senderId: action.senderId,
+                    attempts: refreshResult.attempts,
+                    error: classification.error ??
+                        "paid InMail credit refresh did not return usable current facts",
+                    errors: refreshResult.errors,
+                    receiptStatus: classification.status,
+                    receipt: refreshResult.receipt,
+                });
+            }
         }
         else {
             failedPaidInmailRefreshes.push({
@@ -444,8 +461,8 @@ export async function executeRefillSendsCommand(input = {}) {
     const targetPlan = refreshActions.length > 0
         ? await getRefillTargetPlan(targetPlanInput)
         : targetPlanBeforePaidRefresh;
-    const selectedAction = refreshActions.length > 0 ? null : firstGlobalAction(targetPlan);
-    const primitiveAttempt = refreshActions.length > 0
+    const selectedAction = yolo && refreshActions.length === 0 ? firstGlobalAction(targetPlan) : null;
+    const primitiveAttempt = !yolo || refreshActions.length > 0
         ? null
         : await executeOneYoloPrimitive(selectedAction, workspaceId ?? undefined);
     const shouldRereadAfterPrimitive = primitiveAttempt?.status === "executed_and_reread" ||
@@ -458,7 +475,9 @@ export async function executeRefillSendsCommand(input = {}) {
         ...command,
         targetPlan: finalTargetPlan,
         targetPlanBeforePaidRefresh: refreshActions.length > 0 ? targetPlanBeforePaidRefresh : null,
-        targetPlanBeforeYoloPrimitive: refreshActions.length === 0 && postActionTargetPlan ? targetPlan : null,
+        targetPlanBeforeYoloPrimitive: yolo && refreshActions.length === 0 && postActionTargetPlan
+            ? targetPlan
+            : null,
         autoPaidInmailRefresh: {
             enabled: true,
             status: refreshActions.length === 0
@@ -477,23 +496,30 @@ export async function executeRefillSendsCommand(input = {}) {
                 ? "refill_sends refreshed stale paid InMail credit facts internally with bounded retries, once per sender, then returned the post-refresh targetPlan."
                 : "No stale or missing paid InMail credit refresh candidates were present in the initial target plan.",
         },
-        yoloExecution: refreshActions.length > 0
+        yoloExecution: !yolo
             ? {
-                enabled: true,
-                status: "skipped_after_paid_refresh",
+                enabled: false,
+                status: "not_run_without_yolo",
                 selectedAction: null,
-                targetPlanReread: true,
+                targetPlanReread: false,
             }
-            : {
-                enabled: true,
-                status: primitiveAttempt?.status ?? "no_action",
-                selectedAction,
-                result: primitiveAttempt?.result,
-                targetPlanReread: shouldRereadAfterPrimitive,
-                refusalReason: primitiveAttempt?.refusalReason,
-                postActionFirstAction: postActionTargetPlan
-                    ? firstGlobalAction(postActionTargetPlan)
-                    : null,
-            },
+            : refreshActions.length > 0
+                ? {
+                    enabled: true,
+                    status: "skipped_after_paid_refresh",
+                    selectedAction: null,
+                    targetPlanReread: true,
+                }
+                : {
+                    enabled: true,
+                    status: primitiveAttempt?.status ?? "no_action",
+                    selectedAction,
+                    result: primitiveAttempt?.result,
+                    targetPlanReread: shouldRereadAfterPrimitive,
+                    refusalReason: primitiveAttempt?.refusalReason,
+                    postActionFirstAction: postActionTargetPlan
+                        ? firstGlobalAction(postActionTargetPlan)
+                        : null,
+                },
     };
 }

package/dist/tools/registry.d.ts

@@ -7370,25 +7370,6 @@ export declare const allTools: ({
         };
         required: string[];
     };
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            workspaceId: {
-                type: string;
-                description: string;
-            };
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
 } | {
     name: string;
     description: string;

package/dist/tools/registry.js

@@ -40,7 +40,6 @@ import { refillTargetPlanToolDefinitions } from "./refill-target-plan.js";
 import { rowToolDefinitions } from "./rows.js";
 import { rubricToolDefinitions } from "./rubrics.js";
 import { schedulerFillCapacityToolDefinitions } from "./scheduler-fill-capacity.js";
-import { schedulerRunToolDefinitions } from "./scheduler-run.js";
 import { senderRoutingToolDefinitions } from "./sender-routing.js";
 import { senderToolDefinitions } from "./senders.js";
 import { sequencerToolDefinitions } from "./sequencer.js";
@@ -58,7 +57,6 @@ export const allTools = [
     ...refillPlanV2ToolDefinitions,
     ...refillTargetPlanToolDefinitions,
     ...schedulerFillCapacityToolDefinitions,
-    ...schedulerRunToolDefinitions,
     ...refillSendsToolDefinitions,
     ...refillSendsV2ToolDefinitions,
     ...setupEvergreenCampaignsToolDefinitions,

package/dist/tools/senders.d.ts

@@ -52,16 +52,22 @@ export type PaidInmailCreditStatus = {
 };
 export type RefreshPaidInmailCreditsResponse = {
     senderId: string;
-    refreshed: true;
+    refreshed: boolean;
+    error?: string | null;
     credits: PaidInmailCreditStatus;
-    receipt?: unknown;
+    receipt?: {
+        status?: string;
+        refreshed?: boolean;
+        error?: string;
+        [key: string]: unknown;
+    } | null;
     sideEffects: {
-        refreshedLinkedInDerivedCreditFacts: true;
-        updatedSenderCreditCache: true;
-        campaignMutation: false;
-        schedulerMutation: false;
-        thresholdMutation: false;
-        sendMutation: false;
+        refreshedLinkedInDerivedCreditFacts: boolean;
+        updatedSenderCreditCache: boolean;
+        campaignMutation: boolean;
+        schedulerMutation: boolean;
+        thresholdMutation: boolean;
+        sendMutation: boolean;
     };
 };
 export declare const senderToolDefinitions: ({

package/dist/tools/senders.js

@@ -237,6 +237,21 @@ function normalizeCreditStatus(raw) {
         needsRefresh: raw?.needsRefresh === true,
     };
 }
+function normalizeRefreshReceipt(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    return raw;
+}
+function normalizeCreditRefreshSideEffects(raw, receiptRefreshed) {
+    return {
+        refreshedLinkedInDerivedCreditFacts: raw?.refreshedLinkedInDerivedCreditFacts === true || receiptRefreshed,
+        updatedSenderCreditCache: raw?.updatedSenderCreditCache === true || receiptRefreshed,
+        campaignMutation: raw?.campaignMutation === true,
+        schedulerMutation: raw?.schedulerMutation === true,
+        thresholdMutation: raw?.thresholdMutation === true,
+        sendMutation: raw?.sendMutation === true,
+    };
+}
 export async function refreshPaidInmailCredits(input) {
     const senderId = input.senderId?.trim();
     if (!senderId) {
@@ -268,18 +283,14 @@ export async function refreshPaidInmailCredits(input) {
     if (threshold !== null)
         body.threshold = threshold;
     const result = await api.post(`/api/v3/mcp/senders/${encodeURIComponent(senderId)}/refresh-inmail-credits`, body, requestOptions);
+    const receipt = normalizeRefreshReceipt(result?.receipt);
+    const receiptRefreshed = result?.refreshed === true || receipt?.refreshed === true;
     return {
         senderId,
-        refreshed: true,
+        refreshed: receiptRefreshed,
+        error: pickString(result?.error, receipt?.error),
         credits: normalizeCreditStatus(result?.credits),
-        receipt: result?.receipt,
-        sideEffects: {
-            refreshedLinkedInDerivedCreditFacts: true,
-            updatedSenderCreditCache: true,
-            campaignMutation: false,
-            schedulerMutation: false,
-            thresholdMutation: false,
-            sendMutation: false,
-        },
+        receipt,
+        sideEffects: normalizeCreditRefreshSideEffects(result?.sideEffects, receiptRefreshed),
     };
 }

package/package.json

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

package/skills/refill-sends/SKILL.md

@@ -6,7 +6,6 @@ allowed-tools:
   - mcp__sellable__refill_sends
   - mcp__sellable__get_refill_target_plan
   - mcp__sellable__get_scheduler_fill_capacity
-  - mcp__sellable__run_scheduler_sweep
   - mcp__sellable__refresh_paid_inmail_credits
   - mcp__sellable__get_subskill_asset
   - mcp__sellable__get_auth_status
@@ -115,11 +114,10 @@ or install-time workspace mapping. Pass `workspaceId` on every scheduled or
 `--yolo` refill tool call, including setup/read calls such as
 `refill_sends`, `get_refill_target_plan`, `list_senders`,
 `get_sender_routing`, `resolve_campaign_fill_route`,
-`get_campaign_refill_state`, `get_scheduler_fill_capacity`,
-`run_scheduler_sweep`, and any later refill mutation covered by the packet.
-Missing `workspaceId` in scheduled or `--yolo` mode is a blocker; stop with
-`WORKSPACE_REQUIRED` instead of running against an implicit or guessed
-workspace.
+`get_campaign_refill_state`, `get_scheduler_fill_capacity`, and any later
+refill mutation covered by the packet. Missing `workspaceId` in scheduled or
+`--yolo` mode is a blocker; stop with `WORKSPACE_REQUIRED` instead of running
+against an implicit or guessed workspace.
 
 Do not solve scheduled or `--yolo` workspace uncertainty by changing the shared
 active workspace. Manual interactive workspace switching remains a separate
@@ -271,10 +269,6 @@ need raw proof, call the read-only `get_scheduler_fill_capacity` query for the
 same sender/action/date; it tells the MCP how many cells the product scheduler
 will try to place and does not import, approve, schedule, refresh credits, or
 mutate.
-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
-within existing scheduler gates and returns the receipt, but it never sends or
-bypasses limits.
 If the target plan is complete by projected coverage, report that the selected
 target is already filled and no-op without asking for approval. If the ready
 buffer covers the projected gap, paid InMail credit facts are fresh for every

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

@@ -6,7 +6,6 @@ allowed-tools:
   - mcp__sellable__get_subskill_asset
   - mcp__sellable__get_refill_target_plan
   - mcp__sellable__get_scheduler_fill_capacity
-  - mcp__sellable__run_scheduler_sweep
   - mcp__sellable__refresh_paid_inmail_credits
   - mcp__sellable__list_senders
   - mcp__sellable__get_sender_routing
@@ -68,12 +67,11 @@ request-scoped `workspaceId`. Pass that same `workspaceId` on every refill tool
 call in this workflow: `get_refill_target_plan`, `list_senders`,
 `get_sender_routing`, `resolve_campaign_fill_route`,
 `get_campaign_refill_state`, `get_scheduler_fill_capacity`,
-`run_scheduler_sweep`, `refresh_paid_inmail_credits`, source import/readiness
-calls, preparation calls, approval calls, and campaign start calls. Missing
-`workspaceId` in scheduled or `--yolo` mode is a blocker; return or report
-`WORKSPACE_REQUIRED` instead of falling back to shared config state. Manual
-interactive workspace switching is diagnostic setup only and is not an
-automation control path.
+`refresh_paid_inmail_credits`, source import/readiness calls, preparation calls,
+approval calls, and campaign start calls. Missing `workspaceId` in scheduled or
+`--yolo` mode is a blocker; return or report `WORKSPACE_REQUIRED` instead of
+falling back to shared config state. Manual interactive workspace switching is
+diagnostic setup only and is not an automation control path.
 
 Goal-mode continuation: a skill cannot create or invoke `/goal` by itself. When
 this workflow is already running inside an active Codex goal, keep that goal
@@ -188,10 +186,6 @@ files or memory.
    how many cells the product scheduler will try to place for that sender; it
    does not create rows, import, approve, schedule, refresh paid-InMail credits,
    or mutate thresholds.
-   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.
    If `status:"complete"`, report the target, selected dates, sent count,
    scheduled count, projected count, campaign ids, and no-op proof without
    asking for approval or mutating.

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

@@ -1,28 +0,0 @@
-type RefillSendsEvergreenInput = {
-    workspaceId?: string;
-};
-export declare const refillSendsEvergreenToolDefinitions: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            workspaceId: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-}[];
-export declare function refillSendsEvergreenCommand(input: RefillSendsEvergreenInput): {
-    readOnly: boolean;
-    workspaceId: string | null;
-    firstOperationalSteps: string[];
-    approvalContract: string;
-    forbiddenActions: string[];
-    fillWindow: string;
-    hostExamples: string[];
-};
-export {};

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

@@ -1,47 +0,0 @@
-export const refillSendsEvergreenToolDefinitions = [
-    {
-        name: "refill_sends_evergreen",
-        description: "Read-only Phase 85 evergreen refill command contract. It performs no mutations and only tells the operator to call get_evergreen_refill_plan for a dry-run packet and journal.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                workspaceId: {
-                    type: "string",
-                    description: "Explicit request-scoped workspace id.",
-                },
-            },
-            required: ["workspaceId"],
-            additionalProperties: false,
-        },
-    },
-];
-export function refillSendsEvergreenCommand(input) {
-    return {
-        readOnly: true,
-        workspaceId: input.workspaceId ?? null,
-        firstOperationalSteps: [
-            "Call get_evergreen_refill_plan with the explicit workspaceId.",
-            "Read the returned packet, globalActionQueue, per-sender plans, and itinerary before taking any action.",
-            "Review the dry-run journal file path returned by get_evergreen_refill_plan.",
-            "Phase 85 is PLAN-ONLY; execution arrives in Phase 86.",
-        ],
-        approvalContract: "Nothing is approved or executable in Phase 85. The evergreen command is read-only; Phase 86 introduces execution approval.",
-        forbiddenActions: [
-            "Do not schedule sends.",
-            "Do not send messages.",
-            "Do not approve messages.",
-            "Do not prepare messages.",
-            "Do not start or launch campaigns.",
-            "Do not create campaigns.",
-            "Do not switch providers or source families.",
-            "Do not lower paid InMail thresholds.",
-            "Do not refresh paid InMail credits.",
-            "Do not write scheduler fields.",
-        ],
-        fillWindow: "Use only the target window and caps returned by get_evergreen_refill_plan.",
-        hostExamples: [
-            "refill_sends_evergreen({ workspaceId })",
-            "get_evergreen_refill_plan({ workspaceId })",
-        ],
-    };
-}

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

@@ -1,27 +0,0 @@
-type SchedulerRunAction = "run" | "status";
-type RunSchedulerSweepInput = {
-    workspaceId: string;
-    action?: SchedulerRunAction;
-};
-export declare const schedulerRunToolDefinitions: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            workspaceId: {
-                type: string;
-                description: string;
-            };
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-}[];
-export declare function runSchedulerSweep(input: RunSchedulerSweepInput): Promise<unknown>;
-export {};

package/dist/tools/scheduler-run.js

@@ -1,45 +0,0 @@
-import { getApi } from "../api.js";
-import { normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
-async function postSchedulerRun(body, workspaceId) {
-    const api = getApi();
-    const requestOptions = workspaceRequestOptions(workspaceId);
-    return requestOptions
-        ? api.post("/api/v3/mcp/scheduler-run", body, requestOptions)
-        : api.post("/api/v3/mcp/scheduler-run", body);
-}
-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 returns a synchronous envelope with status ran, attached, backoff, window_closed_noop, or failed; retryAfterMs for backoff replays; and a receipt with cellsConsidered, cellsScheduled, cellsSkipped, cellsDeferred, deterministic skipReasons, and tablesFilteredForNoCapacity. 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.',
-        inputSchema: {
-            type: "object",
-            properties: {
-                workspaceId: {
-                    type: "string",
-                    description: "Explicit request-scoped workspace id for scheduled/yolo refill automation. Pass this instead of switching the shared active workspace.",
-                },
-                action: {
-                    type: "string",
-                    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".',
-                },
-            },
-            required: ["workspaceId"],
-            additionalProperties: false,
-        },
-    },
-];
-export async function runSchedulerSweep(input) {
-    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
-    if (!workspaceId) {
-        throw new Error("workspaceId is required for run_scheduler_sweep.");
-    }
-    const action = input.action ?? "run";
-    if (action !== "run" && action !== "status") {
-        throw new Error('action must be "run" or "status" for run_scheduler_sweep.');
-    }
-    return postSchedulerRun({
-        workspaceId,
-        action,
-    }, workspaceId);
-}