@sellable/install 0.1.260 → 0.1.262

package/README.md

@@ -31,9 +31,9 @@ agent command for launching a campaign:
 sellable create
 ```
 
-Campaign creation, foundation memory, content capture/ideation, and post
-drafting run inside Claude Code or Codex, where the Sellable MCP tools and
-approval flows are available.
+Campaign creation, sender send refills, foundation memory, content
+capture/ideation, and post drafting run inside Claude Code or Codex, where the
+Sellable MCP tools and approval flows are available.
 
 Install is auth-free by default. The normal path is first-run login: launch a
 Sellable workflow in Claude Code or Codex and the agent handles Sellable
@@ -100,12 +100,14 @@ Use the same public entrypoints in both hosts:
 - Claude Code: `/sellable:foundation`
 - Claude Code: `/sellable:content`
 - Claude Code: `/sellable:create-post`
+- Claude Code: `/sellable:refill-sends`
 - Codex: `$sellable:create-campaign`
 - Codex: `$sellable:create-ab-test`
 - Codex: `$sellable:create-evergreen-campaigns`
 - Codex: `$sellable:foundation`
 - Codex: `$sellable:content`
 - Codex: `$sellable:create-post`
+- Codex: `$sellable:refill-sends`
 - Codex Desktop plugin: `sellable@sellable`
 - Codex visible skill: `Sellable Create Campaign`
 - Codex visible skill: `Sellable Create A/B Test`
@@ -113,7 +115,9 @@ Use the same public entrypoints in both hosts:
 - Codex visible skill: `Sellable Foundation`
 - Codex visible skill: `Sellable Content`
 - Codex visible skill: `Sellable Create Post`
+- Codex visible skill: `Sellable Refill Sends`
 - Internal MCP workflow prompt: `create-campaign-v2`
+- Internal MCP workflow prompt: `refill-sends-workflow`
 - Internal/backward-compatible memory prompt: `interview`
 
 Do not ask users to run `/sellable:create-campaign-v2`,

package/bin/sellable-install.mjs

@@ -37,7 +37,7 @@ function getInstallVersion() {
   }
 }
 
-const CODEX_PLUGIN_VERSION = "0.1.51";
+const CODEX_PLUGIN_VERSION = "0.1.52";
 const CODEX_PLUGIN_COMPAT_VERSIONS = [
   "0.1.8",
   "0.1.9",
@@ -73,6 +73,7 @@ const CODEX_PLUGIN_COMPAT_VERSIONS = [
   "0.1.39",
   "0.1.40",
   "0.1.41",
+  "0.1.51",
 ];
 const RAW_INSTALL_PACKAGE_SPEC =
   process.env.SELLABLE_INSTALL_PACKAGE_SPEC || "@sellable/install@latest";
@@ -187,7 +188,8 @@ Options:
 Auth:
   Install is auth-free by default. Sign in happens on the first run of
   /sellable:create-campaign, /sellable:create-evergreen-campaigns,
-  /sellable:foundation, /sellable:content, or /sellable:create-post in Claude Code or Codex,
+  /sellable:foundation, /sellable:content, /sellable:create-post, or
+  /sellable:refill-sends in Claude Code or Codex,
   where the agent walks you through signup or sign-in and stores credentials
   in ~/.sellable/config.json.
 
@@ -217,6 +219,7 @@ function printCreateCommandHint() {
     { label: "Foundation", command: "/sellable:foundation" },
     { label: "Content", command: "/sellable:content" },
     { label: "Post", command: "/sellable:create-post" },
+    { label: "Refill", command: "/sellable:refill-sends" },
   ]);
   console.log("");
   console.log("");
@@ -227,6 +230,7 @@ function printCreateCommandHint() {
     { label: "Foundation", command: "$sellable:foundation" },
     { label: "Content", command: "$sellable:content" },
     { label: "Post", command: "$sellable:create-post" },
+    { label: "Refill", command: "$sellable:refill-sends" },
   ]);
   console.log("");
   console.log(`   ${"─".repeat(63)}`);
@@ -874,7 +878,7 @@ function codexPluginManifest(opts) {
     name: "sellable",
     version: CODEX_PLUGIN_VERSION,
     description:
-      "Sellable MCP tools for campaign creation, foundation memory, content, and workflow sequencing.",
+      "Sellable MCP tools for campaign creation, send refills, foundation memory, content, and workflow sequencing.",
     author: {
       name: "Sellable",
       url: "https://sellable.dev/",
@@ -888,7 +892,7 @@ function codexPluginManifest(opts) {
       displayName: "Sellable",
       shortDescription: "Sellable MCP tools for outbound campaign workflows",
       longDescription:
-        "Loads the Sellable MCP server into Codex Desktop so Sellable skills can create campaigns, find leads, draft messages, and manage approval-gated launch workflows.",
+        "Loads the Sellable MCP server into Codex Desktop so Sellable skills can create campaigns, refill sends, find leads, draft messages, and manage approval-gated launch workflows.",
       developerName: "Sellable",
       category: "Productivity",
       capabilities: ["Interactive", "Write"],
@@ -897,6 +901,7 @@ function codexPluginManifest(opts) {
       termsOfServiceURL: "https://sellable.dev/terms",
       defaultPrompt: [
         "Create a Sellable campaign",
+        "Refill Sellable sends",
         "Find LinkedIn leads",
         "Build an outbound sequence",
       ],
@@ -1040,6 +1045,54 @@ const CREATE_EVERGREEN_CAMPAIGNS_ALLOWED_TOOLS = [
   "codex_app.send_message_to_thread",
 ];
 
+const REFILL_SENDS_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",
+  "mcp__sellable__get_campaign",
+  "mcp__sellable__get_campaign_context",
+  "mcp__sellable__update_campaign",
+  "mcp__sellable__get_provider_prompt",
+  "mcp__sellable__get_campaign_message_preparation_status",
+  "mcp__sellable__start_campaign_message_preparation",
+  "mcp__sellable__cancel_campaign_message_preparation",
+  "mcp__sellable__import_leads",
+  "mcp__sellable__wait_for_lead_list_ready",
+  "mcp__sellable__confirm_lead_list",
+  "mcp__sellable__search_signals",
+  "mcp__sellable__select_promising_posts",
+  "mcp__sellable__fetch_post_engagers",
+  "mcp__sellable__search_sales_nav",
+  "mcp__sellable__lookup_sales_nav_filter",
+  "mcp__sellable__search_prospeo",
+  "mcp__sellable__search_prospeo_companies",
+  "mcp__sellable__confirm_prospeo_company_accounts",
+  "mcp__sellable__load_csv_linkedin_leads",
+  "mcp__sellable__load_csv_domains",
+  "mcp__sellable__list_dnc_entries",
+  "mcp__sellable__load_csv_dnc_entries",
+  "mcp__sellable__get_rows",
+  "mcp__sellable__get_rows_minimal",
+  "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",
+];
+
 function allowedToolsYaml(tools) {
   return [...new Set(tools)].map((tool) => `  - ${tool}`).join("\n");
 }
@@ -1857,6 +1910,71 @@ then retry \`get_subskill_prompt\`.
 `, host, "create-evergreen-campaigns");
 }
 
+function refillSendsSkillMd(host = "shared") {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const templatePath = join(
+      here,
+      "..",
+      "skill-templates",
+      "refill-sends.md"
+    );
+    if (existsSync(templatePath)) {
+      return stampInstalledHost(
+        addOrReplaceAllowedTools(
+          readFileSync(templatePath, "utf8"),
+          REFILL_SENDS_ALLOWED_TOOLS
+        ),
+        host,
+        "refill-sends"
+      );
+    }
+  } catch {
+    // fall through to hardcoded fallback below
+  }
+  return stampInstalledHost(`---
+name: refill-sends
+description: Refill Sellable sender sends through the approval-gated refill workflow.
+visibility: public
+allowed-tools:
+${allowedToolsYaml(REFILL_SENDS_ALLOWED_TOOLS)}
+---
+
+# Sellable Refill Sends
+
+Use this as the customer-facing entrypoint for the Sellable \`refill-sends\`
+workflow. It supports \`--yolo\` and optional repeated \`--sender <name-or-id>\`
+selectors.
+
+## Bootstrap
+
+MCP prompt and command access are required. Do not inspect repo files, run shell
+commands, use \`npm\`, \`node\`, local harness scripts, or read local prompt
+files to emulate this workflow.
+
+If the Sellable MCP prompt tools are unavailable, stop and say this is a Codex
+install/reload problem. Tell the user to run
+\`curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh\`, fully quit and reopen Codex
+Desktop, then start a new thread.
+
+## Execute Workflow
+
+1. Call \`mcp__sellable__get_auth_status({})\`.
+2. Normalize invocation arguments with \`mcp__sellable__refill_sends({ yolo, senders, senderIds, senderNames })\` when the host exposes typed MCP tools.
+3. Load the canonical prompt via
+   \`mcp__sellable__get_subskill_prompt({ subskillName: "refill-sends" })\`,
+   then load \`mcp__sellable__get_subskill_prompt({ subskillName: "refill-sends-workflow" })\`.
+4. Follow the canonical prompt exactly. Do not launch, start, archive, delete,
+   or write scheduler rows as part of refill sends.
+
+## MCP Prompt Fallback
+
+If exact subskill lookup fails, use
+\`mcp__sellable__search_subskill_prompts({ query: "refill-sends", includePublic: true, includeInternal: true })\`,
+then retry \`get_subskill_prompt\`.
+`, host, "refill-sends");
+}
+
 function genericSellableSkillMd({ name, title, description, host = "shared" }) {
   return stampInstalledHost(`---
 name: ${name}
@@ -2330,6 +2448,12 @@ function codexPluginSkills() {
       description: "Capture ideas and draft LinkedIn posts in your voice",
       skillMd: createPostSkillMd(),
     },
+    {
+      dir: "sellable-refill-sends",
+      displayName: "Sellable Refill Sends",
+      description: "Refill sender sends with approval-gated campaign selection",
+      skillMd: refillSendsSkillMd("codex"),
+    },
   ];
 }
 
@@ -2555,6 +2679,16 @@ function claudeCommands() {
       argumentHint: "[post idea or source material]",
       skillMd: createPostSkillMd(),
     },
+    {
+      name: "refill-sends",
+      title: "Refill Sends",
+      filename: join("sellable", "refill-sends.md"),
+      description:
+        "Refill Sellable sender sends through the approval-gated refill workflow.",
+      argumentHint: "[--yolo] [--sender name-or-id ...]",
+      skillMd: refillSendsSkillMd("claude"),
+      allowedTools: ["AskUserQuestion", ...REFILL_SENDS_ALLOWED_TOOLS],
+    },
     {
       name: "create-evergreen-campaigns",
       title: "Create Evergreen Campaigns",
@@ -3852,6 +3986,7 @@ function printNextSteps(installedHosts, authReused) {
       { label: "Foundation", command: "/sellable:foundation" },
       { label: "Content", command: "/sellable:content" },
       { label: "Post", command: "/sellable:create-post" },
+      { label: "Refill", command: "/sellable:refill-sends" },
     ]);
     console.log("");
     console.log("");
@@ -3863,6 +3998,7 @@ function printNextSteps(installedHosts, authReused) {
       { label: "Foundation", command: "$sellable:foundation" },
       { label: "Content", command: "$sellable:content" },
       { label: "Post", command: "$sellable:create-post" },
+      { label: "Refill", command: "$sellable:refill-sends" },
     ]);
     console.log("");
   }
@@ -4153,11 +4289,13 @@ async function main() {
       console.log(`    Claude Code: /sellable:foundation`);
       console.log(`    Claude Code: /sellable:content`);
       console.log(`    Claude Code: /sellable:create-post`);
+      console.log(`    Claude Code: /sellable:refill-sends`);
       console.log(`    Codex: $sellable:create-campaign`);
       console.log(`    Codex: $sellable:create-evergreen-campaigns`);
       console.log(`    Codex: $sellable:foundation`);
       console.log(`    Codex: $sellable:content`);
       console.log(`    Codex: $sellable:create-post`);
+      console.log(`    Codex: $sellable:refill-sends`);
       process.exit(0);
     }
     if (rawArgs[0] === "prefs") {

package/lib/runtime-verify.mjs

@@ -30,6 +30,7 @@ export const REQUIRED_SELLABLE_MCP_TOOLS = [
   "attach_recommended_sequence",
   "resolve_campaign_fill_route",
   "get_campaign_refill_state",
+  "refill_sends",
   "setup_evergreen_campaigns",
   "start_campaign_message_preparation",
   "get_campaign_message_preparation_status",
@@ -70,6 +71,14 @@ export const CREATE_CAMPAIGN_SMOKE_CALLS = [
       limit: 1200,
     },
   },
+  {
+    name: "refill_sends",
+    arguments: {
+      yolo: false,
+      senders: ["smoke"],
+      horizonSendDays: 2,
+    },
+  },
   {
     name: "get_subskill_asset",
     arguments: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/install",
-  "version": "0.1.260",
+  "version": "0.1.262",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code and Codex",
   "bin": {

package/skill-templates/create-campaign.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/skill-templates/create-evergreen-campaigns.md

@@ -1024,16 +1024,31 @@ artifact path, allowed repair side effects, failed sample snippets, failed
 quality codes, and the banned phrase list. The repair prompt must say
 `Do not include existing receipt JSON; load current product state through
 Sellable MCP readbacks and rewrite the durable receipt from fresh readbacks`.
+It must also say that the worker should verify the packaged Sellable MCP
+surface is loaded before declaring MCP unavailable, including `get_auth_status`,
+`get_subskill_prompt`, and the campaign readback tools. If a repair worker still
+cannot access Sellable MCP, it must write a separate repair-blocked artifact
+under `repair-blocked/` or its repair final file and must not overwrite the
+canonical lane receipt. Repair workers must stage successful repaired receipts
+under `repair-staged/` first; only after fresh MCP readbacks, improved current
+samples, exactly one approved generated route-proof row, and a local JSON
+self-check pass may the worker atomically replace the canonical lane receipt.
 After the repair worker completes the final product readbacks
 (`get_campaign_messages_preview`, `get_campaign`, navigation/table readback),
-it must rewrite the durable receipt immediately before any extended narration,
-analysis, or final answer. If the repair worker cannot rewrite the durable
-receipt in one bounded pass, it must exit with
-`blocked: repair_receipt_write_timeout`. The parent must treat an unchanged
-receipt mtime, missing repair final file, or missing updated
+it must stage and then rewrite the durable receipt immediately before any
+extended narration, analysis, or final answer. If the repair worker cannot
+rewrite the durable receipt in one bounded pass, it must exit with
+`blocked: repair_receipt_write_timeout` without modifying the canonical lane
+receipt. The parent must treat an unchanged receipt mtime, missing repair final
+file, missing staged success artifact, or missing updated
 `messageDraftingReceipt.sampleMessages` after repair as blocked, never success.
+The parent must also treat a repair-blocked artifact as a failed run, but it
+must keep the pre-repair canonical receipt available for diagnostics and must
+not promote the blocked repair artifact as the lane receipt.
 Short form: repair prompts use compact repair packets, not full receipt JSON.
 Short form: Do not include existing receipt JSON in repair prompts.
+Short form: repair workers stage repaired receipts before replacing canonical receipts.
+Short form: repair blockers never overwrite canonical success receipts.
 Short form: repair workers write the durable receipt immediately after final readbacks.
 Short form: missing repair receipt rewrite is `blocked: repair_receipt_write_timeout`.
 

package/skill-templates/refill-sends.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