@sellable/mcp 0.1.600 → 0.1.602-phase110.20260717134543

package/dist/refill-run-loop.js

@@ -291,7 +291,20 @@ function sanitizeSchedulerRunReceipt(raw) {
             prefilterReasons,
             prefilterReasonsByType,
             skippedReasons,
+            // CAP110-21: surface the raw skip/defer gate strings so the operator sees
+            // the actual reason a considered cell was rejected instead of only the
+            // normalized "other" bucket.
+            ...(rawReceipt.skippedDetailedReasons
+                ? {
+                    skippedDetailedReasons: schedulerRunCountMap(rawReceipt.skippedDetailedReasons),
+                }
+                : {}),
             deferredReasons,
+            ...(rawReceipt.deferredDetailedReasons
+                ? {
+                    deferredDetailedReasons: schedulerRunCountMap(rawReceipt.deferredDetailedReasons),
+                }
+                : {}),
             skipReasons,
             campaignScopeSummary: schedulerRunCampaignScopeSummary(rawReceipt.campaignScopeSummary),
             ...(stringValue(rawReceipt.summary)
@@ -489,6 +502,104 @@ function runScopedSignalDiscoveryAttemptUpdate(action, runState, now) {
         ],
     };
 }
+// Phase 110-05: Sales Nav / Prospeo same-source continuation gets exactly one
+// bounded add per (campaign, sender) per run, mirroring the Signal Discovery
+// run-scoped attempt bound so the loop never repeats an unchanged failed
+// same-source mutation.
+const PROVIDER_SOURCE_CONTINUATION_TYPES = new Set([
+    "continue_sales_nav_source",
+    "continue_prospeo_source",
+]);
+function hasRunScopedProviderSourceAttempt(action, runState) {
+    const campaignId = actionCampaignId(action);
+    const senderId = actionSenderId(action);
+    if (!campaignId)
+        return false;
+    return arrayValue(runState.providerSourceAttempts)
+        .filter(isRecord)
+        .some((attempt) => stringValue(attempt.campaignId) === campaignId &&
+        stringValue(attempt.senderId) === senderId);
+}
+function runScopedProviderSourceAttemptUpdate(action, runState, now) {
+    const campaignId = actionCampaignId(action);
+    const senderId = actionSenderId(action);
+    if (!campaignId)
+        return {};
+    const attempts = arrayValue(runState.providerSourceAttempts).filter(isRecord);
+    return {
+        providerSourceAttempts: [
+            ...attempts.filter((attempt) => stringValue(attempt.campaignId) !== campaignId ||
+                stringValue(attempt.senderId) !== senderId),
+            {
+                campaignId,
+                senderId,
+                provider: stringValue(actionToolInput(action).provider),
+                sourceFingerprint: actionSourceFingerprint(action),
+                attemptedAt: now.toISOString(),
+                scope: "refill_run",
+            },
+        ],
+    };
+}
+// CAP110-18: A prepare_messages job that terminalizes with stopReason
+// no_eligible_rows for a (campaignId, actionType) proved the source frontier dry
+// for that lane. Record the dry-source attempt run-scoped and refuse an
+// identical re-prep for that key, mirroring the provider-source one-attempt
+// bound above, so the loop never re-runs the same dry prep three times (run
+// cmrow9c4q/cmrowh0tc/cmrowr7rz: three identical preps at cursorPosition 1411).
+// A same-source add for the campaign clears the bound so a genuine re-prep
+// against replenished rows can still run.
+function actionRefillLaneType(action) {
+    const toolInput = actionToolInput(action);
+    const ids = actionIds(action);
+    return (stringValue(action.actionType) ??
+        stringValue(toolInput.actionType) ??
+        stringValue(toolInput.refillLaneKey) ??
+        stringValue(ids.actionType));
+}
+function hasRunScopedDrySourcePrepAttempt(action, runState) {
+    const campaignId = actionCampaignId(action);
+    if (!campaignId)
+        return false;
+    const actionType = actionRefillLaneType(action);
+    return arrayValue(runState.drySourcePrepAttempts)
+        .filter(isRecord)
+        .some((attempt) => stringValue(attempt.campaignId) === campaignId &&
+        stringValue(attempt.actionType) === actionType);
+}
+function runScopedDrySourcePrepAttemptUpdate(action, runState, stopReason, now) {
+    const campaignId = actionCampaignId(action);
+    if (!campaignId)
+        return {};
+    const actionType = actionRefillLaneType(action);
+    const attempts = arrayValue(runState.drySourcePrepAttempts).filter(isRecord);
+    return {
+        drySourcePrepAttempts: [
+            ...attempts.filter((attempt) => stringValue(attempt.campaignId) !== campaignId ||
+                stringValue(attempt.actionType) !== actionType),
+            {
+                campaignId,
+                actionType,
+                stopReason,
+                sourceFingerprint: actionSourceFingerprint(action),
+                attemptedAt: now.toISOString(),
+                scope: "refill_run",
+            },
+        ],
+    };
+}
+// A bounded same-source add (Signal Discovery, Sales Nav, Prospeo) for a
+// campaign may replenish its frontier, so clear that campaign's dry-source prep
+// bounds and let the planner offer a genuine re-prep against the new rows.
+function clearRunScopedDrySourcePrepAttempts(campaignId, runState) {
+    if (!campaignId)
+        return {};
+    const attempts = arrayValue(runState.drySourcePrepAttempts).filter(isRecord);
+    const remaining = attempts.filter((attempt) => stringValue(attempt.campaignId) !== campaignId);
+    if (remaining.length === attempts.length)
+        return {};
+    return { drySourcePrepAttempts: remaining };
+}
 function laneExhaustionRunState(plan, action, currentRunState, reason, now) {
     const senderId = actionSenderId(action);
     const evergreen = recordValue(plan.evergreen) ?? {};
@@ -1387,6 +1498,43 @@ async function gateExecute(input, deps, ctx) {
         };
         outcome = did;
     }
+    else if (typeof action.type === "string" &&
+        PROVIDER_SOURCE_CONTINUATION_TYPES.has(action.type) &&
+        hasRunScopedProviderSourceAttempt(action, ctx.runState)) {
+        // Phase 110-05: Sales Nav / Prospeo same-source add already ran once this
+        // run for this (campaign, sender); do not repeat the unchanged mutation.
+        did = {
+            status: "refused",
+            refusalReason: "same-provider-source continuation already used its bounded run-scoped add without closing projected coverage",
+            result: {
+                scope: "refill_run",
+                campaignId: actionCampaignId(action),
+                senderId: actionSenderId(action),
+                sourceFingerprint: actionSourceFingerprint(action),
+            },
+        };
+        outcome = did;
+    }
+    else if (action.type === "prepare_messages" &&
+        hasRunScopedDrySourcePrepAttempt(action, ctx.runState)) {
+        // CAP110-18: this (campaign, lane) prep already terminalized
+        // no_eligible_rows this run and no same-source add has replenished it since.
+        // Refuse the identical re-prep so the loop escalates to source continuation
+        // or terminalizes typed instead of re-running the dry frontier.
+        did = {
+            status: "refused",
+            refusalReason: "prepare_messages already proved no_eligible_rows for this campaign/lane this run; refusing an identical dry-source re-prep",
+            result: {
+                scope: "refill_run",
+                blocker: "dry_source_prep_refused",
+                campaignId: actionCampaignId(action),
+                actionType: actionRefillLaneType(action),
+                senderId: actionSenderId(action),
+                sourceFingerprint: actionSourceFingerprint(action),
+            },
+        };
+        outcome = did;
+    }
     else if (action.type === "start_paused_campaign") {
         did = await deps.executors.executeStartCampaignPrimitive({
             action,
@@ -1588,9 +1736,16 @@ async function verifyPrepareAction(input, deps, ctx, action, budgets) {
                     },
                 ],
             });
+            const prepStopReason = stringValue(statusRecord.stopReason);
+            // CAP110-18: a dry (no_eligible_rows, zero prepared) terminal records the
+            // run-scoped dry-source bound so the identical prep is refused next cycle.
+            const drySourcePrepUpdate = prepStopReason === "no_eligible_rows" && preparedCount === 0
+                ? runScopedDrySourcePrepAttemptUpdate(action, ctx.runState, prepStopReason, deps.now?.() ?? new Date())
+                : {};
             return advanceBackToPlan(input, deps, ctx, {
+                ...drySourcePrepUpdate,
                 progress: mergeProgress(ctx, {
-                    lastPrepStopReason: stringValue(statusRecord.stopReason),
+                    lastPrepStopReason: prepStopReason,
                     lastPreparedCount: preparedCount,
                     lastCheckedRows: checkedRows,
                 }),
@@ -1760,6 +1915,37 @@ async function runWindowSweepWalk(input, deps, ctx) {
         null;
     return { sweepReceipts, schedulerRunReceipt };
 }
+// CAP110-21: Find an exact target-bound run_scheduler_sweep the current plan
+// already carries (a per-sender one-slot packet with expectedTargets and a
+// bounded maxPlacements), distinct from the broad workspace JIT walk. Used to
+// fall through to that exact sweep when the broad workspace sweep placed zero
+// but a genuinely open slot with eligible supply remains (the dotwork Kyle Byrd
+// last Monday slot).
+function exactTargetBoundSchedulerSweep(plan) {
+    const queue = arrayValue(recordValue(plan)?.globalActionQueue);
+    for (const entry of queue) {
+        const candidate = recordValue(entry);
+        if (!candidate)
+            continue;
+        if (stringValue(candidate.type) !== "run_scheduler_sweep")
+            continue;
+        const toolInput = actionToolInput(candidate);
+        const expectedTargets = arrayValue(toolInput.expectedTargets);
+        const maxPlacements = numberValue(toolInput.maxPlacements) ?? 0;
+        if (expectedTargets.length > 0 && maxPlacements > 0) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function schedulerPrimitivePlacedCount(did) {
+    const payload = resultPayload(did);
+    const receipt = recordValue(payload.receipt);
+    return (numberValue(receipt?.cellsScheduled) ??
+        numberValue(recordValue(payload.changedCounts)?.total) ??
+        numberValue(payload.cellsScheduled) ??
+        0);
+}
 async function verifySchedulerWait(input, deps, ctx, action, budgets) {
     const progress = runStateProgress(ctx);
     const enteredAt = stringValue(progress.schedulerWaitEnteredAt) ??
@@ -1922,6 +2108,51 @@ async function verifySchedulerWait(input, deps, ctx, action, budgets) {
             return waitResult;
     }
     if (zeroScheduledFresh) {
+        // CAP110-21: the broad workspace sweep placed zero, but the plan may still
+        // carry an exact per-sender one-slot run_scheduler_sweep packet (the dotwork
+        // Kyle Byrd last Monday slot: one open slot, 27+ ready rows, a healthy
+        // sender, 49 fresh credits). Fall through to that exact target-bound sweep
+        // once per world state before terminalizing so a genuinely open slot with
+        // eligible supply is filled instead of stranded one short.
+        const exactSweep = exactTargetBoundSchedulerSweep(ctx.plan);
+        const exactSweepFiredForState = currentStateRevision !== null &&
+            stringValue(runStateProgress(ctx).exactTargetSweepStateRevision) ===
+                currentStateRevision;
+        if (exactSweep &&
+            !exactSweepFiredForState &&
+            deps.executors.executeOneYoloPrimitive) {
+            const did = await deps.executors.executeOneYoloPrimitive(exactSweep, input.workspaceId);
+            const placed = schedulerPrimitivePlacedCount(did);
+            await deps.runClient.recordRunOutcome({
+                workspaceId: input.workspaceId,
+                runId: ctx.runId,
+                fence: ctx.fence,
+                eventId: lastEventId(ctx),
+                did,
+                outcome: {
+                    status: placed > 0
+                        ? "exact_target_sweep_placed"
+                        : "exact_target_sweep_zero",
+                    placed,
+                    actionKey: stringValue(exactSweep.actionKey),
+                },
+            });
+            ctx.runState = mergeRunState(ctx.runState, {
+                progress: mergeProgress(ctx, {
+                    exactTargetSweepFired: true,
+                    exactTargetSweepPlaced: placed,
+                    exactTargetSweepAt: (deps.now?.() ?? new Date()).toISOString(),
+                    ...(currentStateRevision
+                        ? { exactTargetSweepStateRevision: currentStateRevision }
+                        : {}),
+                }),
+            });
+            if (placed > 0) {
+                // The exact sweep filled the open slot; replan so coverage reflects the
+                // placement instead of terminalizing one short.
+                return advanceBackToPlan(input, deps, ctx);
+            }
+        }
         // The just-verified sweep placed zero cells, so every remaining candidate
         // is deferred by scheduler gates (per-prospect cooldowns, closed windows,
         // credit thresholds). Spinning on the wait cannot change that; end with a
@@ -2002,7 +2233,25 @@ async function gateVerify(input, deps, ctx, budgets) {
     if (actionType === "continue_signal_discovery_source" &&
         stringValue(recordValue(ctx.runState.lastOutcome)?.status) ===
             "executed_and_reread") {
-        return advanceBackToPlan(input, deps, ctx, runScopedSignalDiscoveryAttemptUpdate(action, ctx.runState, deps.now?.() ?? new Date()));
+        return advanceBackToPlan(input, deps, ctx, {
+            ...runScopedSignalDiscoveryAttemptUpdate(action, ctx.runState, deps.now?.() ?? new Date()),
+            // CAP110-18: replenishing this campaign's source clears its dry-source
+            // prep bound so a genuine re-prep against the new rows can run.
+            ...clearRunScopedDrySourcePrepAttempts(actionCampaignId(action), ctx.runState),
+        });
+    }
+    if (typeof actionType === "string" &&
+        PROVIDER_SOURCE_CONTINUATION_TYPES.has(actionType) &&
+        stringValue(recordValue(ctx.runState.lastOutcome)?.status) ===
+            "executed_and_reread") {
+        // Phase 110-05: record the bounded same-source add so the run does not
+        // repeat it for this (campaign, sender) before replanning.
+        return advanceBackToPlan(input, deps, ctx, {
+            ...runScopedProviderSourceAttemptUpdate(action, ctx.runState, deps.now?.() ?? new Date()),
+            // CAP110-18: a same-source add may replenish the frontier; clear the
+            // campaign's dry-source prep bound so the re-prep is allowed.
+            ...clearRunScopedDrySourcePrepAttempts(actionCampaignId(action), ctx.runState),
+        });
     }
     if (actionType === "wait_for_scheduler") {
         return verifySchedulerWait(input, deps, ctx, action, budgets);

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

@@ -233,6 +233,19 @@ export declare function approveGeneratedMessagesBatch(action: Record<string, unk
 }>;
 export declare function approveSequenceRowsBatch(action: Record<string, unknown>, workspaceId?: string): Promise<YoloPrimitiveAttempt>;
 export declare function continueSignalDiscoverySource(action: Record<string, unknown>, workspaceId?: string): Promise<YoloPrimitiveAttempt>;
+/**
+ * Phase 110-05: bounded SAME-provider-source continuation for cold-outbound
+ * Sales Nav / Prospeo campaigns. Mirrors continueSignalDiscoverySource's
+ * guardrails (campaign + provider + selected-source match) and reuses the
+ * EXISTING import_leads tool to add leads from the campaign's own saved
+ * provider search (mode "add") once eligible/prepared rows are receipt-proven
+ * exhausted. It never switches source families and never creates a campaign.
+ * The add is bounded by the packet's existing sourceRowLimit cap; when the
+ * packet carries no reusable provider search reference the add cannot start
+ * autonomously and the executor refuses with a bounded reason so the run
+ * records the attempt instead of looping on an unchanged mutation.
+ */
+export declare function continueProviderSource(action: Record<string, unknown>, workspaceId?: string): Promise<YoloPrimitiveAttempt>;
 export declare function refreshPaidInmailCreditsWithRetry(senderId: string, workspaceId: string, options?: PaidInmailCreditRefreshOptions): Promise<{
     receipt: import("./senders.js").RefreshPaidInmailCreditsResponse;
     attempts: number;

package/dist/tools/refill-executors.js

@@ -12,6 +12,10 @@ const PAID_INMAIL_REFRESH_RETRY_DELAY_MS = Number(process.env.SELLABLE_MCP_PAID_
 const SIGNAL_DISCOVERY_MIN_REFILL_POSTS = 3;
 const SIGNAL_DISCOVERY_MAX_REFILL_POSTS = 10;
 const SIGNAL_DISCOVERY_TARGET_ROWS_PER_POST = 150;
+// Phase 110-05: bound each same-source Sales Nav / Prospeo yolo continuation to
+// a single provider add batch, mirroring the Signal Discovery continuation cap.
+const PROVIDER_SOURCE_CONTINUATION_MAX_ROWS = 1500;
+const PROVIDER_SOURCE_CONTINUATION_DEFAULT_ROWS = 100;
 const USABLE_PAID_INMAIL_REFRESH_RECEIPT_STATUSES = new Set([
     "fresh",
     "refreshed",
@@ -1005,6 +1009,122 @@ export async function continueSignalDiscoverySource(action, workspaceId) {
         },
     };
 }
+/**
+ * Phase 110-05: bounded SAME-provider-source continuation for cold-outbound
+ * Sales Nav / Prospeo campaigns. Mirrors continueSignalDiscoverySource's
+ * guardrails (campaign + provider + selected-source match) and reuses the
+ * EXISTING import_leads tool to add leads from the campaign's own saved
+ * provider search (mode "add") once eligible/prepared rows are receipt-proven
+ * exhausted. It never switches source families and never creates a campaign.
+ * The add is bounded by the packet's existing sourceRowLimit cap; when the
+ * packet carries no reusable provider search reference the add cannot start
+ * autonomously and the executor refuses with a bounded reason so the run
+ * records the attempt instead of looping on an unchanged mutation.
+ */
+export async function continueProviderSource(action, workspaceId) {
+    const type = stringValue(action.type);
+    const campaignOfferId = actionCampaignId(action);
+    const sourceLeadListId = actionSourceLeadListId(action);
+    const sourceFingerprint = actionSourceFingerprint(action);
+    const toolInput = actionToolInput(action);
+    const packetProvider = stringValue(toolInput.provider);
+    // The owner directive authorizes cold same-source continuation for Sales Nav
+    // OR Prospeo only. continue_prospeo_source also spans apollo-sourced
+    // campaigns, which are NOT an authorized cold yolo source — refuse those.
+    const provider = type === "continue_sales_nav_source"
+        ? "sales-nav"
+        : type === "continue_prospeo_source" &&
+            packetProvider !== "apollo" &&
+            packetProvider !== "apollo-ai"
+            ? "prospeo"
+            : null;
+    if (!provider) {
+        return {
+            status: "refused",
+            refusalReason: "continue_provider_source only runs bounded same-source adds for Sales Nav or Prospeo cold campaigns",
+        };
+    }
+    if (!campaignOfferId || !sourceLeadListId || !sourceFingerprint) {
+        return {
+            status: "refused",
+            refusalReason: `${type} action is missing campaignOfferId, sourceLeadListId, or sourceFingerprint`,
+        };
+    }
+    const api = getApi();
+    const requestOptions = workspaceRequestOptions(workspaceId);
+    const campaign = await api.get(`/api/v2/campaign-offers/${campaignOfferId}`, requestOptions);
+    const campaignProvider = campaign.leadSourceProvider ?? null;
+    const providerMatches = provider === "sales-nav"
+        ? campaignProvider === "sales-nav"
+        : campaignProvider === "prospeo";
+    if (!providerMatches) {
+        return {
+            status: "refused",
+            refusalReason: `campaign leadSourceProvider (${String(campaignProvider)}) is not ${provider}; 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",
+        };
+    }
+    // Bound the same-source add by the packet's existing sourceRowLimit cap.
+    const sourceRowLimit = Math.min(PROVIDER_SOURCE_CONTINUATION_MAX_ROWS, Math.max(1, Math.floor(numberValue(toolInput.sourceRowLimit) ??
+        numberValue(toolInput.targetLeadCount) ??
+        numberValue(toolInput.targetRows) ??
+        numberValue(action.targetRows) ??
+        PROVIDER_SOURCE_CONTINUATION_DEFAULT_ROWS)));
+    // Reuse the campaign's SAME saved provider search reference; never widen to a
+    // different source family. Without a reusable reference the same-source add
+    // cannot start autonomously.
+    const searchId = stringValue(toolInput.searchId);
+    if (!searchId) {
+        return {
+            status: "refused",
+            refusalReason: `${provider} same-source continuation requires a reusable provider search reference on the packet; none was surfaced`,
+            result: {
+                provider,
+                campaignOfferId,
+                sourceLeadListId,
+                sourceFingerprint,
+            },
+        };
+    }
+    markProviderPromptLoaded({ provider, campaignOfferId });
+    const importResult = await importLeads({
+        campaignOfferId,
+        provider,
+        sourceLeadListId,
+        searchId,
+        mode: "add",
+        targetLeadCount: sourceRowLimit,
+        confirmed: true,
+        ...(workspaceId ? { workspaceId } : {}),
+    });
+    const importRecord = recordValue(importResult);
+    if (importRecord?.error || importRecord?.needsModeSelection === true) {
+        return {
+            status: "refused",
+            refusalReason: stringValue(importRecord?.message) ??
+                `${provider} same-source import did not start a bounded add job`,
+            result: { provider, campaignOfferId, sourceLeadListId, importResult },
+        };
+    }
+    return {
+        status: "executed_and_reread",
+        result: {
+            provider,
+            campaignOfferId,
+            previousSourceLeadListId: sourceLeadListId,
+            sourceFingerprint,
+            searchId,
+            sourceRowLimit,
+            importResult,
+        },
+    };
+}
 export async function refreshPaidInmailCreditsWithRetry(senderId, workspaceId, options = {}) {
     const errors = [];
     for (let attempt = 1; attempt <= PAID_INMAIL_REFRESH_MAX_ATTEMPTS; attempt += 1) {
@@ -1433,6 +1553,9 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
         }
         case "continue_signal_discovery_source":
             return continueSignalDiscoverySource(action, workspaceId);
+        case "continue_sales_nav_source":
+        case "continue_prospeo_source":
+            return continueProviderSource(action, workspaceId);
         case "approve_messages":
             return approveSequenceRowsBatch(action, workspaceId);
         default:

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

@@ -223,7 +223,113 @@ export declare function refillSendsCommand(input?: RefillSendsCommandInput): {
     workspaceResolution: string;
     intent: RefillSendsIntent;
 };
+type RefillSenderSelectorMatch = {
+    selector: string;
+    senderId: string;
+    displayName: string;
+    matchType: "id" | "exact_name" | "unambiguous_prefix";
+};
+type RefillSenderSelectorMiss = {
+    selector: string;
+    reason: "no_match" | "ambiguous";
+    candidates: Array<{
+        senderId: string;
+        displayName: string;
+    }>;
+};
 export declare function executeRefillSendsCommand(input?: RefillSendsCommandInput): Promise<import("./workspace-context.js").WorkspaceRequiredResult | {
+    ok: boolean;
+    code: string;
+    senderSelectorResolution: {
+        ok: false;
+        code: "sender_selector_unresolved";
+        workspaceId: string;
+        unresolvedSelectors: RefillSenderSelectorMiss[];
+        resolvedSelectors: RefillSenderSelectorMatch[];
+        availableSenders: Array<{
+            senderId: string;
+            displayName: string;
+        }>;
+    };
+    note: string;
+    targetDate: string | null;
+    untilDate: string | null;
+    horizonSendDays: number | null;
+    fillWindow: {
+        mode: string;
+        targetDate: string;
+        description: string;
+        untilDate?: undefined;
+        horizonSendDays?: undefined;
+        horizonHours?: undefined;
+    } | {
+        mode: string;
+        untilDate: string;
+        description: string;
+        targetDate?: undefined;
+        horizonSendDays?: undefined;
+        horizonHours?: undefined;
+    } | {
+        mode: string;
+        horizonSendDays: number | null;
+        horizonHours: number | null;
+        description: string;
+        targetDate?: undefined;
+        untilDate?: undefined;
+    };
+    approvalMode: RefillSendsApprovalMode;
+    campaignId: string | null;
+    tableId: string | null;
+    senderScope: string;
+    senderSelectors: {
+        senders: string[];
+        senderIds: string[];
+        senderNames: string[];
+    };
+    firstOperationalSteps: string[];
+    approvalContract: string;
+    forbiddenActions: string[];
+    hostExamples: {
+        claude: string[];
+        codex: string[];
+        mcpTool: {
+            name: string;
+            arguments: {
+                fence?: number | undefined;
+                runId?: string | undefined;
+                expectedActionKey?: string | undefined;
+                expectedTargetShapeRevision?: string | undefined;
+                targetDate: string | null;
+                untilDate: string | null;
+                horizonSendDays: number | null;
+                campaignId: string | undefined;
+                tableId: string | undefined;
+                intent: RefillSendsIntent;
+                approvalMode: RefillSendsApprovalMode;
+                workspaceId: string | null;
+                actionTypes?: ("send_invite" | "send_inmail_closed")[] | undefined;
+                yolo: boolean;
+                senders: string[];
+                senderIds: string[];
+                senderNames: string[];
+            };
+        };
+    };
+    actionTypes?: ("send_invite" | "send_inmail_closed")[] | undefined;
+    command: string;
+    tool: string;
+    promptName: string;
+    workflowPromptName: string;
+    workflowAsset: {
+        subskillName: string;
+        assetPath: string;
+    };
+    yolo: boolean;
+    executionMode: RefillSendsExecutionMode;
+    workspaceId: string | null;
+    workspaceResolution: string;
+    intent: RefillSendsIntent;
+} | {
     orchestration: {
         mode: string;
         checkpointedFields: string[];

package/dist/tools/refill-sends.js

@@ -2,6 +2,7 @@ import { decodeRefillReadinessAuthority, refillReadinessFingerprint, } from "../
 import { actionCampaignId, actionIds, actionSenderId, classifyPaidInmailRefreshReceipt, collectPaidInmailRefreshActions, executeOneYoloPrimitive, executeStartCampaignPrimitive, firstGlobalAction, normalizeStrings, numberValue, recordValue, refreshPaidInmailCreditsWithRetry, stringValue, } from "./refill-executors.js";
 import { refillSendsV2Command } from "./refill-sends-v2.js";
 import { getRefillTargetPlan } from "./refill-target-plan.js";
+import { listSenders } from "./senders.js";
 import { createWorkspaceContext, normalizeExplicitWorkspaceId, } from "./workspace-context.js";
 const REFILL_SEND_ACTION_TYPES = ["send_invite", "send_inmail_closed"];
 const REFILL_SEND_ACTION_TYPE_SET = new Set(REFILL_SEND_ACTION_TYPES);
@@ -101,7 +102,7 @@ function normalizeRefillSendsInput(input) {
 export const refillSendsToolDefinitions = [
     {
         name: "refill_sends",
-        description: "Typed command entrypoint for Sellable refill sends. In --yolo it executes one fenced, checkpointed refill-run slice that returns before the MCP host deadline. An in_progress receipt includes the exact runId/fence continuation; the packaged workflow must immediately auto-resume it with the unchanged workspace/sender/action scope until scheduler-projected coverage fills or a concrete blocker appears, without asking the user to continue. Every primitive records actionKey/requestId/effectId before mutation and rereads the fresh target plan afterward. It may refresh stale paid InMail facts once, prepare/approve bounded existing rows, reuse/import receipt-proven same-source rows, start only the exact PAUSED fallback freshly selected by the packet, run a request-scoped product scheduler sweep, and wait/reread. Unselected PAUSED campaigns remain paused. Scheduler placement stays product-native; the command never sends directly or raw-writes scheduler fields.",
+        description: "Typed command entrypoint for Sellable refill sends. In --yolo it executes one fenced, checkpointed refill-run slice that returns before the MCP host deadline. An in_progress receipt includes the exact runId/fence continuation; the packaged workflow must immediately auto-resume it with the unchanged workspace/sender/action scope until scheduler-projected coverage fills or a concrete blocker appears, without asking the user to continue. Every primitive records actionKey/requestId/effectId before mutation and rereads the fresh target plan afterward. It may refresh stale paid InMail facts once, prepare/approve bounded existing rows, reuse/import receipt-proven same-source rows, add more leads to an existing campaign from its SAME provider source once that campaign's eligible/prepared rows are receipt-proven exhausted (cold-outbound campaigns may source Sales Nav or Prospeo), start a route-resolver start-eligible PAUSED campaign-backed sequence campaign selected by the packet when starting is needed to fill the send window, run a request-scoped product scheduler sweep, and wait/reread. Each source add and campaign start is one bounded primitive, then a full replan. It never sends directly, lowers paid InMail thresholds/floors, creates NEW campaigns, archives/deletes, or switches an existing campaign's source family (same provider source only). Unselected PAUSED campaigns that are not start-eligible remain paused. Scheduler placement stays product-native; the command never raw-writes scheduler fields.",
         inputSchema: {
             type: "object",
             properties: {
@@ -322,20 +323,21 @@ function buildRefillSendsCommand(input) {
             "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 the fresh bounded refill target packet after every get_refill_target_plan reread. Execute one globally ranked primitive at a time and continue in the same invocation until projected coverage fills or a concrete blocker appears. Source-copy/fallback requires receipt-proven exhaustion of earlier ready/prep/approval rungs. An exact freshly selected start_paused_campaign packet authorizes starting only that PAUSED fallback; unselected PAUSED campaigns remain paused. Unbounded approval, source-family switches, threshold changes, and campaign creation require their own explicit gates. Ready-to-schedule rows are buffer, not completion. If ready buffer covers the projected gap and the exact-date run_scheduler_sweep is first, execute it once and fully reread. Non-exact scheduler waits are read-only and must keep rereading until projected coverage fills, a receipt deadline/budget is reached, or a concrete blocker appears. Treat fresh packet selection, coverage, blockers, receipts, timestamps, and current action progress as state within the original workspace/sender/lane/date/side-effect envelope. --yolo does not authorize lowering paid InMail thresholds or creating connection campaigns."
+            ? "Auto-accept the fresh bounded refill target packet after every get_refill_target_plan reread. Execute one globally ranked primitive at a time and continue in the same invocation until projected coverage fills or a concrete blocker appears. Source-copy, same-provider-source continuation, and fallback all require receipt-proven exhaustion of earlier ready/prep/approval rungs. A start-eligible start_paused_campaign packet authorizes starting only that route-resolver-selected PAUSED campaign-backed sequence campaign; PAUSED campaigns that are not start-eligible remain paused. --yolo MAY add more leads to an existing campaign from its SAME provider source after receipt-proven exhaustion (cold campaigns: Sales Nav or Prospeo), each as one bounded add followed by a full replan. Unbounded approval, source-FAMILY switches, threshold/floor changes, and NEW campaign creation still require their own explicit gates. Ready-to-schedule rows are buffer, not completion. If ready buffer covers the projected gap and the exact-date run_scheduler_sweep is first, execute it once and fully reread. Non-exact scheduler waits are read-only and must keep rereading until projected coverage fills, a receipt deadline/budget is reached, or a concrete blocker appears. Treat fresh packet selection, coverage, blockers, receipts, timestamps, and current action progress as state within the original workspace/sender/lane/date/side-effect envelope. --yolo does not authorize lowering paid InMail thresholds/floors, switching an existing campaign's source family, or creating 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 and the approved exact-date run_scheduler_sweep is target.globalActionQueue[0], execute it once and fully reread. Only non-exact or no-sweep scheduler waits are read-only; 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.",
         forbiddenActions: [
-            "start_campaign outside the exact freshly selected PAUSED fallback packet",
-            "lower paid InMail thresholds",
-            "create connection campaigns",
+            "start_campaign outside a route-resolver start-eligible PAUSED campaign-backed sequence packet",
+            "lower paid InMail thresholds or floors",
+            "create NEW campaigns (connection or otherwise)",
+            "switch an existing campaign's source family (same provider source only; cold campaigns may source Prospeo or Sales Nav)",
             "manual launch/send or direct sending outside product scheduler side effects",
             "archive or delete cleanup",
             "direct scheduler writes",
             "sender reassignment",
             "campaigns outside the rendered eligible sender packet",
-            "on-demand or unrelated active-campaign fallback unless the refill workflow shows receipt-proven exhaustion for the selected same-sender lane",
+            "same-provider-source continuation or source-copy/fallback unless the refill workflow shows receipt-proven exhaustion for the selected same-sender lane",
         ],
         hostExamples: {
             claude: [
@@ -955,6 +957,111 @@ function paidRefreshOptionsFromApprovalPacket(packet) {
         maxStalenessSeconds: packet.maxStalenessSeconds,
     };
 }
+// CAP110-17: Resolve sender display-name / free-form selectors to EXACT sender
+// ids inside the resolved workspace before any target plan, paid-credit
+// refresh, or fenced yolo dispatch. A selector must match an exact id, an exact
+// display name, or an unambiguous name prefix within THIS workspace's fleet. On
+// no-match or ambiguity the resolver refuses loudly with the candidate list so
+// the caller can never silently fall back to the active workspace's full fleet
+// (the "damiano r" invocation that mutated Clover instead of Damiano R).
+async function resolveRefillSenderSelectors(params) {
+    const explicitSenderIds = normalizeStrings(params.senderIds);
+    const selectors = normalizeStrings(params.selectors);
+    const workspaceId = params.workspaceId;
+    if (!workspaceId || selectors.length === 0) {
+        return {
+            ok: true,
+            applied: false,
+            workspaceId: workspaceId ?? null,
+            resolvedSenderIds: explicitSenderIds,
+            resolvedSelectors: [],
+        };
+    }
+    const listing = await listSenders({ workspaceId });
+    const availableSenders = (listing?.senders ?? [])
+        .map((sender) => ({
+        senderId: String(sender?.id ?? ""),
+        displayName: String(sender?.displayName ?? ""),
+    }))
+        .filter((sender) => sender.senderId.length > 0);
+    const resolvedIds = new Set(explicitSenderIds);
+    const resolvedSelectors = [];
+    const unresolvedSelectors = [];
+    for (const selector of selectors) {
+        const normalized = selector.toLowerCase();
+        const byId = availableSenders.find((sender) => sender.senderId.toLowerCase() === normalized);
+        if (byId) {
+            resolvedIds.add(byId.senderId);
+            resolvedSelectors.push({
+                selector,
+                senderId: byId.senderId,
+                displayName: byId.displayName,
+                matchType: "id",
+            });
+            continue;
+        }
+        const exactName = availableSenders.filter((sender) => sender.displayName.trim().toLowerCase() === normalized);
+        if (exactName.length === 1) {
+            resolvedIds.add(exactName[0].senderId);
+            resolvedSelectors.push({
+                selector,
+                senderId: exactName[0].senderId,
+                displayName: exactName[0].displayName,
+                matchType: "exact_name",
+            });
+            continue;
+        }
+        if (exactName.length > 1) {
+            unresolvedSelectors.push({
+                selector,
+                reason: "ambiguous",
+                candidates: exactName,
+            });
+            continue;
+        }
+        const prefixMatches = availableSenders.filter((sender) => sender.displayName.trim().toLowerCase().startsWith(normalized));
+        if (prefixMatches.length === 1) {
+            resolvedIds.add(prefixMatches[0].senderId);
+            resolvedSelectors.push({
+                selector,
+                senderId: prefixMatches[0].senderId,
+                displayName: prefixMatches[0].displayName,
+                matchType: "unambiguous_prefix",
+            });
+            continue;
+        }
+        if (prefixMatches.length > 1) {
+            unresolvedSelectors.push({
+                selector,
+                reason: "ambiguous",
+                candidates: prefixMatches,
+            });
+            continue;
+        }
+        unresolvedSelectors.push({
+            selector,
+            reason: "no_match",
+            candidates: [],
+        });
+    }
+    if (unresolvedSelectors.length > 0) {
+        return {
+            ok: false,
+            code: "sender_selector_unresolved",
+            workspaceId,
+            unresolvedSelectors,
+            resolvedSelectors,
+            availableSenders,
+        };
+    }
+    return {
+        ok: true,
+        applied: true,
+        workspaceId,
+        resolvedSenderIds: [...resolvedIds],
+        resolvedSelectors,
+    };
+}
 export async function executeRefillSendsCommand(input = {}) {
     const normalizedInput = normalizeRefillSendsInput(input);
     const yolo = normalizedInput.yolo === true;
@@ -972,16 +1079,45 @@ export async function executeRefillSendsCommand(input = {}) {
     if (workspaceContext && !workspaceContext.ok) {
         return workspaceContext;
     }
-    const scopedInput = workspaceContext && workspaceContext.ok
+    const scopedInputBase = workspaceContext && workspaceContext.ok
         ? {
             ...normalizedInput,
             workspaceId: workspaceContext.context.workspaceId,
         }
         : normalizedInput;
-    const command = buildRefillSendsCommand(scopedInput);
     const workspaceId = workspaceContext && workspaceContext.ok
         ? workspaceContext.context.workspaceId
-        : normalizeExplicitWorkspaceId(scopedInput.workspaceId);
+        : normalizeExplicitWorkspaceId(scopedInputBase.workspaceId);
+    // CAP110-17: Resolve any sender name / free-form selectors EXACTLY against the
+    // resolved workspace before building the command or any nested call. A name
+    // that does not resolve in the CORRECT workspace fails loudly with candidates
+    // instead of silently mutating the active workspace's full fleet.
+    const senderSelectorResolution = await resolveRefillSenderSelectors({
+        senderIds: normalizeStrings(scopedInputBase.senderIds),
+        selectors: [
+            ...normalizeStrings(scopedInputBase.senders),
+            ...normalizeStrings(scopedInputBase.senderNames),
+        ],
+        workspaceId,
+    });
+    if (!senderSelectorResolution.ok) {
+        return {
+            ...buildRefillSendsCommand(scopedInputBase),
+            ok: false,
+            code: "sender_selector_unresolved",
+            senderSelectorResolution,
+            note: "One or more sender selectors did not resolve exactly in the requested workspace. Refusing to mutate the active workspace's full fleet. Re-run with an exact sender id, an unambiguous name, or the correct workspaceId.",
+        };
+    }
+    const scopedInput = senderSelectorResolution.applied
+        ? {
+            ...scopedInputBase,
+            senderIds: senderSelectorResolution.resolvedSenderIds,
+            senders: [],
+            senderNames: [],
+        }
+        : scopedInputBase;
+    const command = buildRefillSendsCommand(scopedInput);
     if (yolo && workspaceId) {
         // The tool contract promises that an already-approved packet's
         // expectedTargetShapeRevision/expectedActionKey are compared against a

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

@@ -29,12 +29,18 @@ const SAFE_PACKET_ACTION_TYPES = new Set([
     "next_campaign",
     "done",
 ]);
+// Phase 110-05: continue_sales_nav_source and continue_prospeo_source are the
+// bounded SAME-provider-source continuation rungs for cold-outbound campaigns.
+// Plain --yolo may execute them once eligible/prepared rows are receipt-proven
+// exhausted, so they pass through as yoloEligible (like
+// continue_signal_discovery_source). The remaining manual-only types stay
+// gated: threshold/floor changes, source-family switches, NEW campaign
+// creation, and the capSaturated / unsupported-provider dead-end
+// (manual_source_replenishment) that needs human table cleanup.
 const MANUAL_ONLY_PACKET_ACTION_TYPES = new Set([
     "lower_paid_inmail_threshold",
     "switch_to_connection_lane",
     "create_connection_campaign",
-    "continue_sales_nav_source",
-    "continue_prospeo_source",
     "manual_source_replenishment",
 ]);
 const TERMINAL_NO_ACTION_BLOCKER_CODES = new Set([
@@ -224,35 +230,15 @@ function sanitizePrepFailureDiagnosis(value) {
         },
     };
 }
-function evidenceLatestMs(evidence) {
-    const latestAt = evidence.latestAt;
-    if (typeof latestAt !== "string")
-        return 0;
-    const timestamp = new Date(latestAt).getTime();
-    return Number.isFinite(timestamp) ? timestamp : 0;
-}
-function chooseEvidenceAction(evidence, fallback) {
-    const byAction = new Map();
-    for (const item of evidence) {
-        if (!isRecord(item))
-            continue;
-        const actionType = allowedActionType(item.actionType);
-        if (!actionType)
-            continue;
-        const current = byAction.get(actionType) ?? { count: 0, latestMs: 0 };
-        current.count += numberValue(item.count);
-        current.latestMs = Math.max(current.latestMs, evidenceLatestMs(item));
-        byAction.set(actionType, current);
-    }
-    const [best] = [...byAction.entries()].sort((a, b) => {
-        if (a[1].latestMs !== b[1].latestMs)
-            return b[1].latestMs - a[1].latestMs;
-        if (a[1].count !== b[1].count)
-            return b[1].count - a[1].count;
-        return (REFILL_TARGET_ACTION_TYPES.indexOf(a[0]) -
-            REFILL_TARGET_ACTION_TYPES.indexOf(b[0]));
-    });
-    return best?.[0] ?? fallback[0] ?? null;
+// Phase 110: the backend planner is the single authority on lane selection —
+// it collapses to one lane for non-cascade senders and emits BOTH lanes for
+// invite-capable Sales Nav cascades. This wrapper must not re-collapse
+// (zero-shot i02-clover receipt: request.actionTypes was forced to a single
+// lane with no caller override, so paid lanes with available credits were
+// never targeted). Lanes are ordered by REFILL_TARGET_ACTION_TYPES.
+function orderedLanes(lanes) {
+    const laneSet = new Set(lanes);
+    return REFILL_TARGET_ACTION_TYPES.filter((lane) => laneSet.has(lane));
 }
 function senderActionKey(senderId, actionType) {
     return typeof senderId === "string" && typeof actionType === "string"
@@ -530,6 +516,13 @@ function sanitizeToolInput(value, authority) {
             : undefined,
         campaignOfferId: stringValue(value.campaignOfferId),
         provider: stringValue(value.provider),
+        // Phase 110-05: reusable SAME-provider-source search reference for bounded
+        // sales-nav / prospeo yolo continuation (only consumed for same-source
+        // adds; never authorizes a source-family switch).
+        searchId: stringValue(value.searchId),
+        targetLeadCount: typeof value.targetLeadCount === "number"
+            ? value.targetLeadCount
+            : undefined,
         allowDifferentSourceLeadList: typeof value.allowDifferentSourceLeadList === "boolean"
             ? value.allowDifferentSourceLeadList
             : undefined,
@@ -650,8 +643,8 @@ function sanitizeEligibleSenderLedger(value, selectedBySender) {
         return selectedBySender.has(row.senderId);
     })
         .map((row) => {
-        const selectedLane = selectedBySender.get(row.senderId);
-        const eligibleActionTypes = actionTypesFrom(row.eligibleActionTypes).filter((actionType) => actionType === selectedLane);
+        const selectedLanes = selectedBySender.get(row.senderId) ?? new Set();
+        const eligibleActionTypes = actionTypesFrom(row.eligibleActionTypes).filter((actionType) => selectedLanes.has(actionType));
         return {
             senderId: row.senderId,
             senderName: stringValue(row.senderName) ?? "",
@@ -841,7 +834,7 @@ function sanitizeStructuredSenderPlans(value, selectedBySender) {
         if (!isRecord(plan) || typeof plan.senderId !== "string")
             return false;
         const selectedLane = allowedActionType(plan.selectedLane);
-        return Boolean(selectedLane && selectedBySender.get(plan.senderId) === selectedLane);
+        return Boolean(selectedLane && selectedBySender.get(plan.senderId)?.has(selectedLane));
     })
         .map((plan) => {
         const paidInmail = sanitizePaidInmail(plan.paidInmail);
@@ -1038,7 +1031,7 @@ function sanitizeTargetSchedulerSweep(params) {
     }
     const expectedSenderIds = [...params.sweepEligibleBySender.keys()].sort();
     const expectedActionTypes = [
-        ...new Set(params.sweepEligibleBySender.values()),
+        ...new Set([...params.sweepEligibleBySender.values()].flatMap((lanes) => [...lanes])),
     ].sort();
     if (expectedSenderIds.length === 0 || expectedActionTypes.length === 0) {
         return null;
@@ -1324,31 +1317,36 @@ function sanitizeRefillTargetPlanResult(result) {
     const rawSenderPlans = Array.isArray(target.senderPlans)
         ? target.senderPlans
         : [];
+    // Phase 110: accept every senderId:actionType pair the backend emitted —
+    // the backend planner already decided lane selection (single-lane for
+    // non-cascades, both lanes for invite-capable cascades). Do not pick a
+    // winner per sender here.
     const selectedBySender = new Map();
-    for (const rawSelection of rawSelections) {
-        if (!isRecord(rawSelection) || typeof rawSelection.senderId !== "string") {
-            continue;
-        }
-        const fallback = actionTypesFrom(rawSelection.actionTypes);
-        const evidence = Array.isArray(rawSelection.evidence)
-            ? rawSelection.evidence
-            : [];
-        const chosen = chooseEvidenceAction(evidence, fallback);
-        if (chosen)
-            selectedBySender.set(rawSelection.senderId, chosen);
-    }
+    const addSelectedLane = (senderId, actionType) => {
+        const lanes = selectedBySender.get(senderId) ?? new Set();
+        lanes.add(actionType);
+        selectedBySender.set(senderId, lanes);
+    };
     for (const rawPlan of rawSenderPlans) {
-        if (!isRecord(rawPlan) ||
-            typeof rawPlan.senderId !== "string" ||
-            selectedBySender.has(rawPlan.senderId)) {
+        if (!isRecord(rawPlan) || typeof rawPlan.senderId !== "string")
             continue;
-        }
         const actionType = allowedActionType(rawPlan.actionType);
         if (actionType)
-            selectedBySender.set(rawPlan.senderId, actionType);
+            addSelectedLane(rawPlan.senderId, actionType);
+    }
+    if (selectedBySender.size === 0) {
+        for (const rawSelection of rawSelections) {
+            if (!isRecord(rawSelection) ||
+                typeof rawSelection.senderId !== "string") {
+                continue;
+            }
+            for (const actionType of actionTypesFrom(rawSelection.actionTypes)) {
+                addSelectedLane(rawSelection.senderId, actionType);
+            }
+        }
     }
-    const selectedKeys = new Set([...selectedBySender.entries()].map(([senderId, actionType]) => `${senderId}:${actionType}`));
-    const actionTypes = [...new Set(selectedBySender.values())];
+    const selectedKeys = new Set([...selectedBySender.entries()].flatMap(([senderId, lanes]) => [...lanes].map((actionType) => `${senderId}:${actionType}`)));
+    const actionTypes = orderedLanes([...selectedBySender.values()].flatMap((lanes) => [...lanes]));
     if (selectedKeys.size === 0)
         return emptyUnsupportedResult(result);
     const senderPlans = rawSenderPlans.filter((plan) => isRecord(plan) &&
@@ -1362,13 +1360,13 @@ function sanitizeRefillTargetPlanResult(result) {
         typeof selection.senderId === "string" &&
         selectedBySender.has(selection.senderId))
         .map((selection) => {
-        const actionType = selectedBySender.get(selection.senderId);
+        const lanes = selectedBySender.get(selection.senderId) ?? new Set();
         const evidence = Array.isArray(selection.evidence)
-            ? selection.evidence.filter((item) => isRecord(item) && item.actionType === actionType)
+            ? selection.evidence.filter((item) => isRecord(item) && lanes.has(String(item.actionType)))
             : [];
         return {
             ...selection,
-            actionTypes: actionType ? [actionType] : [],
+            actionTypes: orderedLanes(lanes),
             evidence,
         };
     });
@@ -1401,7 +1399,9 @@ function sanitizeRefillTargetPlanResult(result) {
             numberValue(plan.remainingProjectedGap) > 0 &&
             numberValue(plan.remainingReadyOrProjectedGap) === 0 &&
             numberValue(plan.readyBuffer) > 0) {
-            sweepEligibleBySender.set(senderId, actionType);
+            const lanes = sweepEligibleBySender.get(senderId) ?? new Set();
+            lanes.add(actionType);
+            sweepEligibleBySender.set(senderId, lanes);
         }
     }
     const schedulerSweepAction = sanitizeTargetSchedulerSweep({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.600",
+  "version": "0.1.602-phase110.20260717134543",
   "type": "module",
   "description": "Sellable MCP server for Claude Code, Codex, and Hermes campaign workflows",
   "main": "dist/index.js",

package/skills/refill-sends/SKILL.md

@@ -108,18 +108,24 @@ Safe primitives are paid-credit refresh,
 existing-row message preparation, generated-message approval, receipt-proven
 same-source row copy, one bounded Signal Discovery search derived only from
 the campaign's already-approved positive ICP criteria when no reusable source
-rows or tab keywords remain, the exact freshly selected PAUSED fallback start, a
-request-scoped exact-date product scheduler sweep, and read-only wait rereads.
+rows or tab keywords remain, one bounded SAME-provider-source add for a cold
+campaign whose eligible/prepared rows are receipt-proven exhausted (Sales Nav
+or Prospeo, same saved search — never a source-family switch), the start of a
+route-resolver start-eligible PAUSED campaign-backed sequence campaign selected
+by the packet, a request-scoped exact-date product scheduler sweep, and
+read-only wait rereads. Each source add and campaign start is one bounded
+primitive followed by a full replan.
 Approved-criteria keywords and the attempt/exhaustion marker are scoped to the
 current fenced refill run: archive temporary derived search tabs after the
 source import is materialized, keep normal source-list/import receipts, and
 retry from the campaign's current approved rubric in every new refill run.
-Same-source copy/source
-fallback is safe only after receipt-proven exhaustion:
+Same-source copy, same-provider-source add, and source
+fallback are safe only after receipt-proven exhaustion:
 `hasMoreFrontierRows:false`, zero `approvalCandidates`, no `stuckActiveCells`,
 and no non-terminal `approvedNotDispatched` work. It does not run unbounded
-approval, lower paid-InMail thresholds, switch source families, create
-campaigns, launch, or send directly; it never raw-writes scheduler fields.
+approval, lower paid-InMail thresholds/floors, switch an existing campaign's
+source family, create NEW campaigns, archive/delete, launch, or send directly;
+it never raw-writes scheduler fields.
 Continue with the workflow below for route selection, state rereads, approval
 gating, source import, preparation, and bounded approval.
 
@@ -202,6 +208,27 @@ senders" as sender-scoped requests. The target set is senders enrolled in active
 campaign-backed sequence campaigns, not the first active campaign returned by a
 resolver.
 
+## Sender Selector Resolution
+
+When a request names a sender or workspace ("damiano r", "refill Kyle"), resolve
+that selector EXACTLY inside the CORRECT workspace before any mutation. A
+selector resolves only by exact sender id, exact display name, or an
+unambiguous display-name prefix within `list_senders({ workspaceId })` for the
+resolved workspace. `refill_sends` performs this resolution internally: a
+`--yolo`/scheduled invocation with `senders`/`senderNames` first pins each
+selector to an exact sender id in the requested workspace and passes only ids
+downstream.
+
+If any selector does not resolve, or resolves ambiguously, `refill_sends`
+returns `sender_selector_unresolved` with the candidate sender list and does NOT
+run. Never silently fall back to the active workspace's full fleet, and never
+mutate a different workspace than the one that owns the named sender. A name
+that belongs to another workspace (for example running "damiano r" while Clover
+is active) must fail loudly so the caller re-runs with the correct
+`workspaceId`; it must never create prep jobs in the active workspace instead.
+Resolve the workspace first (via `list_workspaces`/install mapping) when the
+named sender is not present in the currently resolved workspace's fleet.
+
 Goal-mode continuation: a skill cannot create or invoke `/goal` by itself. When
 this command is already running inside an active Codex goal, keep that goal open
 until every selected sender lane is filled by projected coverage
@@ -278,16 +305,23 @@ Structured planner packet:
 - When that primitive is `run_scheduler_sweep`, show `workspaceWide:true` and
   its reason in the approval/yolo packet so the operator sees that the sweep
   may schedule other eligible workspace cells on the approved date.
-- `manualAlternates` are not yolo actions. Threshold lowering and campaign
-  creation are manual continuations only.
+- `manualAlternates` are not yolo actions. Threshold/floor lowering, NEW
+  campaign creation, source-family switches, and the capSaturated
+  `manual_source_replenishment` dead-end (needs human table cleanup) are manual
+  continuations only. Same-provider-source continuation
+  (`continue_sales_nav_source`, `continue_prospeo_source`) and
+  `start_paused_campaign` for a start-eligible campaign are `--yolo` primitives,
+  not manual alternates.
 
 Refill action ladder: approve generated rows only when an explicit bounded
 approval gate exists, process all existing same-campaign unenriched/unprepared
 rows in bounded batches before any source work, then copy bounded net-new rows
 from the selected source (`selectedLeadListId`, provider, and source
-fingerprint preserved), then use provider-aligned source-more. A new source or
-provider switch changes the reply-rate baseline and is a manual alternate, not a
-`--yolo` side effect.
+fingerprint preserved), then use provider-aligned same-source-more against the
+campaign's OWN saved provider search (Sales Nav or Prospeo for cold campaigns).
+Same-provider-source-more is a bounded `--yolo` add. A DIFFERENT source or a
+source-family switch changes the reply-rate baseline and stays a manual
+alternate, not a `--yolo` side effect.
 For Signal Discovery, consume bounded net-new eligible source rows first. If
 none remain and the campaign has no reusable tab keywords or unselected posts,
 derive at most five search keywords from its saved positive ICP criteria without