@sellable/install 0.1.258 → 0.1.259

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.258",
+  "version": "0.1.259",
   "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

@@ -1,7 +1,7 @@
 ---
 name: create-evergreen-campaigns
 description: Reconcile a sender team's evergreen campaigns — create-or-reuse the standing campaigns (per-sender post engagers + shared signal/cold lanes) idempotently, and when asked for customer-ready/full setup, complete each customer-visible campaign to paused send review with brief, rows, generated review messages, one approval gate row, and sequence. Never duplicates, never launches.
-visibility: public
+visibility: internal
 ---
 
 # Create Evergreen Campaigns
@@ -14,40 +14,6 @@ producing duplicates. This skill never launches campaigns; customer-visible
 completion stops at paused send review.
 </role>
 
-## Operational Fast Path
-
-In automation or `--yolo` customer-visible setup, use this path before the
-long-form contract below:
-
-1. Resolve the active workspace and explicit sender scopes, then call
-   `setup_evergreen_campaigns({ mode:"plan", yolo:true, postEngagerSenderIds,
-   sharedSenderIds })`. If the user did not name senders but
-   `get_campaign_waterfall` returns an active managed evergreen/prod waterfall
-   for the workspace, derive exact sender scopes from the waterfall `senderRefs`
-   and canonical Post Engagers/shared slots before the first setup plan. Match
-   `senderRefs` to `list_senders` by LinkedIn public identifier, display name,
-   or obvious handle/name alias; record the mapping in the plan notes. Do not
-   call setup with empty sender arrays when product-visible waterfall evidence
-   identifies the evergreen sender scope.
-2. If the plan is not current, lacks lane packets, or has
-   `autoExecutable:false`, return the exact blocker before mutation.
-3. Choose the worker runtime immediately. When running under Codex CLI or on VPS,
-   the local Codex CLI fallback is the default accepted runtime. Use visible
-   Codex app threads only when the callable thread tools are actually available.
-   If shell execution is unavailable and no visible/durable thread surface is
-   callable, return `blocked: missing_visible_or_durable_lane_worker_runtime`
-   before mutation.
-4. Write one compact prompt file per selected lane packet, create the receipt
-   directory, and launch all lane workers in parallel with the literal Codex CLI
-   worker command shape below. The parent does not create campaign shells.
-5. Collect fresh durable receipts, verify with the original planRevision and
-   selectedActionIds, then run the idempotency plan and show sample messages.
-
-Do not keep reasoning, re-reading prompts, or restating this workflow instead of
-dispatching workers. If the first worker cannot be launched after at most one
-short planning pass, return `blocked: worker_dispatch_deadline_exceeded` before
-directory setup or product mutation.
-
 <inputs>
 The invoking prompt names the senders ("create evergreen campaigns for csreyes92 and thomas"). Resolve each via `list_senders`.
 
@@ -92,32 +58,6 @@ Default evergreen plan per workspace (override only if the prompt specifies diff
 1. **`<Sender Name> - Post Engagers`** — one per sender (warm lane, highest priority)
 2. **`<Workspace/Team> - Shared Signal Discovery`** — one shared warm-signal campaign lane across senders
 3. **`<Workspace/Team> - Shared Cold Fallback`** — one shared cold/fallback campaign lane across senders
-
-Sender scope resolution is safety-critical. Do not pass
-`allConnectedSenders:true` unless the invoking prompt explicitly says "all
-connected senders", "every connected sender", "all seats", or names an
-equivalent all-sender scope. If the user says "all 4 campaigns", "the four
-evergreen campaigns", or names specific senders, resolve those exact senders
-and pass explicit `postEngagerSenderIds` plus `sharedSenderIds`; do not broaden
-the plan to every connected sender. If the prompt does not name senders but the
-active workspace has a product-visible managed evergreen/prod waterfall, derive
-the exact scope from that waterfall instead of using all connected senders:
-Post Engagers sender scope is the senderRefs that own person-specific
-Post Engagers slots; shared sender scope is the union of senderRefs on the
-shared Signal Discovery and Shared Cold Fallback waterfall slots. If the
-waterfall has one clear production evergreen program for the workspace, this is
-not ambiguous even when `list_senders` returns additional connected senders.
-In non-interactive or `--yolo` mode, when more than two connected senders exist
-and neither the prompt nor product-visible waterfall evidence identifies exact
-evergreen sender scope, stop before mutation with
-`blocked: ambiguous_post_engager_sender_scope` and report the sender ids/names
-needed for approval. Never let "workspace default" silently create Post
-Engagers lanes for extra senders.
-Short form: Do not pass `allConnectedSenders:true` unless the prompt explicitly says all/every connected sender.
-Short form: "all 4 campaigns" means explicit sender scope plus two shared lanes, not all connected senders.
-Short form: Product-visible managed evergreen/prod waterfall senderRefs are exact sender scope.
-Short form: Do not report `no_senders` while waterfall senderRefs can be mapped to list_senders.
-Short form: In `--yolo`, ambiguous multi-sender scope blocks before mutation.
 </inputs>
 
 <command_backed_workflow>
@@ -131,13 +71,6 @@ error, or does not return a current `planRevision` with lane packets, stop
 immediately with `blocked: setup_evergreen_campaigns_unavailable`. Do not fall
 back to ad hoc create-campaign calls, inventory-only guesses, or direct shell
 creation when the command-backed plan is missing.
-Exception: if an initial unscoped plan returns only `blocked:no_senders`, and
-the parent has already read `list_senders` plus a product-visible managed
-evergreen/prod waterfall with mappable `senderRefs`, immediately re-run the
-plan once with explicit derived `postEngagerSenderIds` and `sharedSenderIds`.
-Do not report `no_senders` to the user until that scoped plan has also failed.
-If senderRef mapping is partial, stop with
-`blocked: ambiguous_post_engager_sender_scope` and include the unmapped refs.
 
 MCP/product-visible proof only: every success claim must be observable through
 the installed Sellable MCP tools and product-visible readbacks a normal user or
@@ -282,8 +215,7 @@ After bounded delegated approval or safe `--yolo`, fan out lane worker tasks
 only from the current plan. Each worker receives the complete lane packet:
 workspace id, sender ids, lane key/type, existing campaign/table binding or
 create intent, source hints, caps, planRevision, actionId, allowed side effects,
-postconditions, the parent `postEngagerSenderIds`, the parent
-`sharedSenderIds`, and the packet's `workerDispatch` policy. Treat
+postconditions, and the packet's `workerDispatch` policy. Treat
 `workerDispatch.requiresVisibleThreadOrDurableReceipt:true` as a hard
 execution boundary, not guidance. Read and preserve `workerDispatch.acceptedRuntimes`,
 `workerDispatch.rejectedRuntimes`, and `workerDispatch.receiptArtifactHint`
@@ -302,15 +234,6 @@ parent packet, do not mutate and do not use it as `setupPlanCall` proof; stop
 with `blocked: worker_plan_scope_drift` and ask the parent to re-plan.
 Short form: If a worker-local plan omits `postEngagerSenderIds:[]`, do not use it as `setupPlanCall` proof.
 Short form: stop with `blocked: worker_plan_scope_drift`.
-Every worker prompt must include both parent scope arrays as explicit fields:
-`Parent postEngagerSenderIds:` and `Parent sharedSenderIds:`. Workers must
-preserve parent postEngagerSenderIds even for shared lanes. Never run a
-shared-lane worker-local plan with `postEngagerSenderIds:[]` unless the parent
-`postEngagerSenderIds` is exactly `[]`. Every durable receipt must copy these
-arrays to top-level `parentPostEngagerSenderIds` and `parentSharedSenderIds`
-before completion.
-Short form: Workers must preserve parent postEngagerSenderIds even for shared lanes.
-Short form: Never run a shared-lane worker-local plan with `postEngagerSenderIds:[]` unless the parent `postEngagerSenderIds` is exactly `[]`.
 
 Worker fan-out must use visible or durable execution. Preferred in local Codex
 is a visible Codex thread created with the actual Codex app thread tools:
@@ -334,128 +257,35 @@ acceptable only when it writes a fresh durable per-lane receipt artifact as it
 works.
 When visible Codex app thread tools are unavailable but local Codex CLI is
 available, the accepted durable streaming-worker command shape is:
-`codex -a never -s danger-full-access exec --skip-git-repo-check -m <worker-model> -C <repo> -o <worker-final-file> -`.
+`codex -a never -s danger-full-access exec -C <repo> -o <worker-final-file> -`.
 The approval and sandbox flags must come before the `exec` subcommand for Codex
-CLI builds that expose `-a`/`-s` only at top level. `--skip-git-repo-check` belongs after `exec` because current customer and VPS Codex CLI builds expose it
-as an `exec` subcommand flag, not a top-level flag. Do not use
+CLI builds that expose `-a`/`-s` only at top level. Do not use
 `codex exec --ask-for-approval never ...` or `codex exec -a never ...`; those
 forms fail on current customer CLI installs. Pipe the lane packet prompt on
 stdin, require the worker to write `workerDispatch.receiptArtifactHint`, and
 pass exactly one lane packet per worker.
-When launching durable Codex CLI workers from an automation parent, pass an
-explicit supported worker model instead of relying on the Codex CLI default
-model. Use the parent runtime model when known, for example:
-`codex -a never -s danger-full-access exec --skip-git-repo-check -m <worker-model> -C <repo> -o <worker-final-file> -`.
-Do not rely on the Codex CLI default model; some customer and VPS installs
-default to unavailable model aliases. If the parent cannot identify a supported
-worker model and a test `codex exec -m <worker-model>` launch is rejected, stop
-with `blocked: worker_model_unavailable` before mutation.
-When wrapping multiple local Codex CLI workers in a shell launcher, run the
-wrapper with `/bin/bash -lc` or another explicitly chosen portable shell. Do not
-rely on zsh-specific behavior. Do not use `status` as a shell variable because
-zsh treats it as read-only; use `exit_code` or `rc` instead. Receipt polling
-must use `find <receipt-dir> -maxdepth 1 -name 'evg_*.json' -print` or an
-explicit nullglob-safe equivalent. Do not use naked `*.json` globs under zsh,
-and keep zero-receipt polls quiet with no `no matches found` diagnostics.
-Do not embed `<<'WORKER_PROMPT'` heredocs inside a single quoted or double
-quoted `/bin/bash -lc '...'` command string; nested quoting is brittle and can
-truncate the first worker before mutation. For multi-worker launchers, write one
-plain prompt file per lane under the current run directory, then start each
-worker with `codex -a never -s danger-full-access exec --skip-git-repo-check -m "$WORKER_MODEL" -C "$REPO" -o
-"$worker_final_file" - < "$worker_prompt_file"`. Keep launcher shell variables
-double-quoted and keep the prompt heredoc only in a standalone script/prompt-file
-write step, not inside an already quoted shell argument. If the first launcher
-attempt exits with a shell parse error or before starting the first worker,
-stop with `blocked: worker_launcher_quoting_failed` and do not retry by
-loosening sender scope or mutating in the parent.
-Do not use `nohup`, detached background workers, or any launcher that returns
-before the workers finish and before receipts/final files exist. A durable
-worker must run in a foreground command session, visible Codex thread, or a shell
-that stays alive until every worker has finished. If using background jobs inside
-one shell, the same shell must stay alive, wait for every worker PID, poll only
-the expected receipt paths, and record a per-worker exit code plus final-file
-paths and stderr/log paths before returning. If workers exit with empty logs and
-no final files because the subprocess detached or was reaped, stop with
-`blocked: worker_subprocess_detached_without_output` before parent verify.
-When launching multiple local Codex CLI workers from one shell, start each
-background job in the same shell that will call `wait`. Do not capture worker
-PIDs through command substitution, a subshell, a pipeline, or a helper function
-invoked as `worker_pid=$(launch_worker ...)`; those patterns make the captured
-PID non-waitable by the parent shell. Use the same-shell PID array pattern:
-`pids=(); codex ... > "$log_file" 2>&1 & pids+=("$!")`, then
-`for pid in "${pids[@]}"; do wait "$pid" || rc=1; done`. If `wait` reports
-`pid is not a child of this shell`, stop with
-`blocked: worker_subprocess_detached_without_output`.
-Short form: run the wrapper with `/bin/bash -lc`.
-Short form: Do not rely on zsh-specific behavior.
-Short form: Do not use `status` as a shell variable; use `exit_code` or `rc`.
-Short form: Do not capture worker PIDs through command substitution or a subshell.
-Short form: Use same-shell `pids+=("$!")` before waiting on every PID.
-Short form: Receipt polling uses `find <receipt-dir> -maxdepth 1 -name 'evg_*.json' -print`.
-Short form: Do not use naked `*.json` globs under zsh; no `no matches found` diagnostics.
-Short form: Do not embed `<<'WORKER_PROMPT'` heredocs inside a quoted `/bin/bash -lc` command string.
-Short form: Multi-worker launchers write prompt files and run `codex ... - < "$worker_prompt_file"`.
-Short form: Do not use `nohup`; keep the worker process attached until receipt or blocker.
-After the auto-executable plan returns, take at most one short planning pass to
-choose the visible/durable worker runtime and build the worker launch packet.
-Do not keep reasoning, re-reading prompts, or restating the workflow instead of
-dispatching. If the parent cannot name the callable worker runtime and prepare
-the first worker launch command/tool call immediately after that pass, stop with
-`blocked: worker_dispatch_deadline_exceeded` before directory setup or mutation.
 After creating receipt directories, dispatch workers immediately; do not perform extended parent reasoning, extra inventory, or prompt rewriting loops.
-Before any campaign shell creation, the parent must dispatch every selected lane
-worker from the current plan and record the visible thread id or
-`receiptArtifactPath` for each selected actionId. The parent must not call
-`create_campaign`, `import_leads`, `confirm_lead_list`, sequence tools, message
-preparation tools, or `setup_evergreen_campaigns` with `mode:"apply"` or any
-other mutating setup mode. In this wrapper, `setup_evergreen_campaigns` is
-plan/verify authority only; customer-visible creation belongs inside lane
-workers through `$sellable:create-campaign`. If a campaign/table id appears for
-a create lane before that lane has a recorded worker runtime and fresh receipt
-path/thread id, stop with `blocked: parent_mutated_before_worker_receipt` and
-do not continue setup in the parent.
-Short form: dispatch every selected lane worker before shell creation.
-Short form: do not call `setup_evergreen_campaigns` with `mode:"apply"` from the parent.
 Use a compact worker prompt: include lane packet JSON, original selectedActionIds,
-original planRevision, parent postEngagerSenderIds, parent sharedSenderIds,
-receiptArtifactPath, workspace id, sender ids, side-effect caps, and the
-instruction to load packaged prompts through MCP.
-The worker prompt must include the exact filter status rule:
-`filterDecisionReceipt.status:"applied"` only; never `completed`, `confirmed`,
-`done`, or any other alias.
-The worker prompt must include the generated-message write rule: `update_cell`
-is allowed only for the semantic Approved checkbox, never for generated message
-text/body/sample copy. Bad copy requires `revise_message_template_and_rerun` or
-brief/template revision plus Generate Message rerun; any generated-message cell
-override is `blocked: generated_message_cell_override`.
+original planRevision, receiptArtifactPath, workspace id, sender ids,
+side-effect caps, and the instruction to load packaged prompts through MCP.
 Do not paste the entire wrapper skill into worker prompts. If the parent cannot
 launch at least one visible/durable worker immediately after directory setup,
 stop with `blocked: worker_dispatch_stalled` before any mutation.
-After launching workers, poll only the expected current-run receipt paths from
-`workerDispatch.receiptArtifactHint`. If no worker receipt file appears within a
-bounded wait, for example 10 minutes in automation, stop with
-`blocked: worker_receipt_timeout`, include the worker ids/final-file paths/stderr
-if available, and do not create or repair campaign shells in the parent.
 Use only the repo-local `workerDispatch.receiptArtifactHint` returned by the
 current lane packet for receipt paths.
 Do not hardcode machine-specific paths, workspace ids, campaign ids, sender ids, or UAT/phase artifact paths in this MCP prompt or any worker prompt.
 After the receipt-directory `mkdir`, the next shell/tool call must launch the first lane worker.
 Do not run `find`, `ls`, extra inventory, or another preflight between directory setup and the first worker launch.
-For the local Codex CLI fallback, use this literal durable CLI worker launch
-template and fill only the lane-specific placeholders. For one-off direct worker
-launches you may pipe a heredoc directly to `codex`; for multi-worker shell
-launchers, write the same prompt body to `<worker-prompt-file>` and launch the
-worker with stdin redirected from that file:
+For the local Codex CLI fallback, use this literal durable CLI worker launch template
+and fill only the lane-specific placeholders:
 
 ```
-codex -a never -s danger-full-access exec --skip-git-repo-check -m <worker-model> -C <repo> -o <worker-final-file> - <<'WORKER_PROMPT'
+codex -a never -s danger-full-access exec -C <repo> -o <worker-final-file> - <<'WORKER_PROMPT'
 Use $sellable:create-evergreen-campaigns as the governing skill for this one lane worker.
 
 Workspace id: <workspaceId>
 Parent planRevision: <planRevision>
 Parent selectedActionIds: <selectedActionIds JSON>
-Parent postEngagerSenderIds: <postEngagerSenderIds JSON>
-Parent sharedSenderIds: <sharedSenderIds JSON>
 Action id: <actionId>
 Lane key: <laneKey>
 Allowed side effects: <allowedSideEffects JSON>
@@ -467,13 +297,8 @@ Worker lane packet JSON:
 Load `$sellable:create-campaign` and nested prompts/assets through Sellable MCP loaders.
 Use mcp__sellable only. Do not use admin tools, direct DB, Prisma, SQL, web search, or browser search.
 Do not launch, start, schedule, send, or use paid InMail.
-For filter proof, durable receipt status must be `filterDecisionReceipt.status:"applied"` only; never `completed`, `confirmed`, `done`, or aliases.
-For generated messages, `update_cell` is allowed only for the semantic Approved checkbox. Never use `update_cell` for generated message text/body/sample copy. Bad copy requires `revise_message_template_and_rerun` or brief/template revision plus Generate Message rerun. Any generated-message cell override is `blocked: generated_message_cell_override`.
 Complete only this lane, write the required durable receipt JSON, and stop.
 WORKER_PROMPT
-
-# Multi-worker launcher equivalent:
-codex -a never -s danger-full-access exec --skip-git-repo-check -m <worker-model> -C <repo> -o <worker-final-file> - < <worker-prompt-file>
 ```
 
 If any placeholder cannot be filled from the current lane packet, do not inspect
@@ -543,14 +368,7 @@ not a parent-thread summary. The receipt must include:
   `senderIds`, `campaignId`, `tableId`, and `createIntent`. Do not use
   `laneActionId`, `lanePacketActionId`, `delegatedPlanRevision`,
   `delegatedActionId`, or freeform `requestedCall` text as a substitute for
-  these fields. For create lanes, `setupPlanCall.campaignId` and
-  `setupPlanCall.tableId` must be the actual created campaign/table ids after
-  creation and readback. If the parent lane packet carried null ids before
-  creation, preserve that original packet only in a separate `parentLanePacket`
-  object; do not leave `setupPlanCall.campaignId:null` or
-  `setupPlanCall.tableId:null`.
-  Short form: For create lanes, `setupPlanCall.campaignId` and `setupPlanCall.tableId` must be the actual created campaign/table ids.
-  Short form: Do not leave `setupPlanCall.campaignId:null` or `setupPlanCall.tableId:null`.
+  these fields.
 - `createCampaignWorkflowReceipt`: proof the worker loaded the actual installed
   `$sellable:create-campaign` wrapper instead of doing ad hoc MCP calls. It must
   include `skillCommand:"$sellable:create-campaign"`,
@@ -605,26 +423,8 @@ not a parent-thread summary. The receipt must include:
   evidence field such as `rowCount`, `rowIdsHash`, or `rowEvidence`; do not
   leave those only in `searchSignalsProof`, `importProof`, `coldFallbackProof`,
   or narrative text for the parent/verifier to infer.
-- `filterDecisionReceipt`: saved/applied ICP filter proof for the current
-  campaign/table basis. Customer-visible evergreen lanes must enable ICP
-  filtering with `enableICPFilters:true`, call `save_rubrics`, and save at
-  least three rubric/filter criteria before Message Drafting. Do not skip
-  filtering for evergreen setup. Missing or skipped filter proof is
-  `blocked: missing_filter_setup`.
-  Before the worker exits, the durable JSON must contain
-  `filterDecisionReceipt.status:"applied"`,
-  `filterDecisionReceipt.enableICPFilters:true`, the current
-  `workflowTableId`, and concrete saved-filter proof such as
-  `filterDecisionReceipt.filterIds`, `filterDecisionReceipt.rubricIds`,
-  `filterDecisionReceipt.savedRubricCount`, or
-  `filterDecisionReceipt.headlineICPCriteria`.
-  The exact status string is contractual: use `status:"applied"` only.
-  Do not write `status:"completed"`, `status:"confirmed"`, `status:"saved"`,
-  `status:"done"`, or any other alias after saving filters; the parent verifier
-  rejects those aliases even when saved rubric proof exists.
-  Short form: Filter receipt status must be exactly `applied`.
-  Short form: Do not write `filterDecisionReceipt.status:"completed"`.
-  Short form: Do not write `filterDecisionReceipt.status:"confirmed"`.
+- `filterDecisionReceipt`: saved/applied filter ids or explicit skip-filter
+  decision with current campaign/table basis.
 - `messageDraftingReceipt`: the Message Drafting proof described below,
   including packaged `generate-messages` prompt/assets and validation. Raw
   fields like `generateMessagesPromptLoadedToHasMoreFalse`,
@@ -660,10 +460,7 @@ not a parent-thread summary. The receipt must include:
 Before writing the durable receipt, run a receipt self-check. The top-level
 receipt must include top-level `planRevision`, `actionId`, `laneKey`,
 `laneType`, `workspaceId`, and `senderIds`, plus campaign/table/source ids and
-row/message/approval counts. It must also include top-level `receiptArtifactPath`,
-top-level `durableReceiptWritten:true`, top-level `receiptRunId`, and top-level
-`receiptWrittenAt`; do not leave `receiptArtifactPath` only under
-`createCampaignWorkflowReceipt` for the parent to patch during verify. Inside
+row/message/approval counts. Inside
 `createCampaignStepReceipt.messageDraftingReceipt`, `sampleMessages[]` must
 include `rowId`, `generatedMessageText`, `verdict`, and `issues`. Do not
 substitute `message` for `generatedMessageText`. Do not substitute
@@ -675,8 +472,6 @@ before writing JSON; do not leave only raw objects like
 `get_campaign_message_preparation_status`, `attachRecommendedSequenceResult`,
 `finalCampaignRead`, or `finalTableRead`.
 Self-check shorthand: top-level `planRevision`, `actionId`, `laneKey`, `laneType`, `workspaceId`, and `senderIds` must exist before worker completion.
-Self-check shorthand: top-level `receiptArtifactPath`, `durableReceiptWritten:true`, `receiptRunId`, and `receiptWrittenAt` must exist before worker completion.
-Self-check shorthand: top-level `receiptWrittenAt` must exist before worker completion.
 Self-check shorthand: `campaignBriefReceipt.briefHash`,
 `campaignBriefReceipt.deliveryFormat`, `campaignBriefReceipt.tokenRules`,
 `campaignBriefReceipt.hardAvoids`, and `campaignBriefReceipt.sourceUseRules`
@@ -765,12 +560,7 @@ verification unless the same object also appears inside
       "sourceLadderReason": "<why the current source is valid before colder sources>"
     },
     "filterDecisionReceipt": {
-      "status": "applied",
-      "enableICPFilters": true,
-      "filterIds": ["<saved filter/rubric id>"],
-      "rubricIds": ["<saved rubric id>"],
-      "headlineICPCriteria": ["<saved ICP criterion>", "<saved ICP criterion>", "<saved ICP criterion>"],
-      "savedRubricCount": 3,
+      "status": "skipped",
       "workflowTableId": "<workflow table id>"
     },
     "messageDraftingReceipt": {
@@ -851,25 +641,6 @@ path itself in the worker thread:
    exactly one semantic Approved cell through `select_campaign_cells` and
    `update_cell`.
    Approval shorthand: approve exactly one semantic Approved cell.
-   In this message-drafting path, `update_cell` is allowed only for the semantic
-   Approved checkbox. Do not use `update_cell` or any row/cell write to edit
-   generated message text, sample copy, or final message bodies in automation.
-   If generated copy fails review, update the campaign brief/message template
-   with `update_campaign_brief` or `revise_message_template_and_rerun`, then
-   rerun Generate Message and review current-revision generated output. Receipt
-   `sampleMessages` must come from generated current-revision cells after the
-   brief/template rerun, not from hand-edited message cell overrides. If a lane
-   used a generated-message body override, report
-   `blocked: generated_message_cell_override` instead of success.
-   Do not repair by overwriting bad generated message cells and then calling the
-   overwritten cells `sampleMessages`.
-   `messageDraftingReceipt.qualityReview.repairNote`,
-   `messageDraftingReceipt.toolsUsed`, or any proof mentioning generated
-   message cell repair through `update_cell` is self-incriminating and must be
-   `blocked: generated_message_cell_override`.
-   Short form: `update_cell` is allowed only for the semantic Approved checkbox.
-   Short form: Do not use `update_cell` to edit generated message text.
-   Short form: Bad copy requires brief/template revision plus Generate Message rerun.
 4. Poll `get_campaign_message_preparation_status` until no queued/active cells
    remain or a bounded stop reason is returned.
 5. Use `get_campaign_messages_preview` or `select_campaign_cells` to inspect
@@ -896,26 +667,6 @@ The only accepted statusSource values are exactly `branch` and
 `packaged-generate-messages-worker`; descriptive aliases such as
 `package-readback-local-thread` are rejected.
 
-Before any provider-specific source mutation for a newly created campaign,
-reread `get_campaign_navigation_state({ campaignId })` and use that product
-navigation state as the source-step authority. Do not jump from a shell directly
-into `contact-search`, and do not jump from a shell directly into
-`signal-discovery`. Advance through the product-visible source-selection step
-first, then load the provider prompt and write only the provider/source fields
-accepted for that current step. Never include sender reassignment fields in
-source-step updates, never include custom narration fields in source-step
-updates, and do not use guessed `currentStep` or watched narration payloads to
-force the flow forward. If `update_campaign` rejects the source transition
-twice, reread navigation/campaign state once; if the campaign is not already on
-the intended source step, stop the lane with
-`blocked: watched_source_transition_blocked` and include the rejected tool
-result plus the readback. Do not loop on rejected `update_campaign` transitions.
-Short form: do not jump from a shell directly into `contact-search`.
-Short form: do not jump from a shell directly into `signal-discovery`.
-Short form: never include sender reassignment fields in source-step updates.
-Short form: never include custom narration fields in source-step updates.
-Short form: do not loop on rejected `update_campaign` transitions.
-
 One lane may produce exactly one CampaignOffer/campaign id and one current
 workflow table id. For `intent:"create"`, the first successful
 `create_campaign` result establishes the lane's only allowed campaign/table
@@ -954,14 +705,9 @@ the prospect's engagement unless the selected source evidence proves that exact
 sender authored the post.
 Shared lanes must reject generic product-summary samples that explain the
 product in the same broad words for every row. Shared lanes must reject three
-nearly identical samples after stripping the leading name. Shared lanes must
-fail quality review when any reviewed sample has non-empty `issues`; do not
-approve or final-report samples with `verdict:"passed"` and non-empty `issues`.
-If any of these failures appears, revise or rerun the packaged
-create-campaign/generate-messages path from the lane worker before writing a
-success receipt.
-Short form: Shared lanes must fail quality review when any reviewed sample has non-empty `issues`.
-Short form: Do not approve or final-report samples with `verdict:"passed"` and non-empty `issues`.
+nearly identical samples after stripping the leading name. If either failure
+appears, revise or rerun the packaged create-campaign/generate-messages path
+from the lane worker before writing a success receipt.
 The generated-message cells are not prompt proof: `currentRevisionGeneratedMessages`,
 Generate Message column counts, `messagesCount`, or rendered row previews prove
 only that table cells exist from the current brief/template, not that the
@@ -981,62 +727,10 @@ duplicate-lane blockers before you call the command finished. If verify blocks,
 report the blocker and repair only the missing postconditions from the same
 current plan.
 
-Before calling verify, the parent should build compact receipt objects from the
-durable receipt files and pass those compact objects to MCP. The compact receipt
-must preserve every verifier-owned field named above, including top-level ids,
-`createCampaignStepReceipt`, `researchSenderReceipt`, canonical
-filter/message/review/sequence/final proof, and at least three concrete sample
-messages. It should omit large raw
-search outputs, long post lists, full row arrays, raw provider responses, and
-debug-only narration fields. Do not pass multi-hundred-kilobyte raw receipt
-objects when a compact canonical receipt has the same proof; large raw verify
-payloads can stall local MCP bridges and make UAT ambiguous.
-Use a small Node JSON compactor for non-trivial compaction. Do not build complex
-inline `jq` filters inside nested quoted shell strings; quote failures are a
-UAT blocker and waste the verification run. The Node compactor must preserve
-every canonical verifier object under `createCampaignStepReceipt`, including
-`setupPlanCall`, `createCampaignWorkflowReceipt`, `researchSenderReceipt`,
-`campaignBriefReceipt`, `sourceDecisionReceipt`, `filterDecisionReceipt`,
-`messageDraftingReceipt`, `reviewBatchReceipt`, `sequenceReceipt`,
-`finalPausedSendProof`, and `verifyCall`.
-When compacting, normalize `finalPausedSendProof.currentStep` and
-`finalPausedSendProof.campaignStatus` from nested pause/navigation readbacks if
-the worker receipt stored those values under `pauseCampaignResult`,
-`navigationReadback`, or `navigationProof`; do not pass an empty
-`finalPausedSendProof` object to verify.
-Do not print or `jq .` full receipt JSON into the terminal. For local checks,
-print only compact summaries such as file, actionId, laneKey, campaignId,
-filter status, sample count, approved count, and final status.
-Short form: Parent verify uses compact canonical receipt objects, not raw giant receipts.
-Short form: Do not dump full receipt JSON with `jq .`.
-Short form: Do not use complex inline `jq` for receipt compaction; use Node.
-Short form: Compact receipts must preserve `researchSenderReceipt`.
-Short form: Compact receipts must preserve direct `finalPausedSendProof.currentStep` and `campaignStatus`.
-Short form: Never change planRevision/actionId/laneKey while compacting receipts.
-
 Message proof for every customer-visible lane must come from the current
 campaign/table basis and include at least 3 generated review rows from the
 packaged `generate-messages` path before completion is reported.
 Parent-thread handwritten copy or setting `currentStep` is not proof.
-
-The parent must run its own sample-quality gate before final reporting, even
-when worker receipts say `verdict:"passed"`. For Post Engagers lanes, reject
-any sample that adds a relevance question, CTA, product line, or extra paragraph
-after `Thank you for the support on my post about ...`; blocked phrases include
-`curious`, `open to`, `trying to`, `worth seeing`, `want to see`, and any
-Sellable/product explanation. For each shared lane, normalize the reviewed
-sample messages by removing leading greeting/name lines, first names, and
-whitespace-only differences; reject shared-lane samples when the message body is
-identical after removing first names or when all samples share the same paragraph
-skeleton. Also reject final shared-lane samples with `Hey <name>,` letter
-punctuation, weak relevance hedges, internal workflow vocabulary, self-intros,
-or any non-empty `issues`. Shared lanes must also reject mechanical
-product-process wording such as `sequence-prospects`, `dashboard overhead`,
-`campaign map`, `campaign idea into prospects`, `prospects, filters, messages`,
-`send-ready copy`, or `reviewed prospect lists`. If the parent finds repeated
-shared-lane sample copy, report `blocked: repeated_shared_lane_sample_copy`,
-revise the campaign brief/template through the packaged workflow, rerun Generate
-Message, and verify current-revision sample messages before final completion.
 </command_backed_workflow>
 
 <objective>
@@ -1071,26 +765,19 @@ Message, and verify current-revision sample messages before final completion.
      Short form: Do not pass the warm template into Shared Signal Discovery or Shared Cold Fallback.
      Short form: Shared lanes must reject generic product-summary samples.
      Short form: Shared lanes must reject three nearly identical samples.
-     Short form: Shared lanes must reject low-confidence relevance hedges.
-     Short form: Shared lanes must reject internal workflow vocabulary.
      Short form: revise or rerun the packaged create-campaign/generate-messages path.
    - **Post Engagers** first-message style: short, casual, references the
-     sender-authored post they engaged with, and stops after the thank-you
-     line. Use **no internal vocabulary, no pitch, no meeting ask, no product
-     line, and no relevance question** in message one:
+     sender-authored post they engaged with, closed question, **no internal
+     vocabulary, no pitch, no meeting ask** in message one:
 
      ```
      {{first_name}}
 
      Hey there
 
-     Thank you for the support on my post about {{post_topic_line}}
+     Thanks for the support on my post about {{post_topic_line}}
      ```
 
-     Do not add any paragraph after the thank-you line. In particular, do not
-     append `curious, are you trying...`, `open to...`, `worth seeing...`, or
-     Sellable/product copy to a Post Engagers first message.
-
    - **Shared Signal Discovery** first-message style: short, casual, references
      the real observed signal/theme or public conversation. It may mention the
      engagement source only when the source evidence supports it. Do not say
@@ -1104,28 +791,6 @@ Message, and verify current-revision sample messages before final completion.
      say it. Prefer sender-agnostic company/team language such as "we're
      helping CX teams..." or "at cxconnect.ai, we help..." and one clear
      problem question.
-     Before Message Drafting runs, the campaign brief must already include
-     these shared-lane hard avoids and source-use rules. Do not rely on a
-     failed first generation batch to discover that self-intros, generic
-     product summaries, or repeated structure are bad. If the first generated
-     batch violates these rules, rerun, but record that as a repaired UAT path
-     rather than the desired zero-shot path.
-     Do not use low-confidence relevance hedges such as "hope this is
-     relevant" in Shared Signal Discovery samples. Translate source/tool terms
-     into prospect-facing business language; do not put internal workflow
-     vocabulary such as "Codex-style workflow", "MCP", "agent workflows",
-     "Claude Code", or "Claude-style agent workflows" in customer-facing
-     message one. Also avoid generic product-process nouns such as "dashboard",
-     "workflow", "source", "send-ready copy", "reviewed prospect lists",
-     "reviewed pipeline", "leads, filters, messages", "review-ready LinkedIn
-     sequence", "plain-language campaign idea into leads/filters/messages",
-     and "sequence" unless the recipient's own product/category makes that
-     exact word buyer-native.
-     Short form: Shared Signal Discovery uses no self-intro such as "I'm building Sellable".
-     Short form: Shared Signal Discovery uses no self-intro such as "We're building Sellable".
-     Short form: Shared Signal Discovery uses no "I've put together".
-     Short form: no low-confidence relevance hedge such as "hope this is relevant".
-     Short form: no internal workflow vocabulary such as "Codex-style workflow", "MCP", "agent workflows", "Claude Code", or "Claude-style agent workflows".
    - **Shared Cold Fallback** first-message style: cold, direct, and cohesive.
      It must not pretend there was engagement, must not say "saw you pop up",
      and must not use a standalone name line followed by "Hey there" or other
@@ -1140,57 +805,14 @@ Message, and verify current-revision sample messages before final completion.
      Sellable/Codex/Claude-Code feature summary
      across prospects. This is a single-message cold path unless the approved
      create-campaign message workflow proves a better delivery format.
-     Do not open with "hope this is relevant" or a similar low-confidence
-     relevance hedge. Do not use a repeated product-definition paragraph such
-     as "Sellable is a GTM system" across samples; every reviewed cold sample
-     should be specific enough to the role, company, or problem that the three
-     sample messages do not share the same body skeleton.
-     Do not use mechanical Sellable process language such as "campaign idea into
-     prospects, filters, messages, and sequence setup", "sequence-prospects",
-     "dashboard overhead", "campaign map", "send-ready copy", or "reviewed
-     prospect lists" in final cold samples. Say the buyer problem and one plain
-     outcome instead.
-     Before Message Drafting runs, the campaign brief must already forbid
-     self-intros, generic product summaries, opt-out shrugs, product-stack
-     dumps, and repeated template structure. Do not let the first generation
-     batch use "I'm building", "We're building", "I've put together", or
-     similar language and then rely on a cleanup rerun as the normal path.
      Short form: Shared Cold Fallback must not pass just because the receipt says `generate-messages` loaded.
      Short form: Shared Cold Fallback uses no self-intro such as "We're building".
-     Short form: Shared Cold Fallback uses no self-intro such as "I'm building Sellable".
-     Short form: Shared Cold Fallback uses no "I've put together".
      Short form: Shared Cold Fallback uses no opt-out shrug such as "If this isn't relevant, ignore me".
      Short form: Shared Cold Fallback uses no product-stack dump.
-     Short form: no low-confidence relevance hedge such as "hope this is relevant".
-     Short form: no repeated product-definition paragraph such as "Sellable is a GTM system".
-    - Customer-visible evergreen lanes must enable ICP filtering before Message
-      Drafting. This applies to Post Engagers, Shared Signal Discovery, and
-      Shared Cold Fallback. Do not skip filtering for evergreen setup, even when
-      the source is warm. Use the normal `$sellable:create-campaign` filter
-      workflow: set or save 3-5 headline ICP criteria, call `save_rubrics`, and
-      persist `enableICPFilters:true` on the campaign before generating
-      messages. Good evergreen filters should be light but real: role/budget
-      relevance, company/market fit, and obvious non-buyer exclusion. For
-      Post Engagers, keep filters permissive enough that warm source rows are not
-      over-pruned, but still save the filter rules. For shared lanes, filter for
-      buyers/operators relevant to the workspace offer and exclude students,
-      job seekers, vendors, and off-topic commenters. The receipt must show
-      `filterDecisionReceipt.status:"applied"`,
-      `filterDecisionReceipt.enableICPFilters:true`, current `workflowTableId`,
-      and saved filter/rubric proof with at least three saved rubric/filter
-      criteria (`filterIds`, `rubricIds`, `headlineICPCriteria`, or
-      `savedRubricCount`). Missing or skipped filter proof is
-      `blocked: missing_filter_setup`.
-      Short form: Customer-visible evergreen lanes must enable ICP filtering.
-      Short form: `enableICPFilters:true`.
-      Short form: Do not skip filtering for evergreen setup.
-      Short form: at least three saved rubric/filter criteria.
-      Short form: missing or skipped filter proof is `blocked: missing_filter_setup`.
-      Short form: run Message Drafting only after saved filters are applied.
-    - Every customer-visible lane must run Message Drafting from the current
-      campaign/table basis after source rows exist. The worker must load the full
-      packaged `generate-messages` prompt, every required asset, and
-      `create-campaign-v2-validation`; if the internal branch handoff is not
+   - Every customer-visible lane must run Message Drafting from the current
+     campaign/table basis after source rows exist. The worker must load the full
+     packaged `generate-messages` prompt, every required asset, and
+     `create-campaign-v2-validation`; if the internal branch handoff is not
      callable in the packaged runtime, the worker must call
      `start_campaign_message_preparation` and poll
      `get_campaign_message_preparation_status` from the lane worker. The
@@ -1220,13 +842,10 @@ Message, and verify current-revision sample messages before final completion.
    - A source/list decision has been resolved and campaign rows are loaded. If
      there is no approved source or no rows can be copied, report `blocked` with
      the missing source detail; do not call the campaign complete.
-    - The filter step is resolved with saved/applied filters. Customer-visible
-      evergreen lanes must have `enableICPFilters:true`, at least three saved
-      ICP filter/rubric criteria, and a receipt with
-      `filterDecisionReceipt.status:"applied"`. Do not skip filters for
-      evergreen setup. Do not leave customer-visible campaigns at
-      `filter-choice`, `filter-rules`, or `apply-icp-rubric` and report success.
-      Do not proceed to Message Drafting until saved filters are applied.
+   - The filter step is resolved: either saved/applied filters are present, or
+     the campaign explicitly skipped filters. Do not leave customer-visible
+     campaigns at `filter-choice`, `filter-rules`, or `apply-icp-rubric` and
+     report success.
    - Message Drafting has run from the current campaign/table basis, using the
      create-campaign message prompt/assets and validation gate. Updating
      `currentStep:"messages"` is not proof. Parent-thread handwritten copy is
@@ -1245,17 +864,13 @@ Message, and verify current-revision sample messages before final completion.
       reviewed sample messages. For Shared Cold Fallback, reject samples that
       open with a standalone name followed by "Hey there" or a similarly generic
       greeting. For Shared Cold Fallback, also reject samples with a self-intro
-      such as "We're building", "I'm building Sellable", or "I've put
-      together", an opt-out shrug such as "If this isn't relevant, ignore me",
-      or a product-stack dump that repeats the same
+      such as "We're building", an opt-out shrug such as "If this isn't
+      relevant, ignore me", or a product-stack dump that repeats the same
       Sellable/Codex/Claude-Code feature summary across prospects. For all
       shared lanes, reject generic product-summary samples, repeated
-      near-identical samples, low-confidence relevance hedges such as "hope this
-      is relevant", internal workflow vocabulary, any sample with non-empty
-      `issues`, and any preserved Post Engagers opener; revise or rerun the packaged
-      create-campaign/generate-messages path before reporting completion. Do not
-      approve or final-report samples with `verdict:"passed"` and non-empty
-      `issues`.
+      near-identical samples, and any preserved Post Engagers opener; revise or
+      rerun the packaged create-campaign/generate-messages path before reporting
+      completion.
    - The first review batch exists and at least 3 review rows have generated
      messages from the approved brief. If fewer than 3 usable rows exist, report
      the actual count and why.
@@ -1329,9 +944,7 @@ Message, and verify current-revision sample messages before final completion.
    **Also confirm the delivery format and keep config in sync.** Ask the user whether DM lanes should send multiline (paragraph-per-message) or as a single message. Record the answer as the brief's `Delivery format:` line, and when multiline is chosen, set `actionConfig.sendEachParagraphAsMessage: true` on that campaign's `send_dm` column via `update_column` (config edits run no cells and nothing sends from unlaunched campaigns). Never set the paragraph-split flag on InMail columns — the option does not apply to InMail.
 6. **Interactive polish mode only: prove the template on one real row.** For ONE campaign that has at least one lead row (add one via `add_on_demand_leads` if every lane is empty and the user provides/approves a test lead), generate a message for exactly one row (`queue_campaign_cells` with `columnRole: "generateMessage"`, `rowSelector: { type: "reviewBatch", limit: 1 }` or the single row's ID), wait for it, then show the user the generated message next to the template — AND show how it would split if paragraph-per-message sending is enabled (list each paragraph as `msg 1:`, `msg 2:`, …) so the user confirms each one reads like a real typed message. Check alignment: tone, structure, no internal vocabulary, correct token substitution, no letter punctuation. Do NOT approve the row or generate for more rows — one sample only.
 7. **Automation mode template/config audit**: inspect existing send-lane briefs for a `Delivery format:` line and chat-native warm template. If a send lane is missing the line and the prompt allows cleanup, update only the campaign brief metadata with the safest default for that lane (`Delivery format: single message (LinkedIn DM; line breaks remain inside one generated message; no follow-up until reply)`). If cleanup is not allowed, flag it. Do not generate a sample row in automation mode unless the invocation explicitly asks for sample proof. In structure-only automation, do not generate a sample row unless the invocation explicitly asks for sample proof. In customer-visible completion, follow the Customer-Visible Completion Contract instead.
-8. **Final customer-facing completion must include sample messaging**: after customer-visible verify and the idempotency rerun pass, add a `Sample Messaging Review` section to the final answer. For every completed lane, show at least one full generated first message for every completed lane with campaign name, campaign id, row id, and verdict. Extract samples from nested `createCampaignStepReceipt.messageDraftingReceipt.sampleMessages`, not from top-level summaries; extract samples from nested `createCampaignStepReceipt.messageDraftingReceipt.sampleMessages` when building the final answer. Prefer the approved route-proof row when it is quality-valid; otherwise use the best reviewed generated row from the verified receipt. A final `passed` sample must have `issues:[]`; if every reviewed sample has issues, report the lane as needing message revision instead of presenting a passed sample. Never approve or final-report sample text produced by manual `update_cell` body edits. Do not summarize the sample into a copy theme. Show the actual message text so the user can inspect tone and specificity. If any sample is not quite right, tell the user they can ask the AI to update the campaign brief/message template and rerun Generate Message before launch. Never suggest launching, scheduling, or sending as the next step from this command.
-   If the `Sample Messaging Review` section is omitted, the command is incomplete even when the structural campaign setup succeeded.
-9. **Report the reconcile plan and result** — every slot tagged `reused`, `created`, `repaired`, `flagged`, or `blocked`, plus template/sample details only when that mode ran:
+8. **Report the reconcile plan and result** — every slot tagged `reused`, `created`, `repaired`, `flagged`, or `blocked`, plus template/sample details only when that mode ran:
 
 ```
 Evergreen Reconcile — {date}
@@ -1340,17 +953,6 @@ Evergreen Reconcile — {date}
 • Sellable.dev - Shared Signal Discovery: repaired (send review ready; 50 rows, 3 generated, 1 approved gate row, sequence attached, paused)
 • Sellable.dev - Shared Cold Fallback: created (send review ready; 50 rows, 3 generated, 1 approved gate row, sequence attached, paused)
 All campaigns remain unlaunched. Next: enrich/approve more rows when you want more items ready to schedule.
-
-Sample Messaging Review
-• Christian Reyes - Post Engagers (`cmp_...`, row `row_...`, verdict: passed)
-  ```
-  {{full generated first message}}
-  ```
-• Sellable.dev - Shared Cold Fallback (`cmp_...`, row `row_...`, verdict: passed)
-  ```
-  {{full generated first message}}
-  ```
-If any sample is not quite right, ask the AI to update the campaign brief/message template and rerun Generate Message before launch.
 ```
 </objective>
 

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