@sellable/mcp 0.1.503 → 0.1.504

package/dist/tools/refill-sends.js

@@ -1,7 +1,15 @@
+import { getApi, SellableApiError } from "../api.js";
+import { startPrepareCampaignMessages } from "./campaign-message-preparation.js";
+import { confirmLeadList, importLeads, searchSignals, selectPromisingPosts, } from "./leads.js";
+import { markProviderPromptLoaded } from "./provider-preflight.js";
 import { getRefillTargetPlan } from "./refill-target-plan.js";
 import { refreshPaidInmailCredits } from "./senders.js";
-import { createWorkspaceContext, normalizeExplicitWorkspaceId, } from "./workspace-context.js";
 const DEFAULT_SCHEDULER_FORWARD_HOURS = 48;
+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;
 function normalizeStrings(values) {
     if (!Array.isArray(values))
         return [];
@@ -11,6 +19,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;
@@ -56,10 +69,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, then rerun and return the post-refresh target plan. This tool does not mutate campaigns, import leads, approve messages, schedule sends, launch, archive, delete, or write scheduler rows.",
+        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, or execute exactly one safe primitive from target.globalActionQueue[0] (bounded existing-row preparation, bounded same-source copy, bounded generated-message approval, or read-only wait) and reread. It does not run unbounded approval, lower paid InMail thresholds, switch source families, create campaigns, schedule sends, launch, archive, delete, or write scheduler rows.",
         inputSchema: {
             type: "object",
             properties: {
@@ -67,19 +94,6 @@ export const refillSendsToolDefinitions = [
                     type: "boolean",
                     description: "When true, auto-accept the rendered bounded refill packet after the required fresh state reread. Without sender selectors, yolo means all eligible healthy senders enrolled in active campaign-backed sequence campaigns.",
                 },
-                executionMode: {
-                    type: "string",
-                    enum: ["manual", "scheduled", "yolo"],
-                    description: "Explicit run mode. scheduled and yolo require workspaceId and never fall back to the shared active workspace.",
-                },
-                requireWorkspace: {
-                    type: "boolean",
-                    description: "When true, require an explicit request-scoped workspaceId before any refill API call. Scheduled automation should set this.",
-                },
-                workspaceId: {
-                    type: "string",
-                    description: "Explicit request-scoped workspace id for scheduled/yolo refill automation. Pass this on every refill call instead of switching the shared active workspace.",
-                },
                 senders: {
                     type: "array",
                     items: { type: "string" },
@@ -136,13 +150,11 @@ export const refillSendsToolDefinitions = [
     },
 ];
 export function refillSendsCommand(input = {}) {
-    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
     const senders = normalizeStrings(input.senders);
     const senderIds = normalizeStrings(input.senderIds);
     const senderNames = normalizeStrings(input.senderNames);
     const hasSenderSelectors = senders.length > 0 || senderIds.length > 0 || senderNames.length > 0;
     const yolo = input.yolo === true;
-    const executionMode = input.executionMode ?? (yolo ? "yolo" : "manual");
     const targetDate = normalizeTargetDate(input.targetDate);
     const untilDate = targetDate ? null : normalizeUntilDate(input.untilDate);
     const horizonSendDays = targetDate || untilDate
@@ -161,9 +173,6 @@ export function refillSendsCommand(input = {}) {
         promptName: "refill-sends",
         workflowPromptName: "refill-sends-workflow",
         yolo,
-        executionMode,
-        workspaceId,
-        workspaceResolution: workspaceId ? "explicit" : "active_config",
         intent,
         targetDate,
         untilDate,
@@ -202,9 +211,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}"${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}"`
@@ -218,11 +225,9 @@ export function refillSendsCommand(input = {}) {
             "If get_refill_target_plan returns status complete, report eligible sender ledger, target.senderRefillPlans, gross target, selected days, sent count, scheduled count, projected count, campaign ids, targetShapeRevision, and no-op proof without asking for approval.",
             "Refill target lanes are connection invites (send_invite), standalone paid InMails (send_inmail_closed), or unified Sales Nav cascades represented publicly as send_inmail_closed with campaign classification sales_nav_cascade. For a Sales Nav cascade, refill the selected campaign first; its sequence can route prospects to Open InMail, paid InMail while fresh credits are >= 5, or same-campaign connection fallback without asking for separate open/paid/connection campaigns. Do not count send_dm as horizon target capacity.",
             "If remainingReadyOrProjectedGap is 0 but remainingProjectedGap is positive, run only a persistent read-only scheduler wait/reread loop; do not ask for prep/import/approval and do not close out while scheduler pickup is the only remaining state.",
-            `Resolve route with resolve_campaign_fill_route({ intent: "${intent}"${workspaceId ? `, workspaceId: "${workspaceId}"` : ""}${input.campaignId ? `, campaignId: "${input.campaignId}"` : ""}${input.tableId ? `, tableId: "${input.tableId}"` : ""} }).`,
-            `If the plain route shows stale managed waterfall evidence, archived/completed shared slots, or targets that do not cover the selected sender set, immediately call resolve_campaign_fill_route({ intent: "active"${workspaceId ? `, workspaceId: "${workspaceId}"` : ""} }) and inspect current dashboard-active ACTIVE/PAUSED campaign-backed sequence campaigns before declaring a sender blocked.`,
-            workspaceId
-                ? `Call list_senders({ workspaceId: "${workspaceId}" }) and get_sender_routing({ workspaceId: "${workspaceId}" }), then resolve sender selectors against active enrolled campaign-backed sequence senders.`
-                : "Call list_senders and get_sender_routing, then resolve sender selectors against active enrolled campaign-backed sequence senders.",
+            `Resolve route with resolve_campaign_fill_route({ intent: "${intent}"${input.campaignId ? `, campaignId: "${input.campaignId}"` : ""}${input.tableId ? `, tableId: "${input.tableId}"` : ""} }).`,
+            'If the plain route shows stale managed waterfall evidence, archived/completed shared slots, or targets that do not cover the selected sender set, immediately call resolve_campaign_fill_route({ intent: "active" }) and inspect current dashboard-active ACTIVE/PAUSED campaign-backed sequence campaigns before declaring a sender blocked.',
+            "Call list_senders and get_sender_routing, then resolve sender selectors against active enrolled campaign-backed sequence senders.",
             targetDate
                 ? `Use fill window targetDate="${targetDate}" as one exact sender-local date; prepare rows only for scheduler-fillable slots on that date. Do not treat it as an inclusive through-date.`
                 : untilDate
@@ -234,14 +239,14 @@ 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, and returns the post-refresh targetPlan before any prep/import/approval/start action is chosen.",
+            "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.",
             "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/read-only wait action inside that packet. Unbounded approval, start_campaign, source-family switches, 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.",
@@ -283,14 +288,12 @@ export function refillSendsCommand(input = {}) {
                     tableId: input.tableId,
                     intent,
                     approvalMode,
-                    workspaceId,
                 },
             },
         },
     };
 }
 function targetPlanInputFor(input = {}) {
-    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
     const senders = normalizeStrings(input.senders);
     const senderIds = normalizeStrings(input.senderIds);
     const senderNames = normalizeStrings(input.senderNames);
@@ -315,7 +318,6 @@ function targetPlanInputFor(input = {}) {
                     ? {}
                     : { horizonSendDays }),
         approvalMode,
-        ...(workspaceId ? { workspaceId } : {}),
     };
 }
 function recordValue(value) {
@@ -326,6 +328,45 @@ function recordValue(value) {
 function stringValue(value) {
     return typeof value === "string" && value.trim() ? value.trim() : null;
 }
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function prepareRowSelectorValue(value) {
+    const selector = recordValue(value);
+    const type = stringValue(selector?.type);
+    if (type !== "needsEnrichment" &&
+        type !== "needsApproval" &&
+        type !== "needsGeneratedMessage" &&
+        type !== "reviewBatch" &&
+        type !== "staleGeneratedMessages") {
+        return undefined;
+    }
+    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);
+    }
+    return result;
+}
 function paidRefreshActionFrom(value) {
     const action = recordValue(value);
     if (!action || action.type !== "refresh_paid_inmail_credits")
@@ -373,25 +414,493 @@ function collectPaidInmailRefreshActions(plan) {
         add(action);
     return [...bySender.values()];
 }
-export async function executeRefillSendsCommand(input = {}) {
-    const yolo = input.yolo === true;
-    const executionMode = input.executionMode ?? (yolo ? "yolo" : "manual");
-    const mustHaveWorkspace = yolo || input.requireWorkspace === true || executionMode === "scheduled";
-    const workspaceContext = mustHaveWorkspace
-        ? createWorkspaceContext({
-            workspaceId: input.workspaceId,
-            executionMode,
-            toolName: "refill_sends",
-        })
-        : null;
-    if (workspaceContext && !workspaceContext.ok) {
-        return workspaceContext;
+function firstGlobalAction(plan) {
+    const root = recordValue(plan);
+    const target = recordValue(root?.target);
+    const globalActionQueue = Array.isArray(target?.globalActionQueue)
+        ? target.globalActionQueue
+        : [];
+    const [first] = globalActionQueue;
+    return recordValue(first);
+}
+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;
+    }
+    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 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) {
+    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 result = await api.post("/api/v3/workflow-tables/cells/approve-batch", {
+        tableId,
+        ...(columnId ? { columnId } : {}),
+        limit,
+        scope: "generated_unapproved",
+    });
+    return { status: "executed_and_reread", result };
+}
+async function continueSignalDiscoverySource(action) {
+    const campaignOfferId = actionCampaignId(action);
+    const sourceLeadListId = actionSourceLeadListId(action);
+    const sourceFingerprint = actionSourceFingerprint(action);
+    const toolInput = actionToolInput(action);
+    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: "refused",
+            refusalReason: "continue_signal_discovery_source action is missing campaignOfferId, sourceLeadListId, or sourceFingerprint",
+        };
+    }
+    const requestedProvider = actionLeadSourceProvider(action);
+    if (requestedProvider &&
+        requestedProvider !== "signal-discovery" &&
+        requestedProvider !== "campaign-tracked-post") {
+        return {
+            status: "refused",
+            refusalReason: "continue_signal_discovery_source can only run for Signal Discovery source families",
+        };
+    }
+    const api = getApi();
+    const campaign = await api.get(`/api/v2/campaign-offers/${campaignOfferId}`);
+    if (campaign.leadSourceProvider !== "signal-discovery" &&
+        campaign.leadSourceProvider !== "campaign-tracked-post") {
+        return {
+            status: "refused",
+            refusalReason: "campaign leadSourceProvider is not Signal Discovery; refusing same-source continuation",
+        };
+    }
+    if (campaign.selectedLeadListId &&
+        campaign.selectedLeadListId !== sourceLeadListId) {
+        return {
+            status: "refused",
+            refusalReason: "campaign selectedLeadListId changed since the plan packet; rerun get_refill_target_plan before source continuation",
+        };
+    }
+    const sourceMeta = 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 = 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: "refused",
+            refusalReason: "no reusable Signal Discovery keywords were found on the campaign tabs",
+        };
+    }
+    markProviderPromptLoaded({
+        provider: "signal-discovery",
+        campaignOfferId,
+    });
+    const searchSummary = await searchSignals({
+        type: "keywords",
+        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,
+        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,
+        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: "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) {
+    const errors = [];
+    for (let attempt = 1; attempt <= PAID_INMAIL_REFRESH_MAX_ATTEMPTS; attempt += 1) {
+        try {
+            const receipt = await refreshPaidInmailCredits({ senderId });
+            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) {
+    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,
+                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,
+                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);
+        case "approve_messages":
+            return approveGeneratedMessagesBatch(action);
+        default:
+            return {
+                status: "refused",
+                refusalReason: `action ${String(action.type)} is not a safe yolo primitive`,
+            };
     }
-    const scopedInput = workspaceContext && workspaceContext.ok
-        ? { ...input, workspaceId: workspaceContext.context.workspaceId }
-        : input;
-    const command = refillSendsCommand(scopedInput);
-    if (!yolo) {
+}
+export async function executeRefillSendsCommand(input = {}) {
+    const command = refillSendsCommand(input);
+    if (input.yolo !== true) {
         return {
             ...command,
             autoPaidInmailRefresh: {
@@ -401,44 +910,60 @@ 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
-        ? workspaceContext.context.workspaceId
-        : normalizeExplicitWorkspaceId(scopedInput.workspaceId);
-    const targetPlanInput = targetPlanInputFor(scopedInput);
+    const targetPlanInput = targetPlanInputFor(input);
     const targetPlanBeforePaidRefresh = await getRefillTargetPlan(targetPlanInput);
     const refreshActions = collectPaidInmailRefreshActions(targetPlanBeforePaidRefresh);
     const refreshedPaidInmailSenderIds = [];
     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);
+        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 selectedAction = refreshActions.length > 0 ? null : firstGlobalAction(targetPlan);
+    const primitiveAttempt = refreshActions.length > 0
+        ? null
+        : await executeOneYoloPrimitive(selectedAction);
+    const shouldRereadAfterPrimitive = primitiveAttempt?.status === "executed_and_reread" ||
+        primitiveAttempt?.status === "read_only_reread";
+    const postActionTargetPlan = shouldRereadAfterPrimitive
+        ? await getRefillTargetPlan(targetPlanInput)
+        : null;
+    const finalTargetPlan = postActionTargetPlan ?? targetPlan;
     return {
         ...command,
-        targetPlan,
+        targetPlan: finalTargetPlan,
         targetPlanBeforePaidRefresh: refreshActions.length > 0 ? targetPlanBeforePaidRefresh : null,
+        targetPlanBeforeYoloPrimitive: refreshActions.length === 0 && postActionTargetPlan ? targetPlan : null,
         autoPaidInmailRefresh: {
             enabled: true,
             status: refreshActions.length === 0
@@ -451,11 +976,27 @@ export async function executeRefillSendsCommand(input = {}) {
             refreshReceipts,
             attemptedSenderIds: refreshActions.map((action) => action.senderId),
             targetPlanReread: refreshActions.length > 0,
-            workspaceId,
-            workspaceResolution: workspaceId ? "explicit" : "active_config",
             note: refreshActions.length > 0
-                ? "refill_sends refreshed stale paid InMail credit facts internally, once per sender, then returned the post-refresh targetPlan."
+                ? "refill_sends refreshed stale paid InMail credit facts internally with bounded retries, once per sender, then returned the post-refresh targetPlan."
                 : "No stale or missing paid InMail credit refresh candidates were present in the initial target plan.",
         },
+        yoloExecution: refreshActions.length > 0
+            ? {
+                enabled: true,
+                status: "skipped_after_paid_refresh",
+                selectedAction: null,
+                targetPlanReread: true,
+            }
+            : {
+                enabled: true,
+                status: primitiveAttempt?.status ?? "no_action",
+                selectedAction,
+                result: primitiveAttempt?.result,
+                targetPlanReread: shouldRereadAfterPrimitive,
+                refusalReason: primitiveAttempt?.refusalReason,
+                postActionFirstAction: postActionTargetPlan
+                    ? firstGlobalAction(postActionTargetPlan)
+                    : null,
+            },
     };
 }