@sellable/mcp 0.1.553 → 0.1.555

package/dist/tools/refill-executors.js

@@ -3,7 +3,7 @@ import { startPrepareCampaignMessages } from "./campaign-message-preparation.js"
 import { startCampaign } from "./campaigns.js";
 import { confirmLeadList, importLeads, searchSignals, selectPromisingPosts, } from "./leads.js";
 import { markProviderPromptLoaded } from "./provider-preflight.js";
-import { runSchedulerSweep } from "./scheduler-run.js";
+import { runSchedulerSweep, } from "./scheduler-run.js";
 import { refreshPaidInmailCredits } from "./senders.js";
 import { workspaceRequestOptions } from "./workspace-context.js";
 const PAID_INMAIL_REFRESH_MAX_ATTEMPTS = 3;
@@ -86,19 +86,87 @@ export function normalizeSchedulerChangedCounts(value) {
     if (groups.reduce((sum, group) => sum + group.count, 0) !== total) {
         return null;
     }
+    if (!Array.isArray(changedCounts.byCampaignTableActionTypeSender)) {
+        return null;
+    }
+    const senderGroups = [];
+    const senderSeen = new Set();
+    for (const rawGroup of changedCounts.byCampaignTableActionTypeSender) {
+        const group = recordValue(rawGroup);
+        const campaignId = stringValue(group?.campaignId);
+        const tableId = stringValue(group?.tableId);
+        const actionType = stringValue(group?.actionType);
+        const senderId = stringValue(group?.senderId);
+        const count = numberValue(group?.count);
+        if (!campaignId ||
+            !tableId ||
+            !actionType ||
+            !senderId ||
+            count === null ||
+            count <= 0 ||
+            !Number.isInteger(count)) {
+            return null;
+        }
+        const key = `${campaignId}:${tableId}:${actionType}:${senderId}`;
+        if (senderSeen.has(key))
+            return null;
+        senderSeen.add(key);
+        senderGroups.push({ campaignId, tableId, actionType, senderId, count });
+    }
+    if (senderGroups.reduce((sum, group) => sum + group.count, 0) !== total) {
+        return null;
+    }
     return {
         complete: true,
         truncated: false,
         total,
         byCampaignTableActionType: groups,
+        byCampaignTableActionTypeSender: senderGroups,
     };
 }
-export function normalizeSchedulerPrimitiveResult(value) {
+function completeExpectedTargetSummary(value, expectedTargets, maxPlacements) {
+    const summary = recordValue(value);
+    const items = Array.isArray(summary?.items) ? summary.items : [];
+    if (summary?.complete !== true ||
+        summary.truncated !== false ||
+        numberValue(summary.requested) !== expectedTargets.length ||
+        numberValue(summary.included) == null ||
+        numberValue(summary.omitted) == null ||
+        numberValue(summary.included) + numberValue(summary.omitted) !==
+            expectedTargets.length ||
+        numberValue(summary.maxPlacements) !== maxPlacements ||
+        items.length !== expectedTargets.length) {
+        return false;
+    }
+    return items.every((rawItem, index) => {
+        const item = recordValue(rawItem);
+        const target = expectedTargets[index];
+        const senderIds = stringArray(item?.senderIds).sort();
+        const bySender = Array.isArray(item?.bySender) ? item.bySender : [];
+        const accounted = bySender
+            .map((entry) => stringValue(recordValue(entry)?.senderId))
+            .filter((senderId) => Boolean(senderId))
+            .sort();
+        return (Boolean(target) &&
+            item?.campaignId === target?.campaignId &&
+            item?.tableId === target?.tableId &&
+            item?.refillLaneKey === target?.refillLaneKey &&
+            (item?.outcome === "included" || item?.outcome === "omitted") &&
+            JSON.stringify(senderIds) === JSON.stringify(target?.senderIds) &&
+            JSON.stringify(accounted) === JSON.stringify(target?.senderIds));
+    });
+}
+export function normalizeSchedulerPrimitiveResult(value, expected) {
     const response = recordValue(value);
     const receipt = recordValue(response?.receipt);
     const changedCounts = normalizeSchedulerChangedCounts(receipt?.changedCounts ?? response?.changedCounts);
+    const targetAuditComplete = !expected ||
+        (receipt?.receiptVersion === 3 &&
+            receipt.expectedTargetsHash === expected.expectedTargetsHash &&
+            receipt.maxPlacements === expected.maxPlacements &&
+            completeExpectedTargetSummary(receipt.expectedTargetSummary, expected.expectedTargets, expected.maxPlacements));
     const schedulerStatus = stringValue(response?.status) ?? stringValue(receipt?.status) ?? "unknown";
-    if (!changedCounts) {
+    if (!changedCounts || !targetAuditComplete) {
         return {
             status: "scheduler_receipt_incomplete",
             schedulerStatus,
@@ -312,7 +380,9 @@ export function classifyPaidInmailRefreshReceipt(value) {
         refreshed,
         error: stringValue(response?.error) ??
             stringValue(nestedReceipt?.error) ??
-            (usableCurrentFacts ? null : "paid InMail credit refresh did not return usable current facts"),
+            (usableCurrentFacts
+                ? null
+                : "paid InMail credit refresh did not return usable current facts"),
     };
 }
 export function firstGlobalAction(plan) {
@@ -856,7 +926,10 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
         case "wait_for_scheduler":
         case "wait_for_active_work":
         case "wait_for_source_import":
-            return { status: "read_only_reread", result: waitResultForAction(action) };
+            return {
+                status: "read_only_reread",
+                result: waitResultForAction(action),
+            };
         case "run_scheduler_sweep": {
             const toolInput = actionToolInput(action);
             const actionWorkspaceId = stringValue(toolInput.workspaceId);
@@ -867,6 +940,11 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
             const targetShapeRevision = stringValue(toolInput.targetShapeRevision);
             const receiptRequirements = recordValue(action.receiptRequirements);
             const receiptGroups = stringArray(receiptRequirements?.groupBy);
+            const expectedTargets = Array.isArray(toolInput.expectedTargets)
+                ? toolInput.expectedTargets
+                : [];
+            const expectedTargetsHash = stringValue(toolInput.expectedTargetsHash);
+            const maxPlacements = numberValue(toolInput.maxPlacements);
             if (!workspaceId ||
                 !actionWorkspaceId ||
                 actionWorkspaceId !== workspaceId ||
@@ -878,7 +956,13 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
                 !targetShapeRevision ||
                 action.workspaceWide !== true ||
                 receiptRequirements?.nonTruncated !== true ||
-                receiptGroups.join(":") !== "campaignId:tableId:actionType") {
+                receiptGroups.join(":") !== "campaignId:tableId:actionType:senderId" ||
+                receiptRequirements?.expectedTargetSummary !== true ||
+                expectedTargets.length === 0 ||
+                !expectedTargetsHash ||
+                maxPlacements === null ||
+                !Number.isInteger(maxPlacements) ||
+                maxPlacements <= 0) {
                 return {
                     status: "refused",
                     refusalReason: "run_scheduler_sweep action is missing exact workspace/date/revision scope or complete receipt requirements",
@@ -890,10 +974,17 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
                 targetDate,
                 requestKey,
                 targetShapeRevision,
+                expectedTargets,
+                expectedTargetsHash,
+                maxPlacements,
             });
             return {
                 status: "executed_and_reread",
-                result: normalizeSchedulerPrimitiveResult(result),
+                result: normalizeSchedulerPrimitiveResult(result, {
+                    expectedTargets,
+                    expectedTargetsHash,
+                    maxPlacements,
+                }),
             };
         }
         case "prepare_messages": {
@@ -917,7 +1008,9 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
                 tableId,
                 ...(workspaceId ? { workspaceId } : {}),
                 targetPreparedMessages,
-                maxRowsToCheck: numberValue(toolInput.maxRowsToCheck) ?? 300,
+                ...(numberValue(toolInput.maxRowsToCheck) != null
+                    ? { maxRowsToCheck: numberValue(toolInput.maxRowsToCheck) }
+                    : {}),
                 approvalMode,
                 rowSelector,
                 ...(excludeRowIds.length > 0 ? { excludeRowIds } : {}),

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

@@ -1,4 +1,4 @@
-type RefillSendsV2Input = {
+export type RefillSendsV2Input = {
     workspaceId?: string;
     runId?: string;
     fence?: number;
@@ -6,6 +6,39 @@ type RefillSendsV2Input = {
     approvalMode?: "approve" | "mark_ready";
     senderIds?: string[];
     intent?: "auto" | "evergreen" | "plain" | "active";
+    targetDate?: string;
+    untilDate?: string;
+    horizonSendDays?: number;
+    scope?: Record<string, unknown>;
+    scopeHash?: string;
+    approval?: Record<string, unknown>;
+    targetPlan?: Record<string, unknown>;
+    approvalEcho?: {
+        scopeHash: string;
+        targetShapeRevision: string;
+        actionFingerprint: string;
+        expectedTargetsHash: string;
+        approvalExpiresAt: string;
+        approvalFingerprint: string;
+    };
+};
+type RefillV2ApprovalPreparationInput = Pick<RefillSendsV2Input, "workspaceId" | "intent" | "senderIds" | "approvalMode" | "targetDate" | "untilDate" | "horizonSendDays"> & {
+    targetPlan: Record<string, unknown>;
+    now?: Date;
+    approvalExpiresAt?: string;
+};
+export declare const REFILL_V2_RUNTIME_IDENTITY: {
+    readonly contract: {
+        readonly version: "2.0.0";
+        readonly hash: string;
+        readonly cacheKey: "refill-contract-v1";
+    };
+    readonly installed: {
+        readonly mcpVersion: "phase98-local";
+        readonly installVersion: "phase98-local";
+        readonly pluginVersion: "phase98-local";
+        readonly cacheIdentity: "phase98-local-plugin-cache";
+    };
 };
 export declare const refillSendsV2ToolDefinitions: {
     name: string;
@@ -44,11 +77,89 @@ export declare const refillSendsV2ToolDefinitions: {
                 type: string;
                 enum: string[];
             };
+            targetDate: {
+                type: string;
+                description: string;
+            };
+            untilDate: {
+                type: string;
+                description: string;
+            };
+            horizonSendDays: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
         additionalProperties: boolean;
     };
 }[];
+export declare function prepareRefillSendsV2Approval(input: RefillV2ApprovalPreparationInput): Promise<{
+    status: "blocked";
+    blocker: string;
+    response: unknown;
+} | {
+    status: "awaiting_approval";
+    runId: string;
+    fence: number;
+    scope: Record<string, unknown> | {
+        version: 2;
+        workspaceId: string;
+        intent: "active" | "plain" | "evergreen" | "auto";
+        senderIds: string[];
+        campaignIds: string[];
+        tableIds: string[];
+        actionIds: string[];
+        approvalMode: "mark_ready" | "approve";
+        dateSelector: {
+            kind: "target_date";
+            targetDate: string;
+            untilDate?: undefined;
+            horizonSendDays?: undefined;
+        } | {
+            kind: "until_date";
+            untilDate: string;
+            targetDate?: undefined;
+            horizonSendDays?: undefined;
+        } | {
+            kind: "horizon_send_days";
+            horizonSendDays: number;
+            targetDate?: undefined;
+            untilDate?: undefined;
+        } | {
+            kind: "scheduler_default";
+            targetDate?: undefined;
+            untilDate?: undefined;
+            horizonSendDays?: undefined;
+        };
+        senderTimezones: {
+            [k: string]: string;
+        };
+        expectedTargetsHash: string;
+        maxPlacements: number;
+        contract: {
+            version: "2.0.0";
+            hash: string;
+            cacheKey: "refill-contract-v1";
+        };
+        installed: {
+            mcpVersion: "phase98-local";
+            installVersion: "phase98-local";
+            pluginVersion: "phase98-local";
+            cacheIdentity: "phase98-local-plugin-cache";
+        };
+    };
+    approvalFingerprint: string;
+    scopeHash: string;
+    targetShapeRevision: string;
+    actionFingerprint: string;
+    expectedTargetsHash: string;
+    sideEffectEnvelope: string[];
+    maxPlacements: number;
+    approvalExpiresAt: string;
+    blocker?: undefined;
+    response?: undefined;
+}>;
 export declare function refillSendsV2Command(input: RefillSendsV2Input): Promise<{
     readOnly: boolean;
     mode: string;

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

@@ -1,11 +1,26 @@
+import { createHash } from "node:crypto";
+import { REFILL_CONTRACT_CACHE_VERSION, REFILL_CONTRACT_HASH, REFILL_CONTRACT_VERSION, renderRefillSafetyGuidance, } from "../refill-contract.js";
 import { appendIndexLine, appendJournalEvent, createRunJournal, renderBootstrapSection, renderCrashedAbandonedSection, renderExecutionEventSection, renderPlanSection, renderTerminalSection, } from "../refill-journal.js";
 import { writeRefillWorkspaceState } from "../refill-local-state.js";
 import { advanceRefillRunGateRemote, completeRefillRun, heartbeatRefillRun, recordRunOutcome, recordRunPlanned, refillRunStatus, startRefillRunRemote, } from "../refill-run-client.js";
 import { runRefillV2Loop } from "../refill-run-loop.js";
-import { getPrepareCampaignMessagesStatus } from "./campaign-message-preparation.js";
+import { getPrepareCampaignMessagesStatus, stopSatisfiedPrepareCampaignMessages, } 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";
+export const REFILL_V2_RUNTIME_IDENTITY = {
+    contract: {
+        version: REFILL_CONTRACT_VERSION,
+        hash: REFILL_CONTRACT_HASH,
+        cacheKey: REFILL_CONTRACT_CACHE_VERSION,
+    },
+    installed: {
+        mcpVersion: "phase98-local",
+        installVersion: "phase98-local",
+        pluginVersion: "phase98-local",
+        cacheIdentity: "phase98-local-plugin-cache",
+    },
+};
 const FORBIDDEN_ACTIONS = [
     "Do not schedule sends.",
     "Do not send messages.",
@@ -18,7 +33,11 @@ const BOUNDED_AUTHORITY = "Within the refill run, bounded approvals, preparation
 export const refillSendsV2ToolDefinitions = [
     {
         name: "refill_sends_v2",
-        description: "Execute the refill sends v2 loop with run-record fencing, packet re-planning, shared refill executors, and resumable dry-run/real-run modes.",
+        description: [
+            "Execute the server-internal refill loop behind public refill_sends; it is retained for dispatch compatibility but is not advertised.",
+            `contractHash=${REFILL_CONTRACT_HASH}`,
+            renderRefillSafetyGuidance(),
+        ].join(" "),
         inputSchema: {
             type: "object",
             properties: {
@@ -51,6 +70,18 @@ export const refillSendsV2ToolDefinitions = [
                     type: "string",
                     enum: ["auto", "evergreen", "plain", "active"],
                 },
+                targetDate: {
+                    type: "string",
+                    description: "Exact sender-local YYYY-MM-DD date.",
+                },
+                untilDate: {
+                    type: "string",
+                    description: "Inclusive sender-local YYYY-MM-DD through-date.",
+                },
+                horizonSendDays: {
+                    type: "number",
+                    description: "Positive sender-local send-day horizon.",
+                },
             },
             required: ["workspaceId"],
             additionalProperties: false,
@@ -68,6 +99,234 @@ function resumeHandle(input) {
         ? { runId: input.runId, fence: input.fence }
         : undefined;
 }
+function validDate(value, field) {
+    const trimmed = value.trim();
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(trimmed) ||
+        new Date(`${trimmed}T00:00:00.000Z`).toISOString().slice(0, 10) !== trimmed) {
+        throw new Error(`${field} must be a valid YYYY-MM-DD date.`);
+    }
+    return trimmed;
+}
+function normalizeDateSelector(input) {
+    const selected = [
+        input.targetDate !== undefined,
+        input.untilDate !== undefined,
+        input.horizonSendDays !== undefined,
+    ].filter(Boolean).length;
+    if (selected > 1) {
+        throw new Error("Provide exactly one refill date selector.");
+    }
+    if (input.targetDate !== undefined) {
+        const targetDate = validDate(input.targetDate, "targetDate");
+        return {
+            dateSelector: { kind: "target_date", targetDate },
+            targetDate,
+        };
+    }
+    if (input.untilDate !== undefined) {
+        const untilDate = validDate(input.untilDate, "untilDate");
+        return {
+            dateSelector: { kind: "until_date", untilDate },
+            untilDate,
+        };
+    }
+    if (input.horizonSendDays !== undefined) {
+        if (!Number.isInteger(input.horizonSendDays) ||
+            input.horizonSendDays <= 0) {
+            throw new Error("horizonSendDays must be a positive integer.");
+        }
+        return {
+            dateSelector: {
+                kind: "horizon_send_days",
+                horizonSendDays: input.horizonSendDays,
+            },
+            horizonSendDays: input.horizonSendDays,
+        };
+    }
+    return { dateSelector: { kind: "scheduler_default" } };
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function text(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function list(value) {
+    return Array.isArray(value) ? value : [];
+}
+function sortedUnique(values) {
+    return [
+        ...new Set(values.filter((value) => Boolean(value))),
+    ].sort((left, right) => left.localeCompare(right));
+}
+function sha256(value) {
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function targetPlanParts(targetPlan) {
+    const target = record(targetPlan.target) ?? {};
+    const plans = list(target.senderRefillPlans)
+        .map(record)
+        .filter((value) => value != null);
+    const actions = list(target.globalActionQueue)
+        .map(record)
+        .filter((value) => value != null);
+    return { target, plans, actions };
+}
+function stableIdsFromTargetPlan(targetPlan, input) {
+    const { plans, actions } = targetPlanParts(targetPlan);
+    const actionRecords = actions.map((action) => ({
+        action,
+        ids: record(action.ids) ?? {},
+        toolInput: record(action.toolInput) ?? {},
+    }));
+    const senderIds = sortedUnique([
+        ...(input.senderIds ?? []),
+        ...plans.map((plan) => text(plan.senderId)),
+        ...actionRecords.map(({ ids, toolInput }) => text(ids.senderId) ?? text(toolInput.senderId)),
+    ]);
+    const campaignIds = sortedUnique(actionRecords.map(({ ids, toolInput }) => text(ids.campaignId) ?? text(toolInput.campaignId)));
+    const tableIds = sortedUnique(actionRecords.map(({ ids, toolInput }) => text(ids.tableId) ?? text(toolInput.tableId)));
+    const actionIds = sortedUnique(actionRecords.map(({ action }) => text(action.actionKey) ?? text(action.type)));
+    const senderTimezones = Object.fromEntries(plans
+        .flatMap((plan) => list(plan.selectedDays))
+        .map(record)
+        .filter((day) => day != null)
+        .map((day) => [
+        text(day.senderId),
+        text(day.senderTimeZone) ?? text(day.timeZone),
+    ])
+        .filter((entry) => entry[0] != null && entry[1] != null)
+        .sort(([left], [right]) => left.localeCompare(right)));
+    return {
+        senderIds,
+        campaignIds,
+        tableIds,
+        actionIds,
+        senderTimezones,
+        actions: actionRecords,
+    };
+}
+function buildApprovalEnvelope(input) {
+    const workspaceId = normalizeWorkspaceId(input.workspaceId);
+    const date = normalizeDateSelector(input);
+    const stable = stableIdsFromTargetPlan(input.targetPlan, input);
+    const schedulerAction = stable.actions.find(({ action }) => action.type === "run_scheduler_sweep");
+    const schedulerInput = schedulerAction?.toolInput ?? {};
+    const expectedTargets = list(schedulerInput.expectedTargets);
+    const expectedTargetsHash = text(schedulerInput.expectedTargetsHash) ?? sha256(expectedTargets);
+    const maxPlacements = typeof schedulerInput.maxPlacements === "number" &&
+        Number.isInteger(schedulerInput.maxPlacements) &&
+        schedulerInput.maxPlacements > 0
+        ? schedulerInput.maxPlacements
+        : 150;
+    const scope = {
+        version: 2,
+        workspaceId,
+        intent: input.intent ?? "auto",
+        senderIds: stable.senderIds,
+        campaignIds: stable.campaignIds,
+        tableIds: stable.tableIds,
+        actionIds: stable.actionIds,
+        approvalMode: input.approvalMode ?? "approve",
+        dateSelector: date.dateSelector,
+        senderTimezones: stable.senderTimezones,
+        expectedTargetsHash,
+        maxPlacements,
+        contract: { ...REFILL_V2_RUNTIME_IDENTITY.contract },
+        installed: { ...REFILL_V2_RUNTIME_IDENTITY.installed },
+    };
+    const scopeHash = sha256(scope);
+    const targetShapeRevision = text(input.targetPlan.targetShapeRevision) ??
+        text(record(input.targetPlan.target)?.targetShapeRevision) ??
+        "missing_target_shape_revision";
+    const actionFingerprint = text(stable.actions[0]?.action.actionKey) ??
+        text(stable.actions[0]?.action.type) ??
+        "no_action";
+    const sideEffectEnvelope = sortedUnique(stable.actions.map(({ action }) => text(action.type)));
+    const approvalExpiresAt = input.approvalExpiresAt ??
+        new Date((input.now ?? new Date()).getTime() + 15 * 60_000).toISOString();
+    const fingerprintFields = {
+        scopeHash,
+        targetShapeRevision,
+        actionFingerprint,
+        expectedTargetsHash,
+        sideEffectEnvelope,
+        maxPlacements,
+        approvalExpiresAt,
+    };
+    const approval = {
+        status: "awaiting_approval",
+        ...fingerprintFields,
+        approvalFingerprint: sha256(fingerprintFields),
+    };
+    return { scope, scopeHash, approval, date };
+}
+export async function prepareRefillSendsV2Approval(input) {
+    const envelope = buildApprovalEnvelope(input);
+    const started = await startRefillRunRemote({
+        workspaceId: envelope.scope.workspaceId,
+        config: {
+            scope: envelope.scope,
+            scopeHash: envelope.scopeHash,
+            approval: envelope.approval,
+        },
+        runState: {
+            version: 1,
+            scope: envelope.scope,
+            scopeHash: envelope.scopeHash,
+            approval: envelope.approval,
+            senderCursors: [],
+            laneCooldowns: [],
+            passRates: [],
+        },
+    });
+    const result = record(started) ?? {};
+    const runId = text(result.runId);
+    const fence = typeof result.fence === "number" && Number.isFinite(result.fence)
+        ? result.fence
+        : null;
+    if (!runId || fence == null) {
+        return {
+            status: "blocked",
+            blocker: text(result.blocker) ?? "approval_run_unavailable",
+            response: started,
+        };
+    }
+    const persistedConfig = record(result.config);
+    const persistedScope = record(persistedConfig?.scope) ?? envelope.scope;
+    const persistedApproval = record(persistedConfig?.approval) ??
+        envelope.approval;
+    return {
+        ...persistedApproval,
+        status: "awaiting_approval",
+        runId,
+        fence,
+        scope: persistedScope,
+    };
+}
+function validateApprovalEcho(envelope, echo, now = new Date()) {
+    const fields = [
+        "scopeHash",
+        "targetShapeRevision",
+        "actionFingerprint",
+        "expectedTargetsHash",
+        "approvalExpiresAt",
+        "approvalFingerprint",
+    ];
+    const changed = fields.filter((field) => echo[field] !== envelope.approval[field]);
+    if (Date.parse(envelope.approval.approvalExpiresAt) <= now.getTime()) {
+        return { ok: false, blocker: "approval_expired", changed };
+    }
+    return changed.length === 0
+        ? { ok: true }
+        : {
+            ok: false,
+            blocker: "approval_fingerprint_mismatch",
+            changed,
+        };
+}
 async function maybeAddLostFenceGuidance(result, input) {
     if (result.status !== "blocked" ||
         result.blocker !== "lease_lost" ||
@@ -94,12 +353,45 @@ async function maybeAddLostFenceGuidance(result, input) {
 }
 export async function refillSendsV2Command(input) {
     const workspaceId = normalizeWorkspaceId(input.workspaceId);
+    const date = normalizeDateSelector(input);
+    let resolvedScope = input.scope;
+    let resolvedScopeHash = input.scopeHash;
+    let resolvedApproval = input.approval;
+    if (input.targetPlan && input.approvalEcho) {
+        const envelope = buildApprovalEnvelope({
+            workspaceId,
+            intent: input.intent,
+            senderIds: input.senderIds,
+            approvalMode: input.approvalMode,
+            targetDate: input.targetDate,
+            untilDate: input.untilDate,
+            horizonSendDays: input.horizonSendDays,
+            targetPlan: input.targetPlan,
+            approvalExpiresAt: input.approvalEcho.approvalExpiresAt,
+        });
+        const validation = validateApprovalEcho(envelope, input.approvalEcho);
+        if (!validation.ok) {
+            return {
+                status: "blocked",
+                blocker: validation.blocker,
+                guidance: "The durable refill approval no longer matches fresh scope; render and approve a new packet before mutation.",
+                report: { changed: validation.changed, fresh: envelope.approval },
+                readOnly: false,
+                forbiddenActions: FORBIDDEN_ACTIONS,
+                boundedAuthority: BOUNDED_AUTHORITY,
+            };
+        }
+        resolvedScope = envelope.scope;
+        resolvedScopeHash = envelope.scopeHash;
+        resolvedApproval = envelope.approval;
+    }
     if (input.dryRun) {
         const plan = await getRefillPlanV2({
             workspaceId,
             intent: input.intent,
             senderIds: input.senderIds,
             journal: true,
+            ...date,
         });
         return {
             ...plan,
@@ -115,6 +407,10 @@ export async function refillSendsV2Command(input) {
         senderIds: input.senderIds,
         approvalMode: input.approvalMode ?? "approve",
         resume: resumeHandle(input),
+        ...date,
+        scope: resolvedScope,
+        scopeHash: resolvedScopeHash,
+        approval: resolvedApproval,
     }, {
         runClient: {
             startRefillRunRemote,
@@ -131,12 +427,16 @@ export async function refillSendsV2Command(input) {
             senderIds: planInput.senderIds,
             runState: planInput.runState,
             journal: planInput.journal,
+            targetDate: planInput.targetDate,
+            untilDate: planInput.untilDate,
+            horizonSendDays: planInput.horizonSendDays,
         }),
         executors: {
             executeOneYoloPrimitive,
             executeStartCampaignPrimitive,
             refreshPaidInmailCreditsWithRetry,
             getPrepareCampaignMessagesStatus,
+            stopSatisfiedPrepareCampaignMessages,
             refillPrepareRequestHash,
             prepareRowSelectorValue,
         },