@sellable/mcp 0.1.569-phase981.20260711223346 → 0.1.570

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

@@ -5,11 +5,6 @@ export type RefillRunBlockerResult = {
     runId: string;
     gate?: string;
     gateSeq?: number;
-} | {
-    blocker: "scope_drift" | "approval_expired" | "approval_fingerprint_mismatch";
-    runId: string;
-    expectedScopeHash: string | null;
-    receivedScopeHash: string | null;
 };
 export declare function startRefillRunRemote(input: {
     workspaceId?: string;
@@ -29,11 +24,6 @@ export declare function heartbeatRefillRun(input: {
     runId: string;
     fence: number;
 }): Promise<unknown>;
-export declare function yieldRefillRun(input: {
-    workspaceId?: string;
-    runId: string;
-    fence: number;
-}): Promise<unknown>;
 export declare function advanceRefillRunGateRemote(input: {
     workspaceId?: string;
     runId: string;

package/dist/refill-run-client.js

@@ -15,21 +15,6 @@ function parseBlockerBody(body) {
                 gateSeq: typeof parsed.gateSeq === "number" ? parsed.gateSeq : undefined,
             };
         }
-        if ((parsed.blocker === "scope_drift" ||
-            parsed.blocker === "approval_expired" ||
-            parsed.blocker === "approval_fingerprint_mismatch") &&
-            typeof parsed.runId === "string") {
-            return {
-                blocker: parsed.blocker,
-                runId: parsed.runId,
-                expectedScopeHash: typeof parsed.expectedScopeHash === "string"
-                    ? parsed.expectedScopeHash
-                    : null,
-                receivedScopeHash: typeof parsed.receivedScopeHash === "string"
-                    ? parsed.receivedScopeHash
-                    : null,
-            };
-        }
     }
     catch {
         return null;
@@ -70,13 +55,6 @@ export function heartbeatRefillRun(input) {
         fence: input.fence,
     });
 }
-export function yieldRefillRun(input) {
-    return postRefillRuns(input.workspaceId, {
-        action: "yield",
-        runId: input.runId,
-        fence: input.fence,
-    });
-}
 export function advanceRefillRunGateRemote(input) {
     return postRefillRuns(input.workspaceId, {
         action: "advance-gate",

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, yieldRefillRun } from "./refill-run-client.js";
-import type { getPrepareCampaignMessagesStatus, stopSatisfiedPrepareCampaignMessages } from "./tools/campaign-message-preparation.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 { 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,12 +13,6 @@ 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;
@@ -32,7 +26,6 @@ export interface RefillV2RunClient {
     startRefillRunRemote: typeof startRefillRunRemote;
     refillRunStatus: typeof refillRunStatus;
     heartbeatRefillRun: typeof heartbeatRefillRun;
-    yieldRefillRun: typeof yieldRefillRun;
     advanceRefillRunGateRemote: typeof advanceRefillRunGateRemote;
     recordRunPlanned: typeof recordRunPlanned;
     recordRunOutcome: typeof recordRunOutcome;
@@ -43,7 +36,6 @@ export interface RefillV2Executors {
     executeStartCampaignPrimitive: typeof executeStartCampaignPrimitive;
     refreshPaidInmailCreditsWithRetry: typeof refreshPaidInmailCreditsWithRetry;
     getPrepareCampaignMessagesStatus?: typeof getPrepareCampaignMessagesStatus;
-    stopSatisfiedPrepareCampaignMessages?: typeof stopSatisfiedPrepareCampaignMessages;
     refillPrepareRequestHash?: typeof refillPrepareRequestHash;
     prepareRowSelectorValue?: typeof prepareRowSelectorValue;
 }
@@ -69,10 +61,6 @@ 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,16 +59,6 @@ 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;
 }
@@ -266,8 +256,10 @@ 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,
@@ -361,17 +353,11 @@ function actionSenderId(action) {
 }
 function fingerprintFromPlan(plan) {
     const packet = recordValue(plan.packet) ?? {};
-    const targetShapeRevision = stringValue(packet.targetShapeRevision) ??
-        stringValue(packet.targetRevision) ??
-        stringValue(plan.targetShapeRevision) ??
-        stringValue(plan.targetRevision);
     return {
-        // Evergreen packets carry their own semantic plan revision. Regular
-        // active-campaign packets intentionally do not, so their immutable target
-        // shape is the durable planning revision for fencing and recovery.
-        planRevision: stringValue(plan.planRevision) ?? targetShapeRevision,
+        planRevision: stringValue(plan.planRevision),
         stateRevision: stringValue(plan.stateRevision) ?? stringValue(packet.stateRevision),
-        targetShapeRevision,
+        targetShapeRevision: stringValue(packet.targetShapeRevision) ??
+            stringValue(packet.targetRevision),
     };
 }
 function fingerprintChanged(expected, actual) {
@@ -443,43 +429,6 @@ 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),
@@ -723,28 +672,14 @@ 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: input.scope
-            ? {
-                scope: input.scope,
-                scopeHash: input.scopeHash,
-                approval: input.approval,
-            }
-            : {
-                intent: input.intent ?? "auto",
-                senderIds: input.senderIds,
-                approvalMode: input.approvalMode ?? "approve",
-            },
-        runState: scopedInitialRunState,
+        config: {
+            intent: input.intent ?? "auto",
+            senderIds: input.senderIds,
+            approvalMode: input.approvalMode ?? "approve",
+        },
+        runState: initialRunState,
         resume: input.resume,
     });
     if (isLeaseLost(started)) {
@@ -777,7 +712,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(scopedInitialRunState) ??
+        recordValue(initialRunState) ??
         {
             version: 1,
             senderCursors: [],
@@ -820,7 +755,6 @@ 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)
@@ -967,7 +901,6 @@ async function gatePlan(input, deps, ctx) {
         senderIds: input.senderIds,
         runState: ctx.runState,
         journal: false,
-        ...planScopeInput(input),
     });
     if (plan.blocker === "workspace_access") {
         return {
@@ -1027,17 +960,6 @@ 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", {
@@ -1048,17 +970,10 @@ 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,
-            ...(circuitProgress ? { prepCircuit: circuitProgress } : {}),
-        }),
+        progress: mergeProgress(ctx, { noProgress }),
     });
     const advanced = await deps.runClient.advanceRefillRunGateRemote({
         workspaceId: input.workspaceId,
@@ -1095,7 +1010,6 @@ 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) {
@@ -1165,9 +1079,6 @@ 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,
@@ -1261,12 +1172,6 @@ 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",
@@ -1306,58 +1211,6 @@ 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);
@@ -1425,7 +1278,6 @@ 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);
@@ -1508,7 +1360,6 @@ 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));
@@ -1571,7 +1422,6 @@ async function gateVerify(input, deps, ctx, budgets) {
         senderIds: input.senderIds,
         runState: ctx.runState,
         journal: false,
-        ...planScopeInput(input),
     });
     ctx.plan = fresh;
     const doneReason = doneReasonFromPlan(fresh);
@@ -1624,19 +1474,19 @@ function classifyCaughtError(error, ctx) {
     };
 }
 async function heartbeatAndContinue(input, deps, ctx) {
-    const yielded = await deps.runClient.yieldRefillRun({
+    const heartbeat = await deps.runClient.heartbeatRefillRun({
         workspaceId: input.workspaceId,
         runId: ctx.runId,
         fence: ctx.fence,
     });
-    if (isLeaseLost(yielded))
+    if (isLeaseLost(heartbeat))
         return leaseLostResult(ctx);
     return {
         status: "in_progress",
         runId: ctx.runId,
         fence: ctx.fence,
         gate: ctx.gate,
-        guidance: "Per-invocation gate budget reached. Re-invoke public refill_sends with this durable run handle to continue.",
+        guidance: "Per-invocation gate budget reached. Re-invoke refill_sends_v2 with this runId/fence to continue.",
         journalPath: ctx.journalPath,
     };
 }
@@ -1650,7 +1500,6 @@ 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,16 +36,9 @@ 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;
@@ -124,18 +117,6 @@ 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;
@@ -145,7 +126,6 @@ export declare const campaignMessagePreparationToolDefinitions: ({
                 description: string;
             };
             jobId?: undefined;
-            expectedUpdatedAt?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -180,55 +160,13 @@ 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,18 +84,6 @@ 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.",
@@ -123,23 +111,6 @@ 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.",
@@ -174,9 +145,6 @@ 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);
 }
@@ -200,12 +168,3 @@ 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,9 +2,6 @@ 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,7 +2,6 @@ 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",
@@ -200,24 +199,12 @@ export async function getRefillPlanV2(input) {
         : buildRunStateFromLocalHints(workspaceId);
     let raw;
     try {
-        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);
+        raw = await postRefillPlanV2({
+            workspaceId,
+            intent: input.intent ?? "auto",
+            senderIds: input.senderIds,
+            runState,
+        }, workspaceId);
     }
     catch (error) {
         if (!isWorkspaceAccessError(error))
@@ -251,16 +238,7 @@ export async function getRefillPlanV2(input) {
             workspaceResolution: "explicit",
         };
     }
-    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 sanitized = sanitizeEvergreenRefillPlanResult(raw);
     const warnings = Array.isArray(sanitized.warnings)
         ? [...sanitized.warnings]
         : [];