@sellable/mcp 0.1.507 → 0.1.509

package/dist/tools/refill-sends.js

@@ -1,15 +1,19 @@
+import { getApi, SellableApiError } from "../api.js";
+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 { getRefillTargetPlan } from "./refill-target-plan.js";
-import { getPrepareCampaignMessagesStatus, startPrepareCampaignMessages, } from "./campaign-message-preparation.js";
 import { refreshPaidInmailCredits } from "./senders.js";
-import { createWorkspaceContext, normalizeExplicitWorkspaceId, } from "./workspace-context.js";
+import { createWorkspaceContext, normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
 const DEFAULT_SCHEDULER_FORWARD_HOURS = 48;
-const PREPARE_POLL_INTERVAL_MS = 5_000;
-const PREPARE_POLL_TIMEOUT_MS = 120_000;
-const TERMINAL_PREPARE_STATUSES = new Set([
-    "succeeded",
-    "failed",
-    "cancelled",
-]);
+const PAID_INMAIL_REFRESH_MAX_ATTEMPTS = 3;
+const PAID_INMAIL_REFRESH_RETRY_DELAY_MS = Number(process.env.SELLABLE_MCP_PAID_REFRESH_RETRY_DELAY_MS ?? "1000");
+const SIGNAL_DISCOVERY_MIN_REFILL_POSTS = 3;
+const SIGNAL_DISCOVERY_MAX_REFILL_POSTS = 10;
+const SIGNAL_DISCOVERY_TARGET_ROWS_PER_POST = 150;
+const YOLO_MAX_ACTIONS = Math.max(1, Math.floor(Number(process.env.SELLABLE_MCP_REFILL_YOLO_MAX_ACTIONS ?? "24")));
+const YOLO_SCHEDULER_POLL_DELAY_MS = Math.max(0, Math.floor(Number(process.env.SELLABLE_MCP_REFILL_YOLO_POLL_DELAY_MS ?? "0")));
 function normalizeStrings(values) {
     if (!Array.isArray(values))
         return [];
@@ -19,6 +23,11 @@ function normalizeStrings(values) {
             .filter(Boolean)),
     ];
 }
+function sleep(ms) {
+    if (!Number.isFinite(ms) || ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function normalizeHorizonSendDays(value) {
     if (value === undefined || value === null)
         return null;
@@ -64,10 +73,24 @@ function normalizeTargetDate(value) {
     }
     return trimmed;
 }
+function userAddedRowsLimitPayloadFromError(error) {
+    if (!(error instanceof SellableApiError) || error.status !== 400) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(error.body);
+        if (parsed?.code !== "USER_ADDED_ROWS_LIMIT_EXCEEDED")
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
 export const refillSendsToolDefinitions = [
     {
         name: "refill_sends",
-        description: "Typed command entrypoint for Sellable refill sends. Accepts --yolo semantics and optional sender selectors, then returns the bounded execution contract for the skill-led refill workflow. In --yolo, it may refresh stale paid InMail credit cache facts for exact selected senders once, rerun the target plan, execute the first supported yolo-eligible global primitive, and reread the target plan. It never directly writes scheduler rows, launches unrelated campaigns, archives, deletes, or sends messages outside the product scheduler path.",
+        description: "Typed command entrypoint for Sellable refill sends. Accepts --yolo semantics and optional sender selectors, then returns the bounded execution contract for the skill-led refill workflow. In --yolo, it may refresh stale paid InMail credit cache facts once, then run a bounded loop of safe primitives from target.globalActionQueue[0] (start exact selected paused campaign, bounded existing-row preparation, bounded same-source copy, bounded generated-message approval, safe Signal Discovery continuation, or read-only scheduler wait) with a fresh target-plan reread after each primitive. It does not run unbounded approval, lower paid InMail thresholds, switch source families outside the selected packet, create campaigns, schedule sends, archive, delete, or write scheduler rows.",
         inputSchema: {
             type: "object",
             properties: {
@@ -210,9 +233,7 @@ export function refillSendsCommand(input = {}) {
         firstOperationalSteps: [
             'Load get_subskill_prompt({ subskillName: "refill-sends-workflow" }) before any product operation.',
             "A skill cannot create or invoke /goal by itself. If this refill is already running inside an active Codex goal, keep that goal open until every selected sender lane is horizon-filled by projected coverage (sent + scheduled), Christian explicitly stops/statuses the run, or a concrete non-scheduler blocker appears.",
-            `Call get_refill_target_plan({ intent: "${intent}"${workspaceId ? `, workspaceId: "${workspaceId}"` : ""}${input.campaignId ? `, campaignId: "${input.campaignId}"` : ""}${input.tableId ? `, tableId: "${input.tableId}"` : ""}${senderIds.length > 0
-                ? `, senderIds: ${JSON.stringify(senderIds)}`
-                : ""}${senderNames.length > 0
+            `Call get_refill_target_plan({ intent: "${intent}"${workspaceId ? `, workspaceId: "${workspaceId}"` : ""}${input.campaignId ? `, campaignId: "${input.campaignId}"` : ""}${input.tableId ? `, tableId: "${input.tableId}"` : ""}${senderIds.length > 0 ? `, senderIds: ${JSON.stringify(senderIds)}` : ""}${senderNames.length > 0
                 ? `, senderNames: ${JSON.stringify(senderNames)}`
                 : ""}${senders.length > 0 ? `, senders: ${JSON.stringify(senders)}` : ""}${targetDate
                 ? `, targetDate: "${targetDate}"`
@@ -242,14 +263,15 @@ export function refillSendsCommand(input = {}) {
             "Treat current dashboard-active PAUSED campaign-backed sequence campaigns as start-eligible candidates: read refill state before deciding whether to prep, approve, start, or skip.",
             "Fresh reread get_campaign_refill_state immediately before any import, prep, approval, or horizon-fill mutation.",
             "Maintain a target-window saturation ledger per selected sender from get_refill_target_plan: selected days, gross capacity, actual sent counts, future scheduler-owned scheduled counts, projected counts, ready-to-schedule buffer, remaining projected gap, paid InMail threshold feasibility, targetShapeRevision, stateRevision, and next MCP primitive.",
-            "In --yolo, this tool automatically maintains a run-local refreshedPaidInmailSenderIds set: when the first target plan returns refresh_paid_inmail_credits candidates for selected paid-InMail lanes, it refreshes each exact sender at most once, reruns get_refill_target_plan to obtain the post-refresh targetPlan, then may apply the first supported yolo-eligible target.globalActionQueue[0] primitive and return yoloExecution plus a final targetPlan reread.",
-            "Do not present paid-credit refresh as the next operator action after refill_sends returns autoPaidInmailRefresh. Inspect yoloExecution: if it applied an action, continue from the final targetPlan; otherwise continue from the post-refresh targetPlan/targetPlanBeforeYoloAction.",
+            "In --yolo, this tool automatically maintains a run-local refreshedPaidInmailSenderIds set: when the first target plan returns refresh_paid_inmail_credits candidates for selected paid-InMail lanes, it refreshes each exact sender at most once, reruns get_refill_target_plan, and returns the post-refresh targetPlan before any prep/source-copy/bounded-approval/read-only wait action is chosen.",
+            "Do not present paid-credit refresh as the next operator action after refill_sends returns autoPaidInmailRefresh and the post-refresh targetPlan.",
             "If paid InMail feasibility remains below threshold after that automatic refresh, report the exact sender/campaign/table/column threshold action or same-campaign connection fallback; --yolo must not lower paid InMail thresholds or create campaigns.",
             "In --yolo or after one Accept, continue through every safe selected sender/campaign action covered by the rendered target packet; sent/scheduled-count progress changes stateRevision and should continue while targetShapeRevision is stable.",
+            "A start_paused_campaign action is safe in --yolo only when it is target.globalActionQueue[0] for the exact selected PAUSED campaign in the current refill target plan and the request has explicit workspaceId.",
             "Do not complete a fill/schedule request until a final get_refill_target_plan or refill-state reread proves projected coverage (sent + scheduled) fills the scheduler-forward target window. Treat awaiting_scheduler_after_ready_buffer as loaded, awaiting scheduler when ready buffer covers the gap; do not import/prep more rows in that state, and keep polling unless Christian stops/statuses the run or a concrete non-scheduler blocker such as paid_inmail_below_threshold appears.",
         ],
         approvalContract: yolo
-            ? "Auto-accept only the rendered bounded refill target packet after get_refill_target_plan and fresh reread. Execute one globally ranked primitive from target.globalActionQueue at a time, then rerun get_refill_target_plan before taking another action. Continue through every safe apply/prep/start action inside that packet, including start_campaign only for exact selected PAUSED campaign-backed sequence refill targets named in the packet. After each action, rerun get_refill_target_plan; keep going while targetShapeRevision is stable and projected coverage (sent + scheduled) progresses toward the target, even though stateRevision changes. Ready-to-schedule rows are buffer, not completion. If ready buffer covers the projected gap, use only persistent read-only scheduler wait/reread and keep the run open until projected coverage fills or Christian stops/statuses it. Stop immediately if targetShapeRevision changes because sender set, route, ids, caps, dates, blockers, action class, paid InMail threshold feasibility, or side-effect class drifts. --yolo does not authorize lowering paid InMail thresholds or creating connection campaigns."
+            ? "Auto-accept only the rendered bounded refill target packet after get_refill_target_plan and fresh reread. Execute one globally ranked primitive from target.globalActionQueue at a time, then rerun get_refill_target_plan before taking another action. Continue through every safe prep/source-copy/bounded-approval/start exact selected paused campaign/safe same-source continuation/read-only wait action inside that packet. Unbounded approval, source-family switches outside the selected packet, threshold changes, and campaign creation require their own explicit gates. After each safe action, rerun get_refill_target_plan; keep going while targetShapeRevision is stable and projected coverage (sent + scheduled) progresses toward the target, even though stateRevision changes. Ready-to-schedule rows are buffer, not completion. If ready buffer covers the projected gap, use only persistent read-only scheduler wait/reread and keep the run open until projected coverage fills or Christian stops/statuses it. Stop immediately if targetShapeRevision changes because sender set, route, ids, caps, dates, blockers, action class, paid InMail threshold feasibility, or side-effect class drifts. --yolo does not authorize lowering paid InMail thresholds or creating connection campaigns."
             : hasSenderSelectors
                 ? "Before mutation, post the full bounded refill packet in normal chat as Markdown, including workspace, sender scope, campaign table, exact ids, caps/dates, gross target, sent count, scheduled count, projected count, ready buffer, remaining projected gap, paid InMail threshold feasibility, targetShapeRevision/stateRevision, side effects, forbidden actions, and stop condition. Then ask the final Accept/Decline structured approval question with a compact body that refers back to the posted packet instead of duplicating it. Only ask when get_refill_target_plan reports a positive remaining projected/ready gap. If target is complete by projected coverage, no-op without approval. If ready buffer covers the projected gap, run only persistent read-only scheduler wait/reread and keep the run open until projected coverage fills or Christian stops/statuses it. Threshold changes and campaign creation need separate explicit approval."
                 : "Ask which eligible enrolled senders to refill first, then, before mutation, post the full bounded refill packet in normal chat as Markdown and ask the final Accept/Decline structured approval question with a compact body that refers back to the posted packet.",
@@ -337,46 +359,41 @@ function stringValue(value) {
 function numberValue(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
-function approvalModeValue(value) {
-    return value === "approve" || value === "mark_ready" ? value : null;
-}
-function positiveIntegerValue(value) {
-    if (typeof value !== "number" || !Number.isFinite(value))
-        return null;
-    const parsed = Math.floor(value);
-    return parsed > 0 ? parsed : null;
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
 }
-function rowSelectorValue(value) {
+function prepareRowSelectorValue(value) {
     const selector = recordValue(value);
     const type = stringValue(selector?.type);
-    if (!selector || !type)
-        return null;
-    const limit = positiveIntegerValue(selector.limit);
-    const withLimit = (base) => limit ? { ...base, limit: Math.min(limit, 500) } : base;
-    if (type === "rowIds") {
-        const rowIds = normalizeStrings(selector.rowIds);
-        return rowIds.length > 0 ? { type, rowIds } : null;
+    if (type !== "needsEnrichment" &&
+        type !== "needsApproval" &&
+        type !== "needsGeneratedMessage" &&
+        type !== "reviewBatch" &&
+        type !== "staleGeneratedMessages") {
+        return undefined;
     }
-    if (type === "reviewBatch") {
-        const basisHash = stringValue(selector.basisHash);
-        return basisHash
-            ? withLimit({ type, basisHash })
-            : withLimit({ type });
+    const limit = numberValue(selector?.limit);
+    return {
+        type,
+        ...(limit && limit > 0 ? { limit: Math.floor(limit) } : {}),
+    };
+}
+function uniqueStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const normalized = typeof value === "string" ? value.trim() : "";
+        if (!normalized)
+            continue;
+        const key = normalized.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(normalized);
     }
-    if (type === "needsEnrichment")
-        return withLimit({ type });
-    if (type === "needsApproval")
-        return withLimit({ type });
-    if (type === "passedRows")
-        return withLimit({ type });
-    if (type === "needsGeneratedMessage")
-        return withLimit({ type });
-    if (type === "staleGeneratedMessages")
-        return withLimit({ type });
-    return null;
-}
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return result;
 }
 function paidRefreshActionFrom(value) {
     const action = recordValue(value);
@@ -428,127 +445,726 @@ function collectPaidInmailRefreshActions(plan) {
 function firstGlobalAction(plan) {
     const root = recordValue(plan);
     const target = recordValue(root?.target);
-    const queue = Array.isArray(target?.globalActionQueue)
+    const globalActionQueue = Array.isArray(target?.globalActionQueue)
         ? target.globalActionQueue
         : [];
-    return recordValue(queue[0]);
+    const [first] = globalActionQueue;
+    return recordValue(first);
 }
-async function waitForPrepareAction(params) {
-    const receipt = recordValue(params.startReceipt);
-    const jobId = stringValue(receipt?.jobId);
-    const initialStatus = stringValue(receipt?.status) ?? stringValue(receipt?.jobStatus);
-    if (!jobId || (initialStatus && TERMINAL_PREPARE_STATUSES.has(initialStatus))) {
-        return {
-            waited: false,
-            timedOut: false,
-            receipt: params.startReceipt,
-        };
+function planTarget(plan) {
+    return recordValue(recordValue(plan)?.target);
+}
+function planStatus(plan) {
+    return stringValue(recordValue(plan)?.status);
+}
+function planTargetShapeRevision(plan) {
+    const root = recordValue(plan);
+    return (stringValue(root?.targetShapeRevision) ?? stringValue(root?.targetRevision));
+}
+function planStateRevision(plan) {
+    return stringValue(recordValue(plan)?.stateRevision);
+}
+function planSummary(plan) {
+    const target = planTarget(plan);
+    const senderPlans = Array.isArray(target?.senderRefillPlans)
+        ? target.senderRefillPlans
+        : [];
+    const firstSenderPlan = recordValue(senderPlans[0]);
+    return {
+        status: planStatus(plan),
+        targetShapeRevision: planTargetShapeRevision(plan),
+        stateRevision: planStateRevision(plan),
+        grossTarget: numberValue(target?.grossTarget),
+        sent: numberValue(target?.sent),
+        scheduled: numberValue(target?.scheduled),
+        projected: numberValue(target?.projected),
+        readyBuffer: numberValue(target?.readyBuffer),
+        remainingProjectedGap: numberValue(target?.remainingProjectedGap),
+        remainingReadyOrProjectedGap: numberValue(target?.remainingReadyOrProjectedGap),
+        actionType: stringValue(firstSenderPlan?.actionType),
+    };
+}
+function planIsComplete(plan) {
+    const summary = planSummary(plan);
+    return summary.status === "complete" || summary.remainingProjectedGap === 0;
+}
+function yoloLoopExecution(params) {
+    const lastAction = params.actions[params.actions.length - 1];
+    return {
+        enabled: true,
+        status: params.status,
+        stopReason: params.stopReason,
+        selectedAction: params.selectedAction ??
+            params.actions[0]?.selectedAction ??
+            firstGlobalAction(params.initialPlan),
+        actions: params.actions,
+        actionCount: params.actions.length,
+        result: params.result ?? lastAction?.primitive.result,
+        targetPlanReread: params.targetPlanRereads > 0,
+        targetPlanRereads: params.targetPlanRereads,
+        initialTargetShapeRevision: planTargetShapeRevision(params.initialPlan),
+        finalTargetShapeRevision: planTargetShapeRevision(params.finalPlan),
+        finalStateRevision: planStateRevision(params.finalPlan),
+        maxActions: YOLO_MAX_ACTIONS,
+        refusalReason: params.refusalReason ?? lastAction?.primitive.refusalReason,
+        postActionFirstAction: firstGlobalAction(params.finalPlan),
+    };
+}
+function actionIds(action) {
+    return recordValue(action.ids) ?? {};
+}
+function actionToolInput(action) {
+    return recordValue(action.toolInput) ?? {};
+}
+function actionCampaignId(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.campaignId) ??
+        stringValue(toolInput.campaignOfferId) ??
+        stringValue(ids.campaignId) ??
+        stringValue(action.campaignId));
+}
+function actionTableId(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.tableId) ??
+        stringValue(ids.tableId) ??
+        stringValue(action.tableId));
+}
+function actionSourceLeadListId(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.sourceLeadListId) ??
+        stringValue(ids.sourceLeadListId) ??
+        stringValue(action.sourceLeadListId));
+}
+function actionSenderId(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.senderId) ??
+        stringValue(ids.senderId) ??
+        stringValue(action.senderId));
+}
+function actionActionType(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.actionType) ??
+        stringValue(toolInput.selectedLane) ??
+        stringValue(ids.actionType) ??
+        stringValue(action.actionType) ??
+        stringValue(action.selectedLane));
+}
+function actionSourceFingerprint(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.sourceFingerprint) ??
+        stringValue(ids.sourceFingerprint) ??
+        stringValue(action.sourceFingerprint));
+}
+function actionLeadSourceProvider(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.leadSourceProvider) ??
+        stringValue(toolInput.provider) ??
+        stringValue(ids.leadSourceProvider) ??
+        stringValue(action.leadSourceProvider));
+}
+function normalizedSignalKeyword(value) {
+    if (typeof value !== "string")
+        return null;
+    const keyword = value.trim();
+    if (!keyword)
+        return null;
+    if (/^(https?:\/\/|www\.|linkedin\.com\/|\/?in\/)/i.test(keyword)) {
+        return null;
     }
-    const startedAt = Date.now();
-    let lastStatus = params.startReceipt;
-    while (Date.now() - startedAt < PREPARE_POLL_TIMEOUT_MS) {
-        await delay(PREPARE_POLL_INTERVAL_MS);
-        lastStatus = await getPrepareCampaignMessagesStatus({
-            jobId,
-            campaignId: params.campaignId,
-            ...(params.tableId ? { tableId: params.tableId } : {}),
-            ...(params.workspaceId ? { workspaceId: params.workspaceId } : {}),
-        });
-        const statusRecord = recordValue(lastStatus);
-        const status = stringValue(statusRecord?.status) ?? stringValue(statusRecord?.jobStatus);
-        if (status && TERMINAL_PREPARE_STATUSES.has(status)) {
-            return {
-                waited: true,
-                timedOut: false,
-                receipt: lastStatus,
-            };
+    return keyword;
+}
+function keywordsFromSignalTabs(tabs) {
+    const selectedKeywords = [];
+    const fallbackKeywords = [];
+    for (const tab of tabs) {
+        const keyword = normalizedSignalKeyword(tab.keyword);
+        if (!keyword)
+            continue;
+        const selected = (tab.posts ?? []).some((post) => post.isSelected === true);
+        if (selected) {
+            selectedKeywords.push(keyword);
+        }
+        else {
+            fallbackKeywords.push(keyword);
         }
     }
-    return {
-        waited: true,
-        timedOut: true,
-        receipt: lastStatus,
+    return uniqueStrings([...selectedKeywords, ...fallbackKeywords]).slice(0, 5);
+}
+function selectedPostIdsFromSignalTabs(tabs) {
+    return uniqueStrings(tabs.flatMap((tab) => (tab.posts ?? [])
+        .filter((post) => post.isSelected === true)
+        .map((post) => post.id)));
+}
+function postIdsFromSignalSearch(summary, maxPosts, options = {}) {
+    const excludedPostIds = new Set((options.excludePostIds ?? []).map((postId) => postId.toLowerCase()));
+    const recommendedPostIds = stringArray(summary?.recommendedPostIds);
+    const topPostIds = Array.isArray(summary?.topPosts)
+        ? summary.topPosts
+            .map((post) => post && typeof post === "object"
+            ? stringValue(post.id)
+            : null)
+            .filter((id) => Boolean(id))
+        : [];
+    return uniqueStrings([...recommendedPostIds, ...topPostIds])
+        .filter((postId) => !excludedPostIds.has(postId.toLowerCase()))
+        .slice(0, Math.max(1, maxPosts));
+}
+function maxSignalDiscoveryPostsForSourceLimit(sourceRowLimit) {
+    return Math.min(SIGNAL_DISCOVERY_MAX_REFILL_POSTS, Math.max(SIGNAL_DISCOVERY_MIN_REFILL_POSTS, Math.ceil(sourceRowLimit / SIGNAL_DISCOVERY_TARGET_ROWS_PER_POST)));
+}
+function refillPrepareRequestHash(params) {
+    return [
+        "refill_sends",
+        "prepare_messages",
+        params.campaignId,
+        params.tableId ?? "no-table",
+        actionSenderId(params.action) ?? "all-senders",
+        actionSourceLeadListId(params.action) ?? "no-source-list",
+        actionActionType(params.action) ?? "no-action-type",
+        params.approvalMode,
+        params.rowSelector
+            ? `${params.rowSelector.type}:${params.rowSelector.limit ?? "no-limit"}`
+            : "no-row-selector",
+    ].join(":");
+}
+function boundedApprovalLimit(action) {
+    const toolInput = actionToolInput(action);
+    const rowSelector = recordValue(toolInput.rowSelector);
+    const selectorLimit = numberValue(rowSelector?.limit);
+    const inputLimit = numberValue(toolInput.limit);
+    const limit = selectorLimit ?? inputLimit;
+    if (!limit || limit <= 0)
+        return null;
+    return Math.floor(limit);
+}
+async function approveGeneratedMessagesBatch(action, workspaceId) {
+    const tableId = actionTableId(action);
+    const toolInput = actionToolInput(action);
+    const columnId = stringValue(toolInput.columnId) ?? stringValue(actionIds(action).columnId);
+    const limit = boundedApprovalLimit(action);
+    if (!tableId || !limit) {
+        return {
+            status: "refused",
+            refusalReason: "approve_messages action is missing tableId or a bounded rowSelector.limit",
+        };
+    }
+    const api = getApi();
+    const requestOptions = workspaceRequestOptions(workspaceId);
+    const body = {
+        tableId,
+        ...(columnId ? { columnId } : {}),
+        limit,
+        scope: "generated_unapproved",
+        ...(workspaceId ? { workspaceId } : {}),
     };
+    const result = requestOptions
+        ? await api.post("/api/v3/workflow-tables/cells/approve-batch", body, requestOptions)
+        : await api.post("/api/v3/workflow-tables/cells/approve-batch", body);
+    return { status: "executed_and_reread", result };
 }
-async function executeYoloGlobalAction(params) {
-    const action = params.action;
-    if (!action) {
+async function continueSignalDiscoverySource(action, workspaceId) {
+    const campaignOfferId = actionCampaignId(action);
+    const sourceLeadListId = actionSourceLeadListId(action);
+    const sourceFingerprint = actionSourceFingerprint(action);
+    const toolInput = actionToolInput(action);
+    const requestOptions = workspaceRequestOptions(workspaceId);
+    const sourceRowLimit = Math.min(1500, Math.max(100, Math.floor(numberValue(toolInput.sourceRowLimit) ??
+        numberValue(toolInput.targetRows) ??
+        numberValue(action.targetRows) ??
+        100)));
+    const maxPostsToScrape = maxSignalDiscoveryPostsForSourceLimit(sourceRowLimit);
+    if (!campaignOfferId || !sourceLeadListId || !sourceFingerprint) {
         return {
-            status: "no_global_action",
-            applied: false,
-            note: "No target.globalActionQueue[0] action was present after the fresh target-plan reread.",
+            status: "refused",
+            refusalReason: "continue_signal_discovery_source action is missing campaignOfferId, sourceLeadListId, or sourceFingerprint",
         };
     }
-    const actionType = stringValue(action.type);
-    const toolName = stringValue(action.toolName);
-    const yoloEligible = action.yoloEligible === true;
-    if (!yoloEligible) {
+    const requestedProvider = actionLeadSourceProvider(action);
+    if (requestedProvider &&
+        requestedProvider !== "signal-discovery" &&
+        requestedProvider !== "campaign-tracked-post") {
         return {
-            status: "not_yolo_eligible",
-            applied: false,
-            action,
-            note: "The first global action was not marked yoloEligible:true, so refill_sends did not mutate.",
+            status: "refused",
+            refusalReason: "continue_signal_discovery_source can only run for Signal Discovery source families",
         };
     }
-    if (actionType !== "prepare_messages" &&
-        toolName !== "start_campaign_message_preparation") {
+    const api = getApi();
+    const campaign = requestOptions
+        ? await api.get(`/api/v2/campaign-offers/${campaignOfferId}`, requestOptions)
+        : await api.get(`/api/v2/campaign-offers/${campaignOfferId}`);
+    if (campaign.leadSourceProvider !== "signal-discovery" &&
+        campaign.leadSourceProvider !== "campaign-tracked-post") {
         return {
-            status: "unsupported_action",
-            applied: false,
-            action,
-            note: "refill_sends currently auto-applies yolo prepare_messages actions; this action needs the skill workflow/operator path.",
+            status: "refused",
+            refusalReason: "campaign leadSourceProvider is not Signal Discovery; refusing same-source continuation",
         };
     }
-    const ids = recordValue(action.ids);
-    const toolInput = recordValue(action.toolInput);
-    const campaignId = stringValue(toolInput?.campaignId) ?? stringValue(ids?.campaignId);
-    const tableId = stringValue(toolInput?.tableId) ?? stringValue(ids?.tableId);
-    if (!campaignId) {
+    if (campaign.selectedLeadListId &&
+        campaign.selectedLeadListId !== sourceLeadListId) {
         return {
-            status: "missing_campaign_id",
-            applied: false,
-            action,
-            note: "The yolo prepare_messages action did not include a campaignId.",
+            status: "refused",
+            refusalReason: "campaign selectedLeadListId changed since the plan packet; rerun get_refill_target_plan before source continuation",
         };
     }
-    const targetPreparedMessages = numberValue(toolInput?.targetPreparedMessages);
-    const approvalMode = approvalModeValue(toolInput?.approvalMode);
-    const rawRowSelector = toolInput?.rowSelector;
-    const rowSelector = rawRowSelector === undefined ? null : rowSelectorValue(rawRowSelector);
-    if (rawRowSelector !== undefined && !rowSelector) {
+    const sourceMeta = requestOptions
+        ? await api.get(`/api/v3/workflow-tables/${sourceLeadListId}?mode=meta`, requestOptions)
+        : await api.get(`/api/v3/workflow-tables/${sourceLeadListId}?mode=meta`);
+    const sourceConfig = sourceMeta.table?.config ?? null;
+    const headlineICPCriteria = stringArray(sourceConfig?.headlineICPCriteria).length > 0
+        ? stringArray(sourceConfig?.headlineICPCriteria)
+        : stringArray(sourceConfig?.rubricGuidelines);
+    const tabsResponse = requestOptions
+        ? await api.get(`/api/v3/campaigns/${campaignOfferId}/signal-discovery/tabs`, requestOptions)
+        : await api.get(`/api/v3/campaigns/${campaignOfferId}/signal-discovery/tabs`);
+    const signalTabs = tabsResponse.tabs ?? [];
+    const keywords = keywordsFromSignalTabs(signalTabs);
+    const excludedPostIds = selectedPostIdsFromSignalTabs(signalTabs);
+    if (keywords.length === 0) {
         return {
-            status: "invalid_row_selector",
-            applied: false,
-            action,
-            note: "The yolo prepare_messages action included a rowSelector, but it was not valid for start_campaign_message_preparation.",
+            status: "refused",
+            refusalReason: "no reusable Signal Discovery keywords were found on the campaign tabs",
         };
     }
-    const startInput = {
-        campaignId,
-        ...(tableId ? { tableId } : {}),
-        ...(targetPreparedMessages ? { targetPreparedMessages } : {}),
-        ...(approvalMode ? { approvalMode } : {}),
-        ...(rowSelector ? { rowSelector } : {}),
-        ...(params.workspaceId ? { workspaceId: params.workspaceId } : {}),
-    };
-    const startedAt = new Date().toISOString();
-    const startReceipt = await startPrepareCampaignMessages(startInput);
-    const waitReceipt = await waitForPrepareAction({
-        workspaceId: params.workspaceId,
-        campaignId,
-        tableId,
-        startReceipt,
+    markProviderPromptLoaded({
+        provider: "signal-discovery",
+        campaignOfferId,
+    });
+    const searchSummary = await searchSignals({
+        type: "keywords",
+        ...(workspaceId ? { workspaceId } : {}),
+        keywords: keywords.map((keyword) => ({
+            keyword,
+            source: "refill-sends-source-continuation",
+        })),
+        campaignOfferId,
+        currentStep: null,
+        headlineICPCriteria,
+        rubricGuidelines: headlineICPCriteria,
+        confirmed: true,
+        limit: 50,
+    });
+    const selectedPostIds = postIdsFromSignalSearch(searchSummary, maxPostsToScrape, { excludePostIds: excludedPostIds });
+    if (selectedPostIds.length === 0) {
+        return {
+            status: "refused",
+            refusalReason: "Signal Discovery search returned no new recommended posts to continue the source",
+            result: { keywords, excludedPostIds, searchSummary },
+        };
+    }
+    const selectionResult = await selectPromisingPosts({
+        campaignOfferId,
+        ...(workspaceId ? { workspaceId } : {}),
+        selections: selectedPostIds.map((postId) => ({
+            postId,
+            reason: "refill_sends same-source continuation: recent post from the campaign's existing Signal Discovery keyword family",
+        })),
+        headlineICPCriteria,
+        currentStep: null,
+        selectionMode: "replace",
+        scrapePlanMode: "all-selected",
+    });
+    if (selectionResult.success === false) {
+        return {
+            status: "refused",
+            refusalReason: stringValue(selectionResult.message) ??
+                "select_promising_posts did not select any posts",
+            result: { keywords, selectedPostIds, selectionResult },
+        };
+    }
+    const importResult = await importLeads({
+        campaignOfferId,
+        ...(workspaceId ? { workspaceId } : {}),
+        provider: "signal-discovery",
+        sourceLeadListId,
+        currentStep: null,
+        headlineICPCriteria,
+        rubricGuidelines: headlineICPCriteria,
+        confirmed: true,
+        maxPostsToScrape: selectedPostIds.length,
+        allowInvalidSignalPosts: true,
     });
+    const importRecord = recordValue(importResult);
+    if (importRecord?.error) {
+        return {
+            status: "refused",
+            refusalReason: stringValue(importRecord.message) ??
+                `Signal Discovery import returned ${String(importRecord.error)}`,
+            result: {
+                keywords,
+                excludedPostIds,
+                selectedPostIds,
+                selectionResult,
+                importResult,
+            },
+        };
+    }
     return {
-        status: waitReceipt.timedOut ? "applied_wait_timeout" : "applied",
-        applied: true,
-        action,
-        toolName: "start_campaign_message_preparation",
-        input: startInput,
-        startedAt,
-        endedAt: new Date().toISOString(),
-        startReceipt,
-        waitReceipt,
+        status: "executed_and_reread",
+        result: {
+            provider: "signal-discovery",
+            campaignOfferId,
+            previousSourceLeadListId: sourceLeadListId,
+            sourceFingerprint,
+            keywords,
+            excludedPostIds,
+            selectedPostIds,
+            sourceRowLimit,
+            maxPostsToScrape: selectedPostIds.length,
+            searchSummary,
+            selectionResult,
+            importResult,
+        },
+    };
+}
+async function refreshPaidInmailCreditsWithRetry(senderId, workspaceId) {
+    const errors = [];
+    for (let attempt = 1; attempt <= PAID_INMAIL_REFRESH_MAX_ATTEMPTS; attempt += 1) {
+        try {
+            const receipt = await refreshPaidInmailCredits({
+                senderId,
+                ...(workspaceId ? { workspaceId } : {}),
+            });
+            return { receipt, attempts: attempt, errors };
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error.message : String(error));
+            if (attempt < PAID_INMAIL_REFRESH_MAX_ATTEMPTS) {
+                await sleep(PAID_INMAIL_REFRESH_RETRY_DELAY_MS);
+            }
+        }
+    }
+    return {
+        receipt: null,
+        attempts: PAID_INMAIL_REFRESH_MAX_ATTEMPTS,
+        errors,
+    };
+}
+async function executeOneYoloPrimitive(action, context = {}) {
+    if (!action)
+        return { status: "no_action" };
+    if (action.yoloEligible === false) {
+        return {
+            status: "refused",
+            refusalReason: "first global action is not yolo eligible",
+        };
+    }
+    switch (action.type) {
+        case "wait_for_scheduler":
+        case "wait_for_active_work":
+        case "wait_for_source_import":
+            return { status: "read_only_reread", result: { waited: true } };
+        case "prepare_messages": {
+            const campaignId = actionCampaignId(action);
+            const tableId = actionTableId(action) ?? undefined;
+            const toolInput = actionToolInput(action);
+            const targetPreparedMessages = numberValue(toolInput.targetPreparedMessages);
+            const rowSelector = prepareRowSelectorValue(toolInput.rowSelector);
+            const approvalMode = toolInput.approvalMode === "approve" ? "approve" : "mark_ready";
+            if (!campaignId ||
+                !targetPreparedMessages ||
+                targetPreparedMessages <= 0) {
+                return {
+                    status: "refused",
+                    refusalReason: "prepare_messages action is missing campaignId or bounded targetPreparedMessages",
+                };
+            }
+            const result = await startPrepareCampaignMessages({
+                campaignId,
+                tableId,
+                workspaceId: context.workspaceId,
+                targetPreparedMessages,
+                maxRowsToCheck: numberValue(toolInput.maxRowsToCheck) ?? 300,
+                approvalMode,
+                rowSelector,
+                autoContinue: true,
+                disableLowPassRateStop: true,
+                senderId: actionSenderId(action) ?? undefined,
+                actionType: actionActionType(action) ?? undefined,
+                requestHash: refillPrepareRequestHash({
+                    action,
+                    campaignId,
+                    tableId,
+                    approvalMode,
+                    rowSelector,
+                }),
+                requestSource: "refill_sends",
+            });
+            return { status: "executed_and_reread", result };
+        }
+        case "copy_selected_source_rows": {
+            const campaignOfferId = actionCampaignId(action);
+            const sourceLeadListId = actionSourceLeadListId(action);
+            const toolInput = actionToolInput(action);
+            const sourceRowIds = stringArray(toolInput.sourceRowIds);
+            const sourceRowLimit = numberValue(toolInput.sourceRowLimit);
+            const sourceFingerprint = stringValue(toolInput.sourceFingerprint) ??
+                stringValue(actionIds(action).sourceFingerprint);
+            if (!campaignOfferId || !sourceLeadListId || !sourceFingerprint) {
+                return {
+                    status: "refused",
+                    refusalReason: "copy_selected_source_rows action is missing campaignOfferId, sourceLeadListId, or sourceFingerprint",
+                };
+            }
+            if (sourceRowIds.length === 0 &&
+                (!sourceRowLimit || sourceRowLimit <= 0)) {
+                return {
+                    status: "refused",
+                    refusalReason: "copy_selected_source_rows action is missing exact sourceRowIds or a bounded sourceRowLimit",
+                };
+            }
+            const copyInput = {
+                campaignOfferId,
+                workspaceId: context.workspaceId,
+                sourceLeadListId,
+                currentStep: null,
+                confirmed: true,
+                sourceRowIds: sourceRowIds.length > 0 ? sourceRowIds : undefined,
+                sourceRowLimit: sourceRowIds.length > 0 ? undefined : (sourceRowLimit ?? undefined),
+                reviewBatchLimit: sourceRowIds.length > 0
+                    ? sourceRowIds.length
+                    : (sourceRowLimit ?? undefined),
+            };
+            let result;
+            try {
+                result = await confirmLeadList(copyInput);
+            }
+            catch (error) {
+                const rowLimitPayload = userAddedRowsLimitPayloadFromError(error);
+                if (!rowLimitPayload)
+                    throw error;
+                const remainingRows = typeof rowLimitPayload.remainingRows === "number" &&
+                    Number.isFinite(rowLimitPayload.remainingRows)
+                    ? Math.floor(rowLimitPayload.remainingRows)
+                    : 0;
+                if (remainingRows <= 0) {
+                    return {
+                        status: "refused",
+                        refusalReason: rowLimitPayload.error ??
+                            "selected campaign table is at the workflow row limit",
+                    };
+                }
+                const retrySourceRowIds = sourceRowIds.length > 0 ? sourceRowIds.slice(0, remainingRows) : [];
+                const retrySourceRowLimit = retrySourceRowIds.length > 0
+                    ? undefined
+                    : Math.min(sourceRowLimit ?? remainingRows, remainingRows);
+                const retryReviewBatchLimit = retrySourceRowIds.length > 0
+                    ? retrySourceRowIds.length
+                    : retrySourceRowLimit;
+                if (!retryReviewBatchLimit || retryReviewBatchLimit <= 0) {
+                    return {
+                        status: "refused",
+                        refusalReason: rowLimitPayload.error ??
+                            "selected campaign table cannot accept more workflow rows",
+                    };
+                }
+                const retryResult = await confirmLeadList({
+                    ...copyInput,
+                    sourceRowIds: retrySourceRowIds.length > 0 ? retrySourceRowIds : undefined,
+                    sourceRowLimit: retrySourceRowIds.length > 0 ? undefined : retrySourceRowLimit,
+                    reviewBatchLimit: retryReviewBatchLimit,
+                });
+                result =
+                    retryResult && typeof retryResult === "object"
+                        ? {
+                            ...retryResult,
+                            rowLimitRetry: {
+                                code: rowLimitPayload.code,
+                                maxRows: rowLimitPayload.maxRows,
+                                currentRows: rowLimitPayload.currentRows,
+                                requestedRows: rowLimitPayload.requestedRows,
+                                remainingRows,
+                                retriedRows: retryReviewBatchLimit,
+                            },
+                        }
+                        : {
+                            result: retryResult,
+                            rowLimitRetry: {
+                                code: rowLimitPayload.code,
+                                remainingRows,
+                                retriedRows: retryReviewBatchLimit,
+                            },
+                        };
+            }
+            return { status: "executed_and_reread", result };
+        }
+        case "continue_signal_discovery_source":
+            return continueSignalDiscoverySource(action, context.workspaceId);
+        case "approve_messages":
+            return approveGeneratedMessagesBatch(action, context.workspaceId);
+        case "start_paused_campaign": {
+            const campaignId = actionCampaignId(action);
+            if (!campaignId || !context.workspaceId) {
+                return {
+                    status: "refused",
+                    refusalReason: "start_paused_campaign action is missing campaignId or explicit workspaceId",
+                };
+            }
+            const result = await startCampaign({
+                campaignId,
+                workspaceId: context.workspaceId,
+            });
+            return { status: "executed_and_reread", result };
+        }
+        default:
+            return {
+                status: "refused",
+                refusalReason: `action ${String(action.type)} is not a safe yolo primitive`,
+            };
+    }
+}
+async function executeYoloPrimitiveLoop(params) {
+    let currentPlan = params.initialPlan;
+    const actions = [];
+    let targetPlanRereads = 0;
+    let targetPlanBeforeYoloPrimitive = null;
+    const initialTargetShapeRevision = planTargetShapeRevision(currentPlan);
+    if (planIsComplete(currentPlan)) {
+        return {
+            finalTargetPlan: currentPlan,
+            targetPlanBeforeYoloPrimitive: null,
+            execution: yoloLoopExecution({
+                status: "complete",
+                stopReason: "target_complete",
+                actions,
+                targetPlanRereads,
+                initialPlan: params.initialPlan,
+                finalPlan: currentPlan,
+            }),
+        };
+    }
+    for (let attempt = 1; attempt <= YOLO_MAX_ACTIONS; attempt += 1) {
+        const selectedAction = firstGlobalAction(currentPlan);
+        if (!selectedAction) {
+            return {
+                finalTargetPlan: currentPlan,
+                targetPlanBeforeYoloPrimitive,
+                execution: yoloLoopExecution({
+                    status: "no_action",
+                    stopReason: "no_global_action",
+                    actions,
+                    targetPlanRereads,
+                    initialPlan: params.initialPlan,
+                    finalPlan: currentPlan,
+                    selectedAction: null,
+                }),
+            };
+        }
+        const before = planSummary(currentPlan);
+        if (!targetPlanBeforeYoloPrimitive) {
+            targetPlanBeforeYoloPrimitive = currentPlan;
+        }
+        if (selectedAction.type === "wait_for_scheduler" &&
+            YOLO_SCHEDULER_POLL_DELAY_MS > 0) {
+            await sleep(YOLO_SCHEDULER_POLL_DELAY_MS);
+        }
+        const primitive = await executeOneYoloPrimitive(selectedAction, {
+            workspaceId: params.workspaceId,
+        });
+        const shouldReread = primitive.status === "executed_and_reread" ||
+            primitive.status === "read_only_reread";
+        const nextPlan = shouldReread
+            ? await getRefillTargetPlan(params.targetPlanInput)
+            : null;
+        if (shouldReread)
+            targetPlanRereads += 1;
+        const receipt = {
+            attempt,
+            selectedAction,
+            before,
+            primitive,
+            after: nextPlan ? planSummary(nextPlan) : null,
+            postActionFirstAction: nextPlan ? firstGlobalAction(nextPlan) : null,
+        };
+        actions.push(receipt);
+        if (primitive.status === "refused") {
+            return {
+                finalTargetPlan: currentPlan,
+                targetPlanBeforeYoloPrimitive,
+                execution: yoloLoopExecution({
+                    status: "refused",
+                    stopReason: "primitive_refused",
+                    actions,
+                    targetPlanRereads,
+                    initialPlan: params.initialPlan,
+                    finalPlan: currentPlan,
+                    selectedAction,
+                    result: primitive.result,
+                    refusalReason: primitive.refusalReason,
+                }),
+            };
+        }
+        if (!nextPlan) {
+            return {
+                finalTargetPlan: currentPlan,
+                targetPlanBeforeYoloPrimitive,
+                execution: yoloLoopExecution({
+                    status: primitive.status,
+                    stopReason: "no_global_action",
+                    actions,
+                    targetPlanRereads,
+                    initialPlan: params.initialPlan,
+                    finalPlan: currentPlan,
+                    selectedAction,
+                    result: primitive.result,
+                }),
+            };
+        }
+        currentPlan = nextPlan;
+        const nextTargetShapeRevision = planTargetShapeRevision(currentPlan);
+        if (initialTargetShapeRevision &&
+            nextTargetShapeRevision &&
+            nextTargetShapeRevision !== initialTargetShapeRevision &&
+            !planIsComplete(currentPlan)) {
+            return {
+                finalTargetPlan: currentPlan,
+                targetPlanBeforeYoloPrimitive,
+                execution: yoloLoopExecution({
+                    status: "target_shape_drift",
+                    stopReason: "target_shape_drift",
+                    actions,
+                    targetPlanRereads,
+                    initialPlan: params.initialPlan,
+                    finalPlan: currentPlan,
+                    selectedAction,
+                    result: primitive.result,
+                }),
+            };
+        }
+        if (planIsComplete(currentPlan)) {
+            return {
+                finalTargetPlan: currentPlan,
+                targetPlanBeforeYoloPrimitive,
+                execution: yoloLoopExecution({
+                    status: "complete",
+                    stopReason: "target_complete",
+                    actions,
+                    targetPlanRereads,
+                    initialPlan: params.initialPlan,
+                    finalPlan: currentPlan,
+                    selectedAction,
+                    result: primitive.result,
+                }),
+            };
+        }
+    }
+    return {
+        finalTargetPlan: currentPlan,
+        targetPlanBeforeYoloPrimitive,
+        execution: yoloLoopExecution({
+            status: "max_actions_reached",
+            stopReason: "max_actions_reached",
+            actions,
+            targetPlanRereads,
+            initialPlan: params.initialPlan,
+            finalPlan: currentPlan,
+        }),
     };
 }
 export async function executeRefillSendsCommand(input = {}) {
@@ -579,6 +1195,12 @@ export async function executeRefillSendsCommand(input = {}) {
                 failedPaidInmailRefreshes: [],
                 note: "Automatic paid InMail credit refresh only runs for --yolo refill_sends calls.",
             },
+            yoloExecution: {
+                enabled: false,
+                status: "not_run_without_yolo",
+                selectedAction: null,
+                targetPlanReread: false,
+            },
         };
     }
     const workspaceId = workspaceContext && workspaceContext.ok
@@ -591,41 +1213,41 @@ export async function executeRefillSendsCommand(input = {}) {
     const failedPaidInmailRefreshes = [];
     const refreshReceipts = [];
     for (const action of refreshActions) {
-        try {
-            const receipt = await refreshPaidInmailCredits({
-                senderId: action.senderId,
-                ...(workspaceId ? { workspaceId } : {}),
-            });
+        const refreshResult = await refreshPaidInmailCreditsWithRetry(action.senderId, workspaceId ?? undefined);
+        if (refreshResult.receipt) {
             refreshedPaidInmailSenderIds.push(action.senderId);
             refreshReceipts.push({
                 senderId: action.senderId,
                 actionKey: action.actionKey ?? null,
-                receipt,
+                attempts: refreshResult.attempts,
+                retryErrors: refreshResult.errors,
+                receipt: refreshResult.receipt,
             });
         }
-        catch (error) {
+        else {
             failedPaidInmailRefreshes.push({
                 senderId: action.senderId,
-                error: error instanceof Error ? error.message : String(error),
+                attempts: refreshResult.attempts,
+                error: refreshResult.errors[refreshResult.errors.length - 1] ??
+                    "paid InMail credit refresh failed",
+                errors: refreshResult.errors,
             });
         }
     }
     const targetPlan = refreshActions.length > 0
         ? await getRefillTargetPlan(targetPlanInput)
         : targetPlanBeforePaidRefresh;
-    const targetPlanBeforeYoloAction = targetPlan;
-    const yoloExecution = await executeYoloGlobalAction({
-        action: firstGlobalAction(targetPlan),
-        workspaceId,
+    const yoloLoop = await executeYoloPrimitiveLoop({
+        initialPlan: targetPlan,
+        targetPlanInput,
+        workspaceId: workspaceId ?? undefined,
     });
-    const finalTargetPlan = yoloExecution.applied
-        ? await getRefillTargetPlan(targetPlanInput)
-        : targetPlan;
+    const finalTargetPlan = yoloLoop.finalTargetPlan;
     return {
         ...command,
         targetPlan: finalTargetPlan,
-        targetPlanBeforeYoloAction,
         targetPlanBeforePaidRefresh: refreshActions.length > 0 ? targetPlanBeforePaidRefresh : null,
+        targetPlanBeforeYoloPrimitive: yoloLoop.targetPlanBeforeYoloPrimitive,
         autoPaidInmailRefresh: {
             enabled: true,
             status: refreshActions.length === 0
@@ -641,15 +1263,9 @@ export async function executeRefillSendsCommand(input = {}) {
             workspaceId,
             workspaceResolution: workspaceId ? "explicit" : "active_config",
             note: refreshActions.length > 0
-                ? "refill_sends refreshed stale paid InMail credit facts internally, once per sender, then reread the post-refresh targetPlan before yolo action execution."
+                ? "refill_sends refreshed stale paid InMail credit facts internally with bounded retries, once per sender, reran the target plan, then continued the bounded yolo primitive loop from the post-refresh targetPlan."
                 : "No stale or missing paid InMail credit refresh candidates were present in the initial target plan.",
         },
-        yoloExecution: {
-            enabled: true,
-            workspaceId,
-            workspaceResolution: workspaceId ? "explicit" : "active_config",
-            targetPlanRereadAfterAction: yoloExecution.applied,
-            ...yoloExecution,
-        },
+        yoloExecution: yoloLoop.execution,
     };
 }