@sellable/mcp 0.1.554 → 0.1.556

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

@@ -10,6 +10,8 @@ const SAFE_PACKET_ACTION_TYPES = new Set([
     "approve_messages",
     "start_paused_campaign",
     "rerun_errored_cells",
+    "run_scheduler_sweep",
+    "scheduler_first_settle",
     "wait_for_scheduler",
     "wait_for_active_work",
     "wait_for_source_import",
@@ -73,6 +75,17 @@ const PREP_FAILURE_RECOMMENDED_ACTIONS = new Set([
     "approve_or_repair_approval_cells",
     "inspect_rows",
 ]);
+const SCHEDULER_SWEEP_ALLOWED_SIDE_EFFECTS = [
+    "schedule any eligible workspace cells on the approved date within scheduler gates",
+];
+const SCHEDULER_SWEEP_FORBIDDEN_SIDE_EFFECTS = [
+    "send directly",
+    "write scheduler fields directly",
+    "change campaign state",
+    "change sender limits",
+    "change source selection",
+];
+const SCHEDULER_SWEEP_RECEIPT_GROUPS = ["campaignId", "tableId", "actionType"];
 async function postRefillTargetPlan(body, workspaceId) {
     const api = getApi();
     const requestOptions = workspaceRequestOptions(workspaceId);
@@ -199,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
@@ -277,6 +565,7 @@ function sanitizeActionCandidate(candidate) {
             ? "get_refill_target_plan"
             : undefined,
         reason: stringValue(candidate.reason),
+        ...sanitizePhase98RefillContract(candidate),
     };
 }
 function sanitizeRowSelector(value) {
@@ -465,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) {
@@ -515,8 +814,10 @@ function sanitizeStructuredAction(action, selectedBySender, mode, rank) {
             : null,
         stopCondition: stringValue(action.stopCondition) ?? "",
         yoloEligible,
+        actionKey: stringValue(action.actionKey),
         capSaturated: booleanValue(action.capSaturated) === true ? true : undefined,
         prepFailureDiagnosis: sanitizePrepFailureDiagnosis(action.prepFailureDiagnosis),
+        ...sanitizePhase98RefillContract(action),
     };
 }
 function sanitizeLedgerBlockers(value) {
@@ -709,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.",
@@ -755,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)
@@ -814,6 +1121,149 @@ function buildSanitizedGlobalActionQueue(senderRefillPlans) {
         rank: index + 1,
     }));
 }
+function sortedUniqueStrings(value) {
+    return [...new Set(stringArray(value))].sort();
+}
+function sameStrings(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
+}
+function sanitizeSchedulerSweepSourceScopes(value) {
+    if (!Array.isArray(value))
+        return [];
+    const scopes = value.flatMap((entry) => {
+        if (!isRecord(entry))
+            return [];
+        const campaignId = stringValue(entry.campaignId)?.trim();
+        const tableId = stringValue(entry.tableId)?.trim();
+        const sourceLeadListId = stringValue(entry.sourceLeadListId)?.trim();
+        const leadSourceProvider = stringValue(entry.leadSourceProvider)?.trim();
+        if (!campaignId || !tableId || !sourceLeadListId || !leadSourceProvider) {
+            return [];
+        }
+        return [{ campaignId, tableId, sourceLeadListId, leadSourceProvider }];
+    });
+    const unique = new Map(scopes.map((scope) => [
+        [
+            scope.campaignId,
+            scope.tableId,
+            scope.sourceLeadListId,
+            scope.leadSourceProvider,
+        ].join(":"),
+        scope,
+    ]));
+    return [...unique.values()].sort((a, b) => {
+        if (a.campaignId !== b.campaignId) {
+            return a.campaignId.localeCompare(b.campaignId);
+        }
+        return a.tableId.localeCompare(b.tableId);
+    });
+}
+function sanitizeTargetSchedulerSweep(params) {
+    if (!Array.isArray(params.value) ||
+        !params.expectedWorkspaceId ||
+        !params.expectedTargetDate ||
+        !/^\d{4}-\d{2}-\d{2}$/.test(params.expectedTargetDate) ||
+        !params.expectedTargetShapeRevision ||
+        !params.expectedStateRevision ||
+        params.remainingProjectedGap <= 0 ||
+        params.remainingReadyOrProjectedGap !== 0) {
+        return null;
+    }
+    const expectedSenderIds = [...params.selectedBySender.keys()].sort();
+    const expectedActionTypes = [
+        ...new Set(params.selectedBySender.values()),
+    ].sort();
+    if (expectedSenderIds.length === 0 || expectedActionTypes.length === 0) {
+        return null;
+    }
+    for (const rawAction of params.value) {
+        if (!isRecord(rawAction) || rawAction.type !== "run_scheduler_sweep") {
+            continue;
+        }
+        const input = isRecord(rawAction.toolInput) ? rawAction.toolInput : {};
+        const actionKey = stringValue(rawAction.actionKey)?.trim();
+        const requestKey = stringValue(input.requestKey)?.trim();
+        const senderIds = sortedUniqueStrings(input.senderIds);
+        const actionTypes = sortedUniqueStrings(input.actionTypes).filter((actionType) => allowedActionType(actionType) === actionType);
+        const campaignIds = sortedUniqueStrings(input.campaignIds);
+        const tableIds = sortedUniqueStrings(input.tableIds);
+        const sourceScopes = sanitizeSchedulerSweepSourceScopes(input.sourceScopes);
+        const receiptRequirements = isRecord(rawAction.receiptRequirements)
+            ? rawAction.receiptRequirements
+            : {};
+        const groupBy = stringArray(receiptRequirements.groupBy);
+        const allowedSideEffects = stringArray(rawAction.allowedSideEffects);
+        const forbiddenSideEffects = stringArray(rawAction.forbiddenSideEffects);
+        const rawActionType = allowedActionType(rawAction.actionType);
+        if (input.action !== "run" ||
+            input.workspaceId !== params.expectedWorkspaceId ||
+            input.targetDate !== params.expectedTargetDate ||
+            input.targetDateKey !== params.expectedTargetDate ||
+            input.targetShapeRevision !== params.expectedTargetShapeRevision ||
+            input.stateRevision !== params.expectedStateRevision ||
+            !actionKey ||
+            requestKey !== actionKey ||
+            !sameStrings(senderIds, expectedSenderIds) ||
+            !sameStrings(actionTypes, expectedActionTypes) ||
+            (expectedActionTypes.length === 1 &&
+                rawActionType !== expectedActionTypes[0]) ||
+            campaignIds.length === 0 ||
+            tableIds.length === 0 ||
+            sourceScopes.length === 0 ||
+            sourceScopes.some((scope) => !campaignIds.includes(scope.campaignId) ||
+                !tableIds.includes(scope.tableId)) ||
+            rawAction.toolName !== "run_scheduler_sweep" ||
+            rawAction.sideEffectClass !== "scheduler_placement" ||
+            rawAction.workspaceWide !== true ||
+            rawAction.yoloEligible !== true ||
+            receiptRequirements.nonTruncated !== true ||
+            !sameStrings(groupBy, SCHEDULER_SWEEP_RECEIPT_GROUPS) ||
+            !sameStrings(allowedSideEffects, SCHEDULER_SWEEP_ALLOWED_SIDE_EFFECTS) ||
+            !sameStrings(forbiddenSideEffects, SCHEDULER_SWEEP_FORBIDDEN_SIDE_EFFECTS)) {
+            continue;
+        }
+        return {
+            rank: 1,
+            type: "run_scheduler_sweep",
+            actionType: rawActionType,
+            toolName: "run_scheduler_sweep",
+            sideEffectClass: "scheduler_placement",
+            ids: {},
+            toolInput: {
+                action: "run",
+                workspaceId: params.expectedWorkspaceId,
+                targetDate: params.expectedTargetDate,
+                targetDateKey: params.expectedTargetDate,
+                senderIds,
+                actionTypes,
+                campaignIds,
+                tableIds,
+                sourceScopes,
+                targetShapeRevision: params.expectedTargetShapeRevision,
+                stateRevision: params.expectedStateRevision,
+                requestKey,
+            },
+            inputSummary: stringValue(rawAction.inputSummary) ?? "",
+            reason: stringValue(rawAction.reason) ?? "",
+            prerequisites: stringArray(rawAction.prerequisites),
+            rereadAfter: rawAction.rereadAfter === "get_refill_target_plan"
+                ? "get_refill_target_plan"
+                : null,
+            stopCondition: stringValue(rawAction.stopCondition) ?? "",
+            yoloEligible: true,
+            workspaceWide: true,
+            allowedSideEffects: [...SCHEDULER_SWEEP_ALLOWED_SIDE_EFFECTS],
+            forbiddenSideEffects: [...SCHEDULER_SWEEP_FORBIDDEN_SIDE_EFFECTS],
+            receiptRequirements: {
+                nonTruncated: true,
+                groupBy: [...SCHEDULER_SWEEP_RECEIPT_GROUPS],
+            },
+            actionKey,
+        };
+    }
+    return null;
+}
 function paidRefreshNeededSenderIds(senderRefillPlans) {
     const senderIds = new Set();
     for (const plan of senderRefillPlans) {
@@ -935,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) &&
@@ -947,20 +1403,22 @@ 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) => {
-        const target = typeof plan.schedulerCapacityTarget === "number"
-            ? plan.schedulerCapacityTarget
+        const target = typeof plan.effectiveTarget === "number"
+            ? plan.effectiveTarget
             : numberValue(plan.grossTarget);
         return sum + target;
     }, 0);
@@ -975,7 +1433,20 @@ function sanitizeRefillTargetPlanResult(result) {
     const senderRefillPlans = sanitizeStructuredSenderPlans(target.senderRefillPlans, selectedBySender);
     const paidRefreshNeededSenderIdSet = paidRefreshNeededSenderIds(senderRefillPlans);
     const blockers = sanitizeBlockers(result.blockers, selectedKeys, paidRefreshNeededSenderIdSet);
-    const globalActionQueue = buildSanitizedGlobalActionQueue(senderRefillPlans);
+    const request = isRecord(result.request) ? result.request : {};
+    const schedulerSweepAction = sanitizeTargetSchedulerSweep({
+        value: target.globalActionQueue,
+        selectedBySender,
+        expectedWorkspaceId: stringValue(target.workspaceId),
+        expectedTargetDate: stringValue(request.targetDate),
+        expectedTargetShapeRevision: stringValue(result.targetShapeRevision),
+        expectedStateRevision: stringValue(result.stateRevision),
+        remainingProjectedGap,
+        remainingReadyOrProjectedGap,
+    });
+    const globalActionQueue = schedulerSweepAction
+        ? [schedulerSweepAction]
+        : buildSanitizedGlobalActionQueue(senderRefillPlans);
     const hasTerminalNoActionBlocker = globalActionQueue.length === 0 &&
         blockers.some((blocker) => TERMINAL_NO_ACTION_BLOCKER_CODES.has(String(blocker.code)));
     const status = remainingProjectedGap === 0
@@ -1012,6 +1483,7 @@ function sanitizeRefillTargetPlanResult(result) {
             remainingProjectedGap,
             remainingReadyOrProjectedGap,
             remainingReadyOrScheduledGap: remainingReadyOrProjectedGap,
+            ...sanitizePhase98RefillContract(target),
         },
         coverage: isRecord(result.coverage)
             ? {
@@ -1029,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: {