@sellable/mcp 0.1.553 → 0.1.555

package/dist/refill-run-loop.d.ts

@@ -1,6 +1,6 @@
 import type { appendIndexLine, appendJournalEvent, createRunJournal, renderBootstrapSection, renderCrashedAbandonedSection, renderExecutionEventSection, renderPlanSection, renderTerminalSection } from "./refill-journal.js";
 import type { advanceRefillRunGateRemote, completeRefillRun, heartbeatRefillRun, recordRunOutcome, recordRunPlanned, refillRunStatus, startRefillRunRemote } from "./refill-run-client.js";
-import type { getPrepareCampaignMessagesStatus } from "./tools/campaign-message-preparation.js";
+import type { getPrepareCampaignMessagesStatus, stopSatisfiedPrepareCampaignMessages } from "./tools/campaign-message-preparation.js";
 import type { executeOneYoloPrimitive, executeStartCampaignPrimitive, prepareRowSelectorValue, refillPrepareRequestHash, refreshPaidInmailCreditsWithRetry } from "./tools/refill-executors.js";
 export type RefillLoopGate = "g0_bootstrap" | "g1_plan" | "g2_execute" | "g3_verify" | "g4_terminal";
 export interface RefillV2LoopInput {
@@ -13,6 +13,12 @@ export interface RefillV2LoopInput {
     };
     approvalMode?: "approve" | "mark_ready";
     dryRun?: boolean;
+    targetDate?: string;
+    untilDate?: string;
+    horizonSendDays?: number;
+    scope?: Record<string, unknown>;
+    scopeHash?: string;
+    approval?: Record<string, unknown>;
 }
 export interface RefillV2LoopBudgets {
     maxGateCyclesPerInvocation: number;
@@ -36,6 +42,7 @@ export interface RefillV2Executors {
     executeStartCampaignPrimitive: typeof executeStartCampaignPrimitive;
     refreshPaidInmailCreditsWithRetry: typeof refreshPaidInmailCreditsWithRetry;
     getPrepareCampaignMessagesStatus?: typeof getPrepareCampaignMessagesStatus;
+    stopSatisfiedPrepareCampaignMessages?: typeof stopSatisfiedPrepareCampaignMessages;
     refillPrepareRequestHash?: typeof refillPrepareRequestHash;
     prepareRowSelectorValue?: typeof prepareRowSelectorValue;
 }
@@ -61,6 +68,10 @@ export interface RefillV2LoopDeps {
         senderIds?: string[];
         runState?: Record<string, unknown>;
         journal?: boolean;
+        targetDate?: string;
+        untilDate?: string;
+        horizonSendDays?: number;
+        scopeHash?: string;
     }) => Promise<Record<string, unknown>>;
     executors: RefillV2Executors;
     journal: RefillV2JournalDeps;

package/dist/refill-run-loop.js

@@ -59,6 +59,16 @@ const SCHEDULER_RUN_NEXT_ACTIONS = new Set([
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function planScopeInput(input) {
+    return {
+        ...(input.targetDate ? { targetDate: input.targetDate } : {}),
+        ...(input.untilDate ? { untilDate: input.untilDate } : {}),
+        ...(input.horizonSendDays !== undefined
+            ? { horizonSendDays: input.horizonSendDays }
+            : {}),
+        ...(input.scopeHash ? { scopeHash: input.scopeHash } : {}),
+    };
+}
 function stringValue(value) {
     return typeof value === "string" && value.trim() ? value.trim() : null;
 }
@@ -256,10 +266,8 @@ function sanitizeSchedulerRunReceipt(raw) {
         const prefilteredCells = numberValue(rawReceipt.prefilteredCells) ?? 0;
         const tablesFilteredForSenderMismatch = numberValue(rawReceipt.tablesFilteredForSenderMismatch) ?? 0;
         dominantSkipReason = dominantSchedulerRunSkipReason(skipReasons);
-        dominantPrefilterReason =
-            dominantSchedulerRunCountReason(prefilterReasons);
-        dominantDeferredReason =
-            dominantSchedulerRunSkipReason(deferredReasons);
+        dominantPrefilterReason = dominantSchedulerRunCountReason(prefilterReasons);
+        dominantDeferredReason = dominantSchedulerRunSkipReason(deferredReasons);
         recommendedNextAction = schedulerRunRecommendedAction({
             rawAction: stringValue(rawReceipt.nextAction),
             readyCellsFound,
@@ -429,6 +437,43 @@ function normalizeDoneReason(value) {
 function runStateProgress(ctx) {
     return recordValue(ctx.runState.progress) ?? {};
 }
+function prepCircuitFrom(value) {
+    const root = recordValue(value);
+    const result = recordValue(root?.result);
+    const progress = recordValue(root?.progress);
+    return (recordValue(root?.circuit) ??
+        recordValue(result?.circuit) ??
+        recordValue(progress?.circuit) ??
+        null);
+}
+function openCircuitWaits(circuit, now) {
+    if (stringValue(circuit?.state) !== "open")
+        return false;
+    const nextProbeAt = stringValue(circuit?.nextProbeAt);
+    return Boolean(nextProbeAt && Date.parse(nextProbeAt) > now.getTime());
+}
+function activePreparationScopeSatisfied(plan, action) {
+    const packet = recordValue(plan.packet) ?? plan;
+    const target = recordValue(packet.target) ?? recordValue(plan.target) ?? {};
+    const senderId = actionSenderId(action);
+    const toolInput = actionToolInput(action);
+    const targetDate = stringValue(toolInput.targetDate);
+    const refillLaneKey = stringValue(toolInput.refillLaneKey);
+    const senderPlans = arrayValue(target.senderRefillPlans).filter(isRecord);
+    const ledgers = senderPlans
+        .filter((senderPlan) => !senderId || stringValue(senderPlan.senderId) === senderId)
+        .flatMap((senderPlan) => arrayValue(senderPlan.laneLedgers).filter(isRecord));
+    const matching = ledgers.filter((ledger) => (!senderId || stringValue(ledger.senderId) === senderId) &&
+        (!targetDate || stringValue(ledger.targetDate) === targetDate) &&
+        (!refillLaneKey || stringValue(ledger.refillLaneKey) === refillLaneKey));
+    return (matching.length > 0 &&
+        matching.every((ledger) => {
+            const checks = recordValue(ledger.identityChecks);
+            return (numberValue(ledger.initialAllocatablePrepDeficit) === 0 &&
+                checks != null &&
+                Object.values(checks).every((value) => value === true));
+        }));
+}
 function mergeProgress(ctx, updates) {
     return {
         ...runStateProgress(ctx),
@@ -672,14 +717,28 @@ async function createJournal(input, deps, runId) {
 }
 async function startOrResume(input, deps) {
     const initialRunState = buildRunStateFromLocalHints(input.workspaceId);
+    const scopedInitialRunState = input.scope
+        ? {
+            ...initialRunState,
+            scope: input.scope,
+            scopeHash: input.scopeHash,
+            approval: input.approval,
+        }
+        : initialRunState;
     const started = await deps.runClient.startRefillRunRemote({
         workspaceId: input.workspaceId,
-        config: {
-            intent: input.intent ?? "auto",
-            senderIds: input.senderIds,
-            approvalMode: input.approvalMode ?? "approve",
-        },
-        runState: initialRunState,
+        config: input.scope
+            ? {
+                scope: input.scope,
+                scopeHash: input.scopeHash,
+                approval: input.approval,
+            }
+            : {
+                intent: input.intent ?? "auto",
+                senderIds: input.senderIds,
+                approvalMode: input.approvalMode ?? "approve",
+            },
+        runState: scopedInitialRunState,
         resume: input.resume,
     });
     if (isLeaseLost(started)) {
@@ -712,7 +771,7 @@ async function startOrResume(input, deps) {
     const gate = (stringValue(result.gate) ?? "g0_bootstrap");
     const gateSeq = numberValue(result.gateSeq) ?? 0;
     const runState = recordValue(result.runState) ??
-        recordValue(initialRunState) ??
+        recordValue(scopedInitialRunState) ??
         {
             version: 1,
             senderCursors: [],
@@ -755,6 +814,7 @@ async function gateBootstrap(input, deps, ctx) {
         senderIds: input.senderIds,
         runState: ctx.runState,
         journal: false,
+        ...planScopeInput(input),
     });
     const paidCredit = arrayValue(recordValue(plan.bootstrap)?.paidCredit).filter(isRecord);
     const refreshedSenderIds = new Set(arrayValue(recordValue(ctx.runState.creditTrust)?.senderIds)
@@ -901,6 +961,7 @@ async function gatePlan(input, deps, ctx) {
         senderIds: input.senderIds,
         runState: ctx.runState,
         journal: false,
+        ...planScopeInput(input),
     });
     if (plan.blocker === "workspace_access") {
         return {
@@ -960,6 +1021,17 @@ async function gatePlan(input, deps, ctx) {
         fallbackSummary: line.fallbackSummary,
     }));
     const fingerprint = fingerprintFromPlan(plan);
+    const persistedCircuit = recordValue(runStateProgress(ctx).prepCircuit);
+    if (stringValue(action.type) === "prepare_messages" &&
+        openCircuitWaits(persistedCircuit, deps.now?.() ?? new Date())) {
+        const heartbeat = await heartbeatAndContinue(input, deps, ctx);
+        if (heartbeat.status !== "in_progress")
+            return heartbeat;
+        return {
+            ...heartbeat,
+            guidance: `Preparation circuit remains open until ${String(persistedCircuit?.nextProbeAt)}; re-invoke with this handle after the probe deadline.`,
+        };
+    }
     const noProgress = nextNoProgressState(ctx, plan, action);
     if (noProgress.repeatCount >= 3) {
         return completeTerminal(input, deps, ctx, "blocked", {
@@ -970,10 +1042,17 @@ async function gatePlan(input, deps, ctx) {
             guidance: "The same refill rung repeated three times with no coverage, frontier, or lane movement.",
         });
     }
+    const circuitProgress = stringValue(action.type) === "prepare_messages" &&
+        stringValue(persistedCircuit?.state) === "open"
+        ? { ...persistedCircuit, state: "half_open" }
+        : persistedCircuit;
     const nextRunState = mergeRunState(ctx.runState, {
         lastPlan: fingerprint,
         headAction: action,
-        progress: mergeProgress(ctx, { noProgress }),
+        progress: mergeProgress(ctx, {
+            noProgress,
+            ...(circuitProgress ? { prepCircuit: circuitProgress } : {}),
+        }),
     });
     const advanced = await deps.runClient.advanceRefillRunGateRemote({
         workspaceId: input.workspaceId,
@@ -1010,6 +1089,7 @@ async function verifyRecoveryPoint(input, deps, ctx) {
         senderIds: input.senderIds,
         runState: ctx.runState,
         journal: false,
+        ...planScopeInput(input),
     });
     const changed = fingerprintChanged(expected, fingerprintFromPlan(fresh));
     if (changed.length > 0) {
@@ -1079,6 +1159,9 @@ async function gateExecute(input, deps, ctx) {
         dispatchKey: stringValue(action.type),
         evergreenRung: stringValue(action.evergreenRung),
         sideEffectClass: stringValue(action.sideEffectClass),
+        scopeHash: input.scopeHash ?? null,
+        expectedTargetsHash: stringValue(input.scope?.expectedTargetsHash) ?? null,
+        dateSelector: recordValue(input.scope?.dateSelector),
     };
     const plannedResult = await deps.runClient.recordRunPlanned({
         workspaceId: input.workspaceId,
@@ -1172,6 +1255,12 @@ async function advanceBackToPlan(input, deps, ctx, runStateUpdates = {}) {
 async function verifyPrepareAction(input, deps, ctx, action, budgets) {
     const getStatus = deps.executors.getPrepareCampaignMessagesStatus;
     const jobId = activeJobIdFromOutcome(ctx.runState.lastOutcome);
+    const executionCircuit = prepCircuitFrom(ctx.runState.lastOutcome);
+    if (!jobId && executionCircuit) {
+        return advanceBackToPlan(input, deps, ctx, {
+            progress: mergeProgress(ctx, { prepCircuit: executionCircuit }),
+        });
+    }
     if (!getStatus || !jobId) {
         return {
             status: "in_progress",
@@ -1211,6 +1300,58 @@ async function verifyPrepareAction(input, deps, ctx, action, budgets) {
                 }),
             });
         }
+        if (ownJob &&
+            !isTerminalJobStatus(latestStatus) &&
+            deps.executors.stopSatisfiedPrepareCampaignMessages) {
+            const fresh = await deps.readPlan({
+                workspaceId: input.workspaceId,
+                intent: input.intent,
+                senderIds: input.senderIds,
+                runState: ctx.runState,
+                journal: false,
+                ...planScopeInput(input),
+            });
+            ctx.plan = fresh;
+            if (activePreparationScopeSatisfied(fresh, action)) {
+                const plannedStop = await deps.runClient.recordRunPlanned({
+                    workspaceId: input.workspaceId,
+                    runId: ctx.runId,
+                    fence: ctx.fence,
+                    gate: ctx.gate,
+                    gateSeq: ctx.gateSeq,
+                    planned: {
+                        toolName: "stop_satisfied_campaign_message_preparation",
+                        toolInput: { jobId },
+                        dispatchKey: `stop_satisfied:${jobId}`,
+                        sideEffectClass: "message_preparation_stop",
+                        scopeHash: input.scopeHash ?? null,
+                    },
+                });
+                if (isLeaseLost(plannedStop))
+                    return leaseLostResult(ctx);
+                const stopEventId = stringValue(recordValue(plannedStop)?.eventId) ??
+                    `${ctx.runId}:${ctx.gateSeq}:stop`;
+                const stopReceipt = await deps.executors.stopSatisfiedPrepareCampaignMessages({
+                    workspaceId: input.workspaceId,
+                    jobId,
+                    expectedUpdatedAt: stringValue(statusRecord.updatedAt) ?? undefined,
+                });
+                await deps.runClient.recordRunOutcome({
+                    workspaceId: input.workspaceId,
+                    runId: ctx.runId,
+                    fence: ctx.fence,
+                    eventId: stopEventId,
+                    did: { jobId },
+                    outcome: stopReceipt,
+                });
+                return advanceBackToPlan(input, deps, ctx, {
+                    progress: mergeProgress(ctx, {
+                        prepStopReceipt: stopReceipt,
+                        prepStoppedAt: (deps.now?.() ?? new Date()).toISOString(),
+                    }),
+                });
+            }
+        }
         if (isTerminalJobStatus(latestStatus)) {
             const preparedCount = preparedCountFromStatus(latestStatus);
             const checkedRows = checkedRowsFromStatus(latestStatus);
@@ -1278,6 +1419,7 @@ async function verifyReadOnlyWait(input, deps, ctx, budgets, waitKind) {
             senderIds: input.senderIds,
             runState: ctx.runState,
             journal: false,
+            ...planScopeInput(input),
         });
         ctx.plan = fresh;
         const doneReason = doneReasonFromPlan(fresh);
@@ -1360,6 +1502,7 @@ async function verifySchedulerWait(input, deps, ctx, action, budgets) {
             senderIds: input.senderIds,
             runState: ctx.runState,
             journal: false,
+            ...planScopeInput(input),
         });
         ctx.plan = fresh;
         const doneReason = normalizeDoneReason(doneReasonFromPlan(fresh));
@@ -1422,6 +1565,7 @@ async function gateVerify(input, deps, ctx, budgets) {
         senderIds: input.senderIds,
         runState: ctx.runState,
         journal: false,
+        ...planScopeInput(input),
     });
     ctx.plan = fresh;
     const doneReason = doneReasonFromPlan(fresh);
@@ -1486,7 +1630,7 @@ async function heartbeatAndContinue(input, deps, ctx) {
         runId: ctx.runId,
         fence: ctx.fence,
         gate: ctx.gate,
-        guidance: "Per-invocation gate budget reached. Re-invoke refill_sends_v2 with this runId/fence to continue.",
+        guidance: "Per-invocation gate budget reached. Re-invoke public refill_sends with this durable run handle to continue.",
         journalPath: ctx.journalPath,
     };
 }
@@ -1500,6 +1644,7 @@ export async function runRefillV2Loop(input, deps) {
                 intent: input.intent,
                 senderIds: input.senderIds,
                 journal: true,
+                ...planScopeInput(input),
             });
             return { status: "dry_run", plan };
         }

package/dist/tools/campaign-message-preparation.d.ts

@@ -36,9 +36,16 @@ type StartPrepareMessagesInput = PrepareMessagesBaseInput & {
     requestSource?: string;
     senderId?: string;
     actionType?: string;
+    targetDate?: string;
+    refillLaneKey?: string;
+    sourceEpoch?: string;
 };
 type StatusPrepareMessagesInput = PrepareMessagesBaseInput;
 type CancelPrepareMessagesInput = PrepareMessagesBaseInput;
+type StopSatisfiedPrepareMessagesInput = PrepareMessagesBaseInput & {
+    jobId: string;
+    expectedUpdatedAt?: string;
+};
 export declare const campaignMessagePreparationToolDefinitions: ({
     name: string;
     description: string;
@@ -117,6 +124,18 @@ export declare const campaignMessagePreparationToolDefinitions: ({
                 enum: string[];
                 description: string;
             };
+            targetDate: {
+                type: string;
+                description: string;
+            };
+            refillLaneKey: {
+                type: string;
+                description: string;
+            };
+            sourceEpoch: {
+                type: string;
+                description: string;
+            };
             disableLowPassRateStop: {
                 type: string;
                 description: string;
@@ -126,6 +145,7 @@ export declare const campaignMessagePreparationToolDefinitions: ({
                 description: string;
             };
             jobId?: undefined;
+            expectedUpdatedAt?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -160,13 +180,55 @@ export declare const campaignMessagePreparationToolDefinitions: ({
             autoContinue?: undefined;
             senderId?: undefined;
             actionType?: undefined;
+            targetDate?: undefined;
+            refillLaneKey?: undefined;
+            sourceEpoch?: undefined;
             disableLowPassRateStop?: undefined;
+            expectedUpdatedAt?: undefined;
         };
         additionalProperties: boolean;
         required?: undefined;
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            jobId: {
+                type: string;
+            };
+            expectedUpdatedAt: {
+                type: string;
+                description: string;
+            };
+            workspaceId: {
+                type: string;
+                description?: undefined;
+            };
+            campaignId?: undefined;
+            tableId?: undefined;
+            targetPreparedMessages?: undefined;
+            maxRowsToCheck?: undefined;
+            batchSize?: undefined;
+            maxBatchRows?: undefined;
+            approvalMode?: undefined;
+            rowSelector?: undefined;
+            excludeRowIds?: undefined;
+            autoContinue?: undefined;
+            senderId?: undefined;
+            actionType?: undefined;
+            targetDate?: undefined;
+            refillLaneKey?: undefined;
+            sourceEpoch?: undefined;
+            disableLowPassRateStop?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
 })[];
 export declare function startPrepareCampaignMessages(input: StartPrepareMessagesInput): Promise<unknown>;
 export declare function getPrepareCampaignMessagesStatus(input: StatusPrepareMessagesInput): Promise<unknown>;
 export declare function cancelPrepareCampaignMessages(input: CancelPrepareMessagesInput): Promise<unknown>;
+export declare function stopSatisfiedPrepareCampaignMessages(input: StopSatisfiedPrepareMessagesInput): Promise<unknown>;
 export {};

package/dist/tools/campaign-message-preparation.js

@@ -84,6 +84,18 @@ export const campaignMessagePreparationToolDefinitions = [
                     ],
                     description: "Optional refill-scope send action. InMail scopes treat open and paid InMail as one contact-reuse family.",
                 },
+                targetDate: {
+                    type: "string",
+                    description: "Exact sender-local YYYY-MM-DD refill target date.",
+                },
+                refillLaneKey: {
+                    type: "string",
+                    description: "Normalized refill lane identity from the canonical target plan.",
+                },
+                sourceEpoch: {
+                    type: "string",
+                    description: "Stable source/provider epoch; only a material epoch change resets zero-yield recurrence.",
+                },
                 disableLowPassRateStop: {
                     type: "boolean",
                     description: "Operator override for explicit fill/exhaust requests. When true, keep processing eligible rows even if the enriched sample pass rate is low. Still bounded by targetPreparedMessages and maxRowsToCheck.",
@@ -111,6 +123,23 @@ export const campaignMessagePreparationToolDefinitions = [
             additionalProperties: false,
         },
     },
+    {
+        name: "stop_satisfied_campaign_message_preparation",
+        description: "Cooperatively stop exactly one preparation job after the server rereads its persisted refill scope and proves its allocatable preparation deficit is zero. This never cancels table-wide workflow cells.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                jobId: { type: "string" },
+                expectedUpdatedAt: {
+                    type: "string",
+                    description: "Optional optimistic job updatedAt revision from status.",
+                },
+                workspaceId: { type: "string" },
+            },
+            required: ["jobId"],
+            additionalProperties: false,
+        },
+    },
     {
         name: "cancel_campaign_message_preparation",
         description: "Cancel an active campaign message preparation job and cancel the same pending workflow-table cells that the UI Cancel Pending Cells button would cancel. Launch remains a separate explicit start_campaign step.",
@@ -145,6 +174,9 @@ export function startPrepareCampaignMessages(input) {
         requestSource: input.requestSource,
         senderId: input.senderId,
         actionType: input.actionType,
+        targetDate: input.targetDate,
+        refillLaneKey: input.refillLaneKey,
+        sourceEpoch: input.sourceEpoch,
         ...(workspaceId ? { workspaceId } : {}),
     }, workspaceId ?? undefined);
 }
@@ -168,3 +200,12 @@ export function cancelPrepareCampaignMessages(input) {
         ...(workspaceId ? { workspaceId } : {}),
     }, workspaceId ?? undefined);
 }
+export function stopSatisfiedPrepareCampaignMessages(input) {
+    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
+    return postPrepareMessages({
+        action: "stop_if_target_satisfied",
+        jobId: input.jobId,
+        expectedUpdatedAt: input.expectedUpdatedAt,
+        ...(workspaceId ? { workspaceId } : {}),
+    }, workspaceId ?? undefined);
+}

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

@@ -2,6 +2,9 @@ type GetRefillPlanV2Input = {
     workspaceId?: string;
     intent?: "auto" | "evergreen" | "plain" | "active";
     senderIds?: string[];
+    horizonSendDays?: number;
+    untilDate?: string;
+    targetDate?: string;
     runState?: Record<string, unknown>;
     journal?: boolean;
     journalNote?: string;

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

@@ -2,6 +2,7 @@ import * as path from "node:path";
 import { getApi, SellableApiError } from "../api.js";
 import { appendIndexLine, appendJournalEvent, createRunJournal, renderBootstrapSection, renderPlanSection, renderTerminalSection, } from "../refill-journal.js";
 import { readRefillWorkspaceState } from "../refill-local-state.js";
+import { getRefillTargetPlan } from "./refill-target-plan.js";
 import { normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
 const KNOWN_TOP_LEVEL_FIELDS = [
     "readOnly",
@@ -199,12 +200,24 @@ export async function getRefillPlanV2(input) {
         : buildRunStateFromLocalHints(workspaceId);
     let raw;
     try {
-        raw = await postRefillPlanV2({
-            workspaceId,
-            intent: input.intent ?? "auto",
-            senderIds: input.senderIds,
-            runState,
-        }, workspaceId);
+        const hasExplicitDateSelector = input.targetDate !== undefined ||
+            input.untilDate !== undefined ||
+            input.horizonSendDays !== undefined;
+        raw = hasExplicitDateSelector
+            ? await getRefillTargetPlan({
+                workspaceId,
+                intent: input.intent === "auto" ? undefined : (input.intent ?? undefined),
+                senderIds: input.senderIds,
+                targetDate: input.targetDate,
+                untilDate: input.untilDate,
+                horizonSendDays: input.horizonSendDays,
+            })
+            : await postRefillPlanV2({
+                workspaceId,
+                intent: input.intent ?? "auto",
+                senderIds: input.senderIds,
+                runState,
+            }, workspaceId);
     }
     catch (error) {
         if (!isWorkspaceAccessError(error))
@@ -238,7 +251,16 @@ export async function getRefillPlanV2(input) {
             workspaceResolution: "explicit",
         };
     }
-    const sanitized = sanitizeEvergreenRefillPlanResult(raw);
+    const rawRecord = isRecord(raw) ? raw : {};
+    const target = isRecord(rawRecord.target) ? rawRecord.target : null;
+    const sanitized = sanitizeEvergreenRefillPlanResult(target
+        ? {
+            ...rawRecord,
+            plans: target.senderRefillPlans,
+            globalActionQueue: target.globalActionQueue,
+            packet: rawRecord,
+        }
+        : rawRecord);
     const warnings = Array.isArray(sanitized.warnings)
         ? [...sanitized.warnings]
         : [];

package/dist/tools/prompts.js

@@ -2,6 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { getSkillByName, listSkills, resolveSkillsDir, stripFrontmatter, } from "../skills.js";
 import { markCreateCampaignPromptLoaded, markResearchPromptLoaded, markSenderResearchCompleted, } from "./flow-preflight.js";
+import { validateRefillContractAsset, validateRefillFlowProjection, } from "../refill-contract.js";
 // Chunk size sits below Claude Code's max-token cap on tool results
 // (empirically around ~50k chars — fetch_linkedin_profile breached at
 // 53,295 chars, which forced a python3 chunked-read fallback). 48k gives
@@ -511,6 +512,14 @@ export function getSubskillAsset(subskillName, assetPath, offset, limit) {
         throw new Error(`Unknown subskill asset: ${subskillName}/${cleanAssetPath}`);
     }
     const content = fs.readFileSync(resolved, "utf8");
+    if (subskillName === "refill-sends-workflow" &&
+        cleanAssetPath === "core/contract.v2.json") {
+        validateRefillContractAsset(JSON.parse(content));
+    }
+    if (subskillName === "refill-sends-workflow" &&
+        cleanAssetPath === "core/flow.v1.json") {
+        validateRefillFlowProjection(JSON.parse(content));
+    }
     const chunked = readChunkedContent(content, offset, limit, (nextOffset, safeLimit) => `Continue this same asset load with get_subskill_asset({ subskillName: "${subskillName}", assetPath: "${cleanAssetPath}", offset: ${nextOffset}, limit: ${safeLimit} }) until hasMore is false. Treat all chunks as one asset load; do not use saved local tool-output files or machine-specific paths.`);
     return {
         subskillName,

package/dist/tools/refill-executors.d.ts

@@ -1,4 +1,5 @@
 import { searchSignals } from "./leads.js";
+import { type SchedulerExpectedTargetInput } from "./scheduler-run.js";
 export type RefillSendsApprovalMode = "approve" | "mark_ready";
 export type PaidInmailRefreshAction = {
     senderId: string;
@@ -145,9 +146,16 @@ export type SchedulerChangedCounts = {
     truncated: false;
     total: number;
     byCampaignTableActionType: SchedulerChangedCount[];
+    byCampaignTableActionTypeSender: Array<SchedulerChangedCount & {
+        senderId: string;
+    }>;
 };
 export declare function normalizeSchedulerChangedCounts(value: unknown): SchedulerChangedCounts | null;
-export declare function normalizeSchedulerPrimitiveResult(value: unknown): {
+export declare function normalizeSchedulerPrimitiveResult(value: unknown, expected?: {
+    expectedTargets: SchedulerExpectedTargetInput[];
+    expectedTargetsHash: string;
+    maxPlacements: number;
+}): {
     status: "scheduler_receipt_incomplete";
     schedulerStatus: string;
     receipt: {} | null;