@sellable/mcp 0.1.504 → 0.1.506

package/dist/tools/refill-sends.js

@@ -1,15 +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 { getPrepareCampaignMessagesStatus, startPrepareCampaignMessages, } from "./campaign-message-preparation.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;
+const PREPARE_POLL_INTERVAL_MS = 5_000;
+const PREPARE_POLL_TIMEOUT_MS = 120_000;
+const TERMINAL_PREPARE_STATUSES = new Set([
+    "succeeded",
+    "failed",
+    "cancelled",
+]);
 function normalizeStrings(values) {
     if (!Array.isArray(values))
         return [];
@@ -19,11 +19,6 @@ 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;
@@ -69,24 +64,10 @@ 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 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.",
+        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.",
         inputSchema: {
             type: "object",
             properties: {
@@ -94,6 +75,19 @@ 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" },
@@ -150,11 +144,13 @@ 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
@@ -173,6 +169,9 @@ export function refillSendsCommand(input = {}) {
         promptName: "refill-sends",
         workflowPromptName: "refill-sends-workflow",
         yolo,
+        executionMode,
+        workspaceId,
+        workspaceResolution: workspaceId ? "explicit" : "active_config",
         intent,
         targetDate,
         untilDate,
@@ -211,7 +210,9 @@ 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}"${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}"`
@@ -225,9 +226,11 @@ 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}"${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.",
+            `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.",
             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
@@ -239,14 +242,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/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.",
+            "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.",
             "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 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."
+            ? "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."
             : 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.",
@@ -288,12 +291,14 @@ 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);
@@ -318,6 +323,7 @@ function targetPlanInputFor(input = {}) {
                     ? {}
                     : { horizonSendDays }),
         approvalMode,
+        ...(workspaceId ? { workspaceId } : {}),
     };
 }
 function recordValue(value) {
@@ -331,41 +337,46 @@ function stringValue(value) {
 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 approvalModeValue(value) {
+    return value === "approve" || value === "mark_ready" ? value : null;
 }
-function prepareRowSelectorValue(value) {
+function positiveIntegerValue(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    const parsed = Math.floor(value);
+    return parsed > 0 ? parsed : null;
+}
+function rowSelectorValue(value) {
     const selector = recordValue(value);
     const type = stringValue(selector?.type);
-    if (type !== "needsEnrichment" &&
-        type !== "needsApproval" &&
-        type !== "needsGeneratedMessage" &&
-        type !== "reviewBatch" &&
-        type !== "staleGeneratedMessages") {
-        return undefined;
+    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;
     }
-    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 === "reviewBatch") {
+        const basisHash = stringValue(selector.basisHash);
+        return basisHash
+            ? withLimit({ type, basisHash })
+            : withLimit({ type });
     }
-    return result;
+    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));
 }
 function paidRefreshActionFrom(value) {
     const action = recordValue(value);
@@ -417,490 +428,148 @@ function collectPaidInmailRefreshActions(plan) {
 function firstGlobalAction(plan) {
     const root = recordValue(plan);
     const target = recordValue(root?.target);
-    const globalActionQueue = Array.isArray(target?.globalActionQueue)
+    const queue = 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));
+    return recordValue(queue[0]);
 }
-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) {
+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 {
-            status: "refused",
-            refusalReason: "approve_messages action is missing tableId or a bounded rowSelector.limit",
+            waited: false,
+            timedOut: false,
+            receipt: params.startReceipt,
         };
     }
-    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",
-        };
+    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,
+            };
+        }
     }
-    if (campaign.selectedLeadListId &&
-        campaign.selectedLeadListId !== sourceLeadListId) {
+    return {
+        waited: true,
+        timedOut: true,
+        receipt: lastStatus,
+    };
+}
+async function executeYoloGlobalAction(params) {
+    const action = params.action;
+    if (!action) {
         return {
-            status: "refused",
-            refusalReason: "campaign selectedLeadListId changed since the plan packet; rerun get_refill_target_plan before source continuation",
+            status: "no_global_action",
+            applied: false,
+            note: "No target.globalActionQueue[0] action was present after the fresh target-plan reread.",
         };
     }
-    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) {
+    const actionType = stringValue(action.type);
+    const toolName = stringValue(action.toolName);
+    const yoloEligible = action.yoloEligible === true;
+    if (!yoloEligible) {
         return {
-            status: "refused",
-            refusalReason: "no reusable Signal Discovery keywords were found on the campaign tabs",
+            status: "not_yolo_eligible",
+            applied: false,
+            action,
+            note: "The first global action was not marked yoloEligible:true, so refill_sends did not mutate.",
         };
     }
-    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) {
+    if (actionType !== "prepare_messages" &&
+        toolName !== "start_campaign_message_preparation") {
         return {
-            status: "refused",
-            refusalReason: "Signal Discovery search returned no new recommended posts to continue the source",
-            result: { keywords, excludedPostIds, searchSummary },
+            status: "unsupported_action",
+            applied: false,
+            action,
+            note: "refill_sends currently auto-applies yolo prepare_messages actions; this action needs the skill workflow/operator path.",
         };
     }
-    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) {
+    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) {
         return {
-            status: "refused",
-            refusalReason: stringValue(selectionResult.message) ??
-                "select_promising_posts did not select any posts",
-            result: { keywords, selectedPostIds, selectionResult },
+            status: "missing_campaign_id",
+            applied: false,
+            action,
+            note: "The yolo prepare_messages action did not include a campaignId.",
         };
     }
-    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) {
+    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) {
         return {
-            status: "refused",
-            refusalReason: stringValue(importRecord.message) ??
-                `Signal Discovery import returned ${String(importRecord.error)}`,
-            result: {
-                keywords,
-                excludedPostIds,
-                selectedPostIds,
-                selectionResult,
-                importResult,
-            },
+            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.",
         };
     }
-    return {
-        status: "executed_and_reread",
-        result: {
-            provider: "signal-discovery",
-            campaignOfferId,
-            previousSourceLeadListId: sourceLeadListId,
-            sourceFingerprint,
-            keywords,
-            excludedPostIds,
-            selectedPostIds,
-            sourceRowLimit,
-            maxPostsToScrape: selectedPostIds.length,
-            searchSummary,
-            selectionResult,
-            importResult,
-        },
+    const startInput = {
+        campaignId,
+        ...(tableId ? { tableId } : {}),
+        ...(targetPreparedMessages ? { targetPreparedMessages } : {}),
+        ...(approvalMode ? { approvalMode } : {}),
+        ...(rowSelector ? { rowSelector } : {}),
+        ...(params.workspaceId ? { workspaceId: params.workspaceId } : {}),
     };
-}
-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);
-            }
-        }
-    }
+    const startedAt = new Date().toISOString();
+    const startReceipt = await startPrepareCampaignMessages(startInput);
+    const waitReceipt = await waitForPrepareAction({
+        workspaceId: params.workspaceId,
+        campaignId,
+        tableId,
+        startReceipt,
+    });
     return {
-        receipt: null,
-        attempts: PAID_INMAIL_REFRESH_MAX_ATTEMPTS,
-        errors,
+        status: waitReceipt.timedOut ? "applied_wait_timeout" : "applied",
+        applied: true,
+        action,
+        toolName: "start_campaign_message_preparation",
+        input: startInput,
+        startedAt,
+        endedAt: new Date().toISOString(),
+        startReceipt,
+        waitReceipt,
     };
 }
-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`,
-            };
-    }
-}
 export async function executeRefillSendsCommand(input = {}) {
-    const command = refillSendsCommand(input);
-    if (input.yolo !== true) {
+    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;
+    }
+    const scopedInput = workspaceContext && workspaceContext.ok
+        ? { ...input, workspaceId: workspaceContext.context.workspaceId }
+        : input;
+    const command = refillSendsCommand(scopedInput);
+    if (!yolo) {
         return {
             ...command,
             autoPaidInmailRefresh: {
@@ -910,60 +579,53 @@ 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 targetPlanInput = targetPlanInputFor(input);
+    const workspaceId = workspaceContext && workspaceContext.ok
+        ? workspaceContext.context.workspaceId
+        : normalizeExplicitWorkspaceId(scopedInput.workspaceId);
+    const targetPlanInput = targetPlanInputFor(scopedInput);
     const targetPlanBeforePaidRefresh = await getRefillTargetPlan(targetPlanInput);
     const refreshActions = collectPaidInmailRefreshActions(targetPlanBeforePaidRefresh);
     const refreshedPaidInmailSenderIds = [];
     const failedPaidInmailRefreshes = [];
     const refreshReceipts = [];
     for (const action of refreshActions) {
-        const refreshResult = await refreshPaidInmailCreditsWithRetry(action.senderId);
-        if (refreshResult.receipt) {
+        try {
+            const receipt = await refreshPaidInmailCredits({
+                senderId: action.senderId,
+                ...(workspaceId ? { workspaceId } : {}),
+            });
             refreshedPaidInmailSenderIds.push(action.senderId);
             refreshReceipts.push({
                 senderId: action.senderId,
                 actionKey: action.actionKey ?? null,
-                attempts: refreshResult.attempts,
-                retryErrors: refreshResult.errors,
-                receipt: refreshResult.receipt,
+                receipt,
             });
         }
-        else {
+        catch (error) {
             failedPaidInmailRefreshes.push({
                 senderId: action.senderId,
-                attempts: refreshResult.attempts,
-                error: refreshResult.errors[refreshResult.errors.length - 1] ??
-                    "paid InMail credit refresh failed",
-                errors: refreshResult.errors,
+                error: error instanceof Error ? error.message : String(error),
             });
         }
     }
     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
+    const targetPlanBeforeYoloAction = targetPlan;
+    const yoloExecution = await executeYoloGlobalAction({
+        action: firstGlobalAction(targetPlan),
+        workspaceId,
+    });
+    const finalTargetPlan = yoloExecution.applied
         ? await getRefillTargetPlan(targetPlanInput)
-        : null;
-    const finalTargetPlan = postActionTargetPlan ?? targetPlan;
+        : targetPlan;
     return {
         ...command,
         targetPlan: finalTargetPlan,
+        targetPlanBeforeYoloAction,
         targetPlanBeforePaidRefresh: refreshActions.length > 0 ? targetPlanBeforePaidRefresh : null,
-        targetPlanBeforeYoloPrimitive: refreshActions.length === 0 && postActionTargetPlan ? targetPlan : null,
         autoPaidInmailRefresh: {
             enabled: true,
             status: refreshActions.length === 0
@@ -976,27 +638,18 @@ 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 with bounded retries, once per sender, then returned the post-refresh targetPlan."
+                ? "refill_sends refreshed stale paid InMail credit facts internally, once per sender, then reread the post-refresh targetPlan before yolo action execution."
                 : "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,
-            },
+        yoloExecution: {
+            enabled: true,
+            workspaceId,
+            workspaceResolution: workspaceId ? "explicit" : "active_config",
+            targetPlanRereadAfterAction: yoloExecution.applied,
+            ...yoloExecution,
+        },
     };
 }