@sellable/mcp 0.1.553 → 0.1.555

package/dist/tools/refill-sends.js

@@ -1,4 +1,6 @@
 import { actionIds, classifyPaidInmailRefreshReceipt, collectPaidInmailRefreshActions, executeOneYoloPrimitive, firstGlobalAction, normalizeStrings, numberValue, recordValue, refreshPaidInmailCreditsWithRetry, stringValue, } from "./refill-executors.js";
+import { prepareRefillSendsV2Approval, refillSendsV2Command, } from "./refill-sends-v2.js";
+import { REFILL_CONTRACT_CACHE_VERSION, REFILL_CONTRACT_HASH, REFILL_CONTRACT_VERSION, renderRefillBootstrapGuidance, renderRefillSafetyGuidance, renderRefillTerminalGuidance, } from "../refill-contract.js";
 import { getRefillTargetPlan } from "./refill-target-plan.js";
 import { createWorkspaceContext, normalizeExplicitWorkspaceId, } from "./workspace-context.js";
 const REFILL_SEND_ACTION_TYPES = ["send_invite", "send_inmail_closed"];
@@ -94,7 +96,16 @@ function normalizeRefillSendsInput(input) {
 export const refillSendsToolDefinitions = [
     {
         name: "refill_sends",
-        description: "Typed command entrypoint for Sellable refill sends. Accepts --yolo semantics and optional sender selectors, then returns the bounded execution contract for the skill-led refill workflow. In --yolo, it may refresh stale paid InMail credit cache facts once, or execute exactly one safe primitive from target.globalActionQueue[0] (bounded existing-row preparation, bounded generated-message approval, receipt-proven same-source copy, a request-scoped run_scheduler_sweep for an exact date, or a read-only wait) and reread. Same-source copy/source fallback is only safe after receipt-proven exhaustion: hasMoreFrontierRows:false, zero approvalCandidates, no stuckActiveCells, and no non-terminal approvedNotDispatched work. The exact-date sweep may schedule eligible workspace cells through existing product gates; it never sends directly or raw-writes scheduler fields. Wait primitives are gates, not competing goals, and carry absolute wait.deadlineAt when present. It does not run unbounded approval, lower paid InMail thresholds, switch source families, create campaigns, launch, archive, or delete.",
+        description: [
+            "Public durable refill entrypoint. It preserves explicit workspace/date/selectors, renders the normal bounded packet even under yolo, executes one approved primitive, records a typed receipt, rereads, and replans.",
+            "An exact-date request-scoped run_scheduler_sweep may schedule eligible workspace cells through product gates; it never sends directly or raw-writes scheduler fields.",
+            `contractVersion=${REFILL_CONTRACT_VERSION}`,
+            `cacheVersion=${REFILL_CONTRACT_CACHE_VERSION}`,
+            `contractHash=${REFILL_CONTRACT_HASH}`,
+            renderRefillBootstrapGuidance(),
+            renderRefillSafetyGuidance(),
+            renderRefillTerminalGuidance(),
+        ].join(" "),
         inputSchema: {
             type: "object",
             properties: {
@@ -180,6 +191,14 @@ export const refillSendsToolDefinitions = [
                     type: "string",
                     description: "Optional actionKey from the approved packet's first global action. A mismatch returns approval_scope_changed before any refresh or mutation.",
                 },
+                runId: { type: "string" },
+                fence: { type: "number" },
+                scopeHash: { type: "string" },
+                targetShapeRevision: { type: "string" },
+                actionFingerprint: { type: "string" },
+                expectedTargetsHash: { type: "string" },
+                approvalExpiresAt: { type: "string" },
+                approvalFingerprint: { type: "string" },
             },
             required: [],
             additionalProperties: false,
@@ -450,6 +469,51 @@ function paidRefreshOptionsFromApprovalPacket(packet) {
         maxStalenessSeconds: packet.maxStalenessSeconds,
     };
 }
+function durableV2PlanEligible(plan) {
+    const root = recordValue(plan);
+    const target = recordValue(root?.target);
+    const senderPlans = Array.isArray(target?.senderRefillPlans)
+        ? target.senderRefillPlans
+        : [];
+    return Boolean(stringValue(root?.targetShapeRevision) &&
+        senderPlans.some((entry) => {
+            const senderPlan = recordValue(entry);
+            return Array.isArray(senderPlan?.laneLedgers);
+        }));
+}
+function durableApprovalEcho(input) {
+    const values = {
+        scopeHash: stringValue(input.scopeHash),
+        targetShapeRevision: stringValue(input.targetShapeRevision),
+        actionFingerprint: stringValue(input.actionFingerprint),
+        expectedTargetsHash: stringValue(input.expectedTargetsHash),
+        approvalExpiresAt: stringValue(input.approvalExpiresAt),
+        approvalFingerprint: stringValue(input.approvalFingerprint),
+    };
+    return Object.values(values).every(Boolean)
+        ? values
+        : null;
+}
+function durableYoloBaseResult(params) {
+    return {
+        ...params.command,
+        targetPlan: params.targetPlan,
+        targetPlanBeforePaidRefresh: null,
+        targetPlanBeforeYoloPrimitive: params.targetPlan,
+        autoPaidInmailRefresh: {
+            enabled: false,
+            status: "skipped_awaiting_durable_approval",
+            refreshedPaidInmailSenderIds: [],
+            failedPaidInmailRefreshes: [],
+            refreshReceipts: [],
+            attemptedSenderIds: [],
+            targetPlanReread: false,
+            workspaceId: params.workspaceId,
+            workspaceResolution: "explicit",
+            note: "Durable v2 binds approval before credit refresh or any refill primitive.",
+        },
+    };
+}
 export async function executeRefillSendsCommand(input = {}) {
     const normalizedInput = normalizeRefillSendsInput(input);
     const yolo = normalizedInput.yolo === true;
@@ -486,6 +550,7 @@ export async function executeRefillSendsCommand(input = {}) {
                 status: "not_run_without_yolo",
                 refreshedPaidInmailSenderIds: [],
                 failedPaidInmailRefreshes: [],
+                refreshReceipts: [],
                 note: "Automatic paid InMail credit refresh requires --yolo, scheduled mode, or an explicit workspaceId so the request can refresh exact sender facts safely.",
             },
             yoloExecution: {
@@ -513,6 +578,7 @@ export async function executeRefillSendsCommand(input = {}) {
                 status: "skipped_approval_scope_changed",
                 refreshedPaidInmailSenderIds: [],
                 failedPaidInmailRefreshes: [],
+                refreshReceipts: [],
                 attemptedSenderIds: [],
                 targetPlanReread: false,
                 workspaceId,
@@ -527,6 +593,73 @@ export async function executeRefillSendsCommand(input = {}) {
             },
         };
     }
+    if (yolo &&
+        workspaceId &&
+        durableV2PlanEligible(targetPlanBeforePaidRefresh)) {
+        const base = durableYoloBaseResult({
+            command,
+            targetPlan: targetPlanBeforePaidRefresh,
+            workspaceId,
+        });
+        const echo = durableApprovalEcho(scopedInput);
+        if (!scopedInput.approvalFingerprint) {
+            const approval = await prepareRefillSendsV2Approval({
+                workspaceId,
+                intent: scopedInput.intent,
+                senderIds: normalizeStrings(scopedInput.senderIds),
+                approvalMode: scopedInput.approvalMode ?? "approve",
+                targetDate: scopedInput.targetDate ?? undefined,
+                untilDate: scopedInput.untilDate ?? undefined,
+                horizonSendDays: scopedInput.horizonSendDays,
+                targetPlan: targetPlanBeforePaidRefresh,
+            });
+            return {
+                ...base,
+                yoloExecution: {
+                    enabled: true,
+                    ...approval,
+                    selectedAction: firstGlobalAction(targetPlanBeforePaidRefresh),
+                    targetPlanReread: false,
+                },
+            };
+        }
+        if (!echo || !scopedInput.runId || typeof scopedInput.fence !== "number") {
+            return {
+                ...base,
+                ok: false,
+                code: "approval_scope_changed",
+                yoloExecution: {
+                    enabled: true,
+                    status: "approval_scope_changed",
+                    blocker: "approval_echo_incomplete",
+                    selectedAction: firstGlobalAction(targetPlanBeforePaidRefresh),
+                    targetPlanReread: false,
+                },
+            };
+        }
+        const durable = await refillSendsV2Command({
+            workspaceId,
+            runId: scopedInput.runId,
+            fence: scopedInput.fence,
+            intent: scopedInput.intent,
+            senderIds: normalizeStrings(scopedInput.senderIds),
+            approvalMode: scopedInput.approvalMode ?? "approve",
+            targetDate: scopedInput.targetDate ?? undefined,
+            untilDate: scopedInput.untilDate ?? undefined,
+            horizonSendDays: scopedInput.horizonSendDays,
+            targetPlan: targetPlanBeforePaidRefresh,
+            approvalEcho: echo,
+        });
+        return {
+            ...base,
+            yoloExecution: {
+                enabled: true,
+                ...durable,
+                selectedAction: firstGlobalAction(targetPlanBeforePaidRefresh),
+                targetPlanReread: true,
+            },
+        };
+    }
     const refreshActions = collectPaidInmailRefreshActions(targetPlanBeforePaidRefresh);
     const refreshedPaidInmailSenderIds = [];
     const failedPaidInmailRefreshes = [];

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

@@ -11,6 +11,7 @@ const SAFE_PACKET_ACTION_TYPES = new Set([
     "start_paused_campaign",
     "rerun_errored_cells",
     "run_scheduler_sweep",
+    "scheduler_first_settle",
     "wait_for_scheduler",
     "wait_for_active_work",
     "wait_for_source_import",
@@ -84,11 +85,7 @@ const SCHEDULER_SWEEP_FORBIDDEN_SIDE_EFFECTS = [
     "change sender limits",
     "change source selection",
 ];
-const SCHEDULER_SWEEP_RECEIPT_GROUPS = [
-    "campaignId",
-    "tableId",
-    "actionType",
-];
+const SCHEDULER_SWEEP_RECEIPT_GROUPS = ["campaignId", "tableId", "actionType"];
 async function postRefillTargetPlan(body, workspaceId) {
     const api = getApi();
     const requestOptions = workspaceRequestOptions(workspaceId);
@@ -215,14 +212,289 @@ function senderActionKey(senderId, actionType) {
 function sanitizeCounts(counts, selectedKeys) {
     if (!Array.isArray(counts))
         return [];
-    return counts.filter((item) => {
+    return counts
+        .filter((item) => {
         if (!isRecord(item))
             return false;
         const actionType = allowedActionType(item.actionType);
         const key = senderActionKey(item.senderId, actionType);
         return Boolean(key && selectedKeys.has(key));
+    })
+        .map((item) => ({
+        senderId: stringValue(item.senderId),
+        actionType: allowedActionType(item.actionType),
+        refillLaneKey: refillLaneKeyValue(item.refillLaneKey),
+        branchActionType: branchActionTypeValue(item.branchActionType),
+        date: stringValue(item.date),
+        count: nonNegativeNumber(item.count),
+        campaignId: stringValue(item.campaignId),
+        tableId: stringValue(item.tableId),
+    }));
+}
+const REFILL_BRANCH_ACTION_TYPES = new Set([
+    "send_invite",
+    "send_dm",
+    "send_inmail_open",
+    "send_inmail_closed",
+    "react_and_comment",
+]);
+function nonNegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? Math.max(0, value)
+        : 0;
+}
+function refillLaneKeyValue(value) {
+    if (value === "sales_nav_cascade")
+        return value;
+    return allowedActionType(value) ?? undefined;
+}
+function branchActionTypeValue(value) {
+    return typeof value === "string" && REFILL_BRANCH_ACTION_TYPES.has(value)
+        ? value
+        : undefined;
+}
+function sanitizeBranchMetrics(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((metric) => isRecord(metric))
+        .map((metric) => ({
+        actionType: branchActionTypeValue(metric.actionType),
+        count: nonNegativeNumber(metric.count),
+    }))
+        .filter((metric) => Boolean(metric.actionType));
+}
+function sanitizeBranchMetricGroups(value) {
+    if (!isRecord(value)) {
+        return { sentScheduled: [], assignedReady: [], sharedReady: [] };
+    }
+    return {
+        sentScheduled: sanitizeBranchMetrics(value.sentScheduled),
+        assignedReady: sanitizeBranchMetrics(value.assignedReady),
+        sharedReady: sanitizeBranchMetrics(value.sharedReady),
+    };
+}
+function sanitizeLedgerViews(value) {
+    const views = isRecord(value) ? value : {};
+    const raw = isRecord(views.raw) ? views.raw : {};
+    const goalCapped = isRecord(views.goalCapped) ? views.goalCapped : {};
+    const allocatable = isRecord(views.allocatable) ? views.allocatable : {};
+    const unallocatable = isRecord(views.unallocatable)
+        ? views.unallocatable
+        : {};
+    return {
+        raw: {
+            sentScheduled: nonNegativeNumber(raw.sentScheduled),
+            assignedReady: nonNegativeNumber(raw.assignedReady),
+            sharedReady: nonNegativeNumber(raw.sharedReady),
+        },
+        goalCapped: {
+            projected: nonNegativeNumber(goalCapped.projected),
+            ready: nonNegativeNumber(goalCapped.ready),
+            remaining: nonNegativeNumber(goalCapped.remaining),
+        },
+        allocatable: {
+            demand: nonNegativeNumber(allocatable.demand),
+            ready: nonNegativeNumber(allocatable.ready),
+            prepDeficit: nonNegativeNumber(allocatable.prepDeficit),
+        },
+        unallocatable: {
+            assignedReady: nonNegativeNumber(unallocatable.assignedReady),
+            sharedReady: nonNegativeNumber(unallocatable.sharedReady),
+            goalDeficit: nonNegativeNumber(unallocatable.goalDeficit),
+        },
+    };
+}
+function sanitizeIdentityChecks(value) {
+    const checks = isRecord(value) ? value : {};
+    return {
+        assignedConserved: checks.assignedConserved === true,
+        sharedConserved: checks.sharedConserved === true,
+        readyCapped: checks.readyCapped === true,
+        deficitConserved: checks.deficitConserved === true,
+        nonNegative: checks.nonNegative === true,
+    };
+}
+const LEDGER_NUMBER_FIELDS = [
+    "goal",
+    "sentScheduledRawUnique",
+    "goalAfterSentScheduled",
+    "schedulerFillableSlotsFromCandidateSimulation",
+    "preReadyAllocatableDemand",
+    "assignedRawReady",
+    "assignedCreditedReady",
+    "assignedUnallocatableReady",
+    "sharedRawReady",
+    "sharedAllocatedReady",
+    "sharedUnallocatableReady",
+    "readyGoalCredited",
+    "goalCappedProjected",
+    "remainingGoalGap",
+    "initialAllocatablePrepDeficit",
+    "unallocatableGoalDeficit",
+    "matchingCardinality",
+];
+function sanitizeLaneLedger(value, requireScope) {
+    if (!isRecord(value))
+        return null;
+    const senderId = stringValue(value.senderId);
+    const refillLaneKey = refillLaneKeyValue(value.refillLaneKey);
+    const targetDate = stringValue(value.targetDate);
+    if (requireScope && (!senderId || !refillLaneKey || !targetDate))
+        return null;
+    const numbers = Object.fromEntries(LEDGER_NUMBER_FIELDS.map((field) => [
+        field,
+        nonNegativeNumber(value[field]),
+    ]));
+    return {
+        ...(senderId ? { senderId } : {}),
+        ...(refillLaneKey ? { refillLaneKey } : {}),
+        ...(targetDate ? { targetDate } : {}),
+        ...numbers,
+        unmatchedReadyReasons: numericRecord(value.unmatchedReadyReasons),
+        branchMetrics: sanitizeBranchMetricGroups(value.branchMetrics),
+        views: sanitizeLedgerViews(value.views),
+        identityChecks: sanitizeIdentityChecks(value.identityChecks),
+    };
+}
+function sanitizeLaneLedgers(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((ledger) => {
+        const sanitized = sanitizeLaneLedger(ledger, true);
+        return sanitized ? [sanitized] : [];
     });
 }
+function sanitizePhase98RefillContract(value) {
+    if (!isRecord(value))
+        return {};
+    const refillLaneKey = refillLaneKeyValue(value.refillLaneKey);
+    const laneLedgers = sanitizeLaneLedgers(value.laneLedgers);
+    const laneLedgerTotals = sanitizeLaneLedger(value.laneLedgerTotals, false);
+    const settleKey = stringValue(value.settleKey);
+    const settleDeadline = stringValue(value.settleDeadline);
+    const settleBasisRevision = stringValue(value.settleBasisRevision);
+    return {
+        ...(refillLaneKey ? { refillLaneKey } : {}),
+        ...(isRecord(value.branchMetrics)
+            ? { branchMetrics: sanitizeBranchMetricGroups(value.branchMetrics) }
+            : {}),
+        ...(Array.isArray(value.laneLedgers) ? { laneLedgers } : {}),
+        ...(laneLedgerTotals ? { laneLedgerTotals } : {}),
+        ...(settleKey?.startsWith("scheduler_first_settle:") ? { settleKey } : {}),
+        ...(settleDeadline ? { settleDeadline } : {}),
+        ...(settleBasisRevision ? { settleBasisRevision } : {}),
+    };
+}
+function sanitizeSelectedDay(value) {
+    if (!isRecord(value))
+        return null;
+    const senderId = stringValue(value.senderId);
+    const actionType = allowedActionType(value.actionType);
+    if (!senderId || !actionType)
+        return null;
+    return {
+        senderId,
+        senderName: stringValue(value.senderName) ?? senderId,
+        actionType,
+        refillLaneKey: refillLaneKeyValue(value.refillLaneKey),
+        date: stringValue(value.date),
+        timeZone: stringValue(value.timeZone),
+        startUtc: stringValue(value.startUtc),
+        endUtc: stringValue(value.endUtc),
+        limit: nonNegativeNumber(value.limit),
+    };
+}
+function sanitizeSenderPlan(value) {
+    if (!isRecord(value))
+        return null;
+    const senderId = stringValue(value.senderId);
+    const actionType = allowedActionType(value.actionType);
+    if (!senderId || !actionType)
+        return null;
+    const numericFields = [
+        "requestedTarget",
+        "grossTarget",
+        "effectiveTarget",
+        "sent",
+        "scheduled",
+        "projected",
+        "readyBuffer",
+        "remainingScheduledGap",
+        "remainingProjectedGap",
+        "remainingReadyOrProjectedGap",
+        "schedulerFillableSlots",
+        "schedulerCapacityTarget",
+        "remainingSchedulerFillableGap",
+    ];
+    const numbers = Object.fromEntries(numericFields.map((field) => [field, nonNegativeNumber(value[field])]));
+    const campaigns = Array.isArray(value.campaigns)
+        ? value.campaigns
+            .filter((campaign) => isRecord(campaign))
+            .map((campaign) => ({
+            campaignId: stringValue(campaign.campaignId),
+            campaignName: stringValue(campaign.campaignName) ?? "",
+            tableId: stringValue(campaign.tableId),
+            tableName: stringValue(campaign.tableName) ?? null,
+            campaignStatus: stringValue(campaign.campaignStatus) ?? null,
+            classification: campaignClassificationValue(campaign.classification),
+            selectedLeadListId: stringValue(campaign.selectedLeadListId) ?? null,
+            leadSourceProvider: stringValue(campaign.leadSourceProvider) ?? null,
+            sourceFingerprint: stringValue(campaign.sourceFingerprint) ?? null,
+        }))
+        : [];
+    return {
+        senderId,
+        senderName: stringValue(value.senderName) ?? senderId,
+        actionType,
+        ...sanitizePhase98RefillContract(value),
+        selectedDays: Array.isArray(value.selectedDays)
+            ? value.selectedDays
+                .map(sanitizeSelectedDay)
+                .filter((day) => Boolean(day))
+            : [],
+        campaigns,
+        ...numbers,
+        schedulerFillableSlotsKnown: booleanValue(value.schedulerFillableSlotsKnown) ?? undefined,
+        schedulerCapacityMode: stringValue(value.schedulerCapacityMode),
+        allocationScope: stringValue(value.allocationScope),
+        schedulerWarnings: stringArray(value.schedulerWarnings),
+        paidInmail: sanitizePaidInmail(value.paidInmail),
+        refillReceipt: sanitizeRefillReceipt(value.refillReceipt),
+    };
+}
+function sanitizeActionSelection(value) {
+    if (!isRecord(value))
+        return null;
+    const senderId = stringValue(value.senderId);
+    if (!senderId)
+        return null;
+    const evidence = Array.isArray(value.evidence)
+        ? value.evidence
+            .filter((item) => isRecord(item))
+            .map((item) => ({
+            senderId: stringValue(item.senderId),
+            actionType: allowedActionType(item.actionType),
+            refillLaneKey: refillLaneKeyValue(item.refillLaneKey),
+            source: stringValue(item.source),
+            count: nonNegativeNumber(item.count),
+            latestAt: stringValue(item.latestAt),
+            campaignId: stringValue(item.campaignId),
+            tableId: stringValue(item.tableId),
+        }))
+        : [];
+    const refillLaneKeys = Array.isArray(value.refillLaneKeys)
+        ? value.refillLaneKeys.map(refillLaneKeyValue).filter(Boolean)
+        : [];
+    return {
+        senderId,
+        senderName: stringValue(value.senderName) ?? senderId,
+        actionTypes: actionTypesFrom(value.actionTypes),
+        ...(refillLaneKeys.length > 0 ? { refillLaneKeys } : {}),
+        source: stringValue(value.source),
+        evidence,
+    };
+}
 function sanitizeActionCandidates(candidates, selectedKeys, paidRefreshNeededSenderIds, status, remainingReadyOrProjectedGap, remainingProjectedGap) {
     const filtered = Array.isArray(candidates)
         ? candidates
@@ -293,6 +565,7 @@ function sanitizeActionCandidate(candidate) {
             ? "get_refill_target_plan"
             : undefined,
         reason: stringValue(candidate.reason),
+        ...sanitizePhase98RefillContract(candidate),
     };
 }
 function sanitizeRowSelector(value) {
@@ -481,6 +754,16 @@ function sanitizeToolInput(value) {
         wait: sanitizeWait(value.wait),
         refillReceipt: sanitizeRefillReceipt(value.refillReceipt),
         capSaturated: booleanValue(value.capSaturated) === true ? true : undefined,
+        settleKey: stringValue(value.settleKey),
+        settleDeadline: stringValue(value.settleDeadline),
+        settleBasisRevision: stringValue(value.settleBasisRevision),
+        calibration: isRecord(value.calibration)
+            ? {
+                trusted: value.calibration.trusted === true,
+                passRate: optionalNumberValue(value.calibration.passRate),
+                minimumRows: nonNegativeNumber(value.calibration.minimumRows),
+            }
+            : undefined,
     };
 }
 function sanitizePacketIds(value) {
@@ -534,6 +817,7 @@ function sanitizeStructuredAction(action, selectedBySender, mode, rank) {
         actionKey: stringValue(action.actionKey),
         capSaturated: booleanValue(action.capSaturated) === true ? true : undefined,
         prepFailureDiagnosis: sanitizePrepFailureDiagnosis(action.prepFailureDiagnosis),
+        ...sanitizePhase98RefillContract(action),
     };
 }
 function sanitizeLedgerBlockers(value) {
@@ -726,7 +1010,12 @@ function paidInmailRefreshActionForSenderPlan(plan, paidInmail) {
         availableCredits: numberValue(paidInmail?.availableCredits),
         oldThreshold: numberValue(paidInmail?.threshold),
         maxStalenessSeconds: MCP_PAID_INMAIL_CREDITS_MAX_STALENESS_SECONDS,
-        actionKey: ["refresh_paid_inmail_credits", senderId, campaignId, columnId].join(":"),
+        actionKey: [
+            "refresh_paid_inmail_credits",
+            senderId,
+            campaignId,
+            columnId,
+        ].join(":"),
         rereadAfter: "get_refill_target_plan",
         reason: stringValue(paidInmail?.reason) ??
             "MCP paid InMail sender-credit facts require refresh.",
@@ -772,6 +1061,7 @@ function sanitizeStructuredSenderPlans(value, selectedBySender) {
             senderName: stringValue(plan.senderName) ?? "",
             status: stringValue(plan.status) ?? "needs_refill",
             selectedLane: allowedActionType(plan.selectedLane),
+            ...sanitizePhase98RefillContract(plan),
             horizon: isRecord(plan.horizon)
                 ? {
                     selectedDays: Array.isArray(plan.horizon.selectedDays)
@@ -848,15 +1138,10 @@ function sanitizeSchedulerSweepSourceScopes(value) {
         const tableId = stringValue(entry.tableId)?.trim();
         const sourceLeadListId = stringValue(entry.sourceLeadListId)?.trim();
         const leadSourceProvider = stringValue(entry.leadSourceProvider)?.trim();
-        if (!campaignId ||
-            !tableId ||
-            !sourceLeadListId ||
-            !leadSourceProvider) {
+        if (!campaignId || !tableId || !sourceLeadListId || !leadSourceProvider) {
             return [];
         }
-        return [
-            { campaignId, tableId, sourceLeadListId, leadSourceProvider },
-        ];
+        return [{ campaignId, tableId, sourceLeadListId, leadSourceProvider }];
     });
     const unique = new Map(scopes.map((scope) => [
         [
@@ -1100,11 +1385,17 @@ function sanitizeRefillTargetPlanResult(result) {
     const actionTypes = [...new Set(selectedBySender.values())];
     if (selectedKeys.size === 0)
         return emptyUnsupportedResult(result);
-    const senderPlans = rawSenderPlans.filter((plan) => isRecord(plan) &&
-        selectedKeys.has(`${String(plan.senderId)}:${String(plan.actionType)}`));
+    const senderPlans = rawSenderPlans
+        .filter((plan) => isRecord(plan) &&
+        selectedKeys.has(`${String(plan.senderId)}:${String(plan.actionType)}`))
+        .map(sanitizeSenderPlan)
+        .filter((plan) => Boolean(plan));
     const selectedDays = Array.isArray(target.selectedDays)
-        ? target.selectedDays.filter((day) => isRecord(day) &&
+        ? target.selectedDays
+            .filter((day) => isRecord(day) &&
             selectedKeys.has(`${String(day.senderId)}:${String(day.actionType)}`))
+            .map(sanitizeSelectedDay)
+            .filter((day) => Boolean(day))
         : [];
     const actionSelections = rawSelections
         .filter((selection) => isRecord(selection) &&
@@ -1112,15 +1403,17 @@ function sanitizeRefillTargetPlanResult(result) {
         selectedBySender.has(selection.senderId))
         .map((selection) => {
         const actionType = selectedBySender.get(selection.senderId);
-        const evidence = Array.isArray(selection.evidence)
-            ? selection.evidence.filter((item) => isRecord(item) && item.actionType === actionType)
-            : [];
+        const sanitized = sanitizeActionSelection(selection);
+        if (!sanitized)
+            return null;
+        const evidence = sanitized.evidence.filter((item) => item.actionType === actionType);
         return {
-            ...selection,
+            ...sanitized,
             actionTypes: actionType ? [actionType] : [],
             evidence,
         };
-    });
+    })
+        .filter((selection) => Boolean(selection));
     const grossTarget = senderPlans.reduce((sum, plan) => sum + numberValue(plan.grossTarget), 0);
     const requestedTarget = senderPlans.reduce((sum, plan) => sum + numberValue(plan.requestedTarget), 0);
     const effectiveTarget = senderPlans.reduce((sum, plan) => {
@@ -1190,6 +1483,7 @@ function sanitizeRefillTargetPlanResult(result) {
             remainingProjectedGap,
             remainingReadyOrProjectedGap,
             remainingReadyOrScheduledGap: remainingReadyOrProjectedGap,
+            ...sanitizePhase98RefillContract(target),
         },
         coverage: isRecord(result.coverage)
             ? {
@@ -1207,7 +1501,7 @@ function sanitizeRefillTargetPlanResult(result) {
 export const refillTargetPlanToolDefinitions = [
     {
         name: "get_refill_target_plan",
-        description: "read-only refill target planner to call before any refill mutation. It identifies eligible senders and infers one implicit refill lane per sender. For unified Sales Nav cascade campaigns, the public refill lane is the paid-InMail cascade target (send_inmail_closed) with campaign classification sales_nav_cascade; the same campaign can still route prospects to Open InMail or connection-request fallback based on row eligibility and fresh paid credits >= 5. Non-cascade lanes remain connection invites or paid InMails, chosen from future scheduled, recent scheduled, and ready-to-schedule evidence in active campaign-backed sequence campaigns before falling back to campaign sequences. DMs remain follow-up sequence actions, not refill target lanes. By default the planner computes the scheduler-forward 48-hour target window, selected sender-local days whose sending windows overlap that window, gross target, actual sent coverage, scheduler-owned scheduled coverage, projected coverage (sent + scheduled), ready buffer, remaining projected gap, paid InMail credit/threshold/freshness feasibility, same-campaign connection fallback availability, bounded action candidates, and targetRevision drift proof. This tool does not create rows, import leads, prepare messages, approve messages, does not schedule sends, start campaigns, lower paid InMail thresholds, create campaigns, launch, spend InMail credits, or write scheduler fields. Complete projected targets no-op without approval; loaded, awaiting scheduler targets use read-only wait/reread until projected coverage fills.",
+        description: "read-only refill target planner to call before any refill mutation. It identifies eligible senders and infers one implicit refill lane per sender. For unified Sales Nav cascade campaigns with campaign classification sales_nav_cascade, Open InMail, paid InMail, and connection fallback satisfy one sales_nav_cascade goal while branch metrics remain visible; row routing still uses fresh paid credits >= 5 and reports same-campaign connection fallback availability. Campaign and sender names stay primary labels and stable IDs remain execution proof. Non-cascade lanes remain connection invites or paid InMails, chosen from future scheduled, recent scheduled, and ready-to-schedule evidence in active campaign-backed sequence campaigns before falling back to campaign sequences. DMs remain follow-up sequence actions, not refill target lanes. By default the planner computes the scheduler-forward 48-hour target window, selected sender-local days whose sending windows overlap that window, raw coverage, projected coverage (sent + scheduled), goal-capped projected coverage, ready buffer, remaining projected gap, allocatable preparation deficit, unallocatable supply/deficit, paid InMail credit/threshold/freshness feasibility, bounded action candidates, and targetRevision drift proof. A calibrated small gap may return one scheduler_first_settle read-only receipt with a stable key/deadline before bounded preparation. This tool does not create rows, import leads, prepare messages, approve messages, does not schedule sends, start campaigns, lower paid InMail thresholds, create campaigns, launch, spend InMail credits, or write scheduler fields. Complete projected targets no-op without approval; loaded, awaiting scheduler targets use read-only wait/reread until projected coverage fills.",
         inputSchema: {
             type: "object",
             properties: {