@sellable/mcp 0.1.413 → 0.1.415

package/README.md

@@ -16,7 +16,7 @@ Each message gets 5+ minutes of Claude attention with deep research - no other t
 
 ### Prompt Source Of Truth
 
-There are six public Sellable entrypoints shared across hosts:
+There are seven public Sellable entrypoints shared across hosts:
 
 - `sellable:create-campaign`
 - `sellable:create-ab-test`
@@ -24,6 +24,7 @@ There are six public Sellable entrypoints shared across hosts:
 - `sellable:foundation`
 - `sellable:content`
 - `sellable:create-post`
+- `sellable:refill-sends`
 
 The create-campaign public wrapper at
 `mcp/sellable/skills/create-campaign/SKILL.md` handles auth/bootstrap and loads
@@ -63,6 +64,13 @@ reader value, validates proof/AI tells, and saves content artifacts under
 
 - `mcp/sellable/skills/create-post/SKILL.md`
 
+The refill-sends public command wrapper plans and executes approval-gated send
+refills. It supports `--yolo` and optional sender selectors such as
+`--sender "Christian Reyes"` or typed MCP calls to `refill_sends({ yolo,
+senders })` from:
+
+- `mcp/sellable/skills/refill-sends/SKILL.md`
+
 Keep `create-campaign-v2` and `load-voice` internal. Do not advertise either as
 a public command. `load-voice` remains a direct MCP utility for generic writing
 surfaces that are not posts or campaigns.
@@ -186,10 +194,10 @@ The installer does the full local setup:
 After the installer passes, fully quit and reopen Codex Desktop. Start a new
 thread and select `Sellable Create Campaign`, `Sellable Create A/B Test`,
 `Sellable Create Evergreen Campaigns`, `Sellable Foundation`,
-`Sellable Content`, or `Sellable Create Post`; or invoke
+`Sellable Content`, `Sellable Create Post`, or `Sellable Refill Sends`; or invoke
 `$sellable:create-campaign`, `$sellable:create-ab-test`,
 `$sellable:create-evergreen-campaigns`, `$sellable:foundation`,
-`$sellable:content`, or `$sellable:create-post`. If the app still says
+`$sellable:content`, `$sellable:create-post`, or `$sellable:refill-sends`. If the app still says
 `mcp__sellable__*` tools are missing after the installer passes, check that
 `~/.codex/config.toml` contains both `[marketplaces.sellable]` and
 `[plugins."sellable@sellable"]`.
@@ -206,12 +214,14 @@ Use these names consistently:
 - Claude Code command: `/sellable:foundation`
 - Claude Code command: `/sellable:content`
 - Claude Code command: `/sellable:create-post`
+- Claude Code command: `/sellable:refill-sends`
 - Codex command: `$sellable:create-campaign`
 - Codex command: `$sellable:create-ab-test`
 - Codex command: `$sellable:create-evergreen-campaigns`
 - Codex command: `$sellable:foundation`
 - Codex command: `$sellable:content`
 - Codex command: `$sellable:create-post`
+- Codex command: `$sellable:refill-sends`
 - Codex Desktop plugin: `sellable@sellable`
 - Codex visible skill: `Sellable Create Campaign`
 - Codex visible skill: `Sellable Create A/B Test`
@@ -219,14 +229,17 @@ Use these names consistently:
 - Codex visible skill: `Sellable Foundation`
 - Codex visible skill: `Sellable Content`
 - Codex visible skill: `Sellable Create Post`
+- Codex visible skill: `Sellable Refill Sends`
 - Codex skill frontmatter name: `create-campaign`
 - Codex skill frontmatter name: `create-ab-test`
 - Codex skill frontmatter name: `create-evergreen-campaigns`
 - Codex skill frontmatter name: `foundation`
 - Codex skill frontmatter name: `content`
 - Codex skill frontmatter name: `create-post`
+- Codex skill frontmatter name: `refill-sends`
 - MCP server name: `sellable`
 - Internal workflow prompt: `create-campaign-v2`
+- Internal workflow prompt: `refill-sends-workflow`
 - Internal/backward-compatible memory prompt: `interview`
 
 Never tell users to run `/sellable:create-campaign-v2`,
@@ -279,6 +292,13 @@ Use the create-campaign skill:
 /sellable:create-campaign
 ```
 
+Use the refill command for sender send refills:
+
+```
+/sellable:refill-sends --yolo
+/sellable:refill-sends --sender "Christian Reyes" --sender "Thomas Nobbs"
+```
+
 Then describe intent naturally, for example:
 
 - "Let's make a campaign with sellable"
@@ -299,6 +319,13 @@ Use the Codex skill entrypoint:
 $sellable:create-campaign
 ```
 
+Use the Codex refill command with the same flags:
+
+```
+$sellable:refill-sends --yolo
+$sellable:refill-sends --sender "Christian Reyes" --sender "Thomas Nobbs"
+```
+
 Installed skill package path:
 
 - `~/.codex/plugins/cache/sellable/sellable/<version>/skills/sellable-create-campaign/SKILL.md`

package/dist/server.js

@@ -37,6 +37,7 @@ import { addOnDemandLeads, createOnDemandCampaign, createOnDemandTable, initOnDe
 import { upsertRubric } from "./tools/processing.js";
 import { completeSenderResearch, getPostFindLeadsScoutRegistry, getSourceScoutRegistry, getSubskillAsset, getSubskillPrompt, listSubskillPrompts, searchSubskillPrompts, } from "./tools/prompts.js";
 import { waitForCampaignTableReady, waitForLeadListReady, } from "./tools/readiness.js";
+import { refillSendsCommand } from "./tools/refill-sends.js";
 import { allTools } from "./tools/registry.js";
 import { getRows, getTableRows, getTableRowsMinimal } from "./tools/rows.js";
 import { addRubricItem, checkRubric, deleteRubricItem, draftRubrics, saveRubrics, selectNecessaryRubrics, updateRubricItem, waitForRubricResults, } from "./tools/rubrics.js";
@@ -217,6 +218,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_campaign_refill_state":
                 result = await getCampaignRefillState(args);
                 break;
+            case "refill_sends":
+                result = refillSendsCommand(args);
+                break;
             case "setup_evergreen_campaigns":
                 result = await setupEvergreenCampaigns(args);
                 markEvergreenSetupCampaignsDirty(args);

package/dist/tools/prompts.js

@@ -373,7 +373,7 @@ export function getPostFindLeadsScoutRegistry() {
             codex: 'After confirm_lead_list copies source rows and the initial campaign-table execution slice exists, ask the filter-choice question immediately. Do not spawn anything before that question. After the answer, launch only Message Drafting. The filter-choice answer is the post-import user gate for this single worker; do not ask another question about starting it in step-wise or YOLO mode. The registry lookup is not a launch: after get_post_find_leads_scout_registry, immediately invoke Task/spawn_agent or the host background-agent mechanism before loading filter-leads.md, before saving rubrics, and before treating skip-filters as ready for message review. Both choices route through this kickoff; do not let filters_skipped jump straight from filter-choice to message-generation. If filters are chosen, the parent stays on Filter Rules and drafts/saves rubrics with MCP tools while Message Drafting runs in the background. If filters are skipped, move to Messages/message review only after Message Drafting has started or is ready; update_campaign(currentStep=messages) is not proof of launch. If the named Message Drafting custom agent is unavailable, spawn a generic gpt-5.5 xhigh Message Drafting background agent with the same lean campaign/table basis. When the background worker starts, persist workerDetails.messageDraftBuilder with statusSource "branch", status "branch-running", runId, startedAt, updatedAt, basisToken when known, and basis containing campaignId, selectedLeadListId, workflowTableId, filterChoice, and reviewBatchRowHash or reviewBatchRowIds; workerStatuses.messageDraftBuilder may be "running" as a simple badge only. Never put rich proof under workerStatuses and never use workerStatuses.messageDrafting. If no background-agent tool is callable, start the same full message branch inline before filter drafting or before skip-filter message review, record workerDetails.messageDraftBuilder with statusSource "parent-thread-fallback" and status "fallback-active", and require the same live context, prompt, assets, and validation gate before message review; do not wait until filters are saved and then call the registry.',
             claude: "After confirm_lead_list copies source rows and the initial campaign-table execution slice exists, ask the filter-choice question immediately. Do not invoke any Task/Agent before that question. After the answer, invoke only Message Drafting. If filters are chosen, parent drafts/saves rubrics with MCP tools while Message Drafting runs, asks filter approval, then joins Message Drafting. If filters are skipped, invoke only Message Drafting and move to Messages/message review.",
             parentThreadRule: 'Named agents are optional acceleration, but message drafting is not optional. The only normal background worker is Message Drafting. The filter-choice answer is the campaign-scoped go-ahead for this single post-import worker; do not ask another question to start it in step-wise or YOLO mode. If a named agent is unavailable, use a generic gpt-5.5 xhigh Message Drafting background agent. source work and filter work stay in the parent thread with MCP tools. If post-find-leads-message-scout is available, run it as the background Message Draft Builder after the filter-choice answer. The registry lookup is not a launch: get_post_find_leads_scout_registry only identifies the worker, and Message Drafting counts as started only after Task/spawn_agent or the host background-agent tool is invoked, or after the parent begins the same full message branch inline because no background-agent tool is callable. This launch must happen before loading filter-leads.md, save_rubrics, filter approval, or skip-filter message review; currentStep=messages is not proof of launch. If post-find-leads-message-scout is absent, do not customer-surface install status. Do not silently treat message drafting as started; the main thread must either launch the background worker or execute the same message branch from CampaignOffer state, selected source state, workflowTableId, and initial campaign-table execution slice rows. For a spawned worker, record workerDetails.messageDraftBuilder with statusSource branch / status branch-running, runId, startedAt, updatedAt, and basis containing campaignId, selectedLeadListId, workflowTableId, filterChoice, and reviewBatchRowHash or reviewBatchRowIds. workerStatuses.messageDraftBuilder is optional simple badge text only ("running", "ready", "blocked", "idle"); never put runId/statusSource/basis under workerStatuses and never use workerStatuses.messageDrafting. If no background-agent tool is callable, start that same full message branch inline before filter drafting or before skip-filter message review, record workerDetails.messageDraftBuilder with statusSource parent-thread-fallback / status fallback-active then ready, and require the same live context, prompt, assets, and validation gate before message review; do not report that as a background worker failure. If neither branch nor inline fallback can run, return blocked/retry-needed; do not wait until filters are saved and then call the registry. The Message Drafting handoff must be lean. Do not paste copied row counts, brief hashes, review-batch hashes, full reviewBatchRowIds, broad row data, or local debug artifacts into the spawn prompt. Local markdown/json files are not normal-path inputs. The filter-choice question is the first post-import user gate; do not load post-lead registries or filter references before it. Message drafting starts after the filter-choice answer, must load get_subskill_prompt({ subskillName: "generate-messages" }), and must load every required message asset named by generate-messages Mode 0 through get_subskill_asset before drafting. Reference Asset Loading means loading the required pre-draft reference pack before drafting; return blocked/retry-needed if required assets cannot be loaded; load ai-tells.md because it is never optional. The branch or parent-thread fallback loads the full generate-messages prompt and every referenced asset through get_subskill_asset. After generating/revising the candidate and before returning ready, must load get_subskill_prompt({ subskillName: "create-campaign-v2-validation" }) as the final internal validation gate, must read live campaign table state through scoped MCP/product tools, and must reject mismatched selectedLeadListId/workflowTableId/campaign/workspace input. Do not block when filters were chosen but leadScoringRubrics are not yet visible in the branch read; the parent owns save_rubrics and filter approval in parallel, so Message Drafting should return status ready with basisStatus usable_initial when campaign/list/table identity and the non-empty execution slice match. Do not use any alternate, local-artifact, or examples-only message prompt. User copy feedback, message QA, or rewrite requests before approve-message must be routed back to Message Drafting with the current recommendation, lean campaign/table basis, and latest user text; the parent must not rewrite or QA the template from memory and must not call update_campaign_brief before approve-message. The worker validates internally and returns only templateRecommendation, tokenFillRules, renderedGoodSample, status, approveOrReviseRecommendation, validationStatus, outputAt, outputHash, and blocked/retry detail. Do not render renderedFallbackSample, risk notes, or a qaReceipt on the normal happy path. On the filter path, save_rubrics keeps the browser on Filter Rules after save_rubrics so the user can approve the saved criteria; after saved-filter approval, move to Filter Leads with currentStep=apply-icp-rubric whether Message Drafting is ready or still running. Wait there for message approval. Enrichment, filtering, Generate Message cells, sender setup, sequence attach, and launch wait for template approval on the Use Template path. On the skip path, move to Messages/message review after Message Drafting has started or is ready and wait for message approval before enrichment or Settings. Do not render message review from checklist or shortcut instructions; message review requires a messageDraftRecommendation whose basis proves the generate-messages prompt, required message assets, and validation gate ran for the current campaign/table execution slice. Do not automatically rerun Message Drafting after filters/enrichment finish; show the initial draft by default and offer an enriched rewrite only with explicit user opt-in. Handoff and recommendation output are Markdown with labeled fields, not raw JSON.',
-            prepareMessagesRule: `Default create-campaign stays on the existing reviewBatchLimit:15 first campaign-table execution slice. For plain post-mint fill/load/refill requests, load get_subskill_prompt({ subskillName: "refill-sends-workflow" }), then call resolve_campaign_fill_route({ intent:"plain" }) and get_campaign_refill_state before any mutation. Route outcomes are route:"evergreen_horizon", route:"active_campaigns", and route:"ask_create"; stay in the same campaignOfferId/campaignId context after minting. Plain fill is not an alias for fill_campaign_horizon or campaign creation. fill_campaign_horizon is evergreen-only and is not the generic regular-campaign fill path. Campaign creation is allowed only after route:"ask_create" and explicit user selection; it is never the default response to plain fill. Treat "fill up/load sends" as capacity-fill preparation: calculate the bounded target from sender capacity when needed, then use the refill workflow to decide same-campaign source replenishment, enrichment/prep, approval/ready state, scheduler reread, and sender-health blockers. Do not create warm-post-engager side campaigns. For already-running regular campaigns that need Signal Discovery source replenishment, use the guarded currentStep clear with clearCurrentStepIfMatches:"running", campaign-scoped provider prompt/search/select, and import_leads with the existing sourceLeadListId when a newly approved selected-post scrape would otherwise return reusedExistingSourceList. After confirm_lead_list copies rows into an existing table, avoid fixed maxRowsToCheck:100; inspect reviewBatch/table selectors or use adaptive/wider bounded prep so appended rows are included. Do not interpret checkedRows as enriched rows; it is only the table cursor. Prepared, approved, and ready_to_schedule rows are intermediate states; never call them scheduled unless a re-read proves scheduler-owned scheduled cells with non-null scheduledFor. Before source import, prep, or approval, require exact visible approval and a fresh get_campaign_refill_state reread; stop if freshness.stateHash or exact ids changed. For "approve X messages", use approvalMode:approve only when explicitly requested, but still do not launch. For "schedule X sends" or "fill sender sends", approve only when explicitly requested, then re-read campaign/table scheduled counts; if scheduler-owned scheduledFor cells are not present, report prepared/approved/ready - awaiting scheduler instead of success. Do not call start_campaign as part of fill/schedule horizon. Do not call start_campaign as part of refill sends. Launch/start is a separate explicit human action after the operator intentionally wants sends to go out, and it must still verify that the bounded cohort is the only approved cohort and must not broad approve-all. campaignId is CampaignOffer.id. If the user asks to stop preparation, the target is wrong, or status shows the wrong campaign/table, use cancel_campaign_message_preparation only for the exact active job. Low-level selectors are diagnostics and recovery only for this lane. start_campaign remains forbidden until explicit launch/start approval outside refill sends.`,
+            prepareMessagesRule: `Default create-campaign stays on the existing reviewBatchLimit:15 first campaign-table execution slice. For plain post-mint fill/load/refill requests, load get_subskill_prompt({ subskillName: "refill-sends-workflow" }), then call resolve_campaign_fill_route({ intent:"plain" }), list_senders, and get_campaign_refill_state for enough candidate campaigns to identify the campaign that most recently had scheduler-owned sends for the relevant sender set before any mutation. Route outcomes are route:"evergreen_horizon", route:"active_campaigns", and route:"ask_create"; stay in the same campaignOfferId/campaignId context after minting. Plain fill is not an alias for fill_campaign_horizon or campaign creation. fill_campaign_horizon is evergreen-only and is not the generic regular-campaign fill path. Campaign creation is allowed only after route:"ask_create" and explicit user selection; it is never the default response to plain fill. Treat "fill up/load sends" as capacity-fill preparation, and treat "refill senders", "fill senders", "max out senders", and "load everyone up" as sender-scoped capacity-fill preparation. For sender-scoped requests with no named senders, --yolo means all eligible healthy senders enrolled in active campaign-backed sequence campaigns in the active workspace; without --yolo, ask which eligible enrolled senders to refill before choosing campaigns or mutating. In non-yolo interactive Codex or Claude Code sessions, the sender/campaign/action approval packet must be asked through request_user_input/AskUserQuestion with exactly Accept and Decline; do not use plain chat approval. The approval question body must show workspace, sender scope, a campaign-by-campaign table, exact ids/caps/dates, side effects, forbidden actions, and stop condition before mutation. Default --yolo horizon is two sender-local send days, skipping no-send-hour days. For campaign-scoped fill/refill, select the best recent-send campaign and calculate the bounded gap from healthy sender daily capacity minus future scheduler-owned scheduled sends and ready-to-schedule rows, then prepare only that gap. For sender-scoped fill/refill, calculate the bounded gap per eligible sender across active enrolled campaigns, counting future scheduled and ready-to-schedule rows across those campaigns, then choose the best same-sender campaign to fill each sender gap: prefer recent/future scheduler-owned sends for that sender, then strongest recent result evidence, then source health. Do not stop after filling only one sender when the request was sender-scoped. Use the refill workflow to decide whether to enrich/prep more rows in that same recent-send/best-result campaign, add/import more rows to that same campaign/source path, use a different existing campaign only when the selected same-sender lane is blocked/exhausted/already loaded while the sender still has a gap, or ask what to create. Do not create warm-post-engager side campaigns. Surface sender-health blockers separately from prepared/approved/scheduled counts. User-facing refill decisions must be campaign-name-first and sender-name-first, with ids as proof/execution targets only. For already-running regular campaigns that need Signal Discovery source replenishment, use the guarded currentStep clear with clearCurrentStepIfMatches:"running", campaign-scoped provider prompt/search/select, and import_leads with the existing sourceLeadListId when a newly approved selected-post scrape would otherwise return reusedExistingSourceList. After confirm_lead_list copies rows into an existing table, avoid fixed maxRowsToCheck:100; if confirm_lead_list returns USER_ADDED_ROWS_LIMIT_EXCEEDED, create a bounded same-source split from selectedLeadListId with get_rows_minimal/load_csv_linkedin_leads, confirm that smaller source list into the same campaign, and operate on the reviewBatch first; inspect reviewBatch/table selectors or use adaptive/wider bounded prep so appended rows are included. Do not interpret checkedRows as enriched rows; it is only the table cursor. Prepared, approved, and ready_to_schedule rows are intermediate states; never call them scheduled unless a re-read proves scheduler-owned scheduled cells with non-null scheduledFor. Before source import, prep, or approval, require exact visible approval and a fresh get_campaign_refill_state reread; stop if freshness.stateHash or exact ids changed. For "approve X messages", use approvalMode:approve only when explicitly requested, but still do not launch. For "schedule X sends" or "fill sender sends", approve only when explicitly requested, then re-read campaign/table scheduled counts; if scheduler-owned scheduledFor cells are not present, report prepared/approved/ready - awaiting scheduler instead of success. Do not call start_campaign as part of fill/schedule horizon. Do not call start_campaign as part of refill sends. Launch/start is a separate explicit human action after the operator intentionally wants sends to go out, and it must still verify that the bounded cohort is the only approved cohort and must not broad approve-all. campaignId is CampaignOffer.id. If the user asks to stop preparation, the target is wrong, or status shows the wrong campaign/table, use cancel_campaign_message_preparation only for the exact active job. Low-level selectors are diagnostics and recovery only for this lane. start_campaign remains forbidden until explicit launch/start approval outside refill sends.`,
         },
     };
 }

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

@@ -0,0 +1,113 @@
+type RefillSendsIntent = "plain" | "active" | "evergreen";
+type RefillSendsApprovalMode = "approve" | "mark_ready";
+type RefillSendsCommandInput = {
+    yolo?: boolean;
+    senders?: string[];
+    senderIds?: string[];
+    senderNames?: string[];
+    horizonSendDays?: number;
+    campaignId?: string;
+    tableId?: string;
+    intent?: RefillSendsIntent;
+    approvalMode?: RefillSendsApprovalMode;
+};
+export declare const refillSendsToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            yolo: {
+                type: string;
+                description: string;
+            };
+            senders: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            senderIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            senderNames: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            horizonSendDays: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            campaignId: {
+                type: string;
+                description: string;
+            };
+            tableId: {
+                type: string;
+                description: string;
+            };
+            intent: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            approvalMode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function refillSendsCommand(input?: RefillSendsCommandInput): {
+    command: string;
+    tool: string;
+    promptName: string;
+    workflowPromptName: string;
+    yolo: boolean;
+    intent: RefillSendsIntent;
+    horizonSendDays: number;
+    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: {
+                yolo: boolean;
+                senders: string[];
+                senderIds: string[];
+                senderNames: string[];
+                horizonSendDays: number;
+                campaignId: string | undefined;
+                tableId: string | undefined;
+                intent: RefillSendsIntent;
+                approvalMode: RefillSendsApprovalMode;
+            };
+        };
+    };
+};
+export {};

package/dist/tools/refill-sends.js

@@ -0,0 +1,150 @@
+const DEFAULT_HORIZON_SEND_DAYS = 2;
+function normalizeStrings(values) {
+    if (!Array.isArray(values))
+        return [];
+    return [
+        ...new Set(values
+            .map((value) => (typeof value === "string" ? value.trim() : ""))
+            .filter(Boolean)),
+    ];
+}
+function normalizeHorizonSendDays(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return DEFAULT_HORIZON_SEND_DAYS;
+    }
+    return Math.max(1, Math.min(7, Math.floor(value)));
+}
+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. This tool does not mutate campaigns, import leads, approve messages, schedule sends, launch, archive, delete, or write scheduler rows.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                yolo: {
+                    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.",
+                },
+                senders: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional sender selectors as names or ids. Use this for command text like --sender 'Christian Reyes'. Exact resolution still happens through list_senders before mutation.",
+                },
+                senderIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional exact Sender.id values to scope refill work.",
+                },
+                senderNames: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional sender display names to resolve through list_senders before campaign selection.",
+                },
+                horizonSendDays: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 7,
+                    description: "Number of sender-local send days to fill. Defaults to 2.",
+                },
+                campaignId: {
+                    type: "string",
+                    description: "Optional exact CampaignOffer.id to narrow routing. Do not pass campaign names.",
+                },
+                tableId: {
+                    type: "string",
+                    description: "Optional exact WorkflowTable.id to narrow routing. Do not pass table names.",
+                },
+                intent: {
+                    type: "string",
+                    enum: ["plain", "active", "evergreen"],
+                    description: 'Route intent. Use "plain" for normal refill/load requests unless the user explicitly says active or evergreen.',
+                },
+                approvalMode: {
+                    type: "string",
+                    enum: ["approve", "mark_ready"],
+                    description: 'Preparation mode for the final packet. Use "approve" only when the user asked to fill/schedule sender sends; otherwise default to "mark_ready".',
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+];
+export function refillSendsCommand(input = {}) {
+    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 horizonSendDays = normalizeHorizonSendDays(input.horizonSendDays);
+    const intent = input.intent ?? "plain";
+    const approvalMode = input.approvalMode ?? (yolo ? "approve" : "mark_ready");
+    const senderScope = hasSenderSelectors
+        ? "selected_senders"
+        : yolo
+            ? "all_eligible_healthy_senders_enrolled_in_active_campaign_backed_sequences"
+            : "ask_user_for_eligible_enrolled_senders_before_mutation";
+    return {
+        command: "refill-sends",
+        tool: "refill_sends",
+        promptName: "refill-sends",
+        workflowPromptName: "refill-sends-workflow",
+        yolo,
+        intent,
+        horizonSendDays,
+        approvalMode,
+        campaignId: input.campaignId ?? null,
+        tableId: input.tableId ?? null,
+        senderScope,
+        senderSelectors: {
+            senders,
+            senderIds,
+            senderNames,
+        },
+        firstOperationalSteps: [
+            'Load get_subskill_prompt({ subskillName: "refill-sends-workflow" }) before any product operation.',
+            `Resolve route with resolve_campaign_fill_route({ intent: "${intent}"${input.campaignId ? `, campaignId: "${input.campaignId}"` : ""}${input.tableId ? `, tableId: "${input.tableId}"` : ""} }).`,
+            "Call list_senders and get_sender_routing, then resolve sender selectors against active enrolled campaign-backed sequence senders.",
+            "Read get_campaign_refill_state for enough exact candidate campaigns to pick the best per-sender target by recent/future scheduler-owned sends, then recent result evidence, then source health.",
+            "Fresh reread get_campaign_refill_state immediately before any import, prep, approval, or horizon-fill mutation.",
+        ],
+        approvalContract: yolo
+            ? "Auto-accept only the rendered bounded refill packet after fresh reread. Stop if sender set, route, ids, caps, dates, blockers, or side-effect class drift."
+            : hasSenderSelectors
+                ? "Ask the final Accept/Decline structured approval question before mutation, including workspace, sender scope, campaign table, exact ids, caps/dates, side effects, forbidden actions, and stop condition."
+                : "Ask which eligible enrolled senders to refill first, then ask the final Accept/Decline structured approval question before mutation.",
+        forbiddenActions: [
+            "start_campaign",
+            "launch or send",
+            "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 proves the selected same-sender lane is blocked or exhausted",
+        ],
+        hostExamples: {
+            claude: [
+                "/sellable:refill-sends --yolo",
+                '/sellable:refill-sends --sender "Christian Reyes" --sender "Thomas Nobbs"',
+            ],
+            codex: [
+                "$sellable:refill-sends --yolo",
+                '$sellable:refill-sends --sender "Christian Reyes" --sender "Thomas Nobbs"',
+            ],
+            mcpTool: {
+                name: "refill_sends",
+                arguments: {
+                    yolo,
+                    senders,
+                    senderIds,
+                    senderNames,
+                    horizonSendDays,
+                    campaignId: input.campaignId,
+                    tableId: input.tableId,
+                    intent,
+                    approvalMode,
+                },
+            },
+        },
+    };
+}

package/dist/tools/registry.js

@@ -33,6 +33,7 @@ import { onDemandToolDefinitions } from "./one-off.js";
 import { processingToolDefinitions } from "./processing.js";
 import { promptToolDefinitions } from "./prompts.js";
 import { readinessToolDefinitions } from "./readiness.js";
+import { refillSendsToolDefinitions } from "./refill-sends.js";
 import { rowToolDefinitions } from "./rows.js";
 import { rubricToolDefinitions } from "./rubrics.js";
 import { senderRoutingToolDefinitions } from "./sender-routing.js";
@@ -49,6 +50,7 @@ export const allTools = [
     ...campaignAbTestToolDefinitions,
     ...campaignFillRoutingToolDefinitions,
     ...campaignRefillStateToolDefinitions,
+    ...refillSendsToolDefinitions,
     ...setupEvergreenCampaignsToolDefinitions,
     ...campaignHorizonFillToolDefinitions,
     ...campaignMessagePreparationToolDefinitions,

package/package.json

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

package/skills/create-campaign/SKILL.md

@@ -123,6 +123,7 @@ such as "fill campaigns", "fill up", "refill sends", "max out sends", or
 ```text
 get_subskill_prompt({ subskillName: "refill-sends-workflow" })
 resolve_campaign_fill_route({ intent:"plain" })
+list_senders
 get_campaign_refill_state
 ```
 
@@ -133,15 +134,27 @@ campaign refill. Route outcomes are `route:"evergreen_horizon"`,
 returns `route:"ask_create"`, ask whether to create a normal campaign or
 evergreen campaigns. Campaign creation is allowed only after this route and
 explicit user selection; it is never the default response to plain fill. When
-more leads are needed, the refill workflow must recommend same-campaign
-source-ladder replenishment; do not create warm-post-engager side campaigns,
-on-demand campaigns, or unrelated campaigns. Surface sender-health blockers
-separately from prepared/approved/scheduled counts.
+choosing among active targets, use refill-state scheduled-count evidence to
+continue the campaign that most recently had scheduler-owned sends for the
+relevant sender set; do not treat every active campaign as a refill candidate.
+In `--yolo` fill/refill mode, default to one best recent-send campaign and a
+two-send-day horizon: subtract future scheduler-owned scheduled sends and
+ready-to-schedule rows from healthy sender daily capacity, then prepare only
+that bounded gap.
+When more leads are needed, the refill workflow must recommend same-campaign
+source-ladder replenishment first; do not create warm-post-engager side
+campaigns, on-demand campaigns, or unrelated campaigns. If same-source copy hits
+`USER_ADDED_ROWS_LIMIT_EXCEEDED`, split the current source into a bounded
+same-source LinkedIn profile list, confirm that smaller list into the same
+campaign, and operate on the copied review batch first. Surface sender-health
+blockers separately from prepared/approved/scheduled counts.
 
 Treat active fills as capacity-fill preparation: calculate the bounded target
 from sender capacity when needed, then use the refill workflow to decide source
-replenishment, enrichment/prep, approval policy, and scheduler proof. Mutation
-requires exact visible approval and a fresh `get_campaign_refill_state` reread.
+replenishment, enrichment/prep, approval policy, and scheduler proof. Present
+operator decisions by campaign name and sender name first, with campaign/table
+ids as proof only. Mutation requires exact visible approval and a fresh
+`get_campaign_refill_state` reread.
 For already-running regular campaigns that need Signal Discovery source
 replenishment, the refill workflow owns the guarded recovery: clear
 `currentStep` only with `clearCurrentStepIfMatches:"running"`, load the

package/skills/refill-sends/SKILL.md

@@ -3,8 +3,18 @@ name: refill-sends
 description: Plan regular campaign and evergreen campaign send refill work through the skill-led refill workflow.
 visibility: public
 allowed-tools:
+  - mcp__sellable__refill_sends
+  - mcp__sellable__get_auth_status
+  - mcp__sellable__start_cli_login
+  - mcp__sellable__wait_for_cli_login
+  - mcp__sellable__get_active_workspace
+  - mcp__sellable__list_workspaces
+  - mcp__sellable__set_active_workspace
   - mcp__sellable__get_subskill_prompt
   - mcp__sellable__search_subskill_prompts
+  - mcp__sellable__list_senders
+  - mcp__sellable__get_sender_routing
+  - mcp__sellable__get_campaign_waterfall
   - mcp__sellable__resolve_campaign_fill_route
   - mcp__sellable__get_campaign_refill_state
   - mcp__sellable__fill_campaign_horizon
@@ -35,14 +45,50 @@ allowed-tools:
   - mcp__sellable__get_table_rows
   - mcp__sellable__get_campaign_table_schema
   - mcp__sellable__select_campaign_cells
+  - mcp__sellable__queue_campaign_cells
   - mcp__sellable__wait_for_campaign_processing
   - mcp__sellable__get_sender
 ---
 
 # Refill Sends
 
-Use this public wrapper for plain operator requests such as "fill", "refill sends",
-"max out sends", "load everyone up", or "fill horizon sends".
+Use this public command wrapper for plain operator requests such as "fill",
+"refill sends", "max out sends", "load everyone up", or "fill horizon sends".
+
+Host command names:
+
+- Claude Code: `/sellable:refill-sends`
+- Codex: `$sellable:refill-sends`
+
+Accepted invocation flags in the same user request:
+
+- `--yolo`: auto-accept the rendered bounded refill packet after the required
+  fresh state reread.
+- `--sender <name-or-id>`: scope to a specific sender; repeat for multiple
+  senders.
+- `senderIds: <id>, <id>` or `senderNames: <name>, <name>`: explicit selector
+  alternatives when the host preserves natural-language arguments better than
+  shell-style flags.
+
+When the host can call typed MCP tools, start with:
+
+```text
+refill_sends({ yolo?: boolean, senders?: string[], senderIds?: string[], senderNames?: string[], horizonSendDays?: number })
+```
+
+That command helper only normalizes arguments and returns the execution
+contract. It does not mutate. Continue with the workflow below for route
+selection, state rereads, approval gating, source import, preparation, and
+bounded approval.
+
+First call `get_auth_status({})`. If auth or active workspace is not OK, follow
+the returned login/workspace guidance before route resolution. Do not run refill
+research against an implicit or guessed workspace.
+
+Treat "refill senders", "fill senders", "load everyone up", and "max out
+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.
 
 Load the internal workflow prompt before taking any operational step:
 
@@ -51,10 +97,52 @@ get_subskill_prompt({ subskillName: "refill-sends-workflow" })
 ```
 
 Then follow that workflow exactly. The default path is read-only research:
-resolve the route, read target refill state, report the next safe step, and stop
-before mutation unless the user has explicitly approved the exact workspace,
-campaign/table/source ids, caps/dates, approval mode, expected side effects,
-and stop/rollback condition.
+resolve the route, identify the sender-relevant campaign that most recently had
+scheduler-owned sends, read refill state for that target, report the next safe
+step using campaign names first, and stop before mutation unless the user has
+explicitly approved the exact workspace, campaign/table/source ids, caps/dates,
+approval mode, expected side effects, and stop/rollback condition.
+
+For interactive Codex or Claude Code sessions, that approval must use the
+host-native structured question gate, not plain chat:
+
+- Codex: use `request_user_input`.
+- Claude Code: use `AskUserQuestion`.
+
+The approval question must present the final refill step with exactly two
+choices: `Accept` and `Decline`. The question body must include the operator
+output packet: workspace, sender scope, a campaign-by-campaign table with
+campaign name, sender names, action, target count/cap, source/list, and
+blocker/skip reason, then exact ids, expected side effects, forbidden actions,
+and the stop condition. Treat `Accept` as permission for only the rendered
+target, caps, mode, and side effects. Treat `Decline` as a hard stop with no
+mutation.
+
+If Christian includes `--yolo` in the same refill request, treat that flag as
+auto-accept for the rendered bounded refill packet after the required fresh state
+reread. For sender-scoped language with no named senders, `--yolo` means all
+eligible healthy senders enrolled in active campaign-backed sequence campaigns in
+the active workspace. Without `--yolo`, if Christian did not name senders, ask
+which eligible enrolled senders to refill before choosing campaigns or mutating.
+
+`--yolo` only covers the exact sender set, per-sender target campaigns, caps,
+approval mode, and side effects in the packet. It does not authorize
+launch/start, sending, archive or delete cleanup, direct scheduler writes, sender
+reassignment, or campaigns outside those selected for the eligible sender set.
+Stop and re-plan if the route, sender set, ids, caps, blockers, or side-effect
+class drift before mutation.
+
+In `--yolo`, the default two-day fill horizon is two send days. For each target
+sender, compute the bounded gap from that sender's healthy daily capacity,
+existing future scheduler-owned scheduled sends, and rows already ready to
+schedule across active campaigns enrolled with that sender. Then pick the best
+same-sender campaign to fill the gap: prefer recent/future scheduler-owned sends
+for that sender, then strongest recent result evidence, then source health. Do
+not stop after filling only one sender when the request was sender-scoped. If a
+same-source copy hits the campaign-table row cap, split the current source into
+a bounded LinkedIn profile source list, confirm only that smaller list into the
+same campaign, and operate on the copied review batch. Do not fall back to
+on-demand campaigns or unrelated active-campaign fills.
 
 Public concepts are regular campaign and evergreen campaign. Internal direct
 campaign types are unsupported refill targets. `fill_campaign_horizon` is only a

package/skills/refill-sends-workflow/SKILL.md

@@ -3,6 +3,9 @@ name: refill-sends-workflow
 description: Internal skill-led refill sends workflow for regular campaigns and evergreen campaigns.
 visibility: internal
 allowed-tools:
+  - mcp__sellable__list_senders
+  - mcp__sellable__get_sender_routing
+  - mcp__sellable__get_campaign_waterfall
   - mcp__sellable__resolve_campaign_fill_route
   - mcp__sellable__get_campaign_refill_state
   - mcp__sellable__fill_campaign_horizon
@@ -33,6 +36,7 @@ allowed-tools:
   - mcp__sellable__get_table_rows
   - mcp__sellable__get_campaign_table_schema
   - mcp__sellable__select_campaign_cells
+  - mcp__sellable__queue_campaign_cells
   - mcp__sellable__wait_for_campaign_processing
   - mcp__sellable__get_sender
 ---
@@ -48,15 +52,45 @@ prep, readiness, and evergreen primitives.
 Plain phrases that enter here include "fill", "refill sends", "max out sends",
 "load everyone up", and "fill horizon sends".
 
+Sender-scoped phrases include "refill senders", "fill senders", "max out
+senders", and "load everyone up". A sender-scoped request targets senders
+enrolled in active campaign-backed sequence campaigns, not one arbitrary active
+campaign.
+
 1. Call `resolve_campaign_fill_route` first. Use `intent:"plain"` for generic
    fill/load language, `intent:"active"` only when the user explicitly narrowed
    to active regular campaigns, and `intent:"evergreen"` only when the user
    explicitly asked for evergreen or horizon work.
-2. Pick exact ids from the resolver result. Do not use campaign names or table
-   names as target identifiers.
-3. Call `get_campaign_refill_state` for the selected `campaignId` or `tableId`.
-   This must be the next target-specific research primitive.
-4. Classify the target from refill state:
+2. Resolve sender context before choosing a target. Call `list_senders`; when a
+   managed program is involved, also call `get_campaign_waterfall`, and call
+   `get_sender_routing` when territory rules may constrain sender eligibility.
+   If the user named senders, map those names to exact sender ids. If the user
+   did not name senders and the request is sender-scoped:
+   - in `--yolo`, target all eligible healthy senders enrolled in active
+     campaign-backed sequence campaigns returned by the route/state evidence;
+   - outside `--yolo`, ask which eligible enrolled senders to refill before
+     choosing campaigns or mutating.
+   If the request is campaign-scoped or ambiguous "fill sends" language, infer
+   the relevant senders from the most recent scheduler-owned sends in
+   refill-state readbacks and report that inference.
+   Short form: `--yolo refill senders` means all eligible enrolled senders; non-yolo asks which enrolled senders.
+3. Read `get_campaign_refill_state` for candidate campaigns from the resolver
+   result. For a broad `active_campaigns` route, inspect enough candidates to
+   identify the campaign or small campaign set that most recently had
+   scheduler-owned sends for the relevant sender set. Do not stop after the
+   first resolver target unless it is also the most recent sender-relevant send
+   lane.
+   Short form: Do not stop after the first resolver target unless recent-send evidence supports it.
+   In `--yolo` sender-scoped mode, selecting every active campaign is still a
+   scope error, but selecting one best refill campaign per eligible sender is
+   expected. Pick the single highest-ranked recent-send or best-result campaign
+   for each target sender unless the refill-state evidence proves that a sender
+   already has enough ready/scheduled rows across enrolled campaigns or that a
+   different same-sender campaign is needed because the best lane is blocked.
+   Short form: `--yolo refill senders` selects all eligible enrolled senders, then the best campaign per sender.
+4. Pick exact ids from the selected refill-state response. Do not use campaign
+   names or table names as target identifiers for tool calls.
+5. Classify the target from refill state:
    - regular campaign: campaign-backed workflow table with normal source,
      sequence, senders, and send/refill stages.
    - evergreen campaign: managed always-on lane with current source evidence.
@@ -77,7 +111,10 @@ Use the refill-state response as the current facts receipt:
   approved, ready to schedule, scheduled;
 - active message prep job;
 - scheduler-owned scheduled counts by date/action from cells with non-null
-  `scheduledFor`;
+  `scheduledFor`; treat these as the last sends/continuation signal;
+- latest scheduled send date, latest scheduled-cell update when present,
+  sender overlap with the requested or inferred sender set, and whether future
+  scheduled sends already exist;
 - `freshness.stateHash` and exact campaign/table/workspace ids.
 
 Empty or unsafe states stop with the blocker: no fillable target, missing or deleted campaign,
@@ -89,9 +126,76 @@ scheduler, or unsupported direct campaign type.
 
 For regular campaign workspaces, rank regular campaigns from route and
 `get_campaign_refill_state` evidence. Choose the best existing refill target.
+The default campaign-scoped refill interpretation is "continue the campaign that
+was actually sending most recently for the relevant available senders", not
+"touch every active campaign". The default sender-scoped refill interpretation is
+"fill every eligible target sender from the best enrolled active campaign for
+that sender", not "fill only the first/best campaign globally".
+
+Default `--yolo` horizon is two send days when the user asks to fill, refill,
+load, or max sends without naming a different horizon. Send days are sender-local
+days with configured sending hours; do not treat weekends or other no-send-hour
+days as fillable capacity. If the user explicitly names a no-send calendar date,
+report that date as unschedulable and continue only for the next valid send day
+when the packet says "send days" or the user asked to max/refill senders broadly.
+
+For campaign-scoped requests, compute the target from the selected campaign's
+healthy sender daily capacity for the next two send days, minus already
+scheduler-owned future scheduled sends for those days and minus rows already
+ready to schedule. For sender-scoped requests, compute that gap per target sender
+across all active enrolled campaigns for that sender; count future scheduled
+cells and ready-to-schedule cells in any active enrolled campaign toward that
+sender's gap before preparing more rows. If ready/scheduled rows already cover a
+sender's gap, do not add rows or prep for that sender; report that the sender is
+loaded and awaiting the scheduler. If the gap is positive, prepare only the gap
+in the best same-sender campaign and keep all source-copy/prep caps tied to that
+two-day packet.
+Short form: default `--yolo refill senders` target is each eligible sender's two-send-day gap.
+
+Rank candidates in this order:
+
+1. **Sender match**: campaigns whose healthy sender ids match the user-named
+   senders, or the inferred sender set when the user said only "fill sends" or
+   "load senders". Do not include campaigns merely because they are active when
+   their sender set is unrelated.
+2. **Recent sends**: campaigns with the newest scheduler-owned scheduled counts
+   and non-null `scheduledFor` cells for those senders. Future scheduled sends
+   are stronger continuation evidence than old historical sends; otherwise use
+   the latest scheduled send date / newest scheduled-cell update from refill
+   state.
+3. **Continuation capacity**: campaigns with healthy senders, remaining daily
+   capacity, and a gap between current ready-to-schedule rows and the desired
+   sender capacity.
+4. **Same-campaign source health**: prefer campaigns whose current source has
+   enough `sourceAvailable` inventory to prepare the gap. If source inventory
+   is low or exhausted, choose same-campaign row replenishment before switching
+   campaigns.
+5. **Campaign scope**: keep the selected set small. For campaign-scoped
+   requests, normally choose one campaign. For sender-scoped requests, choose at
+   most one best campaign per target sender unless evidence shows one sender
+   needs multiple same-sender campaigns because the first is blocked or already
+   loaded.
+
 Do not create side campaigns, warm-post-engager side campaigns, on-demand campaigns,
 or unrelated campaigns as the default answer to a fill request.
 
+For each selected campaign, decide the next action by the smallest sufficient
+step:
+
+- **Enrich/prep more rows in the same campaign** when sender health is good,
+  recent sends point to this campaign, and `sourceAvailable` can cover the
+  ready-to-schedule gap.
+- **Add/import more rows to the same campaign/source path** when the campaign is
+  the right recent-send lane but source inventory or viable rows cannot cover
+  the gap.
+- **Use a different existing campaign** only when the recent-send/best-result
+  campaign for that sender is blocked, archived, missing sequence/source/senders,
+  disconnected, exhausted with no viable same-campaign replenishment path,
+  already loaded while the sender still has a gap, or the user explicitly asks
+  to move to another campaign.
+- **Ask what to create** only after resolver/state evidence shows there is no
+  suitable existing campaign for the requested sender set.
+
 When the best regular campaign is source-exhausted, recommend same-campaign source-ladder replenishment.
 Keep `selectedLeadListId` source identity distinct
 from the campaign `workflowTableId`.
@@ -109,6 +213,30 @@ Source replenishment choices:
   source prospects into the same campaign/source-list path, then confirm
   readiness.
 
+When reusing an existing source list on an already-large campaign, handle the
+campaign-table row cap automatically in `--yolo` mode. If `confirm_lead_list`
+fails with `USER_ADDED_ROWS_LIMIT_EXCEEDED`, parse `remainingRows`,
+`currentRows`, `requestedRows`, and `maxRows`; do not stop just because the full
+source list is too large. Instead, create a bounded same-source split:
+
+1. choose a split size no larger than `remainingRows`, the two-day refill row
+   budget, and the first-pass processing cap unless the packet named a higher
+   cap;
+2. read compact rows from the current `selectedLeadListId` with
+   `get_rows_minimal`;
+3. create a temporary bounded LinkedIn profile source list with
+   `load_csv_linkedin_leads`, preserving useful source columns such as post URL,
+   post author, engagement type/text, keyword, confidence, and why;
+4. call `confirm_lead_list` with that bounded source-list id, the same campaign
+   id, and `currentStep:"running"` for ACTIVE campaigns;
+5. verify the campaign table row count and review batch with
+   `get_campaign_table_schema` before any prep/approval.
+
+Do not use `add_on_demand_leads` or create an on-demand table as the automatic
+regular-campaign fallback. The fallback must stay same-campaign and
+source-list-backed.
+Short form: row-cap fallback means bounded same-source split, not stop or on-demand.
+
 ### Running Campaign Signal Discovery Recovery
 
 For an already-running regular campaign that needs same-campaign Signal
@@ -146,10 +274,10 @@ returns to Running after same-campaign source rows are copied. Do not call
 post-copy state transition.
 
 Before any source mutation, show exact approval evidence: workspace id,
-campaign id, workflow table id, source/provider id, source-list id when known,
-import caps, target dates/caps, dedupe/DNC/provider exclusion expectations, and
-expected row side effects. Then reread `get_campaign_refill_state`; if
-`freshness.stateHash` or exact ids changed, stop and ask for a fresh approval.
+campaign name, campaign id, workflow table id, source/provider id, source-list
+id when known, import caps, target dates/caps, dedupe/DNC/provider exclusion expectations, and expected row side effects. Present the campaign name and plain-English reason first; include ids only as proof and execution targets.
+Then reread `get_campaign_refill_state`; if `freshness.stateHash` or exact ids
+changed, stop and ask for a fresh approval.
 
 After source import, call `wait_for_lead_list_ready` and `confirm_lead_list`
 with the source-list id and campaign id. Imports append to the existing
@@ -179,18 +307,87 @@ Before prep or approval mutation, reread `get_campaign_refill_state` and compare
 If they changed, stop. A second concurrent refill run must see the first run's
 import/prep state on reread and avoid duplicate work.
 
+After the final reread and before the first mutating refill primitive, render
+one final approval packet in campaign-name-first language, then ask a
+host-native structured question with exactly two choices: `Accept` and
+`Decline`. The question is the execution boundary.
+Short form: exactly two choices: `Accept` and `Decline`.
+
+- In Codex interactive sessions, use `request_user_input`.
+- In Claude Code interactive sessions, use `AskUserQuestion`.
+- The question body must include this exact operator output packet shape before
+  the choices:
+  - workspace name/id and mode (`--yolo` or approval-required);
+  - sender scope, including selected sender names and skipped sender names with
+    health/enrollment reasons;
+  - a campaign-by-campaign plan table with campaign name, sender names, action,
+    target count/cap, source/list, and blocker/skip reason;
+  - exact workspace id, campaign id, workflow table id, source/action ids when
+    relevant, freshness/state hash, caps/dates, approval mode, and the next
+    MCP primitive to call;
+  - expected side effects, forbidden actions, and the stop/rollback condition.
+- The `Accept` choice must name the exact campaign, workspace id, campaign id,
+  workflow table id, source/action ids when relevant, caps/dates, approval mode,
+  expected side effects, and stop/rollback condition.
+- The `Decline` choice must stop with no mutation.
+- Do not proceed from a plain chat "ok", "yes", "go", or "do it" when the
+  structured question tool is available. If the structured question tool is not
+  available in an interactive session, stop and tell the user the quick question
+  panel is required for refill approvals. In non-interactive exec/automation,
+  print the approval packet and stop before mutation.
+
+`--yolo` mode is explicit auto-accept. If Christian includes `--yolo` in the
+same refill request, do not ask the `Accept` / `Decline` question. Instead:
+
+1. render the same final approval packet;
+2. reread `get_campaign_refill_state`;
+3. verify the route, workspace id, campaign id, table id, source/action ids,
+   caps/dates, approval mode, blockers, and side-effect class still match the
+   packet;
+4. execute only the exact packet.
+
+`--yolo` never authorizes launch/start, sending, archive/delete cleanup, raw
+scheduler writes, sender reassignment, unrelated campaigns, extra senders beyond
+the eligible sender set, or higher caps than the packet named. In sender-scoped
+`--yolo`, a bounded packet containing all eligible enrolled senders and at most
+one best campaign per sender is covered; arbitrary expanded campaign sets are
+not. If any state or scope drifts, stop and re-plan instead of auto-accepting the
+changed action.
+Short form: all eligible enrolled senders are covered by sender-scoped `--yolo`; arbitrary expanded campaign sets are not.
+Short form: direct scheduler writes are not covered by `--yolo`.
+Short form: stop and re-plan instead of auto-accepting the changed action.
+
 After same-campaign source copy, inspect the actual campaign-table position of
 the copied rows before starting prep. Newly copied rows often land after the first 100 table rows. Use `get_campaign_table_schema` to read the `reviewBatch`,
 then use `select_campaign_cells` diagnostics against
 `rowSelector:{ type:"reviewBatch" }` for `enrich`, `generateMessage`, and
 `approved` roles when needed.
 
+For bounded split refills, operate on the review batch first. Queue
+`queue_campaign_cells` for `columnRole:"enrich"` on
+`rowSelector:{ type:"reviewBatch" }`, wait for campaign processing, then queue
+`columnRole:"generateMessage"` for the same review batch or
+`needsGeneratedMessage` rows. If the bounded packet explicitly uses
+`approvalMode:"approve"` because the user asked to fill/schedule sends or
+provided `--yolo` for a two-day send fill, approve only the bounded review-batch
+cohort after current generated messages exist. Do not broad approve existing
+table rows.
+
 If review-batch enrich cells are pending or Generate Message cells are
 dependency-blocked, omit `maxRowsToCheck` so the adaptive prep job can cover the
 bounded table scan, or set a bounded cap high enough to include appended rows
 when row count evidence requires it. Do not run a fixed `maxRowsToCheck:100` prep pass after appending rows to a larger existing campaign table; it can spend
 the whole budget on older rows and miss the refill batch.
 
+Bound `targetPreparedMessages` to the actual ready-to-schedule gap for the
+selected campaign and sender set. In sender-scoped mode, compute and report the
+gap per sender. If ready/scheduled rows across active enrolled campaigns already
+cover a sender's gap, do not start prep for that sender; report that the sender
+is already loaded and awaiting the scheduler. If source inventory is available
+and the gap is small, prepare only the sender gap instead of filling every active
+campaign.
+Short form: prepare only the per-sender gap instead of filling every active campaign.
+
 Scheduled success requires a post-action reread proving scheduler-owned cells
 with non-null `scheduledFor`. Prepared, approved, and ready-to-schedule rows are
 intermediate states; report them as awaiting scheduler unless scheduled cells
@@ -225,9 +422,24 @@ the current source or ask for more research instead of walking the ladder.
 - No mutation in production unless Christian explicitly approves exact
   workspace, campaign/table ids, source/action ids, caps/dates, approval mode,
   expected side effects, and rollback/stop condition.
+- In interactive Codex or Claude Code, that explicit approval must be collected
+  through the host-native `Accept` / `Decline` question gate.
+- `--yolo` in the current refill request is explicit auto-accept for the
+  rendered bounded refill packet only; it does not loosen the launch/send,
+  scheduler-write, archive/delete, or drift rules above.
 
 ## Report
 
-Report the selected target, target type, source state, blockers, exact next
-primitive, approval required, and the freshness hash used. Say explicitly that
-nothing was launched and nothing was sent.
+Report in campaign-name-first language:
+
+- selected campaign name(s), target type, and sender names;
+- why they were selected, including last scheduled send date/future scheduled
+  send evidence and sender overlap;
+- whether the smallest next step is enrich/prep more in that campaign, add rows
+  to that campaign/source, use a different existing campaign, or ask what to
+  create;
+- source state, blockers, exact next primitive, approval required, and the
+  freshness hash used.
+
+Keep ids visible but secondary: show them under "Exact target" or "Proof", not
+as the main decision text. Say explicitly: nothing was launched and nothing was sent.