@sellable/mcp 0.1.341 → 0.1.343

package/dist/server.js

@@ -43,6 +43,7 @@ import { addRubricItem, checkRubric, deleteRubricItem, draftRubrics, saveRubrics
 import { getSenderRoutingTool, setSenderRoutingTool, } from "./tools/sender-routing.js";
 import { getSender, listSenders } from "./tools/senders.js";
 import { attachRecommendedSequence, attachSequence, createWorkflowTable, } from "./tools/sequencer.js";
+import { setupEvergreenCampaigns } from "./tools/setup-evergreen-campaigns.js";
 import { exportTableCsv, listTables } from "./tools/tables.js";
 import { handleVerifyTableRow } from "./tools/verify-row.js";
 import { sanitizeWatchUrlsForMcpResult } from "./tools/watch-url-security.js";
@@ -68,6 +69,32 @@ function parseOptionalNumber(value) {
     }
     return undefined;
 }
+function markEvergreenSetupCampaignsDirty(args) {
+    if (!args || args.mode !== "verify")
+        return;
+    const campaignIds = new Set();
+    const bindings = Array.isArray(args.bindings) ? args.bindings : [];
+    for (const binding of bindings) {
+        if (!binding || typeof binding !== "object" || Array.isArray(binding))
+            continue;
+        const campaignId = binding.campaignId;
+        if (typeof campaignId === "string" && campaignId.trim()) {
+            campaignIds.add(campaignId.trim());
+        }
+    }
+    const receipts = Array.isArray(args.receipts) ? args.receipts : [];
+    for (const receipt of receipts) {
+        if (!receipt || typeof receipt !== "object" || Array.isArray(receipt))
+            continue;
+        const campaignId = receipt.campaignId;
+        if (typeof campaignId === "string" && campaignId.trim()) {
+            campaignIds.add(campaignId.trim());
+        }
+    }
+    for (const campaignId of campaignIds) {
+        markCampaignContextDirty(campaignId, "setup_evergreen_campaigns");
+    }
+}
 function formatSubskillPromptText(result) {
     const header = result.chunkCount && result.chunkCount > 1
         ? [
@@ -187,6 +214,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_campaign_refill_state":
                 result = await getCampaignRefillState(args);
                 break;
+            case "setup_evergreen_campaigns":
+                result = await setupEvergreenCampaigns(args);
+                markEvergreenSetupCampaignsDirty(args);
+                break;
             case "fill_campaign_horizon":
                 result = await fillCampaignHorizon(args);
                 if (args?.campaignId) {

package/dist/tools/prompts.js

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

package/dist/tools/registry.js

@@ -38,6 +38,7 @@ import { rubricToolDefinitions } from "./rubrics.js";
 import { senderRoutingToolDefinitions } from "./sender-routing.js";
 import { senderToolDefinitions } from "./senders.js";
 import { sequencerToolDefinitions } from "./sequencer.js";
+import { setupEvergreenCampaignsToolDefinitions } from "./setup-evergreen-campaigns.js";
 import { tableToolDefinitions } from "./tables.js";
 import { verifyRowToolDefinitions } from "./verify-row.js";
 import { waterfallToolDefinitions } from "./waterfalls.js";
@@ -47,6 +48,7 @@ export const allTools = [
     ...campaignAbTestToolDefinitions,
     ...campaignFillRoutingToolDefinitions,
     ...campaignRefillStateToolDefinitions,
+    ...setupEvergreenCampaignsToolDefinitions,
     ...campaignHorizonFillToolDefinitions,
     ...campaignMessagePreparationToolDefinitions,
     ...campaignProcessingToolDefinitions,

package/dist/tools/setup-evergreen-campaigns.d.ts

@@ -0,0 +1,95 @@
+type SetupEvergreenCampaignsInput = {
+    mode?: "plan" | "verify";
+    depth?: "structure_only" | "customer_visible";
+    yolo?: boolean;
+    allConnectedSenders?: boolean;
+    selectedSenderIds?: string[];
+    bindings?: Array<{
+        laneKey: string;
+        campaignId: string;
+        tableId: string;
+    }>;
+    planRevision?: string;
+    selectedActionIds?: string[];
+    receipts?: unknown[];
+};
+export declare const setupEvergreenCampaignsToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            depth: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            yolo: {
+                type: string;
+                description: string;
+            };
+            allConnectedSenders: {
+                type: string;
+                description: string;
+            };
+            selectedSenderIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            bindings: {
+                type: string;
+                maxItems: number;
+                items: {
+                    type: string;
+                    properties: {
+                        laneKey: {
+                            type: string;
+                        };
+                        campaignId: {
+                            type: string;
+                        };
+                        tableId: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                description: string;
+            };
+            planRevision: {
+                type: string;
+                description: string;
+            };
+            selectedActionIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                maxItems: number;
+                description: string;
+            };
+            receipts: {
+                type: string;
+                maxItems: number;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function setupEvergreenCampaigns(input: SetupEvergreenCampaignsInput): Promise<unknown>;
+export {};

package/dist/tools/setup-evergreen-campaigns.js

@@ -0,0 +1,86 @@
+import { getApi } from "../api.js";
+async function postSetupEvergreenCampaigns(body) {
+    const api = getApi();
+    return api.post("/api/v3/mcp/setup-evergreen-campaigns", body);
+}
+export const setupEvergreenCampaignsToolDefinitions = [
+    {
+        name: "setup_evergreen_campaigns",
+        description: "Evergreen campaign setup plan/verify command. Use plan mode first to inspect exact workspace/sender/campaign/table/source state and receive immutable lane packets for one Post Engagers lane per selected sender plus shared Signal Discovery and Shared Cold Fallback lanes. yolo is only a parent-skill auto-execution hint for safe lane packets; this backend command remains read-only in plan mode and verifies receipts in verify mode. Lane workers must execute creation, source import, create-campaign workflow steps, generate-messages, sequence attachment, and review readiness through existing create-campaign workflow/subskills, then return receipts here for verification. This command does not launch campaigns, does not schedule sends, does not assign scheduler-owned send fields, does not archive/delete cleanup targets, and does not spend paid credits.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                mode: {
+                    type: "string",
+                    enum: ["plan", "verify"],
+                    description: 'Defaults to "plan". Verify only validates worker receipts.',
+                },
+                depth: {
+                    type: "string",
+                    enum: ["structure_only", "customer_visible"],
+                    description: 'Use "customer_visible" for full setup proof or "structure_only" when only ensuring lane shells/config.',
+                },
+                yolo: {
+                    type: "boolean",
+                    description: "plan mode only. Requests auto-executable lane packets when state is safe; never authorizes cleanup, launch, scheduling, sending, or ambiguous target choice.",
+                },
+                allConnectedSenders: {
+                    type: "boolean",
+                    description: "Plan sender-owned Post Engagers lanes for all eligible connected senders in the active workspace.",
+                },
+                selectedSenderIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 25,
+                    description: "Exact OutboundSenderIdentity ids for sender-owned Post Engagers lanes and shared-lane sender set.",
+                },
+                bindings: {
+                    type: "array",
+                    maxItems: 20,
+                    items: {
+                        type: "object",
+                        properties: {
+                            laneKey: { type: "string" },
+                            campaignId: { type: "string" },
+                            tableId: { type: "string" },
+                        },
+                        required: ["laneKey", "campaignId", "tableId"],
+                        additionalProperties: false,
+                    },
+                    description: "Exact existing campaign/table bindings to reuse for lane keys. Do not pass names.",
+                },
+                planRevision: {
+                    type: "string",
+                    description: "Required for verify. Copy from the immediately preceding plan.",
+                },
+                selectedActionIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    maxItems: 20,
+                    description: "Required for verify. Immutable action ids selected from the current plan.",
+                },
+                receipts: {
+                    type: "array",
+                    maxItems: 20,
+                    items: { type: "object" },
+                    description: "Required for verify. Structured lane worker receipts from create-campaign/source/message/sequence execution.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+];
+export function setupEvergreenCampaigns(input) {
+    return postSetupEvergreenCampaigns({
+        mode: input.mode,
+        yolo: input.yolo,
+        depth: input.depth,
+        allConnectedSenders: input.allConnectedSenders,
+        selectedSenderIds: input.selectedSenderIds,
+        bindings: input.bindings,
+        planRevision: input.planRevision,
+        selectedActionIds: input.selectedActionIds,
+        receipts: input.receipts,
+    });
+}

package/package.json

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

package/skills/create-campaign/SKILL.md

@@ -142,6 +142,14 @@ 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.
+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
+campaign-scoped provider prompt, run campaign-scoped `search_signals`, select
+posts with a capacity-target scrape plan, import into the same source path, and
+restore Running through `confirm_lead_list`. If the copied rows append beyond
+the first table page, inspect `reviewBatch` with table-schema/selector tools and
+use adaptive or wider bounded message prep; do not rely on a fixed `maxRowsToCheck:100` pass after source copy.
 If the user says "prepare/generate X messages", use message-prep primitives with
 `targetPreparedMessages:X` and default `approvalMode:"mark_ready"`. If the user
 says "approve X messages", use `approvalMode:"approve"` only for the bounded

package/skills/create-evergreen-campaigns/SKILL.md

@@ -51,6 +51,58 @@ Default evergreen plan per workspace (override only if the prompt specifies diff
 3. **`<Workspace/Team> - Shared Cold Fallback`** — one shared cold/fallback campaign lane across senders
 </inputs>
 
+<command_backed_workflow>
+For full/customer-visible setup, the first operational command is always
+`setup_evergreen_campaigns({ mode:"plan", yolo })`. Inventory can happen first
+for operator understanding, but do not create/reuse/repair campaign shells,
+source rows, messages, sequence, approvals, or cleanup before the command-backed
+plan returns lane packets.
+
+Plan shape:
+
+- one Post Engagers lane per selected sender;
+- one shared Signal Discovery lane;
+- one shared Cold Fallback lane;
+- explicit existing campaign/table bindings when the user points at a canonical
+  lane. Pass those exact ids to the plan and reuse/verify them instead of
+  creating duplicates.
+- If a user supplies canonical ids, reuse/verify them instead of creating duplicates.
+
+When senders are ambiguous, ask which sender ids need Post Engagers lanes before
+planning. If the operator says all connected senders, pass `allConnectedSenders`
+and let the command return exact selected sender ids or blockers.
+
+`--yolo` is supported, but it is a safety-scoped execution mode, not a cleanup
+or launch permission. With `--yolo`, pass `yolo:true` to
+`setup_evergreen_campaigns({ mode:"plan", yolo })` and proceed without
+intermediate approval only when every selected lane packet returns
+`autoExecutable:true`. `--yolo` does not authorize archive/delete cleanup,
+launch/start, schedule/send, broad approve-all, wrong workspace work, stale
+plan execution, paid InMail spend, or ambiguous target choice. Stop on wrong
+workspace, cleanup/archive/delete need, stale plan, disconnected sender,
+duplicate candidate, unsafe side effect, missing source proof, or missing
+message proof.
+
+After 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, and postconditions. Workers
+must use the create-campaign workflow and create-campaign workflow/subskills for
+campaign creation/setup, source/import, filter choice, Message Drafting,
+packaged `generate-messages`, sequence attachment, and send-review readiness.
+Do not rebuild those steps ad hoc in the parent thread.
+
+Workers return worker receipts. The parent then calls
+`setup_evergreen_campaigns({ mode:"verify", planRevision, selectedActionIds,
+receipts })` and report only verified completion. If verify blocks, report the
+blocker and repair only the missing postconditions from the same current plan.
+
+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.
+</command_backed_workflow>
+
 <objective>
 1. **Inventory first**: `get_campaigns` + `list_tables` + `get_campaign_waterfall` in the active workspace. Treat `list_tables` and the managed waterfall as authoritative for older managed slots; `get_campaigns` is a recent campaign page and may miss canonical evergreen lanes. Match existing campaigns/tables/waterfall slots to the plan by name (case-insensitive, ignore suffixes like "(Copy)") and stored slot identity. `list_tables.campaignStatus` and `list_tables.dashboardBucket` are part of the identity check: a matching `ARCHIVED` table/campaign is not a plain `REUSE`. If it is the canonical prod slot and the invocation explicitly allows dashboard visibility repair, repair it to `PAUSED`; otherwise mark it `flagged`/`blocked` and do not create a duplicate. A matching non-archived campaign/table/waterfall slot = REUSE; record it and move on. Never create a second campaign for a slot that already has one in any of those inventories.
 2. **Create only the missing slots** with `create_on_demand_campaign({ name, senderIds, campaignBrief })`:

package/skills/refill-sends/SKILL.md

@@ -9,6 +9,9 @@ allowed-tools:
   - 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
@@ -16,6 +19,7 @@ allowed-tools:
   - 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
@@ -29,6 +33,10 @@ allowed-tools:
   - 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__wait_for_campaign_processing
+  - mcp__sellable__get_sender
 ---
 
 # Refill Sends

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

@@ -7,6 +7,9 @@ allowed-tools:
   - 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
@@ -14,6 +17,7 @@ allowed-tools:
   - 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
@@ -27,6 +31,10 @@ allowed-tools:
   - 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__wait_for_campaign_processing
+  - mcp__sellable__get_sender
 ---
 
 # Refill Sends Workflow
@@ -101,6 +109,42 @@ Source replenishment choices:
   source prospects into the same campaign/source-list path, then confirm
   readiness.
 
+### Running Campaign Signal Discovery Recovery
+
+For an already-running regular campaign that needs same-campaign Signal
+Discovery replenishment, treat the watch/current-step transition as a guarded
+repair, not as normal create-campaign navigation.
+
+Do not call `search_signals` with `currentStep:"signal-discovery"` directly from `currentStep:"running"`. The campaign step guard intentionally rejects that
+backwards transition. After exact approval and a fresh refill-state reread, clear `currentStep` only if it still exactly matches `running`:
+
+```text
+update_campaign({ campaignId, currentStep:null, clearCurrentStepIfMatches:"running" })
+```
+
+Then register provider preflight and run a campaign-scoped `search_signals` so
+post rows exist in the campaign's Signal Discovery state:
+
+```text
+get_provider_prompt({ provider:"signal-discovery", campaignOfferId, confirmed:true })
+search_signals({ campaignOfferId, currentStep:"signal-discovery", confirmed:true, ... })
+```
+
+Use `select_promising_posts` before importing. For a fresh source refill, prefer
+`selectionMode:"replace"` and `scrapePlanMode:"capacity-target"` with the
+approved `targetEngagerCount` and `maxPostsToScrape`. If the approved post set cannot cover the target, do not knowingly run an under-capacity scrape; ask for approval to expand the selected post set or switch source.
+
+If `import_leads` returns `reusedExistingSourceList` but the user explicitly
+approved a different selected-post scrape, retry `import_leads` with the existing `sourceLeadListId` from that response or from refill state. For Signal
+Discovery this bypasses the stale reuse guard and materializes the newly
+selected campaign-scoped posts into a fresh source list.
+
+After `wait_for_lead_list_ready`, call `confirm_lead_list` with the new
+source-list id and same campaign id. Pass `currentStep:"running"` to `confirm_lead_list` for an ACTIVE already-running campaign so the watched state
+returns to Running after same-campaign source rows are copied. Do not call
+`update_campaign` to fake this after the copy; `confirm_lead_list` owns the
+post-copy state transition.
+
 Before any source mutation, show exact approval evidence: workspace id,
 campaign id, workflow table id, source/provider id, source-list id when known,
 import caps, target dates/caps, dedupe/DNC/provider exclusion expectations, and
@@ -135,11 +179,28 @@ Before prep or approval mutation, reread `get_campaign_refill_state` and compare
 If they changed, stop. A second concurrent refill run must see the first run's
 import/prep state on reread and avoid duplicate work.
 
+After same-campaign source copy, inspect the actual campaign-table position of
+the copied rows before starting prep. Newly copied rows often land after the first 100 table rows. Use `get_campaign_table_schema` to read the `reviewBatch`,
+then use `select_campaign_cells` diagnostics against
+`rowSelector:{ type:"reviewBatch" }` for `enrich`, `generateMessage`, and
+`approved` roles when needed.
+
+If review-batch enrich cells are pending or Generate Message cells are
+dependency-blocked, omit `maxRowsToCheck` so the adaptive prep job can cover the
+bounded table scan, or set a bounded cap high enough to include appended rows
+when row count evidence requires it. Do not run a fixed `maxRowsToCheck:100` prep pass after appending rows to a larger existing campaign table; it can spend
+the whole budget on older rows and miss the refill batch.
+
 Scheduled success requires a post-action reread proving scheduler-owned cells
 with non-null `scheduledFor`. Prepared, approved, and ready-to-schedule rows are
 intermediate states; report them as awaiting scheduler unless scheduled cells
 are present.
 
+preparedMessages can remain 0 while scheduler-ready state changes downstream.
+After a prep job reaches a terminal state, run `wait_for_campaign_processing`
+when generated/pass counts are still settling, then poll `get_campaign_refill_state` until `readyToSchedule` drops, scheduled counts increase, or the state clearly
+remains awaiting scheduler. Do not force scheduler fields directly.
+
 ## Evergreen Campaign Discipline
 
 `fill_campaign_horizon` is a legacy evergreen-only lower-level primitive. Call it